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