![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to isapnp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / bus|
Return to isapnp.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / drivers / bus |
1.1 ! root 1: /************************************************************************** ! 2: * ! 3: * isapnp.c -- Etherboot isapnp support for the 3Com 3c515 ! 4: * Written 2002-2003 by Timothy Legge <[email protected]> ! 5: * ! 6: * This program is free software; you can redistribute it and/or modify ! 7: * it under the terms of the GNU General Public License as published by ! 8: * the Free Software Foundation; either version 2 of the License, or ! 9: * (at your option) any later version. ! 10: * ! 11: * This program is distributed in the hope that it will be useful, ! 12: * but WITHOUT ANY WARRANTY; without even the implied warranty of ! 13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 14: * GNU General Public License for more details. ! 15: * ! 16: * You should have received a copy of the GNU General Public License ! 17: * along with this program; if not, write to the Free Software ! 18: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ! 19: * ! 20: * Portions of this code: ! 21: * Copyright (C) 2001 P.J.H.Fox ([email protected]) ! 22: * ! 23: * ! 24: * REVISION HISTORY: ! 25: * ================ ! 26: * Version 0.1 April 26, 2002 TJL ! 27: * Version 0.2 01/08/2003 TJL Moved outside the 3c515.c driver file ! 28: * Version 0.3 Sept 23, 2003 timlegge Change delay to currticks ! 29: * ! 30: * ! 31: * Generalised into an ISAPnP bus that can be used by more than just ! 32: * the 3c515 by Michael Brown <[email protected]> ! 33: * ! 34: ***************************************************************************/ ! 35: ! 36: /** @file ! 37: * ! 38: * ISAPnP bus support ! 39: * ! 40: * Etherboot orignally gained ISAPnP support in a very limited way for ! 41: * the 3c515 NIC. The current implementation is almost a complete ! 42: * rewrite based on the ISAPnP specification, with passing reference ! 43: * to the Linux ISAPnP code. ! 44: * ! 45: * There can be only one ISAPnP bus in a system. Once the read port ! 46: * is known and all cards have been allocated CSNs, there's nothing to ! 47: * be gained by re-scanning for cards. ! 48: * ! 49: * External code (e.g. the ISAPnP ROM prefix) may already know the ! 50: * read port address, in which case it can store it in ! 51: * #isapnp_read_port. Note that setting the read port address in this ! 52: * way will prevent further isolation from taking place; you should ! 53: * set the read port address only if you know that devices have ! 54: * already been allocated CSNs. ! 55: * ! 56: */ ! 57: ! 58: FILE_LICENCE ( GPL2_OR_LATER ); ! 59: ! 60: #include <stdint.h> ! 61: #include <stdlib.h> ! 62: #include <string.h> ! 63: #include <stdio.h> ! 64: #include <errno.h> ! 65: #include <ipxe/io.h> ! 66: #include <unistd.h> ! 67: #include <ipxe/isapnp.h> ! 68: ! 69: /** ! 70: * ISAPnP Read Port address. ! 71: * ! 72: * ROM prefix may be able to set this address, which is why this is ! 73: * non-static. ! 74: */ ! 75: uint16_t isapnp_read_port; ! 76: ! 77: static void isapnpbus_remove ( struct root_device *rootdev ); ! 78: ! 79: /* ! 80: * ISAPnP utility functions ! 81: * ! 82: */ ! 83: ! 84: #define ISAPNP_CARD_ID_FMT "ID %04x:%04x (\"%s\") serial %x" ! 85: #define ISAPNP_CARD_ID_DATA(identifier) \ ! 86: (identifier)->vendor_id, (identifier)->prod_id, \ ! 87: isa_id_string ( (identifier)->vendor_id, (identifier)->prod_id ), \ ! 88: (identifier)->serial ! 89: #define ISAPNP_DEV_ID_FMT "ID %04x:%04x (\"%s\")" ! 90: #define ISAPNP_DEV_ID_DATA(isapnp) \ ! 91: (isapnp)->vendor_id, (isapnp)->prod_id, \ ! 92: isa_id_string ( (isapnp)->vendor_id, (isapnp)->prod_id ) ! 93: ! 94: static inline void isapnp_write_address ( unsigned int address ) { ! 95: outb ( address, ISAPNP_ADDRESS ); ! 96: } ! 97: ! 98: static inline void isapnp_write_data ( unsigned int data ) { ! 99: outb ( data, ISAPNP_WRITE_DATA ); ! 100: } ! 101: ! 102: static inline unsigned int isapnp_read_data ( void ) { ! 103: return inb ( isapnp_read_port ); ! 104: } ! 105: ! 106: static inline void isapnp_write_byte ( unsigned int address, ! 107: unsigned int value ) { ! 108: isapnp_write_address ( address ); ! 109: isapnp_write_data ( value ); ! 110: } ! 111: ! 112: static inline unsigned int isapnp_read_byte ( unsigned int address ) { ! 113: isapnp_write_address ( address ); ! 114: return isapnp_read_data (); ! 115: } ! 116: ! 117: static inline unsigned int isapnp_read_word ( unsigned int address ) { ! 118: /* Yes, they're in big-endian order */ ! 119: return ( ( isapnp_read_byte ( address ) << 8 ) ! 120: | isapnp_read_byte ( address + 1 ) ); ! 121: } ! 122: ! 123: /** Inform cards of a new read port address */ ! 124: static inline void isapnp_set_read_port ( void ) { ! 125: isapnp_write_byte ( ISAPNP_READPORT, ( isapnp_read_port >> 2 ) ); ! 126: } ! 127: ! 128: /** ! 129: * Enter the Isolation state. ! 130: * ! 131: * Only cards currently in the Sleep state will respond to this ! 132: * command. ! 133: */ ! 134: static inline void isapnp_serialisolation ( void ) { ! 135: isapnp_write_address ( ISAPNP_SERIALISOLATION ); ! 136: } ! 137: ! 138: /** ! 139: * Enter the Wait for Key state. ! 140: * ! 141: * All cards will respond to this command, regardless of their current ! 142: * state. ! 143: */ ! 144: static inline void isapnp_wait_for_key ( void ) { ! 145: isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_WAIT_FOR_KEY ); ! 146: } ! 147: ! 148: /** ! 149: * Reset (i.e. remove) Card Select Number. ! 150: * ! 151: * Only cards currently in the Sleep state will respond to this ! 152: * command. ! 153: */ ! 154: static inline void isapnp_reset_csn ( void ) { ! 155: isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_RESET_CSN ); ! 156: } ! 157: ! 158: /** ! 159: * Place a specified card into the Config state. ! 160: * ! 161: * @v csn Card Select Number ! 162: * @ret None - ! 163: * @err None - ! 164: * ! 165: * Only cards currently in the Sleep, Isolation, or Config states will ! 166: * respond to this command. The card that has the specified CSN will ! 167: * enter the Config state, all other cards will enter the Sleep state. ! 168: */ ! 169: static inline void isapnp_wake ( uint8_t csn ) { ! 170: isapnp_write_byte ( ISAPNP_WAKE, csn ); ! 171: } ! 172: ! 173: static inline unsigned int isapnp_read_resourcedata ( void ) { ! 174: return isapnp_read_byte ( ISAPNP_RESOURCEDATA ); ! 175: } ! 176: ! 177: static inline unsigned int isapnp_read_status ( void ) { ! 178: return isapnp_read_byte ( ISAPNP_STATUS ); ! 179: } ! 180: ! 181: /** ! 182: * Assign a Card Select Number to a card, and enter the Config state. ! 183: * ! 184: * @v csn Card Select Number ! 185: * ! 186: * Only cards in the Isolation state will respond to this command. ! 187: * The isolation protocol is designed so that only one card will ! 188: * remain in the Isolation state by the time the isolation protocol ! 189: * completes. ! 190: */ ! 191: static inline void isapnp_write_csn ( unsigned int csn ) { ! 192: isapnp_write_byte ( ISAPNP_CARDSELECTNUMBER, csn ); ! 193: } ! 194: ! 195: static inline void isapnp_logicaldevice ( unsigned int logdev ) { ! 196: isapnp_write_byte ( ISAPNP_LOGICALDEVICENUMBER, logdev ); ! 197: } ! 198: ! 199: static inline void isapnp_activate ( unsigned int logdev ) { ! 200: isapnp_logicaldevice ( logdev ); ! 201: isapnp_write_byte ( ISAPNP_ACTIVATE, 1 ); ! 202: } ! 203: ! 204: static inline void isapnp_deactivate ( unsigned int logdev ) { ! 205: isapnp_logicaldevice ( logdev ); ! 206: isapnp_write_byte ( ISAPNP_ACTIVATE, 0 ); ! 207: } ! 208: ! 209: static inline unsigned int isapnp_read_iobase ( unsigned int index ) { ! 210: return isapnp_read_word ( ISAPNP_IOBASE ( index ) ); ! 211: } ! 212: ! 213: static inline unsigned int isapnp_read_irqno ( unsigned int index ) { ! 214: return isapnp_read_byte ( ISAPNP_IRQNO ( index ) ); ! 215: } ! 216: ! 217: static void isapnp_delay ( void ) { ! 218: udelay ( 1000 ); ! 219: } ! 220: ! 221: /** ! 222: * Linear feedback shift register. ! 223: * ! 224: * @v lfsr Current value of the LFSR ! 225: * @v input_bit Current input bit to the LFSR ! 226: * @ret lfsr Next value of the LFSR ! 227: * ! 228: * This routine implements the linear feedback shift register as ! 229: * described in Appendix B of the PnP ISA spec. The hardware ! 230: * implementation uses eight D-type latches and two XOR gates. I ! 231: * think this is probably the smallest possible implementation in ! 232: * software. Six instructions when input_bit is a constant 0 (for ! 233: * isapnp_send_key). :) ! 234: */ ! 235: static inline unsigned int isapnp_lfsr_next ( unsigned int lfsr, ! 236: unsigned int input_bit ) { ! 237: register uint8_t lfsr_next; ! 238: ! 239: lfsr_next = lfsr >> 1; ! 240: lfsr_next |= ( ( ( lfsr ^ lfsr_next ) ^ input_bit ) ) << 7; ! 241: return lfsr_next; ! 242: } ! 243: ! 244: /** ! 245: * Send the ISAPnP initiation key. ! 246: * ! 247: * Sending the key causes all ISAPnP cards that are currently in the ! 248: * Wait for Key state to transition into the Sleep state. ! 249: */ ! 250: static void isapnp_send_key ( void ) { ! 251: unsigned int i; ! 252: unsigned int lfsr; ! 253: ! 254: isapnp_delay(); ! 255: isapnp_write_address ( 0x00 ); ! 256: isapnp_write_address ( 0x00 ); ! 257: ! 258: lfsr = ISAPNP_LFSR_SEED; ! 259: for ( i = 0 ; i < 32 ; i++ ) { ! 260: isapnp_write_address ( lfsr ); ! 261: lfsr = isapnp_lfsr_next ( lfsr, 0 ); ! 262: } ! 263: } ! 264: ! 265: /** ! 266: * Compute ISAPnP identifier checksum ! 267: * ! 268: * @v identifier ISAPnP identifier ! 269: * @ret checksum Expected checksum value ! 270: */ ! 271: static unsigned int isapnp_checksum ( struct isapnp_identifier *identifier ) { ! 272: unsigned int i, j; ! 273: unsigned int lfsr; ! 274: unsigned int byte; ! 275: ! 276: lfsr = ISAPNP_LFSR_SEED; ! 277: for ( i = 0 ; i < 8 ; i++ ) { ! 278: byte = * ( ( ( uint8_t * ) identifier ) + i ); ! 279: for ( j = 0 ; j < 8 ; j++ ) { ! 280: lfsr = isapnp_lfsr_next ( lfsr, byte ); ! 281: byte >>= 1; ! 282: } ! 283: } ! 284: return lfsr; ! 285: } ! 286: ! 287: /* ! 288: * Read a byte of resource data from the current location ! 289: * ! 290: * @ret byte Byte of resource data ! 291: */ ! 292: static inline unsigned int isapnp_peek_byte ( void ) { ! 293: unsigned int i; ! 294: ! 295: /* Wait for data to be ready */ ! 296: for ( i = 0 ; i < 20 ; i++ ) { ! 297: if ( isapnp_read_status() & 0x01 ) { ! 298: /* Byte ready - read it */ ! 299: return isapnp_read_resourcedata(); ! 300: } ! 301: isapnp_delay(); ! 302: } ! 303: /* Data never became ready - return 0xff */ ! 304: return 0xff; ! 305: } ! 306: ! 307: /** ! 308: * Read resource data. ! 309: * ! 310: * @v buf Buffer in which to store data, or NULL ! 311: * @v bytes Number of bytes to read ! 312: * ! 313: * Resource data is read from the current location. If #buf is NULL, ! 314: * the data is discarded. ! 315: */ ! 316: static void isapnp_peek ( void *buf, size_t len ) { ! 317: unsigned int i; ! 318: unsigned int byte; ! 319: ! 320: for ( i = 0 ; i < len ; i++) { ! 321: byte = isapnp_peek_byte(); ! 322: if ( buf ) ! 323: * ( ( uint8_t * ) buf + i ) = byte; ! 324: } ! 325: } ! 326: ! 327: /** ! 328: * Find a tag within the resource data. ! 329: * ! 330: * @v wanted_tag The tag that we're looking for ! 331: * @v buf Buffer in which to store the tag's contents ! 332: * @v len Length of buffer ! 333: * @ret rc Return status code ! 334: * ! 335: * Scan through the resource data until we find a particular tag, and ! 336: * read its contents into a buffer. ! 337: */ ! 338: static int isapnp_find_tag ( unsigned int wanted_tag, void *buf, size_t len ) { ! 339: unsigned int tag; ! 340: unsigned int tag_len; ! 341: ! 342: DBG2 ( "ISAPnP read tag" ); ! 343: do { ! 344: tag = isapnp_peek_byte(); ! 345: if ( ISAPNP_IS_SMALL_TAG ( tag ) ) { ! 346: tag_len = ISAPNP_SMALL_TAG_LEN ( tag ); ! 347: tag = ISAPNP_SMALL_TAG_NAME ( tag ); ! 348: } else { ! 349: tag_len = ( isapnp_peek_byte() + ! 350: ( isapnp_peek_byte() << 8 ) ); ! 351: tag = ISAPNP_LARGE_TAG_NAME ( tag ); ! 352: } ! 353: DBG2 ( " %02x (%02x)", tag, tag_len ); ! 354: if ( tag == wanted_tag ) { ! 355: if ( len > tag_len ) ! 356: len = tag_len; ! 357: isapnp_peek ( buf, len ); ! 358: DBG2 ( "\n" ); ! 359: return 0; ! 360: } else { ! 361: isapnp_peek ( NULL, tag_len ); ! 362: } ! 363: } while ( tag != ISAPNP_TAG_END ); ! 364: DBG2 ( "\n" ); ! 365: return -ENOENT; ! 366: } ! 367: ! 368: /** ! 369: * Find specified Logical Device ID tag ! 370: * ! 371: * @v logdev Logical device ID ! 372: * @v logdevid Logical device ID structure to fill in ! 373: * @ret rc Return status code ! 374: */ ! 375: static int isapnp_find_logdevid ( unsigned int logdev, ! 376: struct isapnp_logdevid *logdevid ) { ! 377: unsigned int i; ! 378: int rc; ! 379: ! 380: for ( i = 0 ; i <= logdev ; i++ ) { ! 381: if ( ( rc = isapnp_find_tag ( ISAPNP_TAG_LOGDEVID, logdevid, ! 382: sizeof ( *logdevid ) ) ) != 0 ) ! 383: return rc; ! 384: } ! 385: return 0; ! 386: } ! 387: ! 388: /** ! 389: * Try isolating ISAPnP cards at the current read port. ! 390: * ! 391: * @ret \>0 Number of ISAPnP cards found ! 392: * @ret 0 There are no ISAPnP cards in the system ! 393: * @ret \<0 A conflict was detected; try a new read port ! 394: * @err None - ! 395: * ! 396: * The state diagram on page 18 (PDF page 24) of the PnP ISA spec ! 397: * gives the best overview of what happens here. ! 398: */ ! 399: static int isapnp_try_isolate ( void ) { ! 400: struct isapnp_identifier identifier; ! 401: unsigned int i, j; ! 402: unsigned int seen_55aa, seen_life; ! 403: unsigned int csn = 0; ! 404: unsigned int data; ! 405: unsigned int byte; ! 406: ! 407: DBG ( "ISAPnP attempting isolation at read port %04x\n", ! 408: isapnp_read_port ); ! 409: ! 410: /* Place all cards into the Sleep state, whatever state ! 411: * they're currently in. ! 412: */ ! 413: isapnp_wait_for_key(); ! 414: isapnp_send_key(); ! 415: ! 416: /* Reset all assigned CSNs */ ! 417: isapnp_reset_csn(); ! 418: isapnp_delay(); ! 419: isapnp_delay(); ! 420: ! 421: /* Place all cards into the Isolation state */ ! 422: isapnp_wait_for_key (); ! 423: isapnp_send_key(); ! 424: isapnp_wake ( 0x00 ); ! 425: ! 426: /* Set the read port */ ! 427: isapnp_set_read_port(); ! 428: isapnp_delay(); ! 429: ! 430: while ( 1 ) { ! 431: ! 432: /* All cards that do not have assigned CSNs are ! 433: * currently in the Isolation state, each time we go ! 434: * through this loop. ! 435: */ ! 436: ! 437: /* Initiate serial isolation */ ! 438: isapnp_serialisolation(); ! 439: isapnp_delay(); ! 440: ! 441: /* Read identifier serially via the ISAPnP read port. */ ! 442: memset ( &identifier, 0, sizeof ( identifier ) ); ! 443: seen_55aa = seen_life = 0; ! 444: for ( i = 0 ; i < 9 ; i++ ) { ! 445: byte = 0; ! 446: for ( j = 0 ; j < 8 ; j++ ) { ! 447: data = isapnp_read_data(); ! 448: isapnp_delay(); ! 449: data = ( ( data << 8 ) | isapnp_read_data() ); ! 450: isapnp_delay(); ! 451: byte >>= 1; ! 452: if ( data != 0xffff ) { ! 453: seen_life++; ! 454: if ( data == 0x55aa ) { ! 455: byte |= 0x80; ! 456: seen_55aa++; ! 457: } ! 458: } ! 459: } ! 460: *( ( ( uint8_t * ) &identifier ) + i ) = byte; ! 461: } ! 462: ! 463: /* If we didn't see any 55aa patterns, stop here */ ! 464: if ( ! seen_55aa ) { ! 465: if ( csn ) { ! 466: DBG ( "ISAPnP found no more cards\n" ); ! 467: } else { ! 468: if ( seen_life ) { ! 469: DBG ( "ISAPnP saw life but no cards, " ! 470: "trying new read port\n" ); ! 471: csn = -1; ! 472: } else { ! 473: DBG ( "ISAPnP saw no signs of life, " ! 474: "abandoning isolation\n" ); ! 475: } ! 476: } ! 477: break; ! 478: } ! 479: ! 480: /* If the checksum was invalid stop here */ ! 481: if ( identifier.checksum != isapnp_checksum ( &identifier) ) { ! 482: DBG ( "ISAPnP found malformed card " ! 483: ISAPNP_CARD_ID_FMT "\n with checksum %02x " ! 484: "(should be %02x), trying new read port\n", ! 485: ISAPNP_CARD_ID_DATA ( &identifier ), ! 486: identifier.checksum, ! 487: isapnp_checksum ( &identifier) ); ! 488: csn = -1; ! 489: break; ! 490: } ! 491: ! 492: /* Give the device a CSN */ ! 493: csn++; ! 494: DBG ( "ISAPnP found card " ISAPNP_CARD_ID_FMT ! 495: ", assigning CSN %02x\n", ! 496: ISAPNP_CARD_ID_DATA ( &identifier ), csn ); ! 497: ! 498: isapnp_write_csn ( csn ); ! 499: isapnp_delay(); ! 500: ! 501: /* Send this card back to Sleep and force all cards ! 502: * without a CSN into Isolation state ! 503: */ ! 504: isapnp_wake ( 0x00 ); ! 505: isapnp_delay(); ! 506: } ! 507: ! 508: /* Place all cards in Wait for Key state */ ! 509: isapnp_wait_for_key(); ! 510: ! 511: /* Return number of cards found */ ! 512: if ( csn > 0 ) { ! 513: DBG ( "ISAPnP found %d cards at read port %04x\n", ! 514: csn, isapnp_read_port ); ! 515: } ! 516: return csn; ! 517: } ! 518: ! 519: /** ! 520: * Find a valid read port and isolate all ISAPnP cards. ! 521: * ! 522: */ ! 523: static void isapnp_isolate ( void ) { ! 524: for ( isapnp_read_port = ISAPNP_READ_PORT_START ; ! 525: isapnp_read_port <= ISAPNP_READ_PORT_MAX ; ! 526: isapnp_read_port += ISAPNP_READ_PORT_STEP ) { ! 527: /* Avoid problematic locations such as the NE2000 ! 528: * probe space ! 529: */ ! 530: if ( ( isapnp_read_port >= 0x280 ) && ! 531: ( isapnp_read_port <= 0x380 ) ) ! 532: continue; ! 533: ! 534: /* If we detect any ISAPnP cards at this location, stop */ ! 535: if ( isapnp_try_isolate() >= 0 ) ! 536: return; ! 537: } ! 538: } ! 539: ! 540: /** ! 541: * Activate or deactivate an ISAPnP device. ! 542: * ! 543: * @v isapnp ISAPnP device ! 544: * @v activation True to enable, False to disable the device ! 545: * @ret None - ! 546: * @err None - ! 547: * ! 548: * This routine simply activates the device in its current ! 549: * configuration, or deactivates the device. It does not attempt any ! 550: * kind of resource arbitration. ! 551: * ! 552: */ ! 553: void isapnp_device_activation ( struct isapnp_device *isapnp, ! 554: int activation ) { ! 555: /* Wake the card and select the logical device */ ! 556: isapnp_wait_for_key (); ! 557: isapnp_send_key (); ! 558: isapnp_wake ( isapnp->csn ); ! 559: isapnp_logicaldevice ( isapnp->logdev ); ! 560: ! 561: /* Activate/deactivate the logical device */ ! 562: isapnp_activate ( activation ); ! 563: isapnp_delay(); ! 564: ! 565: /* Return all cards to Wait for Key state */ ! 566: isapnp_wait_for_key (); ! 567: ! 568: DBG ( "ISAPnP %s device %02x:%02x\n", ! 569: ( activation ? "activated" : "deactivated" ), ! 570: isapnp->csn, isapnp->logdev ); ! 571: } ! 572: ! 573: /** ! 574: * Probe an ISAPnP device ! 575: * ! 576: * @v isapnp ISAPnP device ! 577: * @ret rc Return status code ! 578: * ! 579: * Searches for a driver for the ISAPnP device. If a driver is found, ! 580: * its probe() routine is called. ! 581: */ ! 582: static int isapnp_probe ( struct isapnp_device *isapnp ) { ! 583: struct isapnp_driver *driver; ! 584: struct isapnp_device_id *id; ! 585: unsigned int i; ! 586: int rc; ! 587: ! 588: DBG ( "Adding ISAPnP device %02x:%02x (%04x:%04x (\"%s\") " ! 589: "io %x irq %d)\n", isapnp->csn, isapnp->logdev, ! 590: isapnp->vendor_id, isapnp->prod_id, ! 591: isa_id_string ( isapnp->vendor_id, isapnp->prod_id ), ! 592: isapnp->ioaddr, isapnp->irqno ); ! 593: ! 594: for_each_table_entry ( driver, ISAPNP_DRIVERS ) { ! 595: for ( i = 0 ; i < driver->id_count ; i++ ) { ! 596: id = &driver->ids[i]; ! 597: if ( id->vendor_id != isapnp->vendor_id ) ! 598: continue; ! 599: if ( ISA_PROD_ID ( id->prod_id ) != ! 600: ISA_PROD_ID ( isapnp->prod_id ) ) ! 601: continue; ! 602: isapnp->driver = driver; ! 603: isapnp->dev.driver_name = id->name; ! 604: DBG ( "...using driver %s\n", isapnp->dev.driver_name ); ! 605: if ( ( rc = driver->probe ( isapnp, id ) ) != 0 ) { ! 606: DBG ( "......probe failed\n" ); ! 607: continue; ! 608: } ! 609: return 0; ! 610: } ! 611: } ! 612: ! 613: DBG ( "...no driver found\n" ); ! 614: return -ENOTTY; ! 615: } ! 616: ! 617: /** ! 618: * Remove an ISAPnP device ! 619: * ! 620: * @v isapnp ISAPnP device ! 621: */ ! 622: static void isapnp_remove ( struct isapnp_device *isapnp ) { ! 623: isapnp->driver->remove ( isapnp ); ! 624: DBG ( "Removed ISAPnP device %02x:%02x\n", ! 625: isapnp->csn, isapnp->logdev ); ! 626: } ! 627: ! 628: /** ! 629: * Probe ISAPnP root bus ! 630: * ! 631: * @v rootdev ISAPnP bus root device ! 632: * ! 633: * Scans the ISAPnP bus for devices and registers all devices it can ! 634: * find. ! 635: */ ! 636: static int isapnpbus_probe ( struct root_device *rootdev ) { ! 637: struct isapnp_device *isapnp = NULL; ! 638: struct isapnp_identifier identifier; ! 639: struct isapnp_logdevid logdevid; ! 640: unsigned int csn; ! 641: unsigned int logdev; ! 642: int rc; ! 643: ! 644: /* Perform isolation if it hasn't yet been done */ ! 645: if ( ! isapnp_read_port ) ! 646: isapnp_isolate(); ! 647: ! 648: for ( csn = 1 ; csn <= 0xff ; csn++ ) { ! 649: for ( logdev = 0 ; logdev <= 0xff ; logdev++ ) { ! 650: ! 651: /* Allocate struct isapnp_device */ ! 652: if ( ! isapnp ) ! 653: isapnp = malloc ( sizeof ( *isapnp ) ); ! 654: if ( ! isapnp ) { ! 655: rc = -ENOMEM; ! 656: goto err; ! 657: } ! 658: memset ( isapnp, 0, sizeof ( *isapnp ) ); ! 659: isapnp->csn = csn; ! 660: isapnp->logdev = logdev; ! 661: ! 662: /* Wake the card */ ! 663: isapnp_wait_for_key(); ! 664: isapnp_send_key(); ! 665: isapnp_wake ( csn ); ! 666: ! 667: /* Read the card identifier */ ! 668: isapnp_peek ( &identifier, sizeof ( identifier ) ); ! 669: ! 670: /* No card with this CSN; stop here */ ! 671: if ( identifier.vendor_id & 0x80 ) ! 672: goto done; ! 673: ! 674: /* Find the Logical Device ID tag */ ! 675: if ( ( rc = isapnp_find_logdevid ( logdev, ! 676: &logdevid ) ) != 0){ ! 677: /* No more logical devices; go to next CSN */ ! 678: break; ! 679: } ! 680: ! 681: /* Select the logical device */ ! 682: isapnp_logicaldevice ( logdev ); ! 683: ! 684: /* Populate struct isapnp_device */ ! 685: isapnp->vendor_id = logdevid.vendor_id; ! 686: isapnp->prod_id = logdevid.prod_id; ! 687: isapnp->ioaddr = isapnp_read_iobase ( 0 ); ! 688: isapnp->irqno = isapnp_read_irqno ( 0 ); ! 689: ! 690: /* Return all cards to Wait for Key state */ ! 691: isapnp_wait_for_key(); ! 692: ! 693: /* Add to device hierarchy */ ! 694: snprintf ( isapnp->dev.name, ! 695: sizeof ( isapnp->dev.name ), ! 696: "ISAPnP%02x:%02x", csn, logdev ); ! 697: isapnp->dev.desc.bus_type = BUS_TYPE_ISAPNP; ! 698: isapnp->dev.desc.vendor = isapnp->vendor_id; ! 699: isapnp->dev.desc.device = isapnp->prod_id; ! 700: isapnp->dev.desc.ioaddr = isapnp->ioaddr; ! 701: isapnp->dev.desc.irq = isapnp->irqno; ! 702: isapnp->dev.parent = &rootdev->dev; ! 703: list_add ( &isapnp->dev.siblings, ! 704: &rootdev->dev.children ); ! 705: INIT_LIST_HEAD ( &isapnp->dev.children ); ! 706: ! 707: /* Look for a driver */ ! 708: if ( isapnp_probe ( isapnp ) == 0 ) { ! 709: /* isapnpdev registered, we can drop our ref */ ! 710: isapnp = NULL; ! 711: } else { ! 712: /* Not registered; re-use struct */ ! 713: list_del ( &isapnp->dev.siblings ); ! 714: } ! 715: } ! 716: } ! 717: ! 718: done: ! 719: free ( isapnp ); ! 720: return 0; ! 721: ! 722: err: ! 723: free ( isapnp ); ! 724: isapnpbus_remove ( rootdev ); ! 725: return rc; ! 726: } ! 727: ! 728: /** ! 729: * Remove ISAPnP root bus ! 730: * ! 731: * @v rootdev ISAPnP bus root device ! 732: */ ! 733: static void isapnpbus_remove ( struct root_device *rootdev ) { ! 734: struct isapnp_device *isapnp; ! 735: struct isapnp_device *tmp; ! 736: ! 737: list_for_each_entry_safe ( isapnp, tmp, &rootdev->dev.children, ! 738: dev.siblings ) { ! 739: isapnp_remove ( isapnp ); ! 740: list_del ( &isapnp->dev.siblings ); ! 741: free ( isapnp ); ! 742: } ! 743: } ! 744: ! 745: /** ISAPnP bus root device driver */ ! 746: static struct root_driver isapnp_root_driver = { ! 747: .probe = isapnpbus_probe, ! 748: .remove = isapnpbus_remove, ! 749: }; ! 750: ! 751: /** ISAPnP bus root device */ ! 752: struct root_device isapnp_root_device __root_device = { ! 753: .dev = { .name = "ISAPnP" }, ! 754: .driver = &isapnp_root_driver, ! 755: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.