drivers/net/e2100.c

   1 /* e2100.c: A Cabletron E2100 series ethernet driver for linux. */
   2 /*
   3         Written 1993-1994 by Donald Becker.
   4
   5         Copyright 1994 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 General Public License,
   9         incorporated herein by reference.
  10
  11         This is a driver for the Cabletron E2100 series ethercards.
  12
  13         The Author may be reached as becker@scyld.com, or C/O
  14         Scyld Computing Corporation
  15         410 Severn Ave., Suite 210
  16         Annapolis MD 21403
  17
  18         The E2100 series ethercard is a fairly generic shared memory 8390
  19         implementation.  The only unusual aspect is the way the shared memory
  20         registers are set: first you do an inb() in what is normally the
  21         station address region, and the low three bits of next outb() *address*
  22         is used as the write value for that register.  Either someone wasn't
  23         too used to dem bit en bites, or they were trying to obfuscate the
  24         programming interface.
  25
  26         There is an additional complication when setting the window on the packet
  27         buffer.  You must first do a read into the packet buffer region with the
  28         low 8 address bits the address setting the page for the start of the packet
  29         buffer window, and then do the above operation.  See mem_on() for details.
  30
  31         One bug on the chip is that even a hard reset won't disable the memory
  32         window, usually resulting in a hung machine if mem_off() isn't called.
  33         If this happens, you must power down the machine for about 30 seconds.
  34 */
  35
  36 static const char version[] =
  37         "e2100.c:v1.01 7/21/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
  38
  39 #include <linux/module.h>
  40 #include <linux/kernel.h>
  41 #include <linux/errno.h>
  42 #include <linux/string.h>
  43 #include <linux/ioport.h>
  44 #include <linux/netdevice.h>
  45 #include <linux/etherdevice.h>
  46 #include <linux/init.h>
  47 #include <linux/delay.h>
  48
  49 #include <asm/io.h>
  50 #include <asm/system.h>
  51
  52 #include "8390.h"
  53
  54 #define DRV_NAME "e2100"
  55
  56 static int e21_probe_list[] = {0x300, 0x280, 0x380, 0x220, 0};
  57
  58 /* Offsets from the base_addr.
  59    Read from the ASIC register, and the low three bits of the next outb()
  60    address is used to set the corresponding register. */
  61 #define E21_NIC_OFFSET  0               /* Offset to the 8390 NIC. */
  62 #define E21_ASIC                0x10
  63 #define E21_MEM_ENABLE  0x10
  64 #define  E21_MEM_ON             0x05    /* Enable memory in 16 bit mode. */
  65 #define  E21_MEM_ON_8   0x07    /* Enable memory in  8 bit mode. */
  66 #define E21_MEM_BASE    0x11
  67 #define E21_IRQ_LOW             0x12    /* The low three bits of the IRQ number. */
  68 #define E21_IRQ_HIGH    0x14    /* The high IRQ bit and media select ...  */
  69 #define E21_MEDIA               0x14    /* (alias). */
  70 #define  E21_ALT_IFPORT 0x02    /* Set to use the other (BNC,AUI) port. */
  71 #define  E21_BIG_MEM    0x04    /* Use a bigger (64K) buffer (we don't) */
  72 #define E21_SAPROM              0x10    /* Offset to station address data. */
  73 #define E21_IO_EXTENT    0x20
  74
  75 static inline void mem_on(short port, volatile char __iomem *mem_base,
  76                                                   unsigned char start_page )
  77 {
  78         /* This is a little weird: set the shared memory window by doing a
  79            read.  The low address bits specify the starting page. */
  80         readb(mem_base+start_page);
  81         inb(port + E21_MEM_ENABLE);
  82         outb(E21_MEM_ON, port + E21_MEM_ENABLE + E21_MEM_ON);
  83 }
  84
  85 static inline void mem_off(short port)
  86 {
  87         inb(port + E21_MEM_ENABLE);
  88         outb(0x00, port + E21_MEM_ENABLE);
  89 }
  90
  91 /* In other drivers I put the TX pages first, but the E2100 window circuitry
  92    is designed to have a 4K Tx region last. The windowing circuitry wraps the
  93    window at 0x2fff->0x0000 so that the packets at e.g. 0x2f00 in the RX ring
  94    appear contiguously in the window. */
  95 #define E21_RX_START_PG         0x00    /* First page of RX buffer */
  96 #define E21_RX_STOP_PG          0x30    /* Last page +1 of RX ring */
  97 #define E21_BIG_RX_STOP_PG      0xF0    /* Last page +1 of RX ring */
  98 #define E21_TX_START_PG         E21_RX_STOP_PG  /* First page of TX buffer */
  99
 100 static int e21_probe1(struct net_device *dev, int ioaddr);
 101
 102 static int e21_open(struct net_device *dev);
 103 static void e21_reset_8390(struct net_device *dev);
 104 static void e21_block_input(struct net_device *dev, int count,
 105                                                    struct sk_buff *skb, int ring_offset);
 106 static void e21_block_output(struct net_device *dev, int count,
 107                                                          const unsigned char *buf, int start_page);
 108 static void e21_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
 109                                                         int ring_page);
 110
 111 static int e21_close(struct net_device *dev);
 112
 113 \f
 114 /*  Probe for the E2100 series ethercards.  These cards have an 8390 at the
 115         base address and the station address at both offset 0x10 and 0x18.  I read
 116         the station address from offset 0x18 to avoid the dataport of NE2000
 117         ethercards, and look for Ctron's unique ID (first three octets of the
 118         station address).
 119  */
 120
 121 static int  __init do_e2100_probe(struct net_device *dev)
 122 {
 123         int *port;
 124         int base_addr = dev->base_addr;
 125         int irq = dev->irq;
 126
 127         SET_MODULE_OWNER(dev);
 128
 129         if (base_addr > 0x1ff)          /* Check a single specified location. */
 130                 return e21_probe1(dev, base_addr);
 131         else if (base_addr != 0)        /* Don't probe at all. */
 132                 return -ENXIO;
 133
 134         for (port = e21_probe_list; *port; port++) {
 135                 dev->irq = irq;
 136                 if (e21_probe1(dev, *port) == 0)
 137                         return 0;
 138         }
 139
 140         return -ENODEV;
 141 }
 142
 143 static void cleanup_card(struct net_device *dev)
 144 {
 145         /* NB: e21_close() handles free_irq */
 146         iounmap(ei_status.mem);
 147         release_region(dev->base_addr, E21_IO_EXTENT);
 148 }
 149
 150 #ifndef MODULE
 151 struct net_device * __init e2100_probe(int unit)
 152 {
 153         struct net_device *dev = alloc_ei_netdev();
 154         int err;
 155
 156         if (!dev)
 157                 return ERR_PTR(-ENOMEM);
 158
 159         sprintf(dev->name, "eth%d", unit);
 160         netdev_boot_setup_check(dev);
 161
 162         err = do_e2100_probe(dev);
 163         if (err)
 164                 goto out;
 165         return dev;
 166 out:
 167         free_netdev(dev);
 168         return ERR_PTR(err);
 169 }
 170 #endif
 171
 172 static int __init e21_probe1(struct net_device *dev, int ioaddr)
 173 {
 174         int i, status, retval;
 175         unsigned char *station_addr = dev->dev_addr;
 176         static unsigned version_printed;
 177
 178         if (!request_region(ioaddr, E21_IO_EXTENT, DRV_NAME))
 179                 return -EBUSY;
 180
 181         /* First check the station address for the Ctron prefix. */
 182         if (inb(ioaddr + E21_SAPROM + 0) != 0x00
 183                 || inb(ioaddr + E21_SAPROM + 1) != 0x00
 184                 || inb(ioaddr + E21_SAPROM + 2) != 0x1d) {
 185                 retval = -ENODEV;
 186                 goto out;
 187         }
 188
 189         /* Verify by making certain that there is a 8390 at there. */
 190         outb(E8390_NODMA + E8390_STOP, ioaddr);
 191         udelay(1);      /* we want to delay one I/O cycle - which is 2MHz */
 192         status = inb(ioaddr);
 193         if (status != 0x21 && status != 0x23) {
 194                 retval = -ENODEV;
 195                 goto out;
 196         }
 197
 198         /* Read the station address PROM.  */
 199         for (i = 0; i < 6; i++)
 200                 station_addr[i] = inb(ioaddr + E21_SAPROM + i);
 201
 202         inb(ioaddr + E21_MEDIA);                /* Point to media selection. */
 203         outb(0, ioaddr + E21_ASIC);     /* and disable the secondary interface. */
 204
 205         if (ei_debug  &&  version_printed++ == 0)
 206                 printk(version);
 207
 208         for (i = 0; i < 6; i++)
 209                 printk(" %02X", station_addr[i]);
 210
 211         if (dev->irq < 2) {
 212                 int irqlist[] = {15,11,10,12,5,9,3,4}, i;
 213                 for (i = 0; i < 8; i++)
 214                         if (request_irq (irqlist[i], NULL, 0, "bogus", NULL) != -EBUSY) {
 215                                 dev->irq = irqlist[i];
 216                                 break;
 217                         }
 218                 if (i >= 8) {
 219                         printk(" unable to get IRQ %d.\n", dev->irq);
 220                         retval = -EAGAIN;
 221                         goto out;
 222                 }
 223         } else if (dev->irq == 2)       /* Fixup luser bogosity: IRQ2 is really IRQ9 */
 224                 dev->irq = 9;
 225
 226         /* The 8390 is at the base address. */
 227         dev->base_addr = ioaddr;
 228
 229         ei_status.name = "E2100";
 230         ei_status.word16 = 1;
 231         ei_status.tx_start_page = E21_TX_START_PG;
 232         ei_status.rx_start_page = E21_RX_START_PG;
 233         ei_status.stop_page = E21_RX_STOP_PG;
 234         ei_status.saved_irq = dev->irq;
 235
 236         /* Check the media port used.  The port can be passed in on the
 237            low mem_end bits. */
 238         if (dev->mem_end & 15)
 239                 dev->if_port = dev->mem_end & 7;
 240         else {
 241                 dev->if_port = 0;
 242                 inb(ioaddr + E21_MEDIA);        /* Turn automatic media detection on. */
 243                 for(i = 0; i < 6; i++)
 244                         if (station_addr[i] != inb(ioaddr + E21_SAPROM + 8 + i)) {
 245                                 dev->if_port = 1;
 246                                 break;
 247                         }
 248         }
 249
 250         /* Never map in the E21 shared memory unless you are actively using it.
 251            Also, the shared memory has effective only one setting -- spread all
 252            over the 128K region! */
 253         if (dev->mem_start == 0)
 254                 dev->mem_start = 0xd0000;
 255
 256         ei_status.mem = ioremap(dev->mem_start, 2*1024);
 257         if (!ei_status.mem) {
 258                 printk("unable to remap memory\n");
 259                 retval = -EAGAIN;
 260                 goto out;
 261         }
 262
 263 #ifdef notdef
 264         /* These values are unused.  The E2100 has a 2K window into the packet
 265            buffer.  The window can be set to start on any page boundary. */
 266         ei_status.rmem_start = dev->mem_start + TX_PAGES*256;
 267         dev->mem_end = ei_status.rmem_end = dev->mem_start + 2*1024;
 268 #endif
 269
 270         printk(", IRQ %d, %s media, memory @ %#lx.\n", dev->irq,
 271                    dev->if_port ? "secondary" : "primary", dev->mem_start);
 272
 273         ei_status.reset_8390 = &e21_reset_8390;
 274         ei_status.block_input = &e21_block_input;
 275         ei_status.block_output = &e21_block_output;
 276         ei_status.get_8390_hdr = &e21_get_8390_hdr;
 277         dev->open = &e21_open;
 278         dev->stop = &e21_close;
 279 #ifdef CONFIG_NET_POLL_CONTROLLER
 280         dev->poll_controller = ei_poll;
 281 #endif
 282         NS8390_init(dev, 0);
 283
 284         retval = register_netdev(dev);
 285         if (retval)
 286                 goto out;
 287         return 0;
 288 out:
 289         release_region(ioaddr, E21_IO_EXTENT);
 290         return retval;
 291 }
 292
 293 static int
 294 e21_open(struct net_device *dev)
 295 {
 296         short ioaddr = dev->base_addr;
 297         int retval;
 298
 299         if ((retval = request_irq(dev->irq, ei_interrupt, 0, dev->name, dev)))
 300                 return retval;
 301
 302         /* Set the interrupt line and memory base on the hardware. */
 303         inb(ioaddr + E21_IRQ_LOW);
 304         outb(0, ioaddr + E21_ASIC + (dev->irq & 7));
 305         inb(ioaddr + E21_IRQ_HIGH);                     /* High IRQ bit, and if_port. */
 306         outb(0, ioaddr + E21_ASIC + (dev->irq > 7 ? 1:0)
 307                    + (dev->if_port ? E21_ALT_IFPORT : 0));
 308         inb(ioaddr + E21_MEM_BASE);
 309         outb(0, ioaddr + E21_ASIC + ((dev->mem_start >> 17) & 7));
 310
 311         ei_open(dev);
 312         return 0;
 313 }
 314
 315 static void
 316 e21_reset_8390(struct net_device *dev)
 317 {
 318         short ioaddr = dev->base_addr;
 319
 320         outb(0x01, ioaddr);
 321         if (ei_debug > 1) printk("resetting the E2180x3 t=%ld...", jiffies);
 322         ei_status.txing = 0;
 323
 324         /* Set up the ASIC registers, just in case something changed them. */
 325
 326         if (ei_debug > 1) printk("reset done\n");
 327         return;
 328 }
 329
 330 /* Grab the 8390 specific header. We put the 2k window so the header page
 331    appears at the start of the shared memory. */
 332
 333 static void
 334 e21_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 335 {
 336
 337         short ioaddr = dev->base_addr;
 338         char __iomem *shared_mem = ei_status.mem;
 339
 340         mem_on(ioaddr, shared_mem, ring_page);
 341
 342 #ifdef notdef
 343         /* Officially this is what we are doing, but the readl() is faster */
 344         memcpy_fromio(hdr, shared_mem, sizeof(struct e8390_pkt_hdr));
 345 #else
 346         ((unsigned int*)hdr)[0] = readl(shared_mem);
 347 #endif
 348
 349         /* Turn off memory access: we would need to reprogram the window anyway. */
 350         mem_off(ioaddr);
 351
 352 }
 353
 354 /*  Block input and output are easy on shared memory ethercards.
 355         The E21xx makes block_input() especially easy by wrapping the top
 356         ring buffer to the bottom automatically. */
 357 static void
 358 e21_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 359 {
 360         short ioaddr = dev->base_addr;
 361         char __iomem *shared_mem = ei_status.mem;
 362
 363         mem_on(ioaddr, shared_mem, (ring_offset>>8));
 364
 365         /* Packet is always in one chunk -- we can copy + cksum. */
 366         eth_io_copy_and_sum(skb, ei_status.mem + (ring_offset & 0xff), count, 0);
 367
 368         mem_off(ioaddr);
 369 }
 370
 371 static void
 372 e21_block_output(struct net_device *dev, int count, const unsigned char *buf,
 373                                  int start_page)
 374 {
 375         short ioaddr = dev->base_addr;
 376         volatile char __iomem *shared_mem = ei_status.mem;
 377
 378         /* Set the shared memory window start by doing a read, with the low address
 379            bits specifying the starting page. */
 380         readb(shared_mem + start_page);
 381         mem_on(ioaddr, shared_mem, start_page);
 382
 383         memcpy_toio(shared_mem, buf, count);
 384         mem_off(ioaddr);
 385 }
 386
 387 static int
 388 e21_close(struct net_device *dev)
 389 {
 390         short ioaddr = dev->base_addr;
 391
 392         if (ei_debug > 1)
 393                 printk("%s: Shutting down ethercard.\n", dev->name);
 394
 395         free_irq(dev->irq, dev);
 396         dev->irq = ei_status.saved_irq;
 397
 398         /* Shut off the interrupt line and secondary interface. */
 399         inb(ioaddr + E21_IRQ_LOW);
 400         outb(0, ioaddr + E21_ASIC);
 401         inb(ioaddr + E21_IRQ_HIGH);                     /* High IRQ bit, and if_port. */
 402         outb(0, ioaddr + E21_ASIC);
 403
 404         ei_close(dev);
 405
 406         /* Double-check that the memory has been turned off, because really
 407            really bad things happen if it isn't. */
 408         mem_off(ioaddr);
 409
 410         return 0;
 411 }
 412
 413 \f
 414 #ifdef MODULE
 415 #define MAX_E21_CARDS   4       /* Max number of E21 cards per module */
 416 static struct net_device *dev_e21[MAX_E21_CARDS];
 417 static int io[MAX_E21_CARDS];
 418 static int irq[MAX_E21_CARDS];
 419 static int mem[MAX_E21_CARDS];
 420 static int xcvr[MAX_E21_CARDS];         /* choose int. or ext. xcvr */
 421
 422 module_param_array(io, int, NULL, 0);
 423 module_param_array(irq, int, NULL, 0);
 424 module_param_array(mem, int, NULL, 0);
 425 module_param_array(xcvr, int, NULL, 0);
 426 MODULE_PARM_DESC(io, "I/O base address(es)");
 427 MODULE_PARM_DESC(irq, "IRQ number(s)");
 428 MODULE_PARM_DESC(mem, " memory base address(es)");
 429 MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)");
 430 MODULE_DESCRIPTION("Cabletron E2100 ISA ethernet driver");
 431 MODULE_LICENSE("GPL");
 432
 433 /* This is set up so that only a single autoprobe takes place per call.
 434 ISA device autoprobes on a running machine are not recommended. */
 435 int
 436 init_module(void)
 437 {
 438         struct net_device *dev;
 439         int this_dev, found = 0;
 440
 441         for (this_dev = 0; this_dev < MAX_E21_CARDS; this_dev++) {
 442                 if (io[this_dev] == 0)  {
 443                         if (this_dev != 0) break; /* only autoprobe 1st one */
 444                         printk(KERN_NOTICE "e2100.c: Presently autoprobing (not recommended) for a single card.\n");
 445                 }
 446                 dev = alloc_ei_netdev();
 447                 if (!dev)
 448                         break;
 449                 dev->irq = irq[this_dev];
 450                 dev->base_addr = io[this_dev];
 451                 dev->mem_start = mem[this_dev];
 452                 dev->mem_end = xcvr[this_dev];  /* low 4bits = xcvr sel. */
 453                 if (do_e2100_probe(dev) == 0) {
 454                         dev_e21[found++] = dev;
 455                         continue;
 456                 }
 457                 free_netdev(dev);
 458                 printk(KERN_WARNING "e2100.c: No E2100 card found (i/o = 0x%x).\n", io[this_dev]);
 459                 break;
 460         }
 461         if (found)
 462                 return 0;
 463         return -ENXIO;
 464 }
 465
 466 void
 467 cleanup_module(void)
 468 {
 469         int this_dev;
 470
 471         for (this_dev = 0; this_dev < MAX_E21_CARDS; this_dev++) {
 472                 struct net_device *dev = dev_e21[this_dev];
 473                 if (dev) {
 474                         unregister_netdev(dev);
 475                         cleanup_card(dev);
 476                         free_netdev(dev);
 477                 }
 478         }
 479 }
 480 #endif /* MODULE */