narenas
/
opengnsys_ipxe
mirror of https://github.com/ipxe/ipxe.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Updated all common buses to new API.

pull/1/head
Michael Brown 2005-04-22 02:28:16 +00:00
parent 4e3ebba8e6
commit 924143661a
9 changed files with 542 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
src/drivers/bus/eisa.c
View File

@ -1,15 +1,29 @@
#include "string.h" #include "string.h"
#include "io.h" #include "io.h"
#include "timer.h" #include "timer.h"
#include "console.h"
#include "eisa.h" #include "eisa.h"
/* /*
* Ensure that there is sufficient space in the shared dev_bus * Increment a bus_loc structure to the next possible EISA location.
* structure for a struct pci_device. * Leave the structure zeroed and return 0 if there are no more valid
* locations.
* *
*/ */
DEV_BUS( struct eisa_device, eisa_dev ); static int eisa_next_location ( struct bus_loc *bus_loc ) {
static char eisa_magic[0]; /* guaranteed unique symbol */ struct eisa_loc *eisa_loc = ( struct eisa_loc * ) bus_loc;
/*
* Ensure that there is sufficient space in the shared bus
* structures for a struct isa_loc and a struct
* isa_dev, as mandated by bus.h.
*
*/
BUS_LOC_CHECK ( struct eisa_loc );
BUS_DEV_CHECK ( struct eisa_device );
return ( ++eisa_loc->slot & EISA_MAX_SLOT );
}
/* /*
* Fill in parameters for an EISA device based on slot number * Fill in parameters for an EISA device based on slot number
@ -17,9 +31,20 @@ static char eisa_magic[0]; /* guaranteed unique symbol */
* Return 1 if device present, 0 otherwise * Return 1 if device present, 0 otherwise
* *
*/ */
static int fill_eisa_device ( struct eisa_device *eisa ) { static int eisa_fill_device ( struct bus_dev *bus_dev,
struct bus_loc *bus_loc ) {
struct eisa_loc *eisa_loc = ( struct eisa_loc * ) bus_loc;
struct eisa_device *eisa = ( struct eisa_device * ) bus_dev;
uint8_t present; uint8_t present;
/* Copy slot number to struct eisa, set default values */
eisa->slot = eisa_loc->slot;
eisa->name = "?";
/* Slot 0 is never valid */
if ( ! eisa->slot )
return 0;
/* Set ioaddr */ /* Set ioaddr */
eisa->ioaddr = EISA_SLOT_BASE ( eisa->slot ); eisa->ioaddr = EISA_SLOT_BASE ( eisa->slot );
@ -39,7 +64,7 @@ static int fill_eisa_device ( struct eisa_device *eisa ) {
eisa->prod_id = ( inb ( eisa->ioaddr + EISA_PROD_ID_LO ) << 8 ) eisa->prod_id = ( inb ( eisa->ioaddr + EISA_PROD_ID_LO ) << 8 )
+ inb ( eisa->ioaddr + EISA_PROD_ID_HI ); + inb ( eisa->ioaddr + EISA_PROD_ID_HI );
DBG ( "EISA found slot %d (base %#hx) ID %hx:%hx (\"%s\")\n", DBG ( "EISA found slot %hhx (base %#hx) ID %hx:%hx (\"%s\")\n",
eisa->slot, eisa->ioaddr, eisa->mfg_id, eisa->prod_id, eisa->slot, eisa->ioaddr, eisa->mfg_id, eisa->prod_id,
isa_id_string ( eisa->mfg_id, eisa->prod_id ) ); isa_id_string ( eisa->mfg_id, eisa->prod_id ) );
@ -47,78 +72,86 @@ static int fill_eisa_device ( struct eisa_device *eisa ) {
} }
/* /*
* Find an EISA device matching the specified driver * Test whether or not a driver is capable of driving the device.
* *
*/ */
int find_eisa_device ( struct eisa_device *eisa, struct eisa_driver *driver ) { static int eisa_check_driver ( struct bus_dev *bus_dev,
struct device_driver *device_driver ) {
struct eisa_device *eisa = ( struct eisa_device * ) bus_dev;
struct eisa_driver *driver
= ( struct eisa_driver * ) device_driver->bus_driver_info;
unsigned int i; unsigned int i;
/* Initialise struct eisa if it's the first time it's been used. */ /* Compare against driver's ID list */
if ( eisa->magic != eisa_magic ) { for ( i = 0 ; i < driver->id_count ; i++ ) {
memset ( eisa, 0, sizeof ( *eisa ) ); struct eisa_id *id = &driver->ids[i];
eisa->magic = eisa_magic;
eisa->slot = EISA_MIN_SLOT;
}
/* Iterate through all possible EISA slots, starting where we if ( ( eisa->mfg_id == id->mfg_id ) &&
* left off. ( ISA_PROD_ID ( eisa->prod_id ) ==
*/ ISA_PROD_ID ( id->prod_id ) ) ) {
DBG ( "EISA searching for device matching driver %s\n", driver->name ); DBG ( "EISA found ID %hx:%hx (\"%s\") "
for ( ; eisa->slot <= EISA_MAX_SLOT ; eisa->slot++ ) { "(device %s) matching driver %s\n",
/* If we've already used this device, skip it */ eisa->mfg_id, eisa->prod_id,
if ( eisa->already_tried ) { isa_id_string ( eisa->mfg_id,
eisa->already_tried = 0; eisa->prod_id ),
continue; id->name, driver->name );
} eisa->name = id->name;
return 1;
/* Fill in device parameters */
if ( ! fill_eisa_device ( eisa ) ) {
continue;
}
/* Compare against driver's ID list */
for ( i = 0 ; i < driver->id_count ; i++ ) {
struct eisa_id *id = &driver->ids[i];
if ( ( eisa->mfg_id == id->mfg_id ) &&
( ISA_PROD_ID ( eisa->prod_id ) ==
ISA_PROD_ID ( id->prod_id ) ) ) {
DBG ( "EISA found ID %hx:%hx (\"%s\") "
"(device %s) matching driver %s\n",
eisa->mfg_id, eisa->prod_id,
isa_id_string ( eisa->mfg_id,
eisa->prod_id ),
id->name, driver->name );
eisa->name = id->name;
eisa->already_tried = 1;
return 1;
}
} }
} }
/* No device found */ /* No device found */
DBG ( "EISA found no device matching driver %s\n", driver->name );
eisa->slot = EISA_MIN_SLOT;
return 0; return 0;
} }
/* /*
* Find the next EISA device that can be used to boot using the * Describe an EISA device
* specified driver.
* *
*/ */
int find_eisa_boot_device ( struct dev *dev, struct eisa_driver *driver ) { static char * eisa_describe ( struct bus_dev *bus_dev ) {
struct eisa_device *eisa = ( struct eisa_device * )dev->bus; struct eisa_device *eisa = ( struct eisa_device * ) bus_dev;
static char eisa_description[] = "EISA 00";
if ( ! find_eisa_device ( eisa, driver ) ) sprintf ( eisa_description + 5, "%hhx", eisa->slot );
return 0; return eisa_description;
}
dev->name = eisa->name; /*
dev->devid.bus_type = ISA_BUS_TYPE; * Name an EISA device
dev->devid.vendor_id = eisa->mfg_id; *
dev->devid.device_id = eisa->prod_id; */
static const char * eisa_name ( struct bus_dev *bus_dev ) {
struct eisa_device *eisa = ( struct eisa_device * ) bus_dev;
return 1; return eisa->name;
}
/*
* EISA bus operations table
*
*/
struct bus_driver eisa_driver __bus_driver = {
.next_location = eisa_next_location,
.fill_device = eisa_fill_device,
.check_driver = eisa_check_driver,
.describe = eisa_describe,
.name = eisa_name,
};
/*
* Fill in a nic structure
*
*/
void eisa_fill_nic ( struct nic *nic, struct eisa_device *eisa ) {
/* Fill in ioaddr and irqno */
nic->ioaddr = eisa->ioaddr;
nic->irqno = 0;
/* Fill in DHCP device ID structure */
nic->dhcp_dev_id.bus_type = ISA_BUS_TYPE;
nic->dhcp_dev_id.vendor_id = htons ( eisa->mfg_id );
nic->dhcp_dev_id.device_id = htons ( eisa->prod_id );
} }
/* /*

216
src/drivers/bus/isa.c
View File

@ -1,4 +1,5 @@
#include "string.h" #include "string.h"
#include "console.h"
#include "config/isa.h" #include "config/isa.h"
#include "isa.h" #include "isa.h"
@ -14,139 +15,156 @@
* instead. Some cards (e.g. the 3c509) implement a proprietary * instead. Some cards (e.g. the 3c509) implement a proprietary
* ISAPnP-like mechanism. * ISAPnP-like mechanism.
* *
* The ISA probe address list can be overridden by config.c; if the * The ISA probe address list can be overridden by config.h; if the
* user specifies ISA_PROBE_ADDRS then that list will be used first. * user specifies ISA_PROBE_ADDRS then that list will be used first.
* (If ISA_PROBE_ADDRS ends with a zero, the driver's own list will * (If ISA_PROBE_ADDRS ends with a zero, the driver's own list will
* never be used). * never be used).
*/ */
/*
* Ensure that there is sufficient space in the shared dev_bus
* structure for a struct isa_device.
*
*/
DEV_BUS( struct isa_device, isa_dev );
static char isa_magic[0]; /* guaranteed unique symbol */
/* /*
* User-supplied probe address list * User-supplied probe address list
* *
*/ */
#ifdef ISA_PROBE_ADDRS
# ifdef ISA_PROBE_ONLY
# define HAVE_ISA_PROBE_ADDRS 1
# define ISA_PROBE_ADDR_LIST ISA_PROBE_ADDRS, 0
# else
# define HAVE_ISA_PROBE_ADDRS 1
# define ISA_PROBE_ADDR_LIST ISA_PROBE_ADDRS
# endif
#else
# define HAVE_ISA_PROBE_ADDRS 0
# define ISA_PROBE_ADDR_LIST
#endif
static isa_probe_addr_t isa_extra_probe_addrs[] = { static isa_probe_addr_t isa_extra_probe_addrs[] = {
ISA_PROBE_ADDR_LIST #ifdef ISA_PROBE_ADDRS
ISA_PROBE_ADDRS
#endif
}; };
#define isa_extra_probe_addr_count \ #define isa_extra_probe_addr_count \
( sizeof ( isa_extra_probe_addrs ) / sizeof ( isa_extra_probe_addrs[0] ) ) ( sizeof ( isa_extra_probe_addrs ) / sizeof ( isa_extra_probe_addrs[0] ) )
#ifdef ISA_PROBE_ONLY
# define ISA_PROBE_IDX_LIMIT isa_extra_probe_addr_count
#else
# define ISA_PROBE_IDX_LIMIT ( ISA_MAX_PROBE_IDX + 1 )
#endif
/* /*
* Find an ISA device matching the specified driver * Increment a bus_loc structure to the next possible ISA location.
* Leave the structure zeroed and return 0 if there are no more valid
* locations.
* *
*/ */
int find_isa_device ( struct isa_device *isa, struct isa_driver *driver ) { static int isa_next_location ( struct bus_loc *bus_loc ) {
unsigned int i; struct isa_loc *isa_loc = ( struct isa_loc * ) bus_loc;
uint16_t ioaddr;
/* Initialise struct isa if it's the first time it's been used. */ /*
if ( isa->magic != isa_magic ) { * Ensure that there is sufficient space in the shared bus
memset ( isa, 0, sizeof ( *isa ) ); * structures for a struct isa_loc and a struct
isa->magic = isa_magic; * isa_dev, as mandated by bus.h.
} *
/* Iterate through any ISA probe addresses specified by the
* user, starting where we left off.
*/ */
DBG ( "ISA searching for device matching driver %s\n", driver->name ); BUS_LOC_CHECK ( struct isa_loc );
for ( i = isa->probe_idx ; i < isa_extra_probe_addr_count ; i++ ) { BUS_DEV_CHECK ( struct isa_device );
/* If we've already used this device, skip it */
if ( isa->already_tried ) {
isa->already_tried = 0;
continue;
}
/* Set I/O address */ return ( ( ++isa_loc->probe_idx < ISA_PROBE_IDX_LIMIT ) ?
ioaddr = isa_extra_probe_addrs[i]; 1 : ( isa_loc->probe_idx = 0 ) );
}
/* An I/O address of 0 in extra_probe_addrs list means /*
* stop probing (i.e. don't continue to the * Fill in parameters (vendor & device ids, class, membase etc.) for
* driver-provided list) * an ISA device based on bus_loc.
*/ *
if ( ! ioaddr ) * Returns 1 if a device was found, 0 for no device present.
goto notfound; *
*/
static int isa_fill_device ( struct bus_dev *bus_dev,
struct bus_loc *bus_loc ) {
struct isa_loc *isa_loc = ( struct isa_loc * ) bus_loc;
struct isa_device *isa = ( struct isa_device * ) bus_dev;
signed int driver_probe_idx;
/* Use probe_addr method to see if there's a device driver_probe_idx = isa_loc->probe_idx - isa_extra_probe_addr_count;
* present at this address. if ( driver_probe_idx < 0 ) {
*/ isa->ioaddr = isa_extra_probe_addrs[isa_loc->probe_idx];
if ( driver->probe_addr ( ioaddr ) ) { } else {
isa->probe_idx = i; isa->ioaddr = 0;
goto found; isa->driver_probe_idx = driver_probe_idx;
}
} }
isa->mfg_id = isa->prod_id = 0;
isa->name = "?";
return 1;
}
/* Iterate through all ISA probe addresses provided by the /*
* driver, starting where we left off. * Test whether or not a driver is capable of driving the specified
* device.
*
*/
int isa_check_driver ( struct bus_dev *bus_dev,
struct device_driver *device_driver ) {
struct isa_device *isa = ( struct isa_device * ) bus_dev;
struct isa_driver *driver
= ( struct isa_driver * ) device_driver->bus_driver_info;
/* If ioaddr is zero, it means we're using a driver-specified
* ioaddr
*/ */
for ( i = isa->probe_idx - isa_extra_probe_addr_count ; if ( ! isa->ioaddr )
i < driver->addr_count ; i++ ) { isa->ioaddr = driver->probe_addrs[isa->driver_probe_idx];
/* If we've already used this device, skip it */ /* Use probe_addr method to see if there's a device
if ( isa->already_tried ) { * present at this address.
isa->already_tried = 0; */
continue; if ( driver->probe_addr ( isa->ioaddr ) ) {
} DBG ( "ISA found %s device at address %hx\n",
driver->name, isa->ioaddr );
/* Set I/O address */ isa->name = driver->name;
ioaddr = driver->probe_addrs[i]; isa->mfg_id = driver->mfg_id;
isa->prod_id = driver->prod_id;
/* Use probe_addr method to see if there's a device return 1;
* present at this address.
*/
if ( driver->probe_addr ( ioaddr ) ) {
isa->probe_idx = i + isa_extra_probe_addr_count;
goto found;
}
} }
notfound:
/* No device found */ /* No device found */
DBG ( "ISA found no device matching driver %s\n", driver->name );
isa->probe_idx = 0;
return 0; return 0;
found:
DBG ( "ISA found %s device at address %hx\n", driver->name, ioaddr );
isa->ioaddr = ioaddr;
isa->already_tried = 1;
return 1;
} }
/* /*
* Find the next ISA device that can be used to boot using the * Describe a ISA device
* specified driver.
* *
*/ */
int find_isa_boot_device ( struct dev *dev, struct isa_driver *driver ) { static char * isa_describe ( struct bus_dev *bus_dev ) {
struct isa_device *isa = ( struct isa_device * )dev->bus; struct isa_device *isa = ( struct isa_device * ) bus_dev;
static char isa_description[] = "ISA 0000";
if ( ! find_isa_device ( isa, driver ) ) sprintf ( isa_description + 4, "%hx", isa->ioaddr );
return 0; return isa_description;
}
dev->name = driver->name;
dev->devid.bus_type = ISA_BUS_TYPE; /*
dev->devid.vendor_id = driver->mfg_id; * Name a ISA device
dev->devid.device_id = driver->prod_id; *
*/
return 1; static const char * isa_name ( struct bus_dev *bus_dev ) {
struct isa_device *isa = ( struct isa_device * ) bus_dev;
return isa->name;
}
/*
* ISA bus operations table
*
*/
struct bus_driver isa_driver __bus_driver = {
.next_location = isa_next_location,
.fill_device = isa_fill_device,
.check_driver = isa_check_driver,
.describe = isa_describe,
.name = isa_name,
};
/*
* Fill in a nic structure
*
*/
void isa_fill_nic ( struct nic *nic, struct isa_device *isa ) {
/* Fill in ioaddr and irqno */
nic->ioaddr = isa->ioaddr;
nic->irqno = 0;
/* Fill in DHCP device ID structure */
nic->dhcp_dev_id.bus_type = ISA_BUS_TYPE;
nic->dhcp_dev_id.vendor_id = htons ( isa->mfg_id );
nic->dhcp_dev_id.device_id = htons ( isa->prod_id );
} }

