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