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