src/drivers/net/3c509.c

   1 /*
   2  * Split out into 3c509.c and 3c5x9.c, to make it possible to build a
   3  * 3c529 module without including ISA, ISAPnP and EISA code.
   4  *
   5  */
   6
   7 #include "isa.h"
   8 #include "io.h"
   9 #include "timer.h"
  10 #include "string.h"
  11 #include "console.h"
  12 #include "dev.h"
  13 #include "3c509.h"
  14
  15 /*
  16  * 3c509 cards have their own method of contention resolution; this
  17  * effectively defines another bus type similar to ISAPnP.  Even the
  18  * original ISA cards can be programatically mapped to any I/O address
  19  * in the range 0x200-0x3e0.
  20  *
  21  * However, there is a small problem: once you've activated a card,
  22  * the only ways to deactivate it will also wipe its tag, meaning that
  23  * you won't be able to subsequently reactivate it without going
  24  * through the whole ID sequence again.  The solution we adopt is to
  25  * isolate and tag all cards at the start, and to immediately
  26  * re-isolate and re-tag a card after disabling it.
  27  *
  28  */
  29
  30 static uint16_t t509_id_port = 0;
  31 static uint8_t t509_max_tag = 0;
  32
  33 /*
  34  * A location on a t509 bus
  35  *
  36  */
  37 struct t509_loc {
  38         uint8_t tag;
  39 };
  40
  41 /*
  42  * A physical t509 device
  43  *
  44  */
  45 struct t509_device {
  46         uint16_t ioaddr;
  47         uint8_t tag;
  48 };
  49
  50 /*
  51  * t509 utility functions
  52  *
  53  */
  54
  55 static inline void t509_set_id_port ( void ) {
  56         outb ( 0x00, t509_id_port );
  57 }
  58
  59 static inline void t509_wait_for_id_sequence ( void ) {
  60         outb ( 0x00, t509_id_port );
  61 }
  62
  63 static inline void t509_global_reset ( void ) {
  64         outb ( 0xc0, t509_id_port );
  65 }
  66
  67 static inline void t509_reset_tag ( void ) {
  68         outb ( 0xd0, t509_id_port );
  69 }
  70
  71 static inline void t509_set_tag ( uint8_t tag ) {
  72         outb ( 0xd0 | tag, t509_id_port );
  73 }
  74
  75 static inline void t509_select_tag ( uint8_t tag ) {
  76         outb ( 0xd8 | tag, t509_id_port );
  77 }
  78
  79 static inline void t509_activate ( uint16_t ioaddr ) {
  80         outb ( 0xe0 | ( ioaddr >> 4 ), t509_id_port );
  81 }
  82
  83 static inline void t509_deactivate_and_reset_tag ( uint16_t ioaddr ) {
  84         outb ( GLOBAL_RESET, ioaddr + EP_COMMAND );
  85 }
  86
  87 static inline void t509_load_eeprom_word ( uint8_t offset ) {
  88         outb ( 0x80 | offset, t509_id_port );
  89 }
  90
  91 /*
  92  * Find a suitable ID port
  93  *
  94  */
  95 static inline int t509_find_id_port ( void ) {
  96
  97         for ( t509_id_port = EP_ID_PORT_START ;
  98               t509_id_port < EP_ID_PORT_END ;
  99               t509_id_port += EP_ID_PORT_INC ) {
 100                 t509_set_id_port ();
 101                 /* See if anything's listening */
 102                 outb ( 0xff, t509_id_port );
 103                 if ( inb ( t509_id_port ) & 0x01 ) {
 104                         /* Found a suitable port */
 105                         DBG ( "T509 using ID port at %hx\n", t509_id_port );
 106                         return 1;
 107                 }
 108         }
 109         /* No id port available */
 110         DBG ( "T509 found no available ID port\n" );
 111         return 0;
 112 }
 113
 114 /*
 115  * Send ID sequence to the ID port
 116  *
 117  */
 118 static void t509_send_id_sequence ( void ) {
 119         unsigned short lrs_state, i;
 120
 121         t509_set_id_port ();
 122         /* Reset IDS on cards */
 123         t509_wait_for_id_sequence ();
 124         lrs_state = 0xff;
 125         for ( i = 0; i < 255; i++ ) {
 126                 outb ( lrs_state, t509_id_port );
 127                 lrs_state <<= 1;
 128                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
 129         }
 130 }
 131
 132 /*
 133  * We get eeprom data from the id_port given an offset into the eeprom.
 134  * Basically; after the ID_sequence is sent to all of the cards; they enter
 135  * the ID_CMD state where they will accept command requests. 0x80-0xbf loads
 136  * the eeprom data.  We then read the port 16 times and with every read; the
 137  * cards check for contention (ie: if one card writes a 0 bit and another
 138  * writes a 1 bit then the host sees a 0. At the end of the cycle; each card
 139  * compares the data on the bus; if there is a difference then that card goes
 140  * into ID_WAIT state again). In the meantime; one bit of data is returned in
 141  * the AX register which is conveniently returned to us by inb().  Hence; we
 142  * read 16 times getting one bit of data with each read.
 143  */
 144 static uint16_t t509_id_read_eeprom ( int offset ) {
 145         int i, data = 0;
 146
 147         t509_load_eeprom_word ( offset );
 148         /* Do we really need this wait? Won't be noticeable anyway */
 149         udelay(10000);
 150
 151         for ( i = 0; i < 16; i++ ) {
 152                 data = ( data << 1 ) | ( inw ( t509_id_port ) & 1 );
 153         }
 154         return data;
 155 }
 156
 157 /*
 158  * Isolate and tag all t509 cards
 159  *
 160  */
 161 static void t509_isolate ( void ) {
 162         unsigned int i;
 163         uint16_t contend[3];
 164
 165         /* Find a suitable ID port */
 166         if ( ! t509_find_id_port () )
 167                 return;
 168
 169         while ( 1 ) {
 170
 171                 /* All cards are in ID_WAIT state each time we go
 172                  * through this loop.
 173                  */
 174
 175                 /* Send the ID sequence */
 176                 t509_send_id_sequence ();
 177
 178                 /* First time through, reset all tags.  On subsequent
 179                  * iterations, kill off any already-tagged cards
 180                  */
 181                 if ( t509_max_tag == 0 ) {
 182                         t509_reset_tag();
 183                 } else {
 184                         t509_select_tag(0);
 185                 }
 186
 187                 /* Read the manufacturer ID, to see if there are any
 188                  * more cards
 189                  */
 190                 if ( t509_id_read_eeprom ( EEPROM_MFG_ID ) != MFG_ID ) {
 191                         DBG ( "T509 saw %s signs of life\n",
 192                               t509_max_tag ? "no further" : "no" );
 193                         break;
 194                 }
 195
 196                 /* Perform contention selection on the MAC address */
 197                 for ( i = 0 ; i < 3 ; i++ ) {
 198                         contend[i] = t509_id_read_eeprom ( i );
 199                 }
 200
 201                 /* Only one device will still be left alive.  Tag it. */
 202                 ++t509_max_tag;
 203                 DBG ( "T509 found card %hx%hx%hx, assigning tag %hhx\n",
 204                       contend[0], contend[1], contend[2], t509_max_tag );
 205                 t509_set_tag ( t509_max_tag );
 206
 207                 /* Return all cards back to ID_WAIT state */
 208                 t509_wait_for_id_sequence();
 209         }
 210
 211         DBG ( "T509 found %d cards using ID port %hx\n",
 212               t509_max_tag, t509_id_port );
 213         return;
 214 }
 215
 216 /*
 217  * Increment a bus_loc structure to the next possible T509 location.
 218  * Leave the structure zeroed and return 0 if there are no more valid
 219  * locations.
 220  *
 221  */
 222 static int t509_next_location ( struct bus_loc *bus_loc ) {
 223         struct t509_loc *t509_loc = ( struct t509_loc * ) bus_loc;
 224
 225         /*
 226          * Ensure that there is sufficient space in the shared bus
 227          * structures for a struct t509_loc and a struct t509_dev,
 228          * as mandated by bus.h.
 229          *
 230          */
 231         BUS_LOC_CHECK ( struct t509_loc );
 232         BUS_DEV_CHECK ( struct t509_device );
 233
 234         return ( t509_loc->tag = ( ++t509_loc->tag & EP_TAG_MAX ) );
 235 }
 236
 237 /*
 238  * Fill in parameters for a T509 device based on tag
 239  *
 240  * Return 1 if device present, 0 otherwise
 241  *
 242  */
 243 static int t509_fill_device ( struct bus_dev *bus_dev,
 244                               struct bus_loc *bus_loc ) {
 245         struct t509_device *t509 = ( struct t509_device * ) bus_dev;
 246         struct t509_loc *t509_loc = ( struct t509_loc * ) bus_loc;
 247         uint16_t iobase;
 248
 249         /* Copy tag to struct t509 */
 250         t509->tag = t509_loc->tag;
 251
 252         /* Tag 0 is never valid, but may be passed in */
 253         if ( ! t509->tag )
 254                 return 0;
 255
 256         /* Perform isolation if it hasn't yet been done */
 257         if ( ! t509_id_port )
 258                 t509_isolate();
 259
 260         /* Check tag is in range */
 261         if ( t509->tag > t509_max_tag )
 262                 return 0;
 263
 264         /* Send the ID sequence */
 265         t509_send_id_sequence ();
 266
 267         /* Select the specified tag */
 268         t509_select_tag ( t509->tag );
 269
 270         /* Read the default I/O address */
 271         iobase = t509_id_read_eeprom ( EEPROM_ADDR_CFG );
 272         t509->ioaddr = 0x200 + ( ( iobase & 0x1f ) << 4 );
 273
 274         /* Send card back to ID_WAIT */
 275         t509_wait_for_id_sequence();
 276
 277         DBG ( "T509 found device %hhx, base %hx\n", t509->tag, t509->ioaddr );
 278         return 1;
 279 }
 280
 281 /*
 282  * Test whether or not a driver is capable of driving the device.
 283  * This is a no-op for T509.
 284  *
 285  */
 286 static int t509_check_driver ( struct bus_dev *bus_dev __unused,
 287                                struct device_driver *device_driver __unused ) {
 288         return 1;
 289 }
 290
 291 /*
 292  * Describe a T509 device
 293  *
 294  */
 295 static char * t509_describe_device ( struct bus_dev *bus_dev ) {
 296         struct t509_device *t509 = ( struct t509_device * ) bus_dev;
 297         static char t509_description[] = "T509 00";
 298
 299         sprintf ( t509_description + 4, "%hhx", t509->tag );
 300         return t509_description;
 301 }
 302
 303 /*
 304  * Name a T509 device
 305  *
 306  */
 307 static const char * t509_name_device ( struct bus_dev *bus_dev __unused ) {
 308         return "T509";
 309 }
 310
 311 /*
 312  * T509 bus operations table
 313  *
 314  */
 315 struct bus_driver t509_driver __bus_driver = {
 316         .name                   = "T509",
 317         .next_location          = t509_next_location,
 318         .fill_device            = t509_fill_device,
 319         .check_driver           = t509_check_driver,
 320         .describe_device        = t509_describe_device,
 321         .name_device            = t509_name_device,
 322 };
 323
 324 /*
 325  * Activate a T509 device
 326  *
 327  * The device will be enabled at whatever ioaddr is specified in the
 328  * struct t509_device; there is no need to stick with the default
 329  * ioaddr read from the EEPROM.
 330  *
 331  */
 332 static inline void activate_t509_device ( struct t509_device *t509 ) {
 333         t509_send_id_sequence ();
 334         t509_select_tag ( t509->tag );
 335         t509_activate ( t509->ioaddr );
 336         DBG ( "T509 activated device %hhx at ioaddr %hx\n",
 337               t509->tag, t509->ioaddr );
 338 }
 339
 340 /*
 341  * Deactivate a T509 device
 342  *
 343  * Disabling also clears the tag, so we immediately isolate and re-tag
 344  * this card.
 345  *
 346  */
 347 static inline void deactivate_t509_device ( struct t509_device *t509 ) {
 348         t509_deactivate_and_reset_tag ( t509->ioaddr );
 349         udelay ( 1000 );
 350         t509_send_id_sequence ();
 351         t509_select_tag ( 0 );
 352         t509_set_tag ( t509->tag );
 353         t509_wait_for_id_sequence ();
 354         DBG ( "T509 deactivated device at %hx and re-tagged as %hhx\n",
 355               t509->ioaddr, t509->tag );
 356 }
 357
 358 /*
 359  * Fill in a nic structure
 360  *
 361  * Called only once, so inlined for efficiency
 362  *
 363  */
 364 static inline void t509_fill_nic ( struct nic *nic,
 365                                    struct t509_device *t509 ) {
 366
 367         /* Fill in ioaddr and irqno */
 368         nic->ioaddr = t509->ioaddr;
 369         nic->irqno = 0;
 370
 371         /* Fill in DHCP device ID structure */
 372         nic->dhcp_dev_id.bus_type = ISA_BUS_TYPE;
 373         nic->dhcp_dev_id.vendor_id = htons ( MFG_ID );
 374         nic->dhcp_dev_id.device_id = htons ( PROD_ID );
 375 }
 376
 377 /*
 378  * The ISA probe function
 379  *
 380  */
 381 static int el3_t509_probe ( struct nic *nic, struct t509_device *t509 ) {
 382
 383         /* We could change t509->ioaddr if we wanted to */
 384         activate_t509_device ( t509 );
 385         t509_fill_nic ( nic, t509 );
 386
 387         /* Hand off to generic t5x9 probe routine */
 388         return t5x9_probe ( nic, ISA_PROD_ID ( PROD_ID ), ISA_PROD_ID_MASK );
 389 }
 390
 391 static void el3_t509_disable ( struct nic *nic, struct t509_device *t509 ) {
 392         t5x9_disable ( nic );
 393         deactivate_t509_device ( t509 );
 394 }
 395
 396 struct {} el3_t509_driver;
 397
 398 DRIVER ( "3c509", nic_driver, t509_driver, el3_t509_driver,
 399          el3_t509_probe, el3_t509_disable );
 400
 401 ISA_ROM ( "3c509", "3c509" );