drivers/net/3c509.c

   1 /* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
   2 /*
   3         Written 1993-1998 by Donald Becker.
   4
   5         Copyright 1994-1998 by Donald Becker.
   6         Copyright 1993 United States Government as represented by the
   7         Director, National Security Agency.      This software may be used and
   8         distributed according to the terms of the GNU Public License,
   9         incorporated herein by reference.
  10
  11         This driver is for the 3Com EtherLinkIII series.
  12
  13         The author may be reached as becker@cesdis.gsfc.nasa.gov or
  14         C/O Center of Excellence in Space Data and Information Sciences
  15                 Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
  16
  17         Known limitations:
  18         Because of the way 3c509 ISA detection works it's difficult to predict
  19         a priori which of several ISA-mode cards will be detected first.
  20
  21         This driver does not use predictive interrupt mode, resulting in higher
  22         packet latency but lower overhead.  If interrupts are disabled for an
  23         unusually long time it could also result in missed packets, but in
  24         practice this rarely happens.
  25
  26
  27         FIXES:
  28                 Alan Cox:       Removed the 'Unexpected interrupt' bug.
  29                 Michael Meskes: Upgraded to Donald Becker's version 1.07.
  30                 Alan Cox:       Increased the eeprom delay. Regardless of
  31                                 what the docs say some people definitely
  32                                 get problems with lower (but in card spec)
  33                                 delays
  34                 v1.10 4/21/97 Fixed module code so that multiple cards may be detected,
  35                                 other cleanups.  -djb
  36                 Andrea Arcangeli:       Upgraded to Donald Becker's version 1.12.
  37                 Rick Payne:     Fixed SMP race condition
  38                 v1.13 9/8/97 Made 'max_interrupt_work' an insmod-settable variable -djb
  39                 v1.14 10/15/97 Avoided waiting..discard message for fast machines -djb
  40                 v1.15 1/31/98 Faster recovery for Tx errors. -djb
  41                 v1.16 2/3/98 Different ID port handling to avoid sound cards. -djb
  42 */
  43
  44 static char *version = "3c509.c:1.16 (2.2) 2/3/98 becker@cesdis.gsfc.nasa.gov.\n";
  45 /* A few values that may be tweaked. */
  46
  47 /* Time in jiffies before concluding the transmitter is hung. */
  48 #define TX_TIMEOUT  (400*HZ/1000)
  49 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  50 static int max_interrupt_work = 10;
  51
  52 #include <linux/config.h>
  53 #include <linux/module.h>
  54
  55 #include <linux/mca.h>
  56 #include <linux/isapnp.h>
  57 #include <linux/sched.h>
  58 #include <linux/string.h>
  59 #include <linux/interrupt.h>
  60 #include <linux/errno.h>
  61 #include <linux/in.h>
  62 #include <linux/malloc.h>
  63 #include <linux/ioport.h>
  64 #include <linux/netdevice.h>
  65 #include <linux/etherdevice.h>
  66 #include <linux/skbuff.h>
  67 #include <linux/delay.h>        /* for udelay() */
  68 #include <linux/spinlock.h>
  69
  70 #include <asm/bitops.h>
  71 #include <asm/io.h>
  72 #include <asm/irq.h>
  73
  74 #ifdef EL3_DEBUG
  75 int el3_debug = EL3_DEBUG;
  76 #else
  77 int el3_debug = 2;
  78 #endif
  79
  80 /* To minimize the size of the driver source I only define operating
  81    constants if they are used several times.  You'll need the manual
  82    anyway if you want to understand driver details. */
  83 /* Offsets from base I/O address. */
  84 #define EL3_DATA 0x00
  85 #define EL3_CMD 0x0e
  86 #define EL3_STATUS 0x0e
  87 #define  EEPROM_READ 0x80
  88
  89 #define EL3_IO_EXTENT   16
  90
  91 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
  92
  93
  94 /* The top five bits written to EL3_CMD are a command, the lower
  95    11 bits are the parameter, if applicable. */
  96 enum c509cmd {
  97         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
  98         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
  99         TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
 100         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
 101         SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
 102         SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
 103         StatsDisable = 22<<11, StopCoax = 23<<11,};
 104
 105 enum c509status {
 106         IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
 107         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
 108         IntReq = 0x0040, StatsFull = 0x0080, CmdBusy = 0x1000, };
 109
 110 /* The SetRxFilter command accepts the following classes: */
 111 enum RxFilter {
 112         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
 113
 114 /* Register window 1 offsets, the window used in normal operation. */
 115 #define TX_FIFO         0x00
 116 #define RX_FIFO         0x00
 117 #define RX_STATUS       0x08
 118 #define TX_STATUS       0x0B
 119 #define TX_FREE         0x0C            /* Remaining free bytes in Tx buffer. */
 120
 121 #define WN0_IRQ         0x08            /* Window 0: Set IRQ line in bits 12-15. */
 122 #define WN4_MEDIA       0x0A            /* Window 4: Various transcvr/media bits. */
 123 #define  MEDIA_TP       0x00C0          /* Enable link beat and jabber for 10baseT. */
 124
 125 /*
 126  * Must be a power of two (we use a binary and in the
 127  * circular queue)
 128  */
 129 #define SKB_QUEUE_SIZE  64
 130
 131 struct el3_private {
 132         struct net_device_stats stats;
 133         struct net_device *next_dev;
 134         spinlock_t lock;
 135         /* skb send-queue */
 136         int head, size;
 137         struct sk_buff *queue[SKB_QUEUE_SIZE];
 138         char mca_slot;
 139 };
 140 static int id_port = 0x110;             /* Start with 0x110 to avoid new sound cards.*/
 141 static struct net_device *el3_root_dev = NULL;
 142
 143 static ushort id_read_eeprom(int index);
 144 static ushort read_eeprom(int ioaddr, int index);
 145 static int el3_open(struct net_device *dev);
 146 static int el3_start_xmit(struct sk_buff *skb, struct net_device *dev);
 147 static void el3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 148 static void update_stats(struct net_device *dev);
 149 static struct net_device_stats *el3_get_stats(struct net_device *dev);
 150 static int el3_rx(struct net_device *dev);
 151 static int el3_close(struct net_device *dev);
 152 static void set_multicast_list(struct net_device *dev);
 153 static void el3_tx_timeout (struct net_device *dev);
 154
 155 #ifdef CONFIG_MCA
 156 struct el3_mca_adapters_struct {
 157         char* name;
 158         int id;
 159 };
 160
 161 struct el3_mca_adapters_struct el3_mca_adapters[] = {
 162         { "3Com 3c529 EtherLink III (10base2)", 0x627c },
 163         { "3Com 3c529 EtherLink III (10baseT)", 0x627d },
 164         { "3Com 3c529 EtherLink III (test mode)", 0x62db },
 165         { "3Com 3c529 EtherLink III (TP or coax)", 0x62f6 },
 166         { "3Com 3c529 EtherLink III (TP)", 0x62f7 },
 167         { NULL, 0 },
 168 };
 169 #endif
 170
 171 #ifdef __ISAPNP__
 172 struct el3_isapnp_adapters_struct {
 173         unsigned short vendor, function;
 174         char *name;
 175 };
 176 static struct el3_isapnp_adapters_struct el3_isapnp_adapters[] = {
 177         {ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5090), "3Com Etherlink III (TP)"},
 178         {ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5091), "3Com Etherlink III"},
 179         {ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5094), "3Com Etherlink III (combo)"},
 180         {ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5095), "3Com Etherlink III (TPO)"},
 181         {ISAPNP_VENDOR('T', 'C', 'M'), ISAPNP_FUNCTION(0x5098), "3Com Etherlink III (TPC)"},
 182         {ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_FUNCTION(0x80f8), "3Com Etherlink III compatible"},
 183         {0, }
 184 };
 185 static u16 el3_isapnp_phys_addr[8][3];
 186 #endif /* CONFIG_ISAPNP */
 187 #ifdef __ISAPNP__
 188 static int nopnp;
 189 #endif
 190
 191 int el3_probe(struct net_device *dev)
 192 {
 193         struct el3_private *lp;
 194         short lrs_state = 0xff, i;
 195         int ioaddr, irq, if_port;
 196         u16 phys_addr[3];
 197         static int current_tag = 0;
 198         int mca_slot = -1;
 199 #ifdef __ISAPNP__
 200         static int pnp_cards = 0;
 201 #endif /* __ISAPNP__ */
 202
 203         if (dev) SET_MODULE_OWNER(dev);
 204
 205         /* First check all slots of the EISA bus.  The next slot address to
 206            probe is kept in 'eisa_addr' to support multiple probe() calls. */
 207         if (EISA_bus) {
 208                 static int eisa_addr = 0x1000;
 209                 while (eisa_addr < 0x9000) {
 210                         ioaddr = eisa_addr;
 211                         eisa_addr += 0x1000;
 212
 213                         /* Check the standard EISA ID register for an encoded '3Com'. */
 214                         if (inw(ioaddr + 0xC80) != 0x6d50)
 215                                 continue;
 216
 217                         /* Change the register set to the configuration window 0. */
 218                         outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
 219
 220                         irq = inw(ioaddr + WN0_IRQ) >> 12;
 221                         if_port = inw(ioaddr + 6)>>14;
 222                         for (i = 0; i < 3; i++)
 223                                 phys_addr[i] = htons(read_eeprom(ioaddr, i));
 224
 225                         /* Restore the "Product ID" to the EEPROM read register. */
 226                         read_eeprom(ioaddr, 3);
 227
 228                         /* Was the EISA code an add-on hack?  Nahhhhh... */
 229                         goto found;
 230                 }
 231         }
 232
 233 #ifdef CONFIG_MCA
 234         /* Based on Erik Nygren's (nygren@mit.edu) 3c529 patch, heavily
 235          * modified by Chris Beauregard (cpbeaure@csclub.uwaterloo.ca)
 236          * to support standard MCA probing.
 237          *
 238          * redone for multi-card detection by ZP Gu (zpg@castle.net)
 239          * now works as a module
 240          */
 241
 242         if( MCA_bus ) {
 243                 int slot, j;
 244                 u_char pos4, pos5;
 245
 246                 for( j = 0; el3_mca_adapters[j].name != NULL; j ++ ) {
 247                         slot = 0;
 248                         while( slot != MCA_NOTFOUND ) {
 249                                 slot = mca_find_unused_adapter(
 250                                         el3_mca_adapters[j].id, slot );
 251                                 if( slot == MCA_NOTFOUND ) break;
 252
 253                                 /* if we get this far, an adapter has been
 254                                  * detected and is enabled
 255                                  */
 256
 257                                 pos4 = mca_read_stored_pos( slot, 4 );
 258                                 pos5 = mca_read_stored_pos( slot, 5 );
 259
 260                                 ioaddr = ((short)((pos4&0xfc)|0x02)) << 8;
 261                                 irq = pos5 & 0x0f;
 262
 263                                 /* probing for a card at a particular IO/IRQ */
 264                                 if(dev && ((dev->irq >= 1 && dev->irq != irq) ||
 265                                 (dev->base_addr >= 1 && dev->base_addr != ioaddr))) {
 266                                         slot++;         /* probing next slot */
 267                                         continue;
 268                                 }
 269
 270                                 printk("3c509: found %s at slot %d\n",
 271                                         el3_mca_adapters[j].name, slot + 1 );
 272
 273                                 /* claim the slot */
 274                                 mca_set_adapter_name(slot, el3_mca_adapters[j].name);
 275                                 mca_set_adapter_procfn(slot, NULL, NULL);
 276                                 mca_mark_as_used(slot);
 277
 278                                 if_port = pos4 & 0x03;
 279                                 if (el3_debug > 2) {
 280                                         printk("3c529: irq %d  ioaddr 0x%x  ifport %d\n", irq, ioaddr, if_port);
 281                                 }
 282                                 EL3WINDOW(0);
 283                                 for (i = 0; i < 3; i++) {
 284                                         phys_addr[i] = htons(read_eeprom(ioaddr, i));
 285                                 }
 286
 287                                 mca_slot = slot;
 288
 289                                 goto found;
 290                         }
 291                 }
 292                 /* if we get here, we didn't find an MCA adapter */
 293                 return -ENODEV;
 294         }
 295 #endif /* CONFIG_MCA */
 296
 297 #ifdef __ISAPNP__
 298         if (nopnp == 1)
 299                 goto no_pnp;
 300
 301         for (i=0; el3_isapnp_adapters[i].vendor != 0; i++) {
 302                 struct pci_dev *idev = NULL;
 303                 int j;
 304                 while ((idev = isapnp_find_dev(NULL,
 305                                                 el3_isapnp_adapters[i].vendor,
 306                                                 el3_isapnp_adapters[i].function,
 307                                                 idev))) {
 308                         idev->prepare(idev);
 309                         /* Deactivation is needed if the driver was called
 310                            with "nopnp=1" before, does not harm if not. */
 311                         idev->deactivate(idev);
 312                         idev->activate(idev);
 313                         if (!idev->resource[0].start || check_region(idev->resource[0].start, EL3_IO_EXTENT))
 314                                 continue;
 315                         ioaddr = idev->resource[0].start;
 316                         if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509 PnP"))
 317                                 return -EBUSY;
 318                         irq = idev->irq_resource[0].start;
 319                         if (el3_debug > 3)
 320                                 printk ("ISAPnP reports %s at i/o 0x%x, irq %d\n",
 321                                         el3_isapnp_adapters[i].name, ioaddr, irq);
 322                         EL3WINDOW(0);
 323                         for (j = 0; j < 3; j++)
 324                                 el3_isapnp_phys_addr[pnp_cards][j] =
 325                                         phys_addr[j] =
 326                                                 htons(read_eeprom(ioaddr, j));
 327                         if_port = read_eeprom(ioaddr, 8) >> 14;
 328                         pnp_cards++;
 329                         goto found;
 330                 }
 331         }
 332 no_pnp:
 333 #endif /* __ISAPNP__ */
 334
 335         /* Select an open I/O location at 0x1*0 to do contention select. */
 336         for ( ; id_port < 0x200; id_port += 0x10) {
 337                 if (check_region(id_port, 1))
 338                         continue;
 339                 outb(0x00, id_port);
 340                 outb(0xff, id_port);
 341                 if (inb(id_port) & 0x01)
 342                         break;
 343         }
 344         if (id_port >= 0x200) {
 345                 /* Rare -- do we really need a warning? */
 346                 printk(" WARNING: No I/O port available for 3c509 activation.\n");
 347                 return -ENODEV;
 348         }
 349         /* Next check for all ISA bus boards by sending the ID sequence to the
 350            ID_PORT.  We find cards past the first by setting the 'current_tag'
 351            on cards as they are found.  Cards with their tag set will not
 352            respond to subsequent ID sequences. */
 353
 354         outb(0x00, id_port);
 355         outb(0x00, id_port);
 356         for(i = 0; i < 255; i++) {
 357                 outb(lrs_state, id_port);
 358                 lrs_state <<= 1;
 359                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
 360         }
 361
 362         /* For the first probe, clear all board's tag registers. */
 363         if (current_tag == 0)
 364                 outb(0xd0, id_port);
 365         else                            /* Otherwise kill off already-found boards. */
 366                 outb(0xd8, id_port);
 367
 368         if (id_read_eeprom(7) != 0x6d50) {
 369                 return -ENODEV;
 370         }
 371
 372         /* Read in EEPROM data, which does contention-select.
 373            Only the lowest address board will stay "on-line".
 374            3Com got the byte order backwards. */
 375         for (i = 0; i < 3; i++) {
 376                 phys_addr[i] = htons(id_read_eeprom(i));
 377         }
 378
 379 #ifdef __ISAPNP__
 380         if (nopnp == 0) {
 381                 /* The ISA PnP 3c509 cards respond to the ID sequence.
 382                    This check is needed in order not to register them twice. */
 383                 for (i = 0; i < pnp_cards; i++) {
 384                         if (phys_addr[0] == el3_isapnp_phys_addr[i][0] &&
 385                             phys_addr[1] == el3_isapnp_phys_addr[i][1] &&
 386                             phys_addr[2] == el3_isapnp_phys_addr[i][2])
 387                         {
 388                                 if (el3_debug > 3)
 389                                         printk("3c509 with address %02x %02x %02x %02x %02x %02x was found by ISAPnP\n",
 390                                                 phys_addr[0] & 0xff, phys_addr[0] >> 8,
 391                                                 phys_addr[1] & 0xff, phys_addr[1] >> 8,
 392                                                 phys_addr[2] & 0xff, phys_addr[2] >> 8);
 393                                 /* Set the adaptor tag so that the next card can be found. */
 394                                 outb(0xd0 + ++current_tag, id_port);
 395                                 goto no_pnp;
 396                         }
 397                 }
 398         }
 399 #endif /* __ISAPNP__ */
 400
 401         {
 402                 unsigned int iobase = id_read_eeprom(8);
 403                 if_port = iobase >> 14;
 404                 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
 405         }
 406         irq = id_read_eeprom(9) >> 12;
 407
 408         if (dev) {                                      /* Set passed-in IRQ or I/O Addr. */
 409                 if (dev->irq > 1  &&  dev->irq < 16)
 410                         irq = dev->irq;
 411
 412                 if (dev->base_addr) {
 413                         if (dev->mem_end == 0x3c509                     /* Magic key */
 414                                 && dev->base_addr >= 0x200  &&  dev->base_addr <= 0x3e0)
 415                                 ioaddr = dev->base_addr & 0x3f0;
 416                         else if (dev->base_addr != ioaddr)
 417                                 return -ENODEV;
 418                 }
 419         }
 420
 421         if (!request_region(ioaddr, EL3_IO_EXTENT, "3c509"))
 422                 return -EBUSY;
 423
 424         /* Set the adaptor tag so that the next card can be found. */
 425         outb(0xd0 + ++current_tag, id_port);
 426
 427         /* Activate the adaptor at the EEPROM location. */
 428         outb((ioaddr >> 4) | 0xe0, id_port);
 429
 430         EL3WINDOW(0);
 431         if (inw(ioaddr) != 0x6d50) {
 432                 release_region(ioaddr, EL3_IO_EXTENT);
 433                 return -ENODEV;
 434         }
 435
 436         /* Free the interrupt so that some other card can use it. */
 437         outw(0x0f00, ioaddr + WN0_IRQ);
 438  found:
 439         if (dev == NULL) {
 440                 dev = init_etherdev(dev, sizeof(struct el3_private));
 441                 if (dev == NULL) {
 442                         release_region(ioaddr, EL3_IO_EXTENT);
 443                         return -ENOMEM;
 444                 }
 445                 SET_MODULE_OWNER(dev);
 446         }
 447         memcpy(dev->dev_addr, phys_addr, sizeof(phys_addr));
 448         dev->base_addr = ioaddr;
 449         dev->irq = irq;
 450         dev->if_port = (dev->mem_start & 0x1f) ? dev->mem_start & 3 : if_port;
 451
 452         {
 453                 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
 454                 printk("%s: 3c509 at %#3.3lx, %s port, address ",
 455                            dev->name, dev->base_addr, if_names[dev->if_port]);
 456         }
 457
 458         /* Read in the station address. */
 459         for (i = 0; i < 6; i++)
 460                 printk(" %2.2x", dev->dev_addr[i]);
 461         printk(", IRQ %d.\n", dev->irq);
 462
 463         /* Make up a EL3-specific-data structure. */
 464         if (dev->priv == NULL)
 465                 dev->priv = kmalloc(sizeof(struct el3_private), GFP_KERNEL);
 466         if (dev->priv == NULL)
 467                 return -ENOMEM;
 468         memset(dev->priv, 0, sizeof(struct el3_private));
 469
 470         lp = dev->priv;
 471         lp->mca_slot = mca_slot;
 472         lp->next_dev = el3_root_dev;
 473         spin_lock_init(&lp->lock);
 474         el3_root_dev = dev;
 475
 476         if (el3_debug > 0)
 477                 printk(version);
 478
 479         /* The EL3-specific entries in the device structure. */
 480         dev->open = &el3_open;
 481         dev->hard_start_xmit = &el3_start_xmit;
 482         dev->stop = &el3_close;
 483         dev->get_stats = &el3_get_stats;
 484         dev->set_multicast_list = &set_multicast_list;
 485         dev->tx_timeout = el3_tx_timeout;
 486         dev->watchdog_timeo = TX_TIMEOUT;
 487
 488         /* Fill in the generic fields of the device structure. */
 489         ether_setup(dev);
 490         return 0;
 491 }
 492
 493 /* Read a word from the EEPROM using the regular EEPROM access register.
 494    Assume that we are in register window zero.
 495  */
 496 static ushort read_eeprom(int ioaddr, int index)
 497 {
 498         outw(EEPROM_READ + index, ioaddr + 10);
 499         /* Pause for at least 162 us. for the read to take place. */
 500         udelay (500);
 501         return inw(ioaddr + 12);
 502 }
 503
 504 /* Read a word from the EEPROM when in the ISA ID probe state. */
 505 static ushort id_read_eeprom(int index)
 506 {
 507         int bit, word = 0;
 508
 509         /* Issue read command, and pause for at least 162 us. for it to complete.
 510            Assume extra-fast 16Mhz bus. */
 511         outb(EEPROM_READ + index, id_port);
 512
 513         /* Pause for at least 162 us. for the read to take place. */
 514         udelay (500);
 515
 516         for (bit = 15; bit >= 0; bit--)
 517                 word = (word << 1) + (inb(id_port) & 0x01);
 518
 519         if (el3_debug > 3)
 520                 printk("  3c509 EEPROM word %d %#4.4x.\n", index, word);
 521
 522         return word;
 523 }
 524
 525
 526 static int
 527 el3_open(struct net_device *dev)
 528 {
 529         int ioaddr = dev->base_addr;
 530         int i;
 531
 532         outw(TxReset, ioaddr + EL3_CMD);
 533         outw(RxReset, ioaddr + EL3_CMD);
 534         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 535
 536         i = request_irq(dev->irq, &el3_interrupt, 0, dev->name, dev);
 537         if (i) return i;
 538
 539         EL3WINDOW(0);
 540         if (el3_debug > 3)
 541                 printk("%s: Opening, IRQ %d      status@%x %4.4x.\n", dev->name,
 542                            dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
 543
 544         /* Activate board: this is probably unnecessary. */
 545         outw(0x0001, ioaddr + 4);
 546
 547         /* Set the IRQ line. */
 548         outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
 549
 550         /* Set the station address in window 2 each time opened. */
 551         EL3WINDOW(2);
 552
 553         for (i = 0; i < 6; i++)
 554                 outb(dev->dev_addr[i], ioaddr + i);
 555
 556         if (dev->if_port == 3)
 557                 /* Start the thinnet transceiver. We should really wait 50ms...*/
 558                 outw(StartCoax, ioaddr + EL3_CMD);
 559         else if (dev->if_port == 0) {
 560                 /* 10baseT interface, enabled link beat and jabber check. */
 561                 EL3WINDOW(4);
 562                 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
 563         }
 564
 565         /* Switch to the stats window, and clear all stats by reading. */
 566         outw(StatsDisable, ioaddr + EL3_CMD);
 567         EL3WINDOW(6);
 568         for (i = 0; i < 9; i++)
 569                 inb(ioaddr + i);
 570         inw(ioaddr + 10);
 571         inw(ioaddr + 12);
 572
 573         /* Switch to register set 1 for normal use. */
 574         EL3WINDOW(1);
 575
 576         /* Accept b-case and phys addr only. */
 577         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
 578         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
 579
 580         netif_start_queue(dev);
 581
 582         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
 583         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
 584         /* Allow status bits to be seen. */
 585         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
 586         /* Ack all pending events, and set active indicator mask. */
 587         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 588                  ioaddr + EL3_CMD);
 589         outw(SetIntrEnb | IntLatch|TxAvailable|TxComplete|RxComplete|StatsFull,
 590                  ioaddr + EL3_CMD);
 591
 592         if (el3_debug > 3)
 593                 printk("%s: Opened 3c509  IRQ %d  status %4.4x.\n",
 594                            dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
 595
 596         return 0;
 597 }
 598
 599 static void
 600 el3_tx_timeout (struct net_device *dev)
 601 {
 602         struct el3_private *lp = (struct el3_private *)dev->priv;
 603         int ioaddr = dev->base_addr;
 604
 605         /* Transmitter timeout, serious problems. */
 606         printk("%s: transmit timed out, Tx_status %2.2x status %4.4x "
 607                    "Tx FIFO room %d.\n",
 608                    dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS),
 609                    inw(ioaddr + TX_FREE));
 610         lp->stats.tx_errors++;
 611         dev->trans_start = jiffies;
 612         /* Issue TX_RESET and TX_START commands. */
 613         outw(TxReset, ioaddr + EL3_CMD);
 614         outw(TxEnable, ioaddr + EL3_CMD);
 615         netif_wake_queue(dev);
 616 }
 617
 618
 619 static int
 620 el3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 621 {
 622         struct el3_private *lp = (struct el3_private *)dev->priv;
 623         int ioaddr = dev->base_addr;
 624         unsigned long flags;
 625
 626         netif_stop_queue (dev);
 627
 628         lp->stats.tx_bytes += skb->len;
 629
 630         if (el3_debug > 4) {
 631                 printk("%s: el3_start_xmit(length = %u) called, status %4.4x.\n",
 632                            dev->name, skb->len, inw(ioaddr + EL3_STATUS));
 633         }
 634 #if 0
 635 #ifndef final_version
 636         {       /* Error-checking code, delete someday. */
 637                 ushort status = inw(ioaddr + EL3_STATUS);
 638                 if (status & 0x0001             /* IRQ line active, missed one. */
 639                         && inw(ioaddr + EL3_STATUS) & 1) {                      /* Make sure. */
 640                         printk("%s: Missed interrupt, status then %04x now %04x"
 641                                    "  Tx %2.2x Rx %4.4x.\n", dev->name, status,
 642                                    inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
 643                                    inw(ioaddr + RX_STATUS));
 644                         /* Fake interrupt trigger by masking, acknowledge interrupts. */
 645                         outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
 646                         outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
 647                                  ioaddr + EL3_CMD);
 648                         outw(SetStatusEnb | 0xff, ioaddr + EL3_CMD);
 649                 }
 650         }
 651 #endif
 652 #endif
 653         /*
 654          *      We lock the driver against other processors. Note
 655          *      we don't need to lock versus the IRQ as we suspended
 656          *      that. This means that we lose the ability to take
 657          *      an RX during a TX upload. That sucks a bit with SMP
 658          *      on an original 3c509 (2K buffer)
 659          *
 660          *      Using disable_irq stops us crapping on other
 661          *      time sensitive devices.
 662          */
 663
 664         spin_lock_irqsave(&lp->lock, flags);
 665
 666         /* Put out the doubleword header... */
 667         outw(skb->len, ioaddr + TX_FIFO);
 668         outw(0x00, ioaddr + TX_FIFO);
 669         /* ... and the packet rounded to a doubleword. */
 670 #ifdef  __powerpc__
 671         outsl_unswapped(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 672 #else
 673         outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 674 #endif
 675
 676         dev->trans_start = jiffies;
 677         if (inw(ioaddr + TX_FREE) > 1536)
 678                 netif_start_queue(dev);
 679         else
 680                 /* Interrupt us when the FIFO has room for max-sized packet. */
 681                 outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
 682
 683         spin_unlock_irqrestore(&lp->lock, flags);
 684
 685         dev_kfree_skb (skb);
 686
 687         /* Clear the Tx status stack. */
 688         {
 689                 short tx_status;
 690                 int i = 4;
 691
 692                 while (--i > 0  &&      (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 693                         if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
 694                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 695                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 696                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 697                 }
 698         }
 699         return 0;
 700 }
 701
 702 /* The EL3 interrupt handler. */
 703 static void
 704 el3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 705 {
 706         struct net_device *dev = (struct net_device *)dev_id;
 707         struct el3_private *lp;
 708         int ioaddr, status;
 709         int i = max_interrupt_work;
 710
 711         if (dev == NULL) {
 712                 printk ("el3_interrupt(): irq %d for unknown device.\n", irq);
 713                 return;
 714         }
 715
 716         lp = (struct el3_private *)dev->priv;
 717         spin_lock(&lp->lock);
 718
 719         ioaddr = dev->base_addr;
 720
 721         if (el3_debug > 4) {
 722                 status = inw(ioaddr + EL3_STATUS);
 723                 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
 724         }
 725
 726         while ((status = inw(ioaddr + EL3_STATUS)) &
 727                    (IntLatch | RxComplete | StatsFull)) {
 728
 729                 if (status & RxComplete)
 730                         el3_rx(dev);
 731
 732                 if (status & TxAvailable) {
 733                         if (el3_debug > 5)
 734                                 printk("        TX room bit was handled.\n");
 735                         /* There's room in the FIFO for a full-sized packet. */
 736                         outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
 737                         netif_wake_queue (dev);
 738                 }
 739                 if (status & (AdapterFailure | RxEarly | StatsFull | TxComplete)) {
 740                         /* Handle all uncommon interrupts. */
 741                         if (status & StatsFull)                         /* Empty statistics. */
 742                                 update_stats(dev);
 743                         if (status & RxEarly) {                         /* Rx early is unused. */
 744                                 el3_rx(dev);
 745                                 outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
 746                         }
 747                         if (status & TxComplete) {                      /* Really Tx error. */
 748                                 struct el3_private *lp = (struct el3_private *)dev->priv;
 749                                 short tx_status;
 750                                 int i = 4;
 751
 752                                 while (--i>0 && (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 753                                         if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
 754                                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 755                                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 756                                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 757                                 }
 758                         }
 759                         if (status & AdapterFailure) {
 760                                 /* Adapter failure requires Rx reset and reinit. */
 761                                 outw(RxReset, ioaddr + EL3_CMD);
 762                                 /* Set the Rx filter to the current state. */
 763                                 outw(SetRxFilter | RxStation | RxBroadcast
 764                                          | (dev->flags & IFF_ALLMULTI ? RxMulticast : 0)
 765                                          | (dev->flags & IFF_PROMISC ? RxProm : 0),
 766                                          ioaddr + EL3_CMD);
 767                                 outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
 768                                 outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
 769                         }
 770                 }
 771
 772                 if (--i < 0) {
 773                         printk("%s: Infinite loop in interrupt, status %4.4x.\n",
 774                                    dev->name, status);
 775                         /* Clear all interrupts. */
 776                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 777                         break;
 778                 }
 779                 /* Acknowledge the IRQ. */
 780                 outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD); /* Ack IRQ */
 781         }
 782
 783         if (el3_debug > 4) {
 784                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
 785                            inw(ioaddr + EL3_STATUS));
 786         }
 787         spin_unlock(&lp->lock);
 788         return;
 789 }
 790
 791
 792 static struct net_device_stats *
 793 el3_get_stats(struct net_device *dev)
 794 {
 795         struct el3_private *lp = (struct el3_private *)dev->priv;
 796         unsigned long flags;
 797
 798         /*
 799          *      This is fast enough not to bother with disable IRQ
 800          *      stuff.
 801          */
 802
 803         spin_lock_irqsave(&lp->lock, flags);
 804         update_stats(dev);
 805         spin_unlock_irqrestore(&lp->lock, flags);
 806         return &lp->stats;
 807 }
 808
 809 /*  Update statistics.  We change to register window 6, so this should be run
 810         single-threaded if the device is active. This is expected to be a rare
 811         operation, and it's simpler for the rest of the driver to assume that
 812         window 1 is always valid rather than use a special window-state variable.
 813         */
 814 static void update_stats(struct net_device *dev)
 815 {
 816         struct el3_private *lp = (struct el3_private *)dev->priv;
 817         int ioaddr = dev->base_addr;
 818
 819         if (el3_debug > 5)
 820                 printk("   Updating the statistics.\n");
 821         /* Turn off statistics updates while reading. */
 822         outw(StatsDisable, ioaddr + EL3_CMD);
 823         /* Switch to the stats window, and read everything. */
 824         EL3WINDOW(6);
 825         lp->stats.tx_carrier_errors     += inb(ioaddr + 0);
 826         lp->stats.tx_heartbeat_errors   += inb(ioaddr + 1);
 827         /* Multiple collisions. */         inb(ioaddr + 2);
 828         lp->stats.collisions            += inb(ioaddr + 3);
 829         lp->stats.tx_window_errors      += inb(ioaddr + 4);
 830         lp->stats.rx_fifo_errors        += inb(ioaddr + 5);
 831         lp->stats.tx_packets            += inb(ioaddr + 6);
 832         /* Rx packets   */                 inb(ioaddr + 7);
 833         /* Tx deferrals */                 inb(ioaddr + 8);
 834         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
 835         inw(ioaddr + 12);
 836
 837         /* Back to window 1, and turn statistics back on. */
 838         EL3WINDOW(1);
 839         outw(StatsEnable, ioaddr + EL3_CMD);
 840         return;
 841 }
 842
 843 static int
 844 el3_rx(struct net_device *dev)
 845 {
 846         struct el3_private *lp = (struct el3_private *)dev->priv;
 847         int ioaddr = dev->base_addr;
 848         short rx_status;
 849
 850         if (el3_debug > 5)
 851                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
 852                            inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
 853         while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
 854                 if (rx_status & 0x4000) { /* Error, update stats. */
 855                         short error = rx_status & 0x3800;
 856
 857                         outw(RxDiscard, ioaddr + EL3_CMD);
 858                         lp->stats.rx_errors++;
 859                         switch (error) {
 860                         case 0x0000:            lp->stats.rx_over_errors++; break;
 861                         case 0x0800:            lp->stats.rx_length_errors++; break;
 862                         case 0x1000:            lp->stats.rx_frame_errors++; break;
 863                         case 0x1800:            lp->stats.rx_length_errors++; break;
 864                         case 0x2000:            lp->stats.rx_frame_errors++; break;
 865                         case 0x2800:            lp->stats.rx_crc_errors++; break;
 866                         }
 867                 } else {
 868                         short pkt_len = rx_status & 0x7ff;
 869                         struct sk_buff *skb;
 870
 871                         skb = dev_alloc_skb(pkt_len+5);
 872                         lp->stats.rx_bytes += pkt_len;
 873                         if (el3_debug > 4)
 874                                 printk("Receiving packet size %d status %4.4x.\n",
 875                                            pkt_len, rx_status);
 876                         if (skb != NULL) {
 877                                 skb->dev = dev;
 878                                 skb_reserve(skb, 2);     /* Align IP on 16 byte */
 879
 880                                 /* 'skb->data' points to the start of sk_buff data area. */
 881 #ifdef  __powerpc__
 882                                 insl_unswapped(ioaddr+RX_FIFO, skb_put(skb,pkt_len),
 883                                                            (pkt_len + 3) >> 2);
 884 #else
 885                                 insl(ioaddr + RX_FIFO, skb_put(skb,pkt_len),
 886                                          (pkt_len + 3) >> 2);
 887 #endif
 888
 889                                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
 890                                 skb->protocol = eth_type_trans(skb,dev);
 891                                 netif_rx(skb);
 892                                 lp->stats.rx_packets++;
 893                                 continue;
 894                         }
 895                         outw(RxDiscard, ioaddr + EL3_CMD);
 896                         lp->stats.rx_dropped++;
 897                         if (el3_debug)
 898                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
 899                                            dev->name, pkt_len);
 900                 }
 901                 inw(ioaddr + EL3_STATUS);                               /* Delay. */
 902                 while (inw(ioaddr + EL3_STATUS) & 0x1000)
 903                         printk(KERN_DEBUG "     Waiting for 3c509 to discard packet, status %x.\n",
 904                                    inw(ioaddr + EL3_STATUS) );
 905         }
 906
 907         return 0;
 908 }
 909
 910 /*
 911  *     Set or clear the multicast filter for this adaptor.
 912  */
 913 static void
 914 set_multicast_list(struct net_device *dev)
 915 {
 916         unsigned long flags;
 917         struct el3_private *lp = (struct el3_private *)dev->priv;
 918         int ioaddr = dev->base_addr;
 919
 920         if (el3_debug > 1) {
 921                 static int old = 0;
 922                 if (old != dev->mc_count) {
 923                         old = dev->mc_count;
 924                         printk("%s: Setting Rx mode to %d addresses.\n", dev->name, dev->mc_count);
 925                 }
 926         }
 927         spin_lock_irqsave(&lp->lock, flags);
 928         if (dev->flags&IFF_PROMISC) {
 929                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
 930                          ioaddr + EL3_CMD);
 931         }
 932         else if (dev->mc_count || (dev->flags&IFF_ALLMULTI)) {
 933                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast, ioaddr + EL3_CMD);
 934         }
 935         else
 936                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
 937         spin_unlock_irqrestore(&lp->lock, flags);
 938 }
 939
 940 static int
 941 el3_close(struct net_device *dev)
 942 {
 943         int ioaddr = dev->base_addr;
 944
 945         if (el3_debug > 2)
 946                 printk("%s: Shutting down ethercard.\n", dev->name);
 947
 948         netif_stop_queue(dev);
 949
 950         /* Turn off statistics ASAP.  We update lp->stats below. */
 951         outw(StatsDisable, ioaddr + EL3_CMD);
 952
 953         /* Disable the receiver and transmitter. */
 954         outw(RxDisable, ioaddr + EL3_CMD);
 955         outw(TxDisable, ioaddr + EL3_CMD);
 956
 957         if (dev->if_port == 3)
 958                 /* Turn off thinnet power.  Green! */
 959                 outw(StopCoax, ioaddr + EL3_CMD);
 960         else if (dev->if_port == 0) {
 961                 /* Disable link beat and jabber, if_port may change ere next open(). */
 962                 EL3WINDOW(4);
 963                 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
 964         }
 965
 966         free_irq(dev->irq, dev);
 967         /* Switching back to window 0 disables the IRQ. */
 968         EL3WINDOW(0);
 969         /* But we explicitly zero the IRQ line select anyway. */
 970         outw(0x0f00, ioaddr + WN0_IRQ);
 971
 972         update_stats(dev);
 973         return 0;
 974 }
 975
 976 #ifdef MODULE
 977 /* Parameters that may be passed into the module. */
 978 static int debug = -1;
 979 static int irq[] = {-1, -1, -1, -1, -1, -1, -1, -1};
 980 static int xcvr[] = {-1, -1, -1, -1, -1, -1, -1, -1};
 981
 982 MODULE_PARM(debug,"i");
 983 MODULE_PARM(irq,"1-8i");
 984 MODULE_PARM(xcvr,"1-8i");
 985 MODULE_PARM(max_interrupt_work, "i");
 986 #ifdef __ISAPNP__
 987 MODULE_PARM(nopnp, "i");
 988 #endif
 989
 990 int
 991 init_module(void)
 992 {
 993         int el3_cards = 0;
 994
 995         if (debug >= 0)
 996                 el3_debug = debug;
 997
 998         el3_root_dev = NULL;
 999         while (el3_probe(0) == 0) {
1000                 if (irq[el3_cards] > 1)
1001                         el3_root_dev->irq = irq[el3_cards];
1002                 if (xcvr[el3_cards] >= 0)
1003                         el3_root_dev->if_port = xcvr[el3_cards];
1004                 el3_cards++;
1005         }
1006
1007         return el3_cards ? 0 : -ENODEV;
1008 }
1009
1010 void
1011 cleanup_module(void)
1012 {
1013         struct net_device *next_dev;
1014
1015         /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
1016         while (el3_root_dev) {
1017                 struct el3_private *lp = (struct el3_private *)el3_root_dev->priv;
1018 #ifdef CONFIG_MCA
1019                 if(lp->mca_slot!=-1)
1020                         mca_mark_as_unused(lp->mca_slot);
1021 #endif
1022                 next_dev = lp->next_dev;
1023                 unregister_netdev(el3_root_dev);
1024                 release_region(el3_root_dev->base_addr, EL3_IO_EXTENT);
1025                 kfree(el3_root_dev);
1026                 el3_root_dev = next_dev;
1027         }
1028 }
1029 #endif /* MODULE */
1030
1031 /*
1032  * Local variables:
1033  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c 3c509.c"
1034  *  version-control: t
1035  *  kept-new-versions: 5
1036  *  tab-width: 4
1037  * End:
1038  */