238
src/drivers/bus/isapnp.c
View File

@ -36,16 +36,9 @@
#include "string.h" #include "string.h"
#include "timer.h" #include "timer.h"
#include "io.h" #include "io.h"
#include "console.h"
#include "isapnp.h" #include "isapnp.h"
/*
* Ensure that there is sufficient space in the shared dev_bus
* structure for a struct isapnp_device.
*
*/
DEV_BUS( struct isapnp_device, isapnp_dev );
static char isapnp_magic[0]; /* guaranteed unique symbol */
/* /*
* We can have only one ISAPnP bus in a system. Once the read port is * We can have only one ISAPnP bus in a system. Once the read port is
* known and all cards have been allocated CSNs, there's nothing to be * known and all cards have been allocated CSNs, there's nothing to be
@ -56,9 +49,14 @@ static char isapnp_magic[0]; /* guaranteed unique symbol */
* ISA bus. We therefore probe only when we are first asked to find * ISA bus. We therefore probe only when we are first asked to find
* an ISAPnP device. * an ISAPnP device.
* *
* External code (e.g. the ISAPnP ROM prefix) may already know the
* read port address, in which case it can initialise this value.
* Note that setting the read port address will prevent further
* isolation from taking place; you should set the read port address
* only if you know that devices have already been allocated CSNs.
*
*/ */
static uint16_t isapnp_read_port; uint16_t isapnp_read_port;
static uint16_t isapnp_max_csn;
/* /*
* ISAPnP utility functions * ISAPnP utility functions
@ -297,7 +295,8 @@ static int isapnp_find_tag ( uint8_t wanted_tag, uint8_t *buf ) {
*/ */
static int isapnp_try_isolate ( void ) { static int isapnp_try_isolate ( void ) {
struct isapnp_identifier identifier; struct isapnp_identifier identifier;
int i, j, seen55aa; unsigned int i, j, seen55aa;
unsigned int csn = 0;
uint16_t data; uint16_t data;
uint8_t byte; uint8_t byte;
@ -312,7 +311,6 @@ static int isapnp_try_isolate ( void ) {
/* Reset all assigned CSNs */ /* Reset all assigned CSNs */
isapnp_reset_csn (); isapnp_reset_csn ();
isapnp_max_csn = 0;
isapnp_delay(); isapnp_delay();
isapnp_delay(); isapnp_delay();
@ -358,7 +356,7 @@ static int isapnp_try_isolate ( void ) {
/* If we didn't see any 55aa patterns, stop here */ /* If we didn't see any 55aa patterns, stop here */
if ( ! seen55aa ) { if ( ! seen55aa ) {
DBG ( "ISAPnP saw %s signs of life\n", DBG ( "ISAPnP saw %s signs of life\n",
isapnp_max_csn ? "no futher" : "no" ); csn ? "no futher" : "no" );
break; break;
} }
@ -374,12 +372,12 @@ static int isapnp_try_isolate ( void ) {
} }
/* Give the device a CSN */ /* Give the device a CSN */
isapnp_max_csn++; csn++;
DBG ( "ISAPnP found card " ISAPNP_CARD_ID_FMT DBG ( "ISAPnP found card " ISAPNP_CARD_ID_FMT
", assigning CSN %hhx\n", ", assigning CSN %hhx\n",
ISAPNP_CARD_ID_DATA ( &identifier ), isapnp_max_csn ); ISAPNP_CARD_ID_DATA ( &identifier ), csn );
isapnp_write_csn ( isapnp_max_csn ); isapnp_write_csn ( csn );
isapnp_delay(); isapnp_delay();
/* Send this card back to Sleep and force all cards /* Send this card back to Sleep and force all cards
@ -394,8 +392,8 @@ static int isapnp_try_isolate ( void ) {
/* Return number of cards found */ /* Return number of cards found */
DBG ( "ISAPnP found %d cards at read port %hx\n", DBG ( "ISAPnP found %d cards at read port %hx\n",
isapnp_max_csn, isapnp_read_port ); csn, isapnp_read_port );
return isapnp_max_csn; return csn;
} }
/* /*
@ -419,16 +417,64 @@ static void isapnp_isolate ( void ) {
} }
} }
/*
* Increment a bus_loc structure to the next possible ISAPnP location.
* Leave the structure zeroed and return 0 if there are no more valid
* locations.
*
*/
static int isapnp_next_location ( struct bus_loc *bus_loc ) {
struct isapnp_loc *isapnp_loc = ( struct isapnp_loc * ) bus_loc;
/*
* Ensure that there is sufficient space in the shared bus
* structures for a struct isapnp_loc and a struct isapnp_dev,
* as mandated by bus.h.
*
*/
BUS_LOC_CHECK ( struct isapnp_loc );
BUS_DEV_CHECK ( struct isapnp_device );
return ( ++isapnp_loc->logdev ? 1 : ++isapnp_loc->csn );
}
/* /*
* Fill in parameters for an ISAPnP device based on CSN * Fill in parameters for an ISAPnP device based on CSN
* *
* Return 1 if device present, 0 otherwise * Return 1 if device present, 0 otherwise
* *
*/ */
static int fill_isapnp_device ( struct isapnp_device *isapnp ) { static int isapnp_fill_device ( struct bus_dev *bus_dev,
struct bus_loc *bus_loc ) {
struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
struct isapnp_loc *isapnp_loc = ( struct isapnp_loc * ) bus_loc;
unsigned int i; unsigned int i;
struct isapnp_identifier identifier; struct isapnp_identifier identifier;
struct isapnp_logdevid logdevid; struct isapnp_logdevid logdevid;
static struct {
uint8_t csn;
uint8_t first_nonexistent_logdev;
} cache = { 0, 0 };
/* Copy CSN and logdev to isapnp_device, set default values */
isapnp->csn = isapnp_loc->csn;
isapnp->logdev = isapnp_loc->logdev;
isapnp->name = "?";
/* CSN 0 is never valid, but may be passed in */
if ( ! isapnp->csn )
return 0;
/* Check cache to see if we are already past the highest
* logical device of this CSN
*/
if ( ( isapnp->csn == cache.csn ) &&
( isapnp->logdev >= cache.first_nonexistent_logdev ) )
return 0;
/* Perform isolation if it hasn't yet been done */
if ( ! isapnp_read_port )
isapnp_isolate();
/* Wake the card */ /* Wake the card */
isapnp_wait_for_key (); isapnp_wait_for_key ();
@ -438,6 +484,14 @@ static int fill_isapnp_device ( struct isapnp_device *isapnp ) {
/* Read the card identifier */ /* Read the card identifier */
isapnp_peek ( ( char * ) &identifier, sizeof ( identifier ) ); isapnp_peek ( ( char * ) &identifier, sizeof ( identifier ) );
/* Need to return 0 if no device exists at this CSN */
if ( identifier.vendor_id & 0x80 ) {
DBG ( "ISAPnP found no card %hhx\n", isapnp->csn );
cache.csn = isapnp->csn;
cache.first_nonexistent_logdev = 0;
return 0;
}
/* Find the Logical Device ID tag corresponding to this device */ /* Find the Logical Device ID tag corresponding to this device */
for ( i = 0 ; i <= isapnp->logdev ; i++ ) { for ( i = 0 ; i <= isapnp->logdev ; i++ ) {
if ( ! isapnp_find_tag ( ISAPNP_TAG_LOGDEVID, if ( ! isapnp_find_tag ( ISAPNP_TAG_LOGDEVID,
@ -447,6 +501,8 @@ static int fill_isapnp_device ( struct isapnp_device *isapnp ) {
"card " ISAPNP_CARD_ID_FMT "\n", "card " ISAPNP_CARD_ID_FMT "\n",
isapnp->csn, isapnp->logdev, isapnp->csn, isapnp->logdev,
ISAPNP_CARD_ID_DATA ( &identifier ) ); ISAPNP_CARD_ID_DATA ( &identifier ) );
cache.csn = isapnp->csn;
cache.first_nonexistent_logdev = isapnp->logdev;
return 0; return 0;
} }
} }
@ -475,99 +531,74 @@ static int fill_isapnp_device ( struct isapnp_device *isapnp ) {
} }
/* /*
* Find an ISAPnP device matching the specified driver * Test whether or not a driver is capable of driving the device.
* *
*/ */
int find_isapnp_device ( struct isapnp_device *isapnp, static int isapnp_check_driver ( struct bus_dev *bus_dev,
struct isapnp_driver *driver ) { struct device_driver *device_driver ) {
struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
struct isapnp_driver *driver
= ( struct isapnp_driver * ) device_driver->bus_driver_info;
unsigned int i; unsigned int i;
/* Initialise struct isapnp if it's the first time it's been used. */ /* Compare against driver's ID list */
if ( isapnp->magic != isapnp_magic ) { for ( i = 0 ; i < driver->id_count ; i++ ) {
memset ( isapnp, 0, sizeof ( *isapnp ) ); struct isapnp_id *id = &driver->ids[i];
isapnp->magic = isapnp_magic;
isapnp->csn = 1;
}
/* Ensure that all ISAPnP cards have CSNs allocated to them, if ( ( isapnp->vendor_id == id->vendor_id ) &&
* if we haven't already done so. ( ISA_PROD_ID ( isapnp->prod_id ) ==
*/ ISA_PROD_ID ( id->prod_id ) ) ) {
if ( ! isapnp_read_port ) { DBG ( "ISAPnP found ID %hx:%hx "
isapnp_isolate(); "(\"%s\") (device %s) "
} "matching driver %s\n",
isapnp->vendor_id,
/* Iterate through all possible ISAPNP CSNs, starting where we isapnp->prod_id,
* left off. isa_id_string( isapnp->vendor_id,
*/ isapnp->prod_id ),
DBG ( "ISAPnP searching for device matching driver %s\n", id->name, driver->name );
driver->name ); isapnp->name = id->name;
for ( ; isapnp->csn <= isapnp_max_csn ; isapnp->csn++ ) { return 1;
for ( ; isapnp->logdev <= 0xff ; isapnp->logdev++ ) {
/* If we've already used this device, skip it */
if ( isapnp->already_tried ) {
isapnp->already_tried = 0;
continue;
}
/* Fill in device parameters */
if ( ! fill_isapnp_device ( isapnp ) ) {
/* If fill_isapnp_device fails, assume
* that we've reached the last logical
* device on this card, and proceed to
* the next card.
*/
isapnp->logdev = 0;
break;
}
/* Compare against driver's ID list */
for ( i = 0 ; i < driver->id_count ; i++ ) {
struct isapnp_id *id = &driver->ids[i];
if ( ( isapnp->vendor_id == id->vendor_id ) &&
( ISA_PROD_ID ( isapnp->prod_id ) ==
ISA_PROD_ID ( id->prod_id ) ) ) {
DBG ( "ISAPnP found ID %hx:%hx "
"(\"%s\") (device %s) "
"matching driver %s\n",
isapnp->vendor_id,
isapnp->prod_id,
isa_id_string( isapnp->vendor_id,
isapnp->prod_id ),
id->name, driver->name );
isapnp->name = id->name;
isapnp->already_tried = 1;
return 1;
}
}
} }
} }
/* No device found */
DBG ( "ISAPnP found no device matching driver %s\n", driver->name );
isapnp->csn = 1;
return 0; return 0;
} }
/* /*
* Find the next ISAPNP device that can be used to boot using the * Describe an ISAPnP device
* specified driver.
* *
*/ */
int find_isapnp_boot_device ( struct dev *dev, struct isapnp_driver *driver ) { static char * isapnp_describe ( struct bus_dev *bus_dev ) {
struct isapnp_device *isapnp = ( struct isapnp_device * ) dev->bus; struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
static char isapnp_description[] = "ISAPnP 00:00";
if ( ! find_isapnp_device ( isapnp, driver ) ) sprintf ( isapnp_description + 7, "%hhx:%hhx",
return 0; isapnp->csn, isapnp->logdev );
return isapnp_description;
dev->name = isapnp->name;
dev->devid.bus_type = ISA_BUS_TYPE;
dev->devid.vendor_id = isapnp->vendor_id;
dev->devid.device_id = isapnp->prod_id;
return 1;
} }
/*
* Name an ISAPnP device
*
*/
static const char * isapnp_name ( struct bus_dev *bus_dev ) {
struct isapnp_device *isapnp = ( struct isapnp_device * ) bus_dev;
return isapnp->name;
}
/*
* ISAPnP bus operations table
*
*/
struct bus_driver isapnp_driver __bus_driver = {
.next_location = isapnp_next_location,
.fill_device = isapnp_fill_device,
.check_driver = isapnp_check_driver,
.describe = isapnp_describe,
.name = isapnp_name,
};
/* /*
* Activate or deactivate an ISAPnP device * Activate or deactivate an ISAPnP device
* *
@ -594,3 +625,20 @@ void activate_isapnp_device ( struct isapnp_device *isapnp,
DBG ( "ISAPnP activated device %hhx.%hhx\n", DBG ( "ISAPnP activated device %hhx.%hhx\n",
isapnp->csn, isapnp->logdev ); isapnp->csn, isapnp->logdev );
} }
/*
* Fill in a nic structure
*
*/
void isapnp_fill_nic ( struct nic *nic, struct isapnp_device *isapnp ) {
/* Fill in ioaddr and irqno */
nic->ioaddr = isapnp->ioaddr;
nic->irqno = isapnp->irqno;
/* Fill in DHCP device ID structure */
nic->dhcp_dev_id.bus_type = ISA_BUS_TYPE;
nic->dhcp_dev_id.vendor_id = htons ( isapnp->vendor_id );
nic->dhcp_dev_id.device_id = htons ( isapnp->prod_id );
}

143
src/drivers/bus/mca.c
View File

@ -7,23 +7,45 @@
#include "string.h" #include "string.h"
#include "io.h" #include "io.h"
#include "console.h"
#include "nic.h"
#include "mca.h" #include "mca.h"
/* /*
* Ensure that there is sufficient space in the shared dev_bus * Increment a bus_loc structure to the next possible MCA location.
* structure for a struct pci_device. * Leave the structure zeroed and return 0 if there are no more valid
* locations.
* *
*/ */
DEV_BUS( struct mca_device, mca_dev ); static int mca_next_location ( struct bus_loc *bus_loc ) {
static char mca_magic[0]; /* guaranteed unique symbol */ struct mca_loc *mca_loc = ( struct mca_loc * ) bus_loc;
/*
* Ensure that there is sufficient space in the shared bus
* structures for a struct mca_loc and a struct
* mca_dev, as mandated by bus.h.
*
*/
BUS_LOC_CHECK ( struct mca_loc );
BUS_DEV_CHECK ( struct mca_device );
return ( ++mca_loc->slot & MCA_MAX_SLOT_NR );
}
/* /*
* Fill in parameters for an MCA device based on slot number * Fill in parameters for an MCA device based on slot number
* *
*/ */
static int fill_mca_device ( struct mca_device *mca ) { static int mca_fill_device ( struct bus_dev *bus_dev,
struct bus_loc *bus_loc ) {
struct mca_loc *mca_loc = ( struct mca_loc * ) bus_loc;
struct mca_device *mca = ( struct mca_device * ) bus_dev;
unsigned int i, seen_non_ff; unsigned int i, seen_non_ff;
/* Store slot in struct mca, set default values */
mca->slot = mca_loc->slot;
mca->name = "?";
/* Make sure motherboard setup is off */ /* Make sure motherboard setup is off */
outb_p ( 0xff, MCA_MOTHERBOARD_SETUP_REG ); outb_p ( 0xff, MCA_MOTHERBOARD_SETUP_REG );
@ -58,70 +80,81 @@ static int fill_mca_device ( struct mca_device *mca ) {
} }
/* /*
* Find an MCA device matching the specified driver * Test whether or not a driver is capable of driving the device.
* *
*/ */
int find_mca_device ( struct mca_device *mca, struct mca_driver *driver ) { static int mca_check_driver ( struct bus_dev *bus_dev,
struct device_driver *device_driver ) {
struct mca_device *mca = ( struct mca_device * ) bus_dev;
struct mca_driver *driver
= ( struct mca_driver * ) device_driver->bus_driver_info;
unsigned int i; unsigned int i;
/* Initialise struct mca if it's the first time it's been used. */ /* Compare against driver's ID list */
if ( mca->magic != mca_magic ) { for ( i = 0 ; i < driver->id_count ; i++ ) {
memset ( mca, 0, sizeof ( *mca ) ); struct mca_id *id = &driver->ids[i];
mca->magic = mca_magic;
}
/* Iterate through all possible MCA slots, starting where we if ( MCA_ID ( mca ) == id->id ) {
* left off DBG ( "MCA found ID %hx (device %s) "
*/ "matching driver %s\n",
DBG ( "MCA searching for device matching driver %s\n", driver->name ); id->name, id->id, driver->name );
for ( ; mca->slot < MCA_MAX_SLOT_NR ; mca->slot++ ) { mca->name = id->name;
/* If we've already used this device, skip it */ return 1;
if ( mca->already_tried ) {
mca->already_tried = 0;
continue;
}
/* Fill in device parameters */
if ( ! fill_mca_device ( mca ) ) {
continue;
}
/* Compare against driver's ID list */
for ( i = 0 ; i < driver->id_count ; i++ ) {
struct mca_id *id = &driver->ids[i];
if ( MCA_ID ( mca ) == id->id ) {
DBG ( "MCA found ID %hx (device %s) "
"matching driver %s\n",
id->name, id->id, driver->name );
mca->name = id->name;
mca->already_tried = 1;
return 1;
}
} }
} }
/* No device found */ /* No device found */
DBG ( "MCA found no device matching driver %s\n", driver->name );
mca->slot = 0;
return 0; return 0;
} }
/* /*
* Find the next MCA device that can be used to boot using the * Describe an MCA device
* specified driver.
* *
*/ */
int find_mca_boot_device ( struct dev *dev, struct mca_driver *driver ) { static char * mca_describe ( struct bus_dev *bus_dev ) {
struct mca_device *mca = ( struct mca_device * )dev->bus; struct mca_device *mca = ( struct mca_device * ) bus_dev;
static char mca_description[] = "MCA 00";
if ( ! find_mca_device ( mca, driver ) ) sprintf ( mca_description + 4, "%hhx", mca->slot );
return 0; return mca_description;
}
dev->name = mca->name;
dev->devid.bus_type = MCA_BUS_TYPE; /*
dev->devid.vendor_id = GENERIC_MCA_VENDOR; * Name an MCA device
dev->devid.device_id = MCA_ID ( mca ); *
*/
return 1; static const char * mca_name ( struct bus_dev *bus_dev ) {
struct mca_device *mca = ( struct mca_device * ) bus_dev;
return mca->name;
}
/*
* MCA bus operations table
*
*/
struct bus_driver mca_driver __bus_driver = {
.next_location = mca_next_location,
.fill_device = mca_fill_device,
.check_driver = mca_check_driver,
.describe = mca_describe,
.name = mca_name,
};
/*
* Fill in a nic structure
*
*/
void mca_fill_nic ( struct nic *nic, struct mca_device *mca ) {
/* ioaddr and irqno must be read in a device-dependent way
* from the POS registers
*/
nic->ioaddr = 0;
nic->irqno = 0;
/* Fill in DHCP device ID structure */
nic->dhcp_dev_id.bus_type = MCA_BUS_TYPE;
nic->dhcp_dev_id.vendor_id = htons ( GENERIC_MCA_VENDOR );
nic->dhcp_dev_id.device_id = htons ( MCA_ID ( mca ) );
} }

20
src/drivers/bus/pci.c
View File

@ -45,7 +45,7 @@ static int pci_fill_device ( struct bus_dev *bus_dev,
struct pci_device *pci = ( struct pci_device * ) bus_dev; struct pci_device *pci = ( struct pci_device * ) bus_dev;
uint16_t busdevfn = pci_loc->busdevfn; uint16_t busdevfn = pci_loc->busdevfn;
static struct { static struct {
uint16_t devfn0; uint16_t busdevfn0;
int is_present; int is_present;
} cache = { 0, 1 }; } cache = { 0, 1 };
uint32_t l; uint32_t l;
@ -65,7 +65,7 @@ static int pci_fill_device ( struct bus_dev *bus_dev,
* increase scan speed by a factor of 8. * increase scan speed by a factor of 8.
*/ */
if ( ( PCI_FUNC ( busdevfn ) != 0 ) && if ( ( PCI_FUNC ( busdevfn ) != 0 ) &&
( PCI_FN0 ( busdevfn ) == cache.devfn0 ) && ( PCI_FN0 ( busdevfn ) == cache.busdevfn0 ) &&
( ! cache.is_present ) ) { ( ! cache.is_present ) ) {
return 0; return 0;
} }
@ -79,7 +79,7 @@ static int pci_fill_device ( struct bus_dev *bus_dev,
/* Don't look for subsequent functions if the /* Don't look for subsequent functions if the
* card itself is not present. * card itself is not present.
*/ */
cache.devfn0 = busdevfn; cache.busdevfn0 = busdevfn;
cache.is_present = 0; cache.is_present = 0;
} }
return 0; return 0;
@ -130,7 +130,7 @@ static int pci_fill_device ( struct bus_dev *bus_dev,
pci_read_config_byte ( pci, PCI_INTERRUPT_LINE, &pci->irq ); pci_read_config_byte ( pci, PCI_INTERRUPT_LINE, &pci->irq );
} }
DBG ( "found device %hhx:%hhx.%d Class %hx: %hx:%hx (rev %hhx)\n", DBG ( "PCI found device %hhx:%hhx.%d Class %hx: %hx:%hx (rev %hhx)\n",
PCI_BUS ( pci->busdevfn ), PCI_DEV ( pci->busdevfn ), PCI_BUS ( pci->busdevfn ), PCI_DEV ( pci->busdevfn ),
PCI_FUNC ( pci->busdevfn ), pci->class, pci->vendor_id, PCI_FUNC ( pci->busdevfn ), pci->class, pci->vendor_id,
pci->device_id, pci->revision ); pci->device_id, pci->revision );
@ -152,7 +152,7 @@ static int pci_check_driver ( struct bus_dev *bus_dev,
/* If driver has a class, and class matches, use it */ /* If driver has a class, and class matches, use it */
if ( pci_driver->class && if ( pci_driver->class &&
( pci_driver->class == pci->class ) ) { ( pci_driver->class == pci->class ) ) {
DBG ( "driver %s matches class %hx\n", DBG ( "PCI driver %s matches class %hx\n",
device_driver->name, pci_driver->class ); device_driver->name, pci_driver->class );
pci->name = device_driver->name; pci->name = device_driver->name;
return 1; return 1;
@ -164,7 +164,7 @@ static int pci_check_driver ( struct bus_dev *bus_dev,
if ( ( pci->vendor_id == id->vendor_id ) && if ( ( pci->vendor_id == id->vendor_id ) &&
( pci->device_id == id->device_id ) ) { ( pci->device_id == id->device_id ) ) {
DBG ( "driver %s device %s matches ID %hx:%hx\n", DBG ( "PCI driver %s device %s matches ID %hx:%hx\n",
device_driver->name, id->name, device_driver->name, id->name,
id->vendor_id, id->device_id ); id->vendor_id, id->device_id );
pci->name = id->name; pci->name = id->name;
@ -222,7 +222,7 @@ void adjust_pci_device ( struct pci_device *pci ) {
pci_read_config_word ( pci, PCI_COMMAND, &pci_command ); pci_read_config_word ( pci, PCI_COMMAND, &pci_command );
new_command = pci_command | PCI_COMMAND_MASTER | PCI_COMMAND_IO; new_command = pci_command | PCI_COMMAND_MASTER | PCI_COMMAND_IO;
if ( pci_command != new_command ) { if ( pci_command != new_command ) {
DBG ( "BIOS has not enabled device %hhx:%hhx.%d! " DBG ( "PCI BIOS has not enabled device %hhx:%hhx.%d! "
"Updating PCI command %hX->%hX\n", "Updating PCI command %hX->%hX\n",
PCI_BUS ( pci->busdevfn ), PCI_DEV ( pci->busdevfn ), PCI_BUS ( pci->busdevfn ), PCI_DEV ( pci->busdevfn ),
PCI_FUNC ( pci->busdevfn ), pci_command, new_command ); PCI_FUNC ( pci->busdevfn ), pci_command, new_command );
@ -230,7 +230,7 @@ void adjust_pci_device ( struct pci_device *pci ) {
} }
pci_read_config_byte ( pci, PCI_LATENCY_TIMER, &pci_latency); pci_read_config_byte ( pci, PCI_LATENCY_TIMER, &pci_latency);
if ( pci_latency < 32 ) { if ( pci_latency < 32 ) {
DBG ( "device %hhx:%hhx.%d latency timer is " DBG ( "PCI device %hhx:%hhx.%d latency timer is "
"unreasonably low at %d. Setting to 32.\n", "unreasonably low at %d. Setting to 32.\n",
PCI_BUS ( pci->busdevfn ), PCI_DEV ( pci->busdevfn ), PCI_BUS ( pci->busdevfn ), PCI_DEV ( pci->busdevfn ),
PCI_FUNC ( pci->busdevfn ), pci_latency ); PCI_FUNC ( pci->busdevfn ), pci_latency );
@ -338,7 +338,7 @@ int pci_find_capability ( struct pci_device *pci, int cap ) {
while ( ttl-- && pos >= 0x40 ) { while ( ttl-- && pos >= 0x40 ) {
pos &= ~3; pos &= ~3;
pci_read_config_byte ( pci, pos + PCI_CAP_LIST_ID, &id ); pci_read_config_byte ( pci, pos + PCI_CAP_LIST_ID, &id );
DBG ( "Capability: %d\n", id ); DBG ( "PCI Capability: %d\n", id );
if ( id == 0xff ) if ( id == 0xff )
break; break;
if ( id == cap ) if ( id == cap )
@ -349,7 +349,7 @@ int pci_find_capability ( struct pci_device *pci, int cap ) {
} }
/* /*
* Fill in a DHCP device ID structure * Fill in a nic structure
* *
*/ */
void pci_fill_nic ( struct nic *nic, struct pci_device *pci ) { void pci_fill_nic ( struct nic *nic, struct pci_device *pci ) {

33
src/include/eisa.h
View File

@ -1,8 +1,9 @@
#ifndef EISA_H #ifndef EISA_H
#define EISA_H #define EISA_H
#include "stdint.h"
#include "isa_ids.h" #include "isa_ids.h"
#include "dev.h" #include "nic.h"
/* /*
* EISA constants * EISA constants
@ -10,7 +11,7 @@
*/ */
#define EISA_MIN_SLOT (0x1) #define EISA_MIN_SLOT (0x1)
#define EISA_MAX_SLOT (0xf) #define EISA_MAX_SLOT (0xf) /* Must be 2^n - 1 */
#define EISA_SLOT_BASE( n ) ( 0x1000 * (n) ) #define EISA_SLOT_BASE( n ) ( 0x1000 * (n) )
#define EISA_MFG_ID_HI ( 0xc80 ) #define EISA_MFG_ID_HI ( 0xc80 )
@ -22,18 +23,24 @@
#define EISA_CMD_RESET ( 1 << 2 ) #define EISA_CMD_RESET ( 1 << 2 )
#define EISA_CMD_ENABLE ( 1 << 0 ) #define EISA_CMD_ENABLE ( 1 << 0 )
/*
* A location on an EISA bus
*
*/
struct eisa_loc {
unsigned int slot;
};
/* /*
* A physical EISA device * A physical EISA device
* *
*/ */
struct eisa_device { struct eisa_device {
char *magic; /* must be first */
const char *name; const char *name;
unsigned int slot; unsigned int slot;
uint16_t ioaddr; uint16_t ioaddr;
uint16_t mfg_id; uint16_t mfg_id;
uint16_t prod_id; uint16_t prod_id;
int already_tried;
}; };
/* /*
@ -59,20 +66,22 @@ struct eisa_driver {
* Define an EISA driver * Define an EISA driver
* *
*/ */
#define EISA_DRIVER( driver_name, eisa_ids ) { \ #define EISA_DRIVER( _ids ) { \
.name = driver_name, \ .ids = _ids, \
.ids = eisa_ids, \ .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \
.id_count = sizeof ( eisa_ids ) / sizeof ( eisa_ids[0] ), \
} }
/* /*
* Functions in eisa.c * Functions in eisa.c
* *
*/ */
extern int find_eisa_device ( struct eisa_device *eisa,
struct eisa_driver *driver );
extern int find_eisa_boot_device ( struct dev *dev,
struct eisa_driver *driver );
extern void enable_eisa_device ( struct eisa_device *eisa ); extern void enable_eisa_device ( struct eisa_device *eisa );
extern void fill_eisa_nic ( struct nic *nic, struct eisa_device *eisa );
/*
* EISA bus global definition
*
*/
extern struct bus_driver eisa_driver;
#endif /* EISA_H */ #endif /* EISA_H */

33
src/include/isa.h
View File

@ -1,18 +1,29 @@
#ifndef ISA_H #ifndef ISA_H
#define ISA_H #define ISA_H
#include "stdint.h"
#include "isa_ids.h" #include "isa_ids.h"
#include "dev.h" #include "nic.h"
/*
* A location on an ISA bus
*
*/
struct isa_loc {
unsigned int probe_idx;
};
#define ISA_MAX_PROBE_IDX 255 /* Unlikely to ever be more than ~20 */
/* /*
* A physical ISA device * A physical ISA device
* *
*/ */
struct isa_device { struct isa_device {
char *magic; /* must be first */ const char *name;
unsigned int probe_idx; unsigned int driver_probe_idx;
uint16_t ioaddr; uint16_t ioaddr;
int already_tried; uint16_t mfg_id;
uint16_t prod_id;
}; };
/* /*
@ -41,8 +52,7 @@ struct isa_driver {
* Define an ISA driver * Define an ISA driver
* *
*/ */
#define ISA_DRIVER( _name, _probe_addrs, _probe_addr, _mfg_id, _prod_id ) { \ #define ISA_DRIVER( _probe_addrs, _probe_addr, _mfg_id, _prod_id ) { \
.name = _name, \
.probe_addrs = _probe_addrs, \ .probe_addrs = _probe_addrs, \
.addr_count = sizeof ( _probe_addrs ) / sizeof ( _probe_addrs[0] ), \ .addr_count = sizeof ( _probe_addrs ) / sizeof ( _probe_addrs[0] ), \
.probe_addr = _probe_addr, \ .probe_addr = _probe_addr, \
@ -61,10 +71,13 @@ struct isa_driver {
* Functions in isa.c * Functions in isa.c
* *
*/ */
extern int find_isa_device ( struct isa_device *eisa, extern void fill_isa_nic ( struct nic *nic, struct isa_device *isa );
struct isa_driver *driver );
extern int find_isa_boot_device ( struct dev *dev, /*
struct isa_driver *driver ); * ISA bus global definition
*
*/
extern struct bus_driver isa_driver;
#endif /* ISA_H */ #endif /* ISA_H */

39
src/include/isapnp.h
View File

@ -36,8 +36,9 @@
#ifndef ISAPNP_H #ifndef ISAPNP_H
#define ISAPNP_H #define ISAPNP_H
#include "stdint.h"
#include "nic.h"
#include "isa_ids.h" #include "isa_ids.h"
#include "dev.h"
/* /*
* ISAPnP constants * ISAPnP constants
@ -154,12 +155,20 @@ struct isapnp_logdevid {
uint16_t flags; uint16_t flags;
} __attribute__ (( packed )); } __attribute__ (( packed ));
/*
* A location on an ISAPnP bus
*
*/
struct isapnp_loc {
uint8_t csn;
uint8_t logdev;
};
/* /*
* A physical ISAPnP device * A physical ISAPnP device
* *
*/ */
struct isapnp_device { struct isapnp_device {
char *magic; /* must be first */
const char *name; const char *name;
uint8_t csn; uint8_t csn;
uint8_t logdev; uint8_t logdev;
@ -167,7 +176,6 @@ struct isapnp_device {
uint16_t prod_id; uint16_t prod_id;
uint16_t ioaddr; uint16_t ioaddr;
uint8_t irqno; uint8_t irqno;
int already_tried;
}; };
/* /*
@ -184,7 +192,6 @@ struct isapnp_id {
* *
*/ */
struct isapnp_driver { struct isapnp_driver {
const char *name;
struct isapnp_id *ids; struct isapnp_id *ids;
unsigned int id_count; unsigned int id_count;
}; };
@ -193,21 +200,29 @@ struct isapnp_driver {
* Define an ISAPnP driver * Define an ISAPnP driver
* *
*/ */
#define ISAPNP_DRIVER( driver_name, isapnp_ids ) { \ #define ISAPNP_DRIVER( _ids ) { \
.name = driver_name, \ .ids = _ids, \
.ids = isapnp_ids, \ .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \
.id_count = sizeof ( isapnp_ids ) / sizeof ( isapnp_ids[0] ), \
} }
/* /*
* Functions in isapnp.c * Functions in isapnp.c
* *
*/ */
extern int find_isapnp_device ( struct isapnp_device *isapnp,
struct isapnp_driver *driver );
extern int find_isapnp_boot_device ( struct dev *dev,
struct isapnp_driver *driver );
extern void activate_isapnp_device ( struct isapnp_device *isapnp, extern void activate_isapnp_device ( struct isapnp_device *isapnp,
int active ); int active );
extern void isapnp_fill_nic ( struct nic *nic, struct isapnp_device *isapnp );
/*
* ISAPnP bus global definition
*
*/
extern struct bus_driver isapnp_driver;
/*
* ISAPnP read port. ROM prefix may be able to set this address.
*
*/
extern uint16_t isapnp_read_port;
#endif /* ISAPNP_H */ #endif /* ISAPNP_H */

26
src/include/mca.h
View File

@ -20,22 +20,28 @@
#define MCA_MOTHERBOARD_SETUP_REG 0x94 #define MCA_MOTHERBOARD_SETUP_REG 0x94
#define MCA_ADAPTER_SETUP_REG 0x96 #define MCA_ADAPTER_SETUP_REG 0x96
#define MCA_MAX_SLOT_NR 8 #define MCA_MAX_SLOT_NR 0x07 /* Must be 2^n - 1 */
#define MCA_POS_REG(n) (0x100+(n)) #define MCA_POS_REG(n) (0x100+(n))
/* Is there a standard that would define this? */ /* Is there a standard that would define this? */
#define GENERIC_MCA_VENDOR ISA_VENDOR ( 'M', 'C', 'A' ) #define GENERIC_MCA_VENDOR ISA_VENDOR ( 'M', 'C', 'A' )
/*
* A location on an MCA bus
*
*/
struct mca_loc {
unsigned int slot;
};
/* /*
* A physical MCA device * A physical MCA device
* *
*/ */
struct mca_device { struct mca_device {
char *magic; /* must be first */
const char *name; const char *name;
unsigned int slot; unsigned int slot;
unsigned char pos[8]; unsigned char pos[8];
int already_tried;
}; };
#define MCA_ID(mca) ( ( (mca)->pos[1] << 8 ) + (mca)->pos[0] ) #define MCA_ID(mca) ( ( (mca)->pos[1] << 8 ) + (mca)->pos[0] )
@ -53,7 +59,6 @@ struct mca_id {
* *
*/ */
struct mca_driver { struct mca_driver {
const char *name;
struct mca_id *ids; struct mca_id *ids;
unsigned int id_count; unsigned int id_count;
}; };
@ -62,18 +67,15 @@ struct mca_driver {
* Define an MCA driver * Define an MCA driver
* *
*/ */
#define MCA_DRIVER( driver_name, mca_ids ) { \ #define MCA_DRIVER( _ids ) { \
.name = driver_name, \ .ids = _ids, \
.ids = mca_ids, \ .id_count = sizeof ( _ids ) / sizeof ( _ids[0] ), \
.id_count = sizeof ( mca_ids ) / sizeof ( mca_ids[0] ), \
} }
/* /*
* Functions in mca.c * MCA bus global definition
* *
*/ */
extern int find_mca_device ( struct mca_device *mca, extern struct bus_driver mca_driver;
struct mca_driver *driver );
extern int find_mca_boot_device ( struct dev *dev, struct mca_driver *driver );
#endif #endif