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