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 };