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