src/drivers/bus/isapnp.c

   1 /**************************************************************************
   2 *
   3 *    isapnp.c -- Etherboot isapnp support for the 3Com 3c515
   4 *    Written 2002-2003 by Timothy Legge <tlegge@rogers.com>
   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 (fox@roestock.demon.co.uk)
  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 <mbrown@fensystems.co.uk>
  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  * However, we shouldn't make scanning the ISAPnP bus an INIT_FN(),
  50  * because even ISAPnP probing can still screw up other devices on the
  51  * ISA bus.  We therefore probe only when we are first asked to find
  52  * an ISAPnP device.
  53  *
  54  * External code (e.g. the ISAPnP ROM prefix) may already know the
  55  * read port address, in which case it can store it in
  56  * #isapnp_read_port.  Note that setting the read port address in this
  57  * way will prevent further isolation from taking place; you should
  58  * set the read port address only if you know that devices have
  59  * already been allocated CSNs.
  60  *
  61  */
  62
  63 #include "string.h"
  64 #include "timer.h"
  65 #include "io.h"
  66 #include "console.h"
  67 #include "dev.h"
  68 #include "isapnp.h"
  69
  70 /**
  71  * ISAPnP Read Port address.
  72  *
  73  */
  74 uint16_t isapnp_read_port;
  75
  76 /**
  77  * Highest assigned CSN.
  78  *
  79  * Note that @b we do not necessarily assign CSNs; it could be done by
  80  * the PnP BIOS instead.  We therefore set this only when we first try
  81  * to Wake[CSN] a device and find that there's nothing there.  Page 16
  82  * (PDF page 22) of the ISAPnP spec states that "Valid Card Select
  83  * Numbers for identified ISA cards range from 1 to 255 and must be
  84  * assigned sequentially starting from 1", so we are (theoretically,
  85  * at least) safe to assume that there are no ISAPnP cards at CSNs
  86  * higher than the first unused CSN.
  87  *
  88  */
  89 static uint8_t isapnp_max_csn = 0xff;
  90
  91 /*
  92  * ISAPnP utility functions
  93  *
  94  */
  95
  96 #define ISAPNP_CARD_ID_FMT "ID %hx:%hx (\"%s\") serial %x"
  97 #define ISAPNP_CARD_ID_DATA(identifier)                                   \
  98         (identifier)->vendor_id, (identifier)->prod_id,                   \
  99         isa_id_string ( (identifier)->vendor_id, (identifier)->prod_id ), \
 100         (identifier)->serial
 101 #define ISAPNP_DEV_ID_FMT "ID %hx:%hx (\"%s\")"
 102 #define ISAPNP_DEV_ID_DATA(isapnp)                                        \
 103         (isapnp)->vendor_id, (isapnp)->prod_id,                           \
 104         isa_id_string ( (isapnp)->vendor_id, (isapnp)->prod_id )
 105
 106 static inline void isapnp_write_address ( uint8_t address ) {
 107         outb ( address, ISAPNP_ADDRESS );
 108 }
 109
 110 static inline void isapnp_write_data ( uint8_t data ) {
 111         outb ( data, ISAPNP_WRITE_DATA );
 112 }
 113
 114 static inline uint8_t isapnp_read_data ( void ) {
 115         return inb ( isapnp_read_port );
 116 }
 117
 118 static inline void isapnp_write_byte ( uint8_t address, uint8_t value ) {
 119         isapnp_write_address ( address );
 120         isapnp_write_data ( value );
 121 }
 122
 123 static inline uint8_t isapnp_read_byte ( uint8_t address ) {
 124         isapnp_write_address ( address );
 125         return isapnp_read_data ();
 126 }
 127
 128 static inline uint16_t isapnp_read_word ( uint8_t address ) {
 129         /* Yes, they're in big-endian order */
 130         return ( ( isapnp_read_byte ( address ) << 8 )
 131                  + isapnp_read_byte ( address + 1 ) );
 132 }
 133
 134 /** Inform cards of a new read port address */
 135 static inline void isapnp_set_read_port ( void ) {
 136         isapnp_write_byte ( ISAPNP_READPORT, isapnp_read_port >> 2 );
 137 }
 138
 139 /**
 140  * Enter the Isolation state.
 141  *
 142  * Only cards currently in the Sleep state will respond to this
 143  * command.
 144  *
 145  */
 146 static inline void isapnp_serialisolation ( void ) {
 147         isapnp_write_address ( ISAPNP_SERIALISOLATION );
 148 }
 149
 150 /**
 151  * Enter the Wait for Key state.
 152  *
 153  * All cards will respond to this command, regardless of their current
 154  * state.
 155  *
 156  */
 157 static inline void isapnp_wait_for_key ( void ) {
 158         isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_WAIT_FOR_KEY );
 159 }
 160
 161 /**
 162  * Reset (i.e. remove) Card Select Number.
 163  *
 164  * Only cards currently in the Sleep state will respond to this
 165  * command.
 166  *
 167  */
 168 static inline void isapnp_reset_csn ( void ) {
 169         isapnp_write_byte ( ISAPNP_CONFIGCONTROL, ISAPNP_CONFIG_RESET_CSN );
 170 }
 171
 172 /**
 173  * Place a specified card into the Config state.
 174  *
 175  * @v csn               Card Select Number
 176  * @ret None            -
 177  * @err None            -
 178  *
 179  * Only cards currently in the Sleep, Isolation, or Config states will
 180  * respond to this command.  The card that has the specified CSN will
 181  * enter the Config state, all other cards will enter the Sleep state.
 182  *
 183  */
 184 static inline void isapnp_wake ( uint8_t csn ) {
 185         isapnp_write_byte ( ISAPNP_WAKE, csn );
 186 }
 187
 188 static inline uint8_t isapnp_read_resourcedata ( void ) {
 189         return isapnp_read_byte ( ISAPNP_RESOURCEDATA );
 190 }
 191
 192 static inline uint8_t isapnp_read_status ( void ) {
 193         return isapnp_read_byte ( ISAPNP_STATUS );
 194 }
 195
 196 /**
 197  * Assign a Card Select Number to a card, and enter the Config state.
 198  *
 199  * @v csn               Card Select Number
 200  * @ret None            -
 201  * @err None            -
 202  *
 203  * Only cards in the Isolation state will respond to this command.
 204  * The isolation protocol is designed so that only one card will
 205  * remain in the Isolation state by the time the isolation protocol
 206  * completes.
 207  *
 208  */
 209 static inline void isapnp_write_csn ( uint8_t csn ) {
 210         isapnp_write_byte ( ISAPNP_CARDSELECTNUMBER, csn );
 211 }
 212
 213 static inline void isapnp_logicaldevice ( uint8_t logdev ) {
 214         isapnp_write_byte ( ISAPNP_LOGICALDEVICENUMBER, logdev );
 215 }
 216
 217 static inline void isapnp_activate ( uint8_t logdev ) {
 218         isapnp_logicaldevice ( logdev );
 219         isapnp_write_byte ( ISAPNP_ACTIVATE, 1 );
 220 }
 221
 222 static inline void isapnp_deactivate ( uint8_t logdev ) {
 223         isapnp_logicaldevice ( logdev );
 224         isapnp_write_byte ( ISAPNP_ACTIVATE, 0 );
 225 }
 226
 227 static inline uint16_t isapnp_read_iobase ( unsigned int index ) {
 228         return isapnp_read_word ( ISAPNP_IOBASE ( index ) );
 229 }
 230
 231 static inline uint8_t isapnp_read_irqno ( unsigned int index ) {
 232         return isapnp_read_byte ( ISAPNP_IRQNO ( index ) );
 233 }
 234
 235 static void isapnp_delay ( void ) {
 236         udelay ( 1000 );
 237 }
 238
 239 /**
 240  * Linear feedback shift register.
 241  *
 242  * @v lfsr              Current value of the LFSR
 243  * @v input_bit         Current input bit to the LFSR
 244  * @ret lfsr            Next value of the LFSR
 245  * @err None            -
 246  *
 247  * This routine implements the linear feedback shift register as
 248  * described in Appendix B of the PnP ISA spec.  The hardware
 249  * implementation uses eight D-type latches and two XOR gates.  I
 250  * think this is probably the smallest possible implementation in
 251  * software.  Six instructions when input_bit is a constant 0 (for
 252  * isapnp_send_key).  :)
 253  *
 254  */
 255 static inline uint8_t isapnp_lfsr_next ( uint8_t lfsr, int input_bit ) {
 256         register uint8_t lfsr_next;
 257
 258         lfsr_next = lfsr >> 1;
 259         lfsr_next |= ( ( ( lfsr ^ lfsr_next ) ^ input_bit ) ) << 7;
 260         return lfsr_next;
 261 }
 262
 263 /**
 264  * Send the ISAPnP initiation key.
 265  *
 266  * Sending the key causes all ISAPnP cards that are currently in the
 267  * Wait for Key state to transition into the Sleep state.
 268  *
 269  */
 270 static void isapnp_send_key ( void ) {
 271         unsigned int i;
 272         uint8_t lfsr;
 273
 274         isapnp_delay();
 275         isapnp_write_address ( 0x00 );
 276         isapnp_write_address ( 0x00 );
 277
 278         lfsr = ISAPNP_LFSR_SEED;
 279         for ( i = 0 ; i < 32 ; i++ ) {
 280                 isapnp_write_address ( lfsr );
 281                 lfsr = isapnp_lfsr_next ( lfsr, 0 );
 282         }
 283 }
 284
 285 /**
 286  * Compute ISAPnP identifier checksum
 287  *
 288  * @v identifier                ISAPnP identifier
 289  * @ret checksum                Expected checksum value
 290  * @err None                    -
 291  *
 292  */
 293 static uint8_t isapnp_checksum ( struct isapnp_identifier *identifier ) {
 294         int i, j;
 295         uint8_t lfsr;
 296         uint8_t byte;
 297
 298         lfsr = ISAPNP_LFSR_SEED;
 299         for ( i = 0 ; i < 8 ; i++ ) {
 300                 byte = ( (char *) identifier )[i];
 301                 for ( j = 0 ; j < 8 ; j++ ) {
 302                         lfsr = isapnp_lfsr_next ( lfsr, byte );
 303                         byte >>= 1;
 304                 }
 305         }
 306         return lfsr;
 307 }
 308
 309 /*
 310  * Read a byte of resource data from the current location
 311  *
 312  */
 313 static inline uint8_t isapnp_peek_byte ( void ) {
 314         int i;
 315
 316         /* Wait for data to be ready */
 317         for ( i = 0 ; i < 20 ; i ++ ) {
 318                 if ( isapnp_read_status() & 0x01 ) {
 319                         /* Byte ready - read it */
 320                         return isapnp_read_resourcedata();
 321                 }
 322                 isapnp_delay ();
 323         }
 324         /* Data never became ready - return 0xff */
 325         return 0xff;
 326 }
 327
 328 /**
 329  * Read resource data.
 330  *
 331  * @v buf               Buffer in which to store data, or NULL
 332  * @v bytes             Number of bytes to read
 333  * @ret None            -
 334  * @err None            -
 335  *
 336  * Resource data is read from the current location.  If #buf is NULL,
 337  * the data is discarded.
 338  *
 339  */
 340 static void isapnp_peek ( uint8_t *buf, size_t bytes ) {
 341         unsigned int i;
 342         uint8_t byte;
 343
 344         for ( i = 0 ; i < bytes ; i++) {
 345                 byte = isapnp_peek_byte();
 346                 if ( buf ) {
 347                         buf[i] = byte;
 348                 }
 349         }
 350 }
 351
 352 /**
 353  * Find a tag within the resource data.
 354  *
 355  * @v wanted_tag        The tag that we're looking for
 356  * @v buf               Buffer in which to store the tag's contents
 357  * @ret True            Tag was found
 358  * @ret False           Tag was not found
 359  * @err None            -
 360  *
 361  * Scan through the resource data until we find a particular tag, and
 362  * read its contents into a buffer.  It is the caller's responsibility
 363  * to ensure that #buf is large enough to contain a tag of the
 364  * requested size.
 365  *
 366  */
 367 static int isapnp_find_tag ( uint8_t wanted_tag, uint8_t *buf ) {
 368         uint8_t tag;
 369         uint16_t len;
 370
 371         DBG2 ( "ISAPnP read tag" );
 372         do {
 373                 tag = isapnp_peek_byte();
 374                 if ( ISAPNP_IS_SMALL_TAG ( tag ) ) {
 375                         len = ISAPNP_SMALL_TAG_LEN ( tag );
 376                         tag = ISAPNP_SMALL_TAG_NAME ( tag );
 377                 } else {
 378                         len = isapnp_peek_byte() + ( isapnp_peek_byte() << 8 );
 379                         tag = ISAPNP_LARGE_TAG_NAME ( tag );
 380                 }
 381                 DBG2 ( " %hhx (%hhx)", tag, len );
 382                 if ( tag == wanted_tag ) {
 383                         isapnp_peek ( buf, len );
 384                         DBG2 ( "\n" );
 385                         return 1;
 386                 } else {
 387                         isapnp_peek ( NULL, len );
 388                 }
 389         } while ( tag != ISAPNP_TAG_END );
 390         DBG2 ( "\n" );
 391         return 0;
 392 }
 393
 394 /**
 395  * Try isolating ISAPnP cards at the current read port.
 396  *
 397  * @ret \>0             Number of ISAPnP cards found
 398  * @ret 0               There are no ISAPnP cards in the system
 399  * @ret \<0             A conflict was detected; try a new read port
 400  * @err None            -
 401  *
 402  * The state diagram on page 18 (PDF page 24) of the PnP ISA spec
 403  * gives the best overview of what happens here.
 404  *
 405  */
 406 static int isapnp_try_isolate ( void ) {
 407         struct isapnp_identifier identifier;
 408         unsigned int i, j;
 409         unsigned int seen_55aa, seen_life;
 410         unsigned int csn = 0;
 411         uint16_t data;
 412         uint8_t byte;
 413
 414         DBG ( "ISAPnP attempting isolation at read port %hx\n",
 415               isapnp_read_port );
 416
 417         /* Place all cards into the Sleep state, whatever state
 418          * they're currently in.
 419          */
 420         isapnp_wait_for_key ();
 421         isapnp_send_key ();
 422
 423         /* Reset all assigned CSNs */
 424         isapnp_reset_csn ();
 425         isapnp_delay();
 426         isapnp_delay();
 427
 428         /* Place all cards into the Isolation state */
 429         isapnp_wait_for_key ();
 430         isapnp_send_key ();
 431         isapnp_wake ( 0x00 );
 432
 433         /* Set the read port */
 434         isapnp_set_read_port ();
 435         isapnp_delay();
 436
 437         while ( 1 ) {
 438
 439                 /* All cards that do not have assigned CSNs are
 440                  * currently in the Isolation state, each time we go
 441                  * through this loop.
 442                  */
 443
 444                 /* Initiate serial isolation */
 445                 isapnp_serialisolation ();
 446                 isapnp_delay();
 447
 448                 /* Read identifier serially via the ISAPnP read port. */
 449                 memset ( &identifier, 0, sizeof ( identifier ) );
 450                 seen_55aa = seen_life = 0;
 451                 for ( i = 0 ; i < 9 ; i++ ) {
 452                         byte = 0;
 453                         for ( j = 0 ; j < 8 ; j++ ) {
 454                                 data = isapnp_read_data ();
 455                                 isapnp_delay();
 456                                 data = ( data << 8 ) | isapnp_read_data ();
 457                                 isapnp_delay();
 458                                 byte >>= 1;
 459                                 if (  data != 0xffff ) {
 460                                         seen_life++;
 461                                         if ( data == 0x55aa ) {
 462                                                 byte |= 0x80;
 463                                                 seen_55aa++;
 464                                         }
 465                                 }
 466                         }
 467                         ( (char *) &identifier )[i] = byte;
 468                 }
 469
 470                 /* If we didn't see any 55aa patterns, stop here */
 471                 if ( ! seen_55aa ) {
 472                         if ( csn ) {
 473                                 DBG ( "ISAPnP found no more cards\n" );
 474                         } else {
 475                                 if ( seen_life ) {
 476                                         DBG ( "ISAPnP saw life but no cards, "
 477                                               "trying new read port\n" );
 478                                         csn = -1;
 479                                 } else {
 480                                         DBG ( "ISAPnP saw no signs of life, "
 481                                               "abandoning isolation\n" );
 482                                 }
 483                         }
 484                         break;
 485                 }
 486
 487                 /* If the checksum was invalid stop here */
 488                 if ( identifier.checksum != isapnp_checksum ( &identifier) ) {
 489                         DBG ( "ISAPnP found malformed card "
 490                               ISAPNP_CARD_ID_FMT "\n  with checksum %hhx "
 491                               "(should be %hhx), trying new read port\n",
 492                               ISAPNP_CARD_ID_DATA ( &identifier ),
 493                               identifier.checksum,
 494                               isapnp_checksum ( &identifier) );
 495                         csn = -1;
 496                         break;
 497                 }
 498
 499                 /* Give the device a CSN */
 500                 csn++;
 501                 DBG ( "ISAPnP found card " ISAPNP_CARD_ID_FMT
 502                       ", assigning CSN %hhx\n",
 503                       ISAPNP_CARD_ID_DATA ( &identifier ), csn );
 504
 505                 isapnp_write_csn ( csn );
 506                 isapnp_delay();
 507
 508                 /* Send this card back to Sleep and force all cards
 509                  * without a CSN into Isolation state
 510                  */
 511                 isapnp_wake ( 0x00 );
 512                 isapnp_delay();
 513         }
 514
 515         /* Place all cards in Wait for Key state */
 516         isapnp_wait_for_key ();
 517
 518         /* Return number of cards found */
 519         if ( csn > 0 ) {
 520                 DBG ( "ISAPnP found %d cards at read port %hx\n",
 521                       csn, isapnp_read_port );
 522         }
 523         return csn;
 524 }
 525
 526 /**
 527  * Find a valid read port and isolate all ISAPnP cards.
 528  *
 529  */
 530 static void isapnp_isolate ( void ) {
 531         for ( isapnp_read_port = ISAPNP_READ_PORT_MIN ;
 532               isapnp_read_port <= ISAPNP_READ_PORT_MAX ;
 533               isapnp_read_port += ISAPNP_READ_PORT_STEP ) {
 534                 /* Avoid problematic locations such as the NE2000
 535                  * probe space
 536                  */
 537                 if ( ( isapnp_read_port >= 0x280 ) &&
 538                      ( isapnp_read_port <= 0x380 ) )
 539                         continue;
 540
 541                 /* If we detect any ISAPnP cards at this location, stop */
 542                 if ( isapnp_try_isolate () >= 0 )
 543                         return;
 544         }
 545 }
 546
 547 /**
 548  * Increment a #bus_loc structure to the next possible ISAPnP
 549  * location.
 550  *
 551  * @v bus_loc           Bus location
 552  * @ret True            #bus_loc contains a valid ISAPnP location
 553  * @ret False           There are no more valid ISAPnP locations
 554  * @err None            -
 555  *
 556  * If there are no more valid locations, the #bus_loc structure will
 557  * be zeroed.
 558  *
 559  */
 560 static int isapnp_next_location ( struct bus_loc *bus_loc ) {
 561         struct isapnp_loc *isapnp_loc = ( struct isapnp_loc * ) bus_loc;
 562
 563         /*
 564          * Ensure that there is sufficient space in the shared bus
 565          * structures for a struct isapnp_loc and a struct isapnp_dev,
 566          * as mandated by bus.h.
 567          *
 568          */
 569         BUS_LOC_CHECK ( struct isapnp_loc );
 570         BUS_DEV_CHECK ( struct isapnp_device );
 571
 572         return ( ++isapnp_loc->logdev ? 1 : ++isapnp_loc->csn );
 573 }
 574
 575 /**
 576  * Fill in parameters for an ISAPnP device based on CSN.
 577  *
 578  * @v bus_dev           Bus device to be filled in
 579  * @v bus_loc           Bus location as filled in by isapnp_next_location()
 580  * @ret True            A device is present at this location
 581  * @ret False           No device is present at this location
 582  * @err None            -
 583  *
 584  */
 585 static int isapnp_fill_device ( struct bus_dev *bus_dev,
 586                                 struct bus_loc *bus_loc ) {
 587         struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
 588         struct isapnp_loc *isapnp_loc = ( struct isapnp_loc * ) bus_loc;
 589         unsigned int i;
 590         struct isapnp_identifier identifier;
 591         struct isapnp_logdevid logdevid;
 592         static struct {
 593                 uint8_t csn;
 594                 uint8_t first_nonexistent_logdev;
 595         } cache = { 0, 0 };
 596
 597         /* Copy CSN and logdev to isapnp_device, set default values */
 598         isapnp->csn = isapnp_loc->csn;
 599         isapnp->logdev = isapnp_loc->logdev;
 600         isapnp->name = "?";
 601
 602         /* CSN 0 is never valid, but may be passed in */
 603         if ( ! isapnp->csn )
 604                 return 0;
 605
 606         /* Check to see if we are already past the maximum CSN */
 607         if ( isapnp->csn > isapnp_max_csn )
 608                 return 0;
 609
 610         /* Check cache to see if we are already past the highest
 611          * logical device of this CSN
 612          */
 613         if ( ( isapnp->csn == cache.csn ) &&
 614              ( isapnp->logdev >= cache.first_nonexistent_logdev ) )
 615                 return 0;
 616
 617         /* Perform isolation if it hasn't yet been done */
 618         if ( ! isapnp_read_port )
 619                 isapnp_isolate();
 620
 621         /* Wake the card */
 622         isapnp_wait_for_key ();
 623         isapnp_send_key ();
 624         isapnp_wake ( isapnp->csn );
 625
 626         /* Read the card identifier */
 627         isapnp_peek ( ( char * ) &identifier, sizeof ( identifier ) );
 628
 629         /* Need to return 0 if no device exists at this CSN */
 630         if ( identifier.vendor_id & 0x80 ) {
 631                 isapnp_max_csn = isapnp->csn - 1;
 632                 return 0;
 633         }
 634
 635         /* Find the Logical Device ID tag corresponding to this device */
 636         for ( i = 0 ; i <= isapnp->logdev ; i++ ) {
 637                 if ( ! isapnp_find_tag ( ISAPNP_TAG_LOGDEVID,
 638                                          ( char * ) &logdevid ) ) {
 639                         /* No tag for this device */
 640                         if ( isapnp->logdev == 0 ) {
 641                                 DBG ( "ISAPnP found no device %hhx.0 on card "
 642                                       ISAPNP_CARD_ID_FMT "\n", isapnp->csn,
 643                                       ISAPNP_CARD_ID_DATA ( &identifier ) );
 644                         }
 645                         cache.csn = isapnp->csn;
 646                         cache.first_nonexistent_logdev = isapnp->logdev;
 647                         return 0;
 648                 }
 649         }
 650
 651         /* Read information from logdevid structure */
 652         isapnp->vendor_id = logdevid.vendor_id;
 653         isapnp->prod_id = logdevid.prod_id;
 654
 655         /* Select the logical device */
 656         isapnp_logicaldevice ( isapnp->logdev );
 657
 658         /* Read the current ioaddr and irqno */
 659         isapnp->ioaddr = isapnp_read_iobase ( 0 );
 660         isapnp->irqno = isapnp_read_irqno ( 0 );
 661
 662         /* Return all cards to Wait for Key state */
 663         isapnp_wait_for_key ();
 664
 665         DBG ( "ISAPnP found device %hhx.%hhx " ISAPNP_DEV_ID_FMT
 666               ", base %hx irq %d\n", isapnp->csn, isapnp->logdev,
 667               ISAPNP_DEV_ID_DATA ( isapnp ), isapnp->ioaddr, isapnp->irqno );
 668         DBG ( "  on card " ISAPNP_CARD_ID_FMT "\n",
 669               ISAPNP_CARD_ID_DATA ( &identifier ) );
 670
 671         return 1;
 672 }
 673
 674 /**
 675  * Test whether or not a driver is capable of driving the device.
 676  *
 677  * @v bus_dev           Bus device as filled in by isapnp_fill_device()
 678  * @v device_driver     Device driver
 679  * @ret True            Driver is capable of driving this device
 680  * @ret False           Driver is not capable of driving this device
 681  * @err None            -
 682  *
 683  */
 684 static int isapnp_check_driver ( struct bus_dev *bus_dev,
 685                                  struct device_driver *device_driver ) {
 686         struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
 687         struct isapnp_driver *driver
 688                 = ( struct isapnp_driver * ) device_driver->bus_driver_info;
 689         unsigned int i;
 690
 691         /* Compare against driver's ID list */
 692         for ( i = 0 ; i < driver->id_count ; i++ ) {
 693                 struct isapnp_id *id = &driver->ids[i];
 694
 695                 if ( ( isapnp->vendor_id == id->vendor_id ) &&
 696                      ( ISA_PROD_ID ( isapnp->prod_id ) ==
 697                        ISA_PROD_ID ( id->prod_id ) ) ) {
 698                         DBG ( "ISAPnP found ID %hx:%hx (\"%s\") (device %s) "
 699                               "matching driver %s\n",
 700                               isapnp->vendor_id, isapnp->prod_id,
 701                               isa_id_string( isapnp->vendor_id,
 702                                              isapnp->prod_id ),
 703                               id->name, device_driver->name );
 704                         isapnp->name = id->name;
 705                         return 1;
 706                 }
 707         }
 708
 709         return 0;
 710 }
 711
 712 /**
 713  * Describe an ISAPnP device.
 714  *
 715  * @v bus_dev           Bus device as filled in by isapnp_fill_device()
 716  * @ret string          Printable string describing the device
 717  * @err None            -
 718  *
 719  * The string returned by isapnp_describe_device() is valid only until
 720  * the next call to isapnp_describe_device().
 721  *
 722  */
 723 static char * isapnp_describe_device ( struct bus_dev *bus_dev ) {
 724         struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
 725         static char isapnp_description[] = "ISAPnP 00:00";
 726
 727         sprintf ( isapnp_description + 7, "%hhx:%hhx",
 728                   isapnp->csn, isapnp->logdev );
 729         return isapnp_description;
 730 }
 731
 732 /**
 733  * Name an ISAPnP device.
 734  *
 735  * @v bus_dev           Bus device as filled in by isapnp_fill_device()
 736  * @ret string          Printable string naming the device
 737  * @err None            -
 738  *
 739  * The string returned by isapnp_name_device() is valid only until the
 740  * next call to isapnp_name_device().
 741  *
 742  */
 743 static const char * isapnp_name_device ( struct bus_dev *bus_dev ) {
 744         struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
 745
 746         return isapnp->name;
 747 }
 748
 749 /*
 750  * ISAPnP bus operations table
 751  *
 752  */
 753 struct bus_driver isapnp_driver __bus_driver = {
 754         .name                   = "ISAPnP",
 755         .next_location          = isapnp_next_location,
 756         .fill_device            = isapnp_fill_device,
 757         .check_driver           = isapnp_check_driver,
 758         .describe_device        = isapnp_describe_device,
 759         .name_device            = isapnp_name_device,
 760 };
 761
 762 /**
 763  * Activate or deactivate an ISAPnP device.
 764  *
 765  * @v isapnp            ISAPnP device
 766  * @v activation        True to enable, False to disable the device
 767  * @ret None            -
 768  * @err None            -
 769  *
 770  * This routine simply activates the device in its current
 771  * configuration, or deactivates the device.  It does not attempt any
 772  * kind of resource arbitration.
 773  *
 774  */
 775 void isapnp_device_activation ( struct isapnp_device *isapnp,
 776                                 int activation ) {
 777         /* Wake the card and select the logical device */
 778         isapnp_wait_for_key ();
 779         isapnp_send_key ();
 780         isapnp_wake ( isapnp->csn );
 781         isapnp_logicaldevice ( isapnp->logdev );
 782
 783         /* Activate/deactivate the logical device */
 784         isapnp_activate ( activation );
 785         isapnp_delay();
 786
 787         /* Return all cards to Wait for Key state */
 788         isapnp_wait_for_key ();
 789
 790         DBG ( "ISAPnP %s device %hhx.%hhx\n",
 791               ( activation ? "activated" : "deactivated" ),
 792               isapnp->csn, isapnp->logdev );
 793 }
 794
 795 /**
 796  * Fill in a nic structure.
 797  *
 798  * @v nic               NIC structure to be filled in
 799  * @v isapnp            ISAPnP device
 800  * @ret None            -
 801  * @err None            -
 802  *
 803  * This fills in generic NIC parameters (e.g. I/O address and IRQ
 804  * number) that can be determined directly from the ISAPnP device,
 805  * without any driver-specific knowledge.
 806  *
 807  */
 808 void isapnp_fill_nic ( struct nic *nic, struct isapnp_device *isapnp ) {
 809
 810         /* Fill in ioaddr and irqno */
 811         nic->ioaddr = isapnp->ioaddr;
 812         nic->irqno = isapnp->irqno;
 813
 814         /* Fill in DHCP device ID structure */
 815         nic->dhcp_dev_id.bus_type = ISA_BUS_TYPE;
 816         nic->dhcp_dev_id.vendor_id = htons ( isapnp->vendor_id );
 817         nic->dhcp_dev_id.device_id = htons ( isapnp->prod_id );
 818 }
 819