1 /* 2 * Copyright (c) 1996, Sujal M. Patel 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/time.h> 31 32 #include <err.h> 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include <unistd.h> 36 #include <fcntl.h> 37 #include <string.h> 38 39 #include <machine/cpufunc.h> 40 41 #include <isa/pnpreg.h> 42 43 #ifdef DEBUG 44 #define DEB(x) x 45 #else 46 #define DEB(x) 47 #endif 48 #define DDB(x) x 49 50 void 51 pnp_write(int d, u_char r) 52 { 53 outb (_PNP_ADDRESS, d); 54 outb (_PNP_WRITE_DATA, r); 55 } 56 57 /* The READ_DATA port that we are using currently */ 58 static int rd_port; 59 60 u_char 61 pnp_read(int d) 62 { 63 outb(_PNP_ADDRESS, d); 64 return inb( (rd_port << 2) + 3) & 0xff; 65 } 66 67 u_short 68 pnp_readw(int d) 69 { 70 int c = pnp_read(d) << 8 ; 71 c |= pnp_read(d+1); 72 return c; 73 } 74 75 int logdevs=0; 76 77 void DELAY __P((int i)); 78 void send_Initiation_LFSR(); 79 int get_serial __P((u_char *data)); 80 int get_resource_info __P((u_char *buffer, int len)); 81 int handle_small_res __P((u_char *resinfo, int item, int len)); 82 void handle_large_res __P((u_char *resinfo, int item, int len)); 83 void dump_resdata __P((u_char *data, int csn)); 84 int isolation_protocol(); 85 86 87 /* 88 * DELAY does accurate delaying in user-space. 89 * This function busy-waits. 90 */ 91 void 92 DELAY (int i) 93 { 94 struct timeval t; 95 long start, stop; 96 97 i *= 4; 98 99 gettimeofday (&t, NULL); 100 start = t.tv_sec * 1000000 + t.tv_usec; 101 do { 102 gettimeofday (&t, NULL); 103 stop = t.tv_sec * 1000000 + t.tv_usec; 104 } while (start + i > stop); 105 } 106 107 108 /* 109 * Send Initiation LFSR as described in "Plug and Play ISA Specification, 110 * Intel May 94." 111 */ 112 void 113 send_Initiation_LFSR() 114 { 115 int cur, i; 116 117 pnp_write(PNP_CONFIG_CONTROL, 0x2); 118 119 /* Reset the LSFR */ 120 outb(_PNP_ADDRESS, 0); 121 outb(_PNP_ADDRESS, 0); /* yes, we do need it twice! */ 122 123 cur = 0x6a; 124 125 for (i = 0; i < 32; i++) { 126 outb(_PNP_ADDRESS, cur); 127 cur = (cur >> 1) | (((cur ^ (cur >> 1)) << 7) & 0xff); 128 } 129 } 130 131 /* 132 * Get the device's serial number. Returns 1 if the serial is valid. 133 */ 134 int 135 get_serial(u_char *data) 136 { 137 int i, bit, valid = 0, sum = 0x6a; 138 139 bzero(data, sizeof(char) * 9); 140 141 for (i = 0; i < 72; i++) { 142 bit = inb((rd_port << 2) | 0x3) == 0x55; 143 DELAY(250); /* Delay 250 usec */ 144 145 /* Can't Short Circuit the next evaluation, so 'and' is last */ 146 bit = (inb((rd_port << 2) | 0x3) == 0xaa) && bit; 147 DELAY(250); /* Delay 250 usec */ 148 149 valid = valid || bit; 150 151 if (i < 64) 152 sum = (sum >> 1) | 153 (((sum ^ (sum >> 1) ^ bit) << 7) & 0xff); 154 155 data[i / 8] = (data[i / 8] >> 1) | (bit ? 0x80 : 0); 156 } 157 158 valid = valid && (data[8] == sum); 159 160 return valid; 161 } 162 163 164 /* 165 * Fill's the buffer with resource info from the device. 166 * Returns 0 if the device fails to report 167 */ 168 int 169 get_resource_info(u_char *buffer, int len) 170 { 171 int i, j; 172 173 for (i = 0; i < len; i++) { 174 outb(_PNP_ADDRESS, PNP_STATUS); 175 for (j = 0; j < 100; j++) { 176 if ((inb((rd_port << 2) | 0x3)) & 0x1) 177 break; 178 DELAY(1); 179 } 180 if (j == 100) { 181 printf("PnP device failed to report resource data\n"); 182 return 0; 183 } 184 outb(_PNP_ADDRESS, PNP_RESOURCE_DATA); 185 buffer[i] = inb((rd_port << 2) | 0x3); 186 DEB(printf("--- get_resource_info: got 0x%02x\n",(unsigned)buffer[i])); 187 } 188 return 1; 189 } 190 191 void 192 report_dma_info (x) 193 int x; 194 { 195 char *s1=NULL, *s2=NULL, *s3=NULL, *s4=NULL, *s5=NULL; 196 197 switch (x & 0x3) { 198 case 0: 199 s1="8-bit"; 200 break; 201 case 1: 202 s1="8/16-bit"; 203 break; 204 case 2: 205 s1="16-bit"; 206 break; 207 #ifdef DIAGNOSTIC 208 case 3: 209 s1="Reserved"; 210 break; 211 #endif 212 } 213 214 s2 = (x & 0x4) ? "bus master" : "not a bus master"; 215 216 s3 = (x & 0x8) ? "count by byte" : ""; 217 218 s4 = (x & 0x10) ? "count by word" : ""; 219 220 switch ((x & 0x60) >> 5) { 221 case 0: 222 s5="Compatibility mode"; 223 break; 224 case 1: 225 s5="Type A"; 226 break; 227 case 2: 228 s5="Type B"; 229 break; 230 case 3: 231 s5="Type F"; 232 break; 233 } 234 printf("\t%s, %s, %s, %s, %s\n",s1,s2,s3,s4,s5); 235 } 236 237 238 void 239 report_memory_info (int x) 240 { 241 if (x & 0x1) 242 printf ("Memory Range: Writeable\n"); 243 else 244 printf ("Memory Range: Not writeable (ROM)\n"); 245 246 if (x & 0x2) 247 printf ("Memory Range: Read-cacheable, write-through\n"); 248 else 249 printf ("Memory Range: Non-cacheable\n"); 250 251 if (x & 0x4) 252 printf ("Memory Range: Decode supports high address\n"); 253 else 254 printf ("Memory Range: Decode supports range length\n"); 255 256 switch ((x & 0x18) >> 3) { 257 case 0: 258 printf ("Memory Range: 8-bit memory only\n"); 259 break; 260 case 1: 261 printf ("Memory Range: 16-bit memory only\n"); 262 break; 263 case 2: 264 printf ("Memory Range: 8-bit and 16-bit memory supported\n"); 265 break; 266 #ifdef DIAGNOSTIC 267 case 3: 268 printf ("Memory Range: Reserved\n"); 269 break; 270 #endif 271 } 272 273 if (x & 0x20) 274 printf ("Memory Range: Memory is shadowable\n"); 275 else 276 printf ("Memory Range: Memory is not shadowable\n"); 277 278 if (x & 0x40) 279 printf ("Memory Range: Memory is an expansion ROM\n"); 280 else 281 printf ("Memory Range: Memory is not an expansion ROM\n"); 282 283 #ifdef DIAGNOSTIC 284 if (x & 0x80) 285 printf ("Memory Range: Reserved (Device is brain-damaged)\n"); 286 #endif 287 } 288 289 290 /* 291 * Small Resource Tag Handler 292 * 293 * Returns 1 if checksum was valid (and an END_TAG was received). 294 * Returns -1 if checksum was invalid (and an END_TAG was received). 295 * Returns 0 for other tags. 296 */ 297 int 298 handle_small_res(u_char *resinfo, int item, int len) 299 { 300 int i; 301 302 DEB(printf("*** ITEM 0x%04x len %d detected\n", item, len)); 303 304 switch (item) { 305 default: 306 printf("*** ITEM 0x%02x detected\n", item); 307 break; 308 case PNP_TAG_VERSION: 309 printf("PnP Version %d.%d, Vendor Version %d\n", 310 resinfo[0] >> 4, resinfo[0] & (0xf), resinfo[1]); 311 break; 312 case PNP_TAG_LOGICAL_DEVICE: 313 printf("\nLogical Device ID: %c%c%c%02x%02x 0x%08x #%d\n", 314 ((resinfo[0] & 0x7c) >> 2) + 64, 315 (((resinfo[0] & 0x03) << 3) | 316 ((resinfo[1] & 0xe0) >> 5)) + 64, 317 (resinfo[1] & 0x1f) + 64, 318 resinfo[2], resinfo[3], *(int *)(resinfo), 319 logdevs++); 320 321 if (resinfo[4] & 0x1) 322 printf ("\tDevice powers up active\n"); /* XXX */ 323 if (resinfo[4] & 0x2) 324 printf ("\tDevice supports I/O Range Check\n"); 325 if (resinfo[4] > 0x3) 326 printf ("\tReserved register funcs %02x\n", 327 resinfo[4]); 328 329 if (len == 6) 330 printf("\tVendor register funcs %02x\n", resinfo[5]); 331 break; 332 case PNP_TAG_COMPAT_DEVICE: 333 printf("Compatible Device ID: %c%c%c%02x%02x (%08x)\n", 334 ((resinfo[0] & 0x7c) >> 2) + 64, 335 (((resinfo[0] & 0x03) << 3) | 336 ((resinfo[1] & 0xe0) >> 5)) + 64, 337 (resinfo[1] & 0x1f) + 64, 338 resinfo[2], resinfo[3], *(int *)resinfo); 339 break; 340 case PNP_TAG_IRQ_FORMAT: 341 printf(" IRQ: "); 342 343 for (i = 0; i < 8; i++) 344 if (resinfo[0] & (1<<i)) 345 printf("%d ", i); 346 for (i = 0; i < 8; i++) 347 if (resinfo[1] & (1<<i)) 348 printf("%d ", i + 8); 349 if (len == 3) { 350 if (resinfo[2] & 0x1) 351 printf("IRQ: High true edge sensitive\n"); 352 if (resinfo[2] & 0x2) 353 printf("IRQ: Low true edge sensitive\n"); 354 if (resinfo[2] & 0x4) 355 printf("IRQ: High true level sensitive\n"); 356 if (resinfo[2] & 0x8) 357 printf("IRQ: Low true level sensitive\n"); 358 } else { 359 printf(" - only one type (true/edge)\n"); 360 } 361 break; 362 case PNP_TAG_DMA_FORMAT: 363 printf(" DMA: channel(s) "); 364 for (i = 0; i < 8; i++) 365 if (resinfo[0] & (1<<i)) 366 printf("%d ", i); 367 printf ("\n"); 368 report_dma_info (resinfo[1]); 369 break; 370 case PNP_TAG_START_DEPENDANT: 371 printf("TAG Start DF\n"); 372 if (len == 1) { 373 switch (resinfo[0]) { 374 case 0: 375 printf("Good Configuration\n"); 376 break; 377 case 1: 378 printf("Acceptable Configuration\n"); 379 break; 380 case 2: 381 printf("Sub-optimal Configuration\n"); 382 break; 383 } 384 } 385 break; 386 case PNP_TAG_END_DEPENDANT: 387 printf("TAG End DF\n"); 388 break; 389 case PNP_TAG_IO_RANGE: 390 printf(" I/O Range 0x%x .. 0x%x, alignment 0x%x, len 0x%x\n", 391 resinfo[1] + (resinfo[2] << 8), 392 resinfo[3] + (resinfo[4] << 8), 393 resinfo[5], resinfo[6] ); 394 if (resinfo[0]) 395 printf("\t[16-bit addr]\n"); 396 else 397 printf("\t[not 16-bit addr]\n"); 398 break; 399 case PNP_TAG_IO_FIXED: 400 printf (" FIXED I/O base address 0x%x length 0x%x\n", 401 resinfo[0] + ( (resinfo[1] & 3 ) << 8), /* XXX */ 402 resinfo[2]); 403 break; 404 #ifdef DIAGNOSTIC 405 case PNP_TAG_RESERVED: 406 printf("Reserved Tag Detected\n"); 407 break; 408 #endif 409 case PNP_TAG_VENDOR: 410 printf("*** Small Vendor Tag Detected\n"); 411 break; 412 case PNP_TAG_END: 413 printf("End Tag\n\n"); 414 /* XXX Record and Verify Checksum */ 415 return 1; 416 break; 417 } 418 return 0; 419 } 420 421 422 void 423 handle_large_res(u_char *resinfo, int item, int len) 424 { 425 int i; 426 427 DEB(printf("*** Large ITEM %d len %d found\n", item, len)); 428 switch (item) { 429 case PNP_TAG_MEMORY_RANGE: 430 report_memory_info(resinfo[0]); 431 printf("Memory range minimum address: 0x%x\n", 432 (resinfo[1] << 8) + (resinfo[2] << 16)); 433 printf("Memory range maximum address: 0x%x\n", 434 (resinfo[3] << 8) + (resinfo[4] << 16)); 435 printf("Memory range base alignment: 0x%x\n", 436 (i = (resinfo[5] + (resinfo[6] << 8))) ? i : (1 << 16)); 437 printf("Memory range length: 0x%x\n", 438 (resinfo[7] + (resinfo[8] << 8)) * 256); 439 break; 440 case PNP_TAG_ID_ANSI: 441 printf("Device Description: "); 442 443 for (i = 0; i < len; i++) { 444 if (resinfo[i]) /* XXX */ 445 printf("%c", resinfo[i]); 446 } 447 printf("\n"); 448 break; 449 case PNP_TAG_ID_UNICODE: 450 printf("ID String Unicode Detected (Undefined)\n"); 451 break; 452 case PNP_TAG_LARGE_VENDOR: 453 printf("Large Vendor Defined Detected\n"); 454 break; 455 case PNP_TAG_MEMORY32_RANGE: 456 printf("32bit Memory Range Desc Unimplemented\n"); 457 break; 458 case PNP_TAG_MEMORY32_FIXED: 459 printf("32bit Fixed Location Desc Unimplemented\n"); 460 break; 461 #ifdef DIAGNOSTIC 462 case PNP_TAG_LARGE_RESERVED: 463 printf("Large Reserved Tag Detected\n"); 464 break; 465 #endif 466 } 467 } 468 469 470 /* 471 * Dump all the information about configurations. 472 */ 473 void 474 dump_resdata(u_char *data, int csn) 475 { 476 int i, large_len; 477 478 u_char tag, *resinfo; 479 480 DDB(printf("\nCard assigned CSN #%d\n", csn)); 481 printf("Vendor ID %c%c%c%02x%02x (0x%08x), Serial Number 0x%08x\n", 482 ((data[0] & 0x7c) >> 2) + 64, 483 (((data[0] & 0x03) << 3) | ((data[1] & 0xe0) >> 5)) + 64, 484 (data[1] & 0x1f) + 64, data[2], data[3], 485 *(int *)&(data[0]), 486 *(int *)&(data[4])); 487 488 pnp_write(PNP_SET_CSN, csn); /* Move this out of this function XXX */ 489 outb(_PNP_ADDRESS, PNP_STATUS); 490 491 /* Allows up to 1kb of Resource Info, Should be plenty */ 492 for (i = 0; i < 1024; i++) { 493 if (!get_resource_info(&tag, 1)) 494 break; 495 496 if (PNP_RES_TYPE(tag) == 0) { 497 /* Handle small resouce data types */ 498 499 resinfo = malloc(PNP_SRES_LEN(tag)); 500 if (!get_resource_info(resinfo, PNP_SRES_LEN(tag))) 501 break; 502 503 if (handle_small_res(resinfo, PNP_SRES_NUM(tag), PNP_SRES_LEN(tag)) == 1) 504 break; 505 free(resinfo); 506 } else { 507 /* Handle large resouce data types */ 508 u_char buf[2]; 509 if (!get_resource_info((char *)buf, 2)) 510 break; 511 large_len = (buf[1] << 8) + buf[0]; 512 513 resinfo = malloc(large_len); 514 if (!get_resource_info(resinfo, large_len)) 515 break; 516 517 handle_large_res(resinfo, PNP_LRES_NUM(tag), large_len); 518 free(resinfo); 519 } 520 } 521 printf("Successfully got %d resources, %d logical fdevs\n", i, 522 logdevs); 523 printf("-- card select # 0x%04x\n", pnp_read(PNP_SET_CSN)); 524 printf("\nCSN %c%c%c%02x%02x (0x%08x), Serial Number 0x%08x\n", 525 ((data[0] & 0x7c) >> 2) + 64, 526 (((data[0] & 0x03) << 3) | ((data[1] & 0xe0) >> 5)) + 64, 527 (data[1] & 0x1f) + 64, data[2], data[3], 528 *(int *)&(data[0]), 529 *(int *)&(data[4])); 530 531 for (i=0; i<logdevs; i++) { 532 int j; 533 534 pnp_write(PNP_SET_LDN, i); 535 536 printf("\nLogical device #%d\n", pnp_read(PNP_SET_LDN) ); 537 printf("IO: "); 538 for (j=0; j<8; j++) 539 printf(" 0x%02x%02x", pnp_read(PNP_IO_BASE_HIGH(j)), 540 pnp_read(PNP_IO_BASE_LOW(j))); 541 printf("\nIRQ %d %d\n", 542 pnp_read(PNP_IRQ_LEVEL(0)), pnp_read(PNP_IRQ_LEVEL(1)) ); 543 printf("DMA %d %d\n", 544 pnp_read(PNP_DMA_CHANNEL(0)), pnp_read(PNP_DMA_CHANNEL(1)) ); 545 printf("IO range check 0x%02x activate 0x%02x\n", 546 pnp_read(PNP_IO_RANGE_CHECK), pnp_read(PNP_ACTIVATE) ); 547 } 548 } 549 550 551 /* 552 * Run the isolation protocol. Use rd_port as the READ_DATA port 553 * value (caller should try multiple READ_DATA locations before giving 554 * up). Upon exiting, all cards are aware that they should use rd_port 555 * as the READ_DATA port; 556 * 557 */ 558 int 559 isolation_protocol() 560 { 561 int csn; 562 u_char data[9]; 563 564 send_Initiation_LFSR(); 565 566 /* Reset CSN for All Cards */ 567 pnp_write(PNP_CONFIG_CONTROL, 0x04); 568 569 for (csn = 1; (csn < PNP_MAX_CARDS); csn++) { 570 /* Wake up cards without a CSN */ 571 logdevs = 0 ; 572 pnp_write(PNP_WAKE, 0); 573 pnp_write(PNP_SET_RD_DATA, rd_port); 574 outb(_PNP_ADDRESS, PNP_SERIAL_ISOLATION); 575 DELAY(1000); /* Delay 1 msec */ 576 577 if (get_serial(data)) 578 dump_resdata(data, csn); 579 else 580 break; 581 } 582 return csn - 1; 583 } 584 585 586 int 587 main(int argc, char **argv) 588 { 589 int num_pnp_devs; 590 591 #ifdef __i386__ 592 /* Hey what about a i386_iopl() call :) */ 593 if (open("/dev/io", O_RDONLY) < 0) 594 errx(1, "can't get I/O privilege"); 595 #endif 596 597 printf("Checking for Plug-n-Play devices...\n"); 598 599 /* Try various READ_DATA ports from 0x203-0x3ff */ 600 for (rd_port = 0x80; (rd_port < 0xff); rd_port += 0x10) { 601 DEB(printf("Trying Read_Port at %x...\n", (rd_port << 2) | 0x3) ); 602 num_pnp_devs = isolation_protocol(); 603 if (num_pnp_devs) 604 break; 605 } 606 if (!num_pnp_devs) { 607 printf("No Plug-n-Play devices were found\n"); 608 return (0); 609 } 610 return (0); 611 } 612