From e44e3482bdb4d0ebde2d8b41830ac2cdb07948fb Mon Sep 17 00:00:00 2001 From: Yang Zhang Date: Fri, 28 Aug 2015 09:58:54 +0800 Subject: Add qemu 2.4.0 Change-Id: Ic99cbad4b61f8b127b7dc74d04576c0bcbaaf4f5 Signed-off-by: Yang Zhang --- qemu/roms/ipxe/src/drivers/net/3c509.c | 432 +++++++++++++++++++++++++++++++++ 1 file changed, 432 insertions(+) create mode 100644 qemu/roms/ipxe/src/drivers/net/3c509.c (limited to 'qemu/roms/ipxe/src/drivers/net/3c509.c') diff --git a/qemu/roms/ipxe/src/drivers/net/3c509.c b/qemu/roms/ipxe/src/drivers/net/3c509.c new file mode 100644 index 000000000..4326a835c --- /dev/null +++ b/qemu/roms/ipxe/src/drivers/net/3c509.c @@ -0,0 +1,432 @@ +/* + * Split out into 3c509.c and 3c5x9.c, to make it possible to build a + * 3c529 module without including ISA, ISAPnP and EISA code. + * + */ + +FILE_LICENCE ( BSD2 ); + +#include +#include +#include +#include +#include +#include +#include +#include +#include "3c509.h" + +/* + * 3c509 cards have their own method of contention resolution; this + * effectively defines another bus type similar to ISAPnP. Even the + * original ISA cards can be programatically mapped to any I/O address + * in the range 0x200-0x3e0. + * + * However, there is a small problem: once you've activated a card, + * the only ways to deactivate it will also wipe its tag, meaning that + * you won't be able to subsequently reactivate it without going + * through the whole ID sequence again. The solution we adopt is to + * isolate and tag all cards at the start, and to immediately + * re-isolate and re-tag a card after disabling it. + * + */ + +static void t509bus_remove ( struct root_device *rootdev ); + +static unsigned int t509_id_port = 0; +static unsigned int t509_max_tag = 0; + +/** A 3c509 device */ +struct t509_device { + /** Generic device */ + struct device dev; + /** Tag */ + unsigned int tag; + /** I/O address */ + uint16_t ioaddr; + /** Driver-private data + * + * Use t509_set_drvdata() and t509_get_drvdata() to access + * this field. + */ + void *priv; +}; + +/** + * Set 3c509 driver-private data + * + * @v t509 3c509 device + * @v priv Private data + */ +static inline void t509_set_drvdata ( struct t509_device *t509, void *priv ) { + t509->priv = priv; +} + +/** + * Get 3c509 driver-private data + * + * @v t509 3c509 device + * @ret priv Private data + */ +static inline void * t509_get_drvdata ( struct t509_device *t509 ) { + return t509->priv; +} + +/* + * t509 utility functions + * + */ + +static inline void t509_set_id_port ( void ) { + outb ( 0x00, t509_id_port ); +} + +static inline void t509_wait_for_id_sequence ( void ) { + outb ( 0x00, t509_id_port ); +} + +static inline void t509_global_reset ( void ) { + outb ( 0xc0, t509_id_port ); +} + +static inline void t509_reset_tag ( void ) { + outb ( 0xd0, t509_id_port ); +} + +static inline void t509_set_tag ( uint8_t tag ) { + outb ( 0xd0 | tag, t509_id_port ); +} + +static inline void t509_select_tag ( uint8_t tag ) { + outb ( 0xd8 | tag, t509_id_port ); +} + +static inline void t509_activate ( uint16_t ioaddr ) { + outb ( 0xe0 | ( ioaddr >> 4 ), t509_id_port ); +} + +static inline void t509_deactivate_and_reset_tag ( uint16_t ioaddr ) { + outb ( GLOBAL_RESET, ioaddr + EP_COMMAND ); +} + +static inline void t509_load_eeprom_word ( uint8_t offset ) { + outb ( 0x80 | offset, t509_id_port ); +} + +/* + * Find a suitable ID port + * + */ +static inline int t509_find_id_port ( void ) { + + for ( t509_id_port = EP_ID_PORT_START ; + t509_id_port < EP_ID_PORT_END ; + t509_id_port += EP_ID_PORT_INC ) { + t509_set_id_port (); + /* See if anything's listening */ + outb ( 0xff, t509_id_port ); + if ( inb ( t509_id_port ) & 0x01 ) { + /* Found a suitable port */ + DBG ( "T509 using ID port at %04x\n", t509_id_port ); + return 0; + } + } + /* No id port available */ + DBG ( "T509 found no available ID port\n" ); + return -ENOENT; +} + +/* + * Send ID sequence to the ID port + * + */ +static void t509_send_id_sequence ( void ) { + unsigned short lrs_state, i; + + t509_set_id_port (); + /* Reset IDS on cards */ + t509_wait_for_id_sequence (); + lrs_state = 0xff; + for ( i = 0; i < 255; i++ ) { + outb ( lrs_state, t509_id_port ); + lrs_state <<= 1; + lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state; + } +} + +/* + * We get eeprom data from the id_port given an offset into the eeprom. + * Basically; after the ID_sequence is sent to all of the cards; they enter + * the ID_CMD state where they will accept command requests. 0x80-0xbf loads + * the eeprom data. We then read the port 16 times and with every read; the + * cards check for contention (ie: if one card writes a 0 bit and another + * writes a 1 bit then the host sees a 0. At the end of the cycle; each card + * compares the data on the bus; if there is a difference then that card goes + * into ID_WAIT state again). In the meantime; one bit of data is returned in + * the AX register which is conveniently returned to us by inb(). Hence; we + * read 16 times getting one bit of data with each read. + */ +static uint16_t t509_id_read_eeprom ( int offset ) { + int i, data = 0; + + t509_load_eeprom_word ( offset ); + /* Do we really need this wait? Won't be noticeable anyway */ + udelay(10000); + + for ( i = 0; i < 16; i++ ) { + data = ( data << 1 ) | ( inw ( t509_id_port ) & 1 ); + } + return data; +} + +/* + * Isolate and tag all t509 cards + * + */ +static int t509_isolate ( void ) { + unsigned int i; + uint16_t contend[3]; + int rc; + + /* Find a suitable ID port */ + if ( ( rc = t509_find_id_port() ) != 0 ) + return rc; + + while ( 1 ) { + + /* All cards are in ID_WAIT state each time we go + * through this loop. + */ + + /* Send the ID sequence */ + t509_send_id_sequence(); + + /* First time through, reset all tags. On subsequent + * iterations, kill off any already-tagged cards + */ + if ( t509_max_tag == 0 ) { + t509_reset_tag(); + } else { + t509_select_tag ( 0 ); + } + + /* Read the manufacturer ID, to see if there are any + * more cards + */ + if ( t509_id_read_eeprom ( EEPROM_MFG_ID ) != MFG_ID ) { + DBG ( "T509 saw %s signs of life\n", + t509_max_tag ? "no further" : "no" ); + break; + } + + /* Perform contention selection on the MAC address */ + for ( i = 0 ; i < 3 ; i++ ) { + contend[i] = t509_id_read_eeprom ( i ); + } + + /* Only one device will still be left alive. Tag it. */ + ++t509_max_tag; + DBG ( "T509 found card %04x%04x%04x, assigning tag %02x\n", + contend[0], contend[1], contend[2], t509_max_tag ); + t509_set_tag ( t509_max_tag ); + + /* Return all cards back to ID_WAIT state */ + t509_wait_for_id_sequence(); + } + + DBG ( "T509 found %d cards using ID port %04x\n", + t509_max_tag, t509_id_port ); + return 0; +} + +/* + * Activate a T509 device + * + * The device will be enabled at whatever ioaddr is specified in the + * struct t509_device; there is no need to stick with the default + * ioaddr read from the EEPROM. + * + */ +static inline void activate_t509_device ( struct t509_device *t509 ) { + t509_send_id_sequence (); + t509_select_tag ( t509->tag ); + t509_activate ( t509->ioaddr ); + DBG ( "T509 activated device %02x at ioaddr %04x\n", + t509->tag, t509->ioaddr ); +} + +/* + * Deactivate a T509 device + * + * Disabling also clears the tag, so we immediately isolate and re-tag + * this card. + * + */ +static inline void deactivate_t509_device ( struct t509_device *t509 ) { + t509_deactivate_and_reset_tag ( t509->ioaddr ); + udelay ( 1000 ); + t509_send_id_sequence (); + t509_select_tag ( 0 ); + t509_set_tag ( t509->tag ); + t509_wait_for_id_sequence (); + DBG ( "T509 deactivated device at %04x and re-tagged as %02x\n", + t509->ioaddr, t509->tag ); +} + +/* + * The ISA probe function + * + */ +static int legacy_t509_probe ( struct nic *nic, void *hwdev ) { + struct t509_device *t509 = hwdev; + + /* We could change t509->ioaddr if we wanted to */ + activate_t509_device ( t509 ); + nic->ioaddr = t509->ioaddr; + + /* Hand off to generic t5x9 probe routine */ + return t5x9_probe ( nic, ISA_PROD_ID ( PROD_ID ), ISA_PROD_ID_MASK ); +} + +static void legacy_t509_disable ( struct nic *nic, void *hwdev ) { + struct t509_device *t509 = hwdev; + + t5x9_disable ( nic ); + deactivate_t509_device ( t509 ); +} + +static inline void legacy_t509_set_drvdata ( void *hwdev, void *priv ) { + t509_set_drvdata ( hwdev, priv ); +} + +static inline void * legacy_t509_get_drvdata ( void *hwdev ) { + return t509_get_drvdata ( hwdev ); +} + +/** + * Probe a 3c509 device + * + * @v t509 3c509 device + * @ret rc Return status code + * + * Searches for a driver for the 3c509 device. If a driver is found, + * its probe() routine is called. + */ +static int t509_probe ( struct t509_device *t509 ) { + DBG ( "Adding 3c509 device %02x (I/O %04x)\n", + t509->tag, t509->ioaddr ); + return legacy_probe ( t509, legacy_t509_set_drvdata, &t509->dev, + legacy_t509_probe, legacy_t509_disable ); +} + +/** + * Remove a 3c509 device + * + * @v t509 3c509 device + */ +static void t509_remove ( struct t509_device *t509 ) { + legacy_remove ( t509, legacy_t509_get_drvdata, legacy_t509_disable ); + DBG ( "Removed 3c509 device %02x\n", t509->tag ); +} + +/** + * Probe 3c509 root bus + * + * @v rootdev 3c509 bus root device + * + * Scans the 3c509 bus for devices and registers all devices it can + * find. + */ +static int t509bus_probe ( struct root_device *rootdev ) { + struct t509_device *t509 = NULL; + unsigned int tag; + unsigned int iobase; + int rc; + + /* Perform isolation and tagging */ + if ( ( rc = t509_isolate() ) != 0 ) + return rc; + + for ( tag = 1 ; tag <= t509_max_tag ; tag++ ) { + /* Allocate struct t509_device */ + if ( ! t509 ) + t509 = malloc ( sizeof ( *t509 ) ); + if ( ! t509 ) { + rc = -ENOMEM; + goto err; + } + memset ( t509, 0, sizeof ( *t509 ) ); + t509->tag = tag; + + /* Send the ID sequence */ + t509_send_id_sequence (); + + /* Select the specified tag */ + t509_select_tag ( t509->tag ); + + /* Read the default I/O address */ + iobase = t509_id_read_eeprom ( EEPROM_ADDR_CFG ); + t509->ioaddr = 0x200 + ( ( iobase & 0x1f ) << 4 ); + + /* Send card back to ID_WAIT */ + t509_wait_for_id_sequence(); + + /* Add to device hierarchy */ + snprintf ( t509->dev.name, sizeof ( t509->dev.name ), + "t509%02x", tag ); + t509->dev.desc.bus_type = BUS_TYPE_ISA; + t509->dev.desc.vendor = MFG_ID; + t509->dev.desc.device = PROD_ID; + t509->dev.parent = &rootdev->dev; + list_add ( &t509->dev.siblings, &rootdev->dev.children ); + INIT_LIST_HEAD ( &t509->dev.children ); + + /* Look for a driver */ + if ( t509_probe ( t509 ) == 0 ) { + /* t509dev registered, we can drop our ref */ + t509 = NULL; + } else { + /* Not registered; re-use struct */ + list_del ( &t509->dev.siblings ); + } + } + + free ( t509 ); + return 0; + + err: + free ( t509 ); + t509bus_remove ( rootdev ); + return rc; +} + +/** + * Remove 3c509 root bus + * + * @v rootdev 3c509 bus root device + */ +static void t509bus_remove ( struct root_device *rootdev ) { + struct t509_device *t509; + struct t509_device *tmp; + + list_for_each_entry_safe ( t509, tmp, &rootdev->dev.children, + dev.siblings ) { + t509_remove ( t509 ); + list_del ( &t509->dev.siblings ); + free ( t509 ); + } +} + +/** 3c509 bus root device driver */ +static struct root_driver t509_root_driver = { + .probe = t509bus_probe, + .remove = t509bus_remove, +}; + +/** 3c509 bus root device */ +struct root_device t509_root_device __root_device = { + .dev = { .name = "3c509" }, + .driver = &t509_root_driver, +}; + +ISA_ROM ( "3c509", "3c509" ); -- cgit 1.2.3-korg