[tables] Redefine methods for accessing linker tables
[people/lynusvaz/gpxe.git] / src / drivers / bus / isa.c
1 #include <stdint.h>
2 #include <string.h>
3 #include <stdlib.h>
4 #include <stdio.h>
5 #include <errno.h>
6 #include <gpxe/io.h>
7 #include <gpxe/isa.h>
8
9 /*
10  * isa.c implements a "classical" port-scanning method of ISA device
11  * detection.  The driver must provide a list of probe addresses
12  * (probe_addrs), together with a function (probe_addr) that can be
13  * used to test for the physical presence of a device at any given
14  * address.
15  *
16  * Note that this should probably be considered the "last resort" for
17  * device probing.  If the card supports ISAPnP or EISA, use that
18  * instead.  Some cards (e.g. the 3c509) implement a proprietary
19  * ISAPnP-like mechanism.
20  *
21  * The ISA probe address list can be overridden by config.h; if the
22  * user specifies ISA_PROBE_ADDRS then that list will be used first.
23  * (If ISA_PROBE_ONLY is defined, the driver's own list will never be
24  * used).
25  */
26
27 /*
28  * User-supplied probe address list
29  *
30  */
31 static isa_probe_addr_t isa_extra_probe_addrs[] = {
32 #ifdef ISA_PROBE_ADDRS
33         ISA_PROBE_ADDRS
34 #endif
35 };
36 #define ISA_EXTRA_PROBE_ADDR_COUNT \
37      ( sizeof ( isa_extra_probe_addrs ) / sizeof ( isa_extra_probe_addrs[0] ) )
38
39 #define ISA_IOIDX_MIN( driver ) ( -ISA_EXTRA_PROBE_ADDR_COUNT )
40 #ifdef ISA_PROBE_ONLY
41 #define ISA_IOIDX_MAX( driver ) ( -1 )
42 #else
43 #define ISA_IOIDX_MAX( driver ) ( (int) (driver)->addr_count - 1 )
44 #endif
45
46 #define ISA_IOADDR( driver, ioidx )                                       \
47         ( ( (ioidx) < 0 ) ?                                               \
48           isa_extra_probe_addrs[ (ioidx) + ISA_EXTRA_PROBE_ADDR_COUNT ] : \
49           (driver)->probe_addrs[(ioidx)] )
50
51 static void isabus_remove ( struct root_device *rootdev );
52
53 /**
54  * Probe an ISA device
55  *
56  * @v isa               ISA device
57  * @ret rc              Return status code
58  */
59 static int isa_probe ( struct isa_device *isa ) {
60         int rc;
61
62         DBG ( "Trying ISA driver %s at I/O %04x\n",
63               isa->driver->name, isa->ioaddr );
64
65         if ( ( rc = isa->driver->probe ( isa ) ) != 0 ) {
66                 DBG ( "...probe failed\n" );
67                 return rc;
68         }
69
70         DBG ( "...device found\n" );
71         return 0;
72 }
73
74 /**
75  * Remove an ISA device
76  *
77  * @v isa               ISA device
78  */
79 static void isa_remove ( struct isa_device *isa ) {
80         isa->driver->remove ( isa );
81         DBG ( "Removed ISA%04x\n", isa->ioaddr );
82 }
83
84 /**
85  * Probe ISA root bus
86  *
87  * @v rootdev           ISA bus root device
88  *
89  * Scans the ISA bus for devices and registers all devices it can
90  * find.
91  */
92 static int isabus_probe ( struct root_device *rootdev ) {
93         struct isa_device *isa = NULL;
94         struct isa_driver *driver;
95         int ioidx;
96         int rc;
97
98         for_each_table_entry ( driver, ISA_DRIVERS ) {
99                 for ( ioidx = ISA_IOIDX_MIN ( driver ) ;
100                       ioidx <= ISA_IOIDX_MAX ( driver ) ; ioidx++ ) {
101                         /* Allocate struct isa_device */
102                         if ( ! isa )
103                                 isa = malloc ( sizeof ( *isa ) );
104                         if ( ! isa ) {
105                                 rc = -ENOMEM;
106                                 goto err;
107                         }
108                         memset ( isa, 0, sizeof ( *isa ) );
109                         isa->driver = driver;
110                         isa->ioaddr = ISA_IOADDR ( driver, ioidx );
111
112                         /* Add to device hierarchy */
113                         snprintf ( isa->dev.name, sizeof ( isa->dev.name ),
114                                    "ISA%04x", isa->ioaddr );
115                         isa->dev.desc.bus_type = BUS_TYPE_ISA;
116                         isa->dev.desc.vendor = driver->vendor_id;
117                         isa->dev.desc.device = driver->prod_id;
118                         isa->dev.parent = &rootdev->dev;
119                         list_add ( &isa->dev.siblings,
120                                    &rootdev->dev.children );
121                         INIT_LIST_HEAD ( &isa->dev.children );
122
123                         /* Try probing at this I/O address */
124                         if ( isa_probe ( isa ) == 0 ) {
125                                 /* isadev registered, we can drop our ref */
126                                 isa = NULL;
127                         } else {
128                                 /* Not registered; re-use struct */
129                                 list_del ( &isa->dev.siblings );
130                         }
131                 }
132         }
133
134         free ( isa );
135         return 0;
136
137  err:
138         free ( isa );
139         isabus_remove ( rootdev );
140         return rc;
141 }
142
143 /**
144  * Remove ISA root bus
145  *
146  * @v rootdev           ISA bus root device
147  */
148 static void isabus_remove ( struct root_device *rootdev ) {
149         struct isa_device *isa;
150         struct isa_device *tmp;
151
152         list_for_each_entry_safe ( isa, tmp, &rootdev->dev.children,
153                                    dev.siblings ) {
154                 isa_remove ( isa );
155                 list_del ( &isa->dev.siblings );
156                 free ( isa );
157         }
158 }
159
160 /** ISA bus root device driver */
161 static struct root_driver isa_root_driver = {
162         .probe = isabus_probe,
163         .remove = isabus_remove,
164 };
165
166 /** ISA bus root device */
167 struct root_device isa_root_device __root_device = {
168         .dev = { .name = "ISA" },
169         .driver = &isa_root_driver,
170 };