[tables] Redefine methods for accessing linker tables
[people/lynusvaz/gpxe.git] / src / drivers / bus / mca.c
1 /*
2  * MCA bus driver code
3  *
4  * Abstracted from 3c509.c.
5  *
6  */
7
8 #include <stdint.h>
9 #include <string.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <errno.h>
13 #include <gpxe/io.h>
14 #include <gpxe/mca.h>
15
16 static void mcabus_remove ( struct root_device *rootdev );
17
18 /**
19  * Probe an MCA device
20  *
21  * @v mca               MCA device
22  * @ret rc              Return status code
23  *
24  * Searches for a driver for the MCA device.  If a driver is found,
25  * its probe() routine is called.
26  */
27 static int mca_probe ( struct mca_device *mca ) {
28         struct mca_driver *driver;
29         struct mca_device_id *id;
30         unsigned int i;
31         int rc;
32
33         DBG ( "Adding MCA slot %02x (ID %04x POS "
34               "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x)\n",
35               mca->slot, MCA_ID ( mca ),
36               mca->pos[0], mca->pos[1], mca->pos[2], mca->pos[3],
37               mca->pos[4], mca->pos[5], mca->pos[6], mca->pos[7] );
38
39         for_each_table_entry ( driver, MCA_DRIVERS ) {
40                 for ( i = 0 ; i < driver->id_count ; i++ ) {
41                         id = &driver->ids[i];
42                         if ( id->id != MCA_ID ( mca ) )
43                                 continue;
44                         mca->driver = driver;
45                         mca->driver_name = id->name;
46                         DBG ( "...using driver %s\n", mca->driver_name );
47                         if ( ( rc = driver->probe ( mca, id ) ) != 0 ) {
48                                 DBG ( "......probe failed\n" );
49                                 continue;
50                         }
51                         return 0;
52                 }
53         }
54
55         DBG ( "...no driver found\n" );
56         return -ENOTTY;
57 }
58
59 /**
60  * Remove an MCA device
61  *
62  * @v mca               MCA device
63  */
64 static void mca_remove ( struct mca_device *mca ) {
65         mca->driver->remove ( mca );
66         DBG ( "Removed MCA device %02x\n", mca->slot );
67 }
68
69 /**
70  * Probe MCA root bus
71  *
72  * @v rootdev           MCA bus root device
73  *
74  * Scans the MCA bus for devices and registers all devices it can
75  * find.
76  */
77 static int mcabus_probe ( struct root_device *rootdev ) {
78         struct mca_device *mca = NULL;
79         unsigned int slot;
80         int seen_non_ff;
81         unsigned int i;
82         int rc;
83
84         for ( slot = 0 ; slot <= MCA_MAX_SLOT_NR ; slot++ ) {
85                 /* Allocate struct mca_device */
86                 if ( ! mca )
87                         mca = malloc ( sizeof ( *mca ) );
88                 if ( ! mca ) {
89                         rc = -ENOMEM;
90                         goto err;
91                 }
92                 memset ( mca, 0, sizeof ( *mca ) );
93                 mca->slot = slot;
94
95                 /* Make sure motherboard setup is off */
96                 outb_p ( 0xff, MCA_MOTHERBOARD_SETUP_REG );
97
98                 /* Select the slot */
99                 outb_p ( 0x8 | ( mca->slot & 0xf ), MCA_ADAPTER_SETUP_REG );
100
101                 /* Read the POS registers */
102                 seen_non_ff = 0;
103                 for ( i = 0 ; i < ( sizeof ( mca->pos ) /
104                                     sizeof ( mca->pos[0] ) ) ; i++ ) {
105                         mca->pos[i] = inb_p ( MCA_POS_REG ( i ) );
106                         if ( mca->pos[i] != 0xff )
107                                 seen_non_ff = 1;
108                 }
109         
110                 /* Kill all setup modes */
111                 outb_p ( 0, MCA_ADAPTER_SETUP_REG );
112
113                 /* If all POS registers are 0xff, this means there's no device
114                  * present
115                  */
116                 if ( ! seen_non_ff )
117                         continue;
118
119                 /* Add to device hierarchy */
120                 snprintf ( mca->dev.name, sizeof ( mca->dev.name ),
121                            "MCA%02x", slot );
122                 mca->dev.desc.bus_type = BUS_TYPE_MCA;
123                 mca->dev.desc.vendor = GENERIC_MCA_VENDOR;
124                 mca->dev.desc.device = MCA_ID ( mca );
125                 mca->dev.parent = &rootdev->dev;
126                 list_add ( &mca->dev.siblings, &rootdev->dev.children );
127                 INIT_LIST_HEAD ( &mca->dev.children );
128
129                 /* Look for a driver */
130                 if ( mca_probe ( mca ) == 0 ) {
131                         /* mcadev registered, we can drop our ref */
132                         mca = NULL;
133                 } else {
134                         /* Not registered; re-use struct */
135                         list_del ( &mca->dev.siblings );
136                 }
137         }
138
139         free ( mca );
140         return 0;
141
142  err:
143         free ( mca );
144         mcabus_remove ( rootdev );
145         return rc;
146 }
147
148 /**
149  * Remove MCA root bus
150  *
151  * @v rootdev           MCA bus root device
152  */
153 static void mcabus_remove ( struct root_device *rootdev ) {
154         struct mca_device *mca;
155         struct mca_device *tmp;
156
157         list_for_each_entry_safe ( mca, tmp, &rootdev->dev.children,
158                                    dev.siblings ) {
159                 mca_remove ( mca );
160                 list_del ( &mca->dev.siblings );
161                 free ( mca );
162         }
163 }
164
165 /** MCA bus root device driver */
166 static struct root_driver mca_root_driver = {
167         .probe = mcabus_probe,
168         .remove = mcabus_remove,
169 };
170
171 /** MCA bus root device */
172 struct root_device mca_root_device __root_device = {
173         .dev = { .name = "MCA" },
174         .driver = &mca_root_driver,
175 };