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