Updated to new bus API, and improved using the 3c5x9 reference manual.
authorMichael Brown <mcb30@etherboot.org>
Fri, 22 Apr 2005 15:55:13 +0000 (15:55 +0000)
committerMichael Brown <mcb30@etherboot.org>
Fri, 22 Apr 2005 15:55:13 +0000 (15:55 +0000)
src/drivers/net/3c509.c

index c29dea8..bc21978 100644 (file)
 
 /*
  * 3c509 cards have their own method of contention resolution; this
 
 /*
  * 3c509 cards have their own method of contention resolution; this
- * effectively defines another bus type.
+ * 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 uint16_t t509_id_port = 0;
+static uint8_t t509_max_tag = 0;
+
 /*
 /*
- * A physical t509 device
+ * A location on a t509 bus
  *
  */
  *
  */
-struct t509_device {
-       char *magic; /* must be first */
-       uint16_t id_port;
-       uint16_t ioaddr;
-       unsigned char current_tag;
+struct t509_loc {
+       uint8_t tag;
 };
 
 /*
 };
 
 /*
- * A t509 driver
+ * A physical t509 device
  *
  */
  *
  */
-struct t509_driver {
-       const char *name;
+struct t509_device {
+       uint16_t ioaddr;
+       uint8_t tag;
 };
 
 /*
 };
 
 /*
- * Ensure that there is sufficient space in the shared dev_bus
- * structure for a struct pci_device.
+ * t509 utility functions
  *
  */
  *
  */
-DEV_BUS( struct t509_device, t509_dev );
-static char t509_magic[0]; /* guaranteed unique symbol */
+
+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 port that can be used for contention select
- *
- * Called only once, so inlined for efficiency.
+ * Find a suitable ID port
  *
  */
  *
  */
-static inline int find_id_port ( struct t509_device *t509 ) {
-       for ( t509->id_port = EP_ID_PORT_START ;
-             t509->id_port < EP_ID_PORT_END ;
-             t509->id_port += EP_ID_PORT_INC ) {
-               outb ( 0x00, t509->id_port );
-               outb ( 0xff, t509->id_port );
-               if ( inb ( t509->id_port ) & 0x01 ) {
+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 */
                        /* Found a suitable port */
+                       DBG ( "T509 using ID port at %hx\n", t509_id_port );
                        return 1;
                }
        }
        /* No id port available */
                        return 1;
                }
        }
        /* No id port available */
+       DBG ( "T509 found no available ID port\n" );
        return 0;
 }
 
 /*
  * Send ID sequence to the ID port
  *
        return 0;
 }
 
 /*
  * Send ID sequence to the ID port
  *
- * Called only once, so inlined for efficiency.
- *
  */
  */
-static inline void send_id_sequence ( struct t509_device *t509 ) {
+static void t509_send_id_sequence ( void ) {
        unsigned short lrs_state, i;
 
        unsigned short lrs_state, i;
 
-       outb ( 0x00, t509->id_port );
-        outb ( 0x00, t509->id_port );
+       t509_set_id_port ();
+       /* Reset IDS on cards */
+       t509_wait_for_id_sequence ();
        lrs_state = 0xff;
         for ( i = 0; i < 255; i++ ) {
        lrs_state = 0xff;
         for ( i = 0; i < 255; i++ ) {
-                outb ( lrs_state, t509->id_port );
+                outb ( lrs_state, t509_id_port );
                 lrs_state <<= 1;
                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
         }
                 lrs_state <<= 1;
                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
         }
@@ -96,142 +140,260 @@ static inline void send_id_sequence ( struct t509_device *t509 ) {
  * the AX register which is conveniently returned to us by inb().  Hence; we
  * read 16 times getting one bit of data with each read.
  */
  * 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 id_read_eeprom ( struct t509_device *t509, int offset ) {
+static uint16_t t509_id_read_eeprom ( int offset ) {
        int i, data = 0;
 
        int i, data = 0;
 
-       outb ( 0x80 + offset, t509->id_port );
+       t509_load_eeprom_word ( offset );
        /* Do we really need this wait? Won't be noticeable anyway */
        udelay(10000);
 
        for ( i = 0; i < 16; i++ ) {
        /* 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 );
+               data = ( data << 1 ) | ( inw ( t509_id_port ) & 1 );
        }
        return data;
 }
 
 /*
        }
        return data;
 }
 
 /*
- * Find the next t509 device
- *
- * Called only once, so inlined for efficiency.
+ * Isolate and tag all t509 cards
  *
  */
  *
  */
-static inline int fill_t509_device ( struct t509_device *t509 ) {
-       int i;
-       uint16_t iobase;
+static void t509_isolate ( void ) {
+       unsigned int i;
+       uint16_t contend[3];
 
 
-       /*
-        * We need an ID port, if we don't already have one.
-        *
-        */
-       if ( ! t509->id_port ) {
-               if ( ! find_id_port ( t509 ) ) {
-                       DBG ( "No ID port available for contention select\n" );
-                       return 0;
+       /* Find a suitable ID port */
+       if ( ! t509_find_id_port () )
+               return;
+
+       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 );
                }
                }
-               DBG ( "T509 scan using ID port at %hx\n", t509->id_port );
+
+               /* Only one device will still be left alive.  Tag it. */
+               ++t509_max_tag;
+               DBG ( "T509 found card %hx%hx%hx, assigning tag %hhx\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();
        }
 
        }
 
-       /* 
-        * If this is the start of the scan, clear all tag registers.
-        * Otherwise, tell already-found NICs not to respond.
+       DBG ( "T509 found %d cards using ID port %hx\n",
+             t509_max_tag, t509_id_port );
+       return;
+}
+
+/*
+ * Increment a bus_loc structure to the next possible T509 location.
+ * Leave the structure zeroed and return 0 if there are no more valid
+ * locations.
+ *
+ */
+static int t509_next_location ( struct bus_loc *bus_loc ) {
+       struct t509_loc *t509_loc = ( struct t509_loc * ) bus_loc;
+       
+       /*
+        * Ensure that there is sufficient space in the shared bus
+        * structures for a struct t509_loc and a struct t509_dev,
+        * as mandated by bus.h.
         *
         */
         *
         */
-       if ( t509->current_tag == 0 ) {
-               outb ( 0xd0, t509->id_port );
-       } else {
-               outb ( 0xd8, t509->id_port ) ;
-       }
+       BUS_LOC_CHECK ( struct t509_loc );
+       BUS_DEV_CHECK ( struct t509_device );
 
 
-       /* Send the ID sequence */
-       send_id_sequence ( t509 );
+       return ( t509_loc->tag = ( ++t509_loc->tag & EP_TAG_MAX ) );
+}
 
 
-       /* Check the manufacturer ID */
-       if ( id_read_eeprom ( t509, EEPROM_MFG_ID ) != MFG_ID ) {
-               /* No more t509 devices */
+/*
+ * Fill in parameters for a T509 device based on tag
+ *
+ * Return 1 if device present, 0 otherwise
+ *
+ */
+static int t509_fill_device ( struct bus_dev *bus_dev,
+                             struct bus_loc *bus_loc ) {
+       struct t509_device *t509 = ( struct t509_device * ) bus_dev;
+       struct t509_loc *t509_loc = ( struct t509_loc * ) bus_loc;
+       uint16_t iobase;
+
+       /* Copy tag to struct t509 */
+       t509->tag = t509_loc->tag;
+
+       /* Tag 0 is never valid, but may be passed in */
+       if ( ! t509->tag )
                return 0;
                return 0;
-       }
 
 
-       /* Do contention select by reading the MAC address */
-       for ( i = 0 ; i < 3 ; i++ ) {
-               id_read_eeprom ( t509, i );
-       }
+       /* Perform isolation if it hasn't yet been done */
+       if ( ! t509_id_port )
+               t509_isolate();
 
 
-       /* By now, only one device will be left active.  Get its I/O
-        * address, tag and activate the adaptor.  Tagging will
-        * prevent it taking part in the next scan, enabling us to see
-        * the next device.
-        */
-       iobase = id_read_eeprom ( t509, EEPROM_ADDR_CFG );
+       /* Check tag is in range */
+       if ( t509->tag > t509_max_tag )
+               return 0;
+
+       /* 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 );
        t509->ioaddr = 0x200 + ( ( iobase & 0x1f ) << 4 );
-       outb ( ++t509->current_tag, t509->id_port ); /* tag */
-       outb ( ( 0xe0 | iobase ), t509->id_port ); /* activate */
 
 
-       DBG ( "T509 found at %hx (tagged as %hhx)\n", t509->ioaddr,
-             t509->current_tag );
+       /* Send card back to ID_WAIT */
+       t509_wait_for_id_sequence();
 
 
+       DBG ( "T509 found device %hhx, base %hx\n", t509->tag, t509->ioaddr );
        return 1;
 }
 
 /*
        return 1;
 }
 
 /*
- * Find a t509 device matching the specified driver.  ("Matching the
- * specified driver" is, in this case, a no-op, but we want to
- * preserve the common bus API).
+ * Test whether or not a driver is capable of driving the device.
+ * This is a no-op for T509.
  *
  *
- * Called only once, so inlined for efficiency.
+ */
+static int t509_check_driver ( struct bus_dev *bus_dev __unused,
+                              struct device_driver *device_driver __unused ) {
+       return 1;
+}
+
+/*
+ * Describe a T509 device
  *
  */
  *
  */
-static inline int find_t509_device ( struct t509_device *t509,
-                                    struct t509_driver *driver __unused ) {
+static char * t509_describe ( struct bus_dev *bus_dev ) {
+       struct t509_device *t509 = ( struct t509_device * ) bus_dev;
+       static char t509_description[] = "T509 00";
 
 
-       /* Initialise struct t509 if it's the first time it's been used. */
-       if ( t509->magic != t509_magic ) {
-               memset ( t509, 0, sizeof ( *t509 ) );
-               t509->magic = t509_magic;
-       }
+       sprintf ( t509_description + 4, "%hhx", t509->tag );
+       return t509_description;
+}
 
 
-       /* Find the next t509 device */
-       if ( ! fill_t509_device ( t509 ) )
-               return 0;
-       
-       return 1;
+/*
+ * Name a T509 device
+ *
+ */
+static const char * t509_name ( struct bus_dev *bus_dev __unused ) {
+       return "T509";
 }
 
 /*
 }
 
 /*
- * Find the next T509 device that can be used to boot using the
- * specified driver.
+ * T509 bus operations table
  *
  */
  *
  */
-int find_t509_boot_device ( struct dev *dev, struct t509_driver *driver ) {
-       struct t509_device *t509 = ( struct t509_device * )dev->bus;
+struct bus_driver t509_driver __bus_driver = {
+       .next_location  = t509_next_location,
+       .fill_device    = t509_fill_device,
+       .check_driver   = t509_check_driver,
+       .describe       = t509_describe,
+       .name           = t509_name,
+};
 
 
-       if ( ! find_t509_device ( t509, driver ) )
-               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 %hhx at ioaddr %hx\n",
+             t509->tag, t509->ioaddr );
+}
 
 
-       dev->name = driver->name;
-       dev->devid.bus_type = ISA_BUS_TYPE;
-       dev->devid.vendor_id = MFG_ID;
-       dev->devid.device_id = PROD_ID;
-       return 1;
+/*
+ * 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 %hx and re-tagged as %hhx\n",
+             t509->ioaddr, t509->tag );
 }
 
 /*
 }
 
 /*
- * The ISA probe function
+ * Fill in a nic structure
+ *
+ * Called only once, so inlined for efficiency
  *
  */
  *
  */
-static int el3_t509_probe ( struct dev *dev, struct t509_device *t509 ) {
-       struct nic *nic = nic_device ( dev );
-       
+static inline void t509_fill_nic ( struct nic *nic,
+                                  struct t509_device *t509 ) {
+
+       /* Fill in ioaddr and irqno */
        nic->ioaddr = t509->ioaddr;
        nic->irqno = 0;
        nic->ioaddr = t509->ioaddr;
        nic->irqno = 0;
-       printf ( "3c509 board on ISA at %#hx - ", nic->ioaddr );
+
+       /* Fill in DHCP device ID structure */
+       nic->dhcp_dev_id.bus_type = ISA_BUS_TYPE;
+       nic->dhcp_dev_id.vendor_id = htons ( MFG_ID );
+       nic->dhcp_dev_id.device_id = htons ( PROD_ID );
+}
+
+/*
+ * The ISA probe function
+ *
+ */
+static int el3_t509_probe ( struct nic *nic, struct t509_device *t509 ) {
+       
+       /* We could change t509->ioaddr if we wanted to */
+       activate_t509_device ( t509 );
+       t509_fill_nic ( nic, t509 );
 
        /* Hand off to generic t5x9 probe routine */
        return t5x9_probe ( nic, ISA_PROD_ID ( PROD_ID ), ISA_PROD_ID_MASK );
 }
 
 
        /* Hand off to generic t5x9 probe routine */
        return t5x9_probe ( nic, ISA_PROD_ID ( PROD_ID ), ISA_PROD_ID_MASK );
 }
 
-static struct t509_driver el3_t509_driver = { "3c509 (ISA)" };
+static void el3_t509_disable ( struct nic *nic, struct t509_device *t509 ) {
+       t5x9_disable ( nic );
+       deactivate_t509_device ( t509 );
+}
+
+static struct {} el3_t509_driver;
 
 
-BOOT_DRIVER ( "3c509", find_t509_boot_device, el3_t509_driver,
-             el3_t509_probe );
+DRIVER ( "3c509", nic_driver, t509_driver, el3_t509_driver,
+        el3_t509_probe, el3_t509_disable );
 
 
-ISA_ROM ( "3c509","3c509" );
+ISA_ROM ( "3c509", "3c509" );