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