drivers/net/smc-ultra32.c

   1 /*      smc-ultra32.c: An SMC Ultra32 EISA ethernet driver for linux.
   2
   3 Sources:
   4
   5         This driver is based on (cloned from) the ISA SMC Ultra driver
   6         written by Donald Becker. Modifications to support the EISA
   7         version of the card by Paul Gortmaker and Leonard N. Zubkoff.
   8
   9         This software may be used and distributed according to the terms
  10         of the GNU Public License, incorporated herein by reference.
  11
  12 Theory of Operation:
  13
  14         The SMC Ultra32C card uses the SMC 83c790 chip which is also
  15         found on the ISA SMC Ultra cards. It has a shared memory mode of
  16         operation that makes it similar to the ISA version of the card.
  17         The main difference is that the EISA card has 32KB of RAM, but
  18         only an 8KB window into that memory. The EISA card also can be
  19         set for a bus-mastering mode of operation via the ECU, but that
  20         is not (and probably will never be) supported by this driver.
  21         The ECU should be run to enable shared memory and to disable the
  22         bus-mastering feature for use with linux.
  23
  24         By programming the 8390 to use only 8KB RAM, the modifications
  25         to the ISA driver can be limited to the probe and initialization
  26         code. This allows easy integration of EISA support into the ISA
  27         driver. However, the driver development kit from SMC provided the
  28         register information for sliding the 8KB window, and hence the 8390
  29         is programmed to use the full 32KB RAM.
  30
  31         Unfortunately this required code changes outside the probe/init
  32         routines, and thus we decided to separate the EISA driver from
  33         the ISA one. In this way, ISA users don't end up with a larger
  34         driver due to the EISA code, and EISA users don't end up with a
  35         larger driver due to the ISA EtherEZ PIO code. The driver is
  36         similar to the 3c503/16 driver, in that the window must be set
  37         back to the 1st 8KB of space for access to the two 8390 Tx slots.
  38
  39         In testing, using only 8KB RAM (3 Tx / 5 Rx) didn't appear to
  40         be a limiting factor, since the EISA bus could get packets off
  41         the card fast enough, but having the use of lots of RAM as Rx
  42         space is extra insurance if interrupt latencies become excessive.
  43
  44 */
  45
  46 static const char *version = "smc-ultra32.c: 06/97 v1.00\n";
  47
  48
  49 #include <linux/module.h>
  50 #include <linux/kernel.h>
  51 #include <linux/sched.h>
  52 #include <linux/errno.h>
  53 #include <linux/string.h>
  54 #include <linux/init.h>
  55
  56 #include <asm/io.h>
  57 #include <asm/system.h>
  58
  59 #include <linux/netdevice.h>
  60 #include <linux/etherdevice.h>
  61 #include "8390.h"
  62
  63 int ultra32_probe(struct net_device *dev);
  64 int ultra32_probe1(struct net_device *dev, int ioaddr);
  65 static int ultra32_open(struct net_device *dev);
  66 static void ultra32_reset_8390(struct net_device *dev);
  67 static void ultra32_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  68                                  int ring_page);
  69 static void ultra32_block_input(struct net_device *dev, int count,
  70                                 struct sk_buff *skb, int ring_offset);
  71 static void ultra32_block_output(struct net_device *dev, int count,
  72                                  const unsigned char *buf,
  73                                  const int start_page);
  74 static int ultra32_close(struct net_device *dev);
  75 \f
  76 #define ULTRA32_CMDREG  0       /* Offset to ASIC command register. */
  77 #define  ULTRA32_RESET  0x80    /* Board reset, in ULTRA32_CMDREG. */
  78 #define  ULTRA32_MEMENB 0x40    /* Enable the shared memory. */
  79 #define ULTRA32_NIC_OFFSET 16   /* NIC register offset from the base_addr. */
  80 #define ULTRA32_IO_EXTENT 32
  81 #define EN0_ERWCNT              0x08    /* Early receive warning count. */
  82
  83 /*
  84  * Defines that apply only to the Ultra32 EISA card. Note that
  85  * "smc" = 10011 01101 00011 = 0x4da3, and hence !smc8010.cfg translates
  86  * into an EISA ID of 0x1080A34D
  87  */
  88 #define ULTRA32_BASE    0xca0
  89 #define ULTRA32_ID      0x1080a34d
  90 #define ULTRA32_IDPORT  (-0x20) /* 0xc80 */
  91 /* Config regs 1->7 from the EISA !SMC8010.CFG file. */
  92 #define ULTRA32_CFG1    0x04    /* 0xca4 */
  93 #define ULTRA32_CFG2    0x05    /* 0xca5 */
  94 #define ULTRA32_CFG3    (-0x18) /* 0xc88 */
  95 #define ULTRA32_CFG4    (-0x17) /* 0xc89 */
  96 #define ULTRA32_CFG5    (-0x16) /* 0xc8a */
  97 #define ULTRA32_CFG6    (-0x15) /* 0xc8b */
  98 #define ULTRA32_CFG7    0x0d    /* 0xcad */
  99
 100
 101 /*      Probe for the Ultra32.  This looks like a 8013 with the station
 102         address PROM at I/O ports <base>+8 to <base>+13, with a checksum
 103         following.
 104 */
 105
 106 int __init ultra32_probe(struct net_device *dev)
 107 {
 108         const char *ifmap[] = {"UTP No Link", "", "UTP/AUI", "UTP/BNC"};
 109         int ioaddr, edge, media;
 110
 111         if (!EISA_bus) return -ENODEV;
 112
 113         /* EISA spec allows for up to 16 slots, but 8 is typical. */
 114         for (ioaddr = 0x1000 + ULTRA32_BASE; ioaddr < 0x9000; ioaddr += 0x1000)
 115         if (check_region(ioaddr, ULTRA32_IO_EXTENT) == 0 &&
 116             inb(ioaddr + ULTRA32_IDPORT) != 0xff &&
 117             inl(ioaddr + ULTRA32_IDPORT) == ULTRA32_ID) {
 118                 media = inb(ioaddr + ULTRA32_CFG7) & 0x03;
 119                 edge = inb(ioaddr + ULTRA32_CFG5) & 0x08;
 120                 printk("SMC Ultra32 in EISA Slot %d, Media: %s, %s IRQs.\n",
 121                        ioaddr >> 12, ifmap[media],
 122                        (edge ? "Edge Triggered" : "Level Sensitive"));
 123                 if (ultra32_probe1(dev, ioaddr) == 0)
 124                   return 0;
 125         }
 126         return -ENODEV;
 127 }
 128
 129 int __init ultra32_probe1(struct net_device *dev, int ioaddr)
 130 {
 131         int i;
 132         int checksum = 0;
 133         const char *model_name;
 134         static unsigned version_printed = 0;
 135         /* Values from various config regs. */
 136         unsigned char idreg = inb(ioaddr + 7);
 137         unsigned char reg4 = inb(ioaddr + 4) & 0x7f;
 138
 139         /* Check the ID nibble. */
 140         if ((idreg & 0xf0) != 0x20)                     /* SMC Ultra */
 141                 return -ENODEV;
 142
 143         /* Select the station address register set. */
 144         outb(reg4, ioaddr + 4);
 145
 146         for (i = 0; i < 8; i++)
 147                 checksum += inb(ioaddr + 8 + i);
 148         if ((checksum & 0xff) != 0xff)
 149                 return -ENODEV;
 150
 151         /* We should have a "dev" from Space.c or the static module table. */
 152         if (dev == NULL) {
 153                 printk("smc-ultra32.c: Passed a NULL device.\n");
 154                 dev = init_etherdev(0, 0);
 155         }
 156
 157         if (ei_debug  &&  version_printed++ == 0)
 158                 printk(version);
 159
 160         model_name = "SMC Ultra32";
 161
 162         printk("%s: %s at 0x%X,", dev->name, model_name, ioaddr);
 163
 164         for (i = 0; i < 6; i++)
 165                 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
 166
 167         /* Switch from the station address to the alternate register set and
 168            read the useful registers there. */
 169         outb(0x80 | reg4, ioaddr + 4);
 170
 171         /* Enable FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
 172         outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
 173
 174         /* Reset RAM addr. */
 175         outb(0x00, ioaddr + 0x0b);
 176
 177         /* Switch back to the station address register set so that the
 178            MS-DOS driver can find the card after a warm boot. */
 179         outb(reg4, ioaddr + 4);
 180
 181         if ((inb(ioaddr + ULTRA32_CFG5) & 0x40) == 0) {
 182                 printk("\nsmc-ultra32: Card RAM is disabled!  "
 183                        "Run EISA config utility.\n");
 184                 return -ENODEV;
 185         }
 186         if ((inb(ioaddr + ULTRA32_CFG2) & 0x04) == 0)
 187                 printk("\nsmc-ultra32: Ignoring Bus-Master enable bit.  "
 188                        "Run EISA config utility.\n");
 189
 190         if (dev->irq < 2) {
 191                 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
 192                 int irq = irqmap[inb(ioaddr + ULTRA32_CFG5) & 0x07];
 193                 if (irq == 0) {
 194                         printk(", failed to detect IRQ line.\n");
 195                         return -EAGAIN;
 196                 }
 197                 dev->irq = irq;
 198         }
 199
 200         /* Allocate dev->priv and fill in 8390 specific dev fields. */
 201         if (ethdev_init(dev)) {
 202                 printk (", no memory for dev->priv.\n");
 203                 return -ENOMEM;
 204         }
 205
 206         /* OK, we are certain this is going to work.  Setup the device. */
 207         request_region(ioaddr, ULTRA32_IO_EXTENT, model_name);
 208
 209         /* The 8390 isn't at the base address, so fake the offset */
 210         dev->base_addr = ioaddr + ULTRA32_NIC_OFFSET;
 211
 212         /* Save RAM address in the unused reg0 to avoid excess inb's. */
 213         ei_status.reg0 = inb(ioaddr + ULTRA32_CFG3) & 0xfc;
 214
 215         dev->mem_start =  0xc0000 + ((ei_status.reg0 & 0x7c) << 11);
 216
 217         ei_status.name = model_name;
 218         ei_status.word16 = 1;
 219         ei_status.tx_start_page = 0;
 220         ei_status.rx_start_page = TX_PAGES;
 221         /* All Ultra32 cards have 32KB memory with an 8KB window. */
 222         ei_status.stop_page = 128;
 223
 224         dev->rmem_start = dev->mem_start + TX_PAGES*256;
 225         dev->mem_end = dev->rmem_end = dev->mem_start + 0x1fff;
 226
 227         printk(", IRQ %d, 32KB memory, 8KB window at 0x%lx-0x%lx.\n",
 228                dev->irq, dev->mem_start, dev->mem_end);
 229         ei_status.block_input = &ultra32_block_input;
 230         ei_status.block_output = &ultra32_block_output;
 231         ei_status.get_8390_hdr = &ultra32_get_8390_hdr;
 232         ei_status.reset_8390 = &ultra32_reset_8390;
 233         dev->open = &ultra32_open;
 234         dev->stop = &ultra32_close;
 235         NS8390_init(dev, 0);
 236
 237         return 0;
 238 }
 239
 240 static int ultra32_open(struct net_device *dev)
 241 {
 242         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC addr */
 243         int irq_flags = (inb(ioaddr + ULTRA32_CFG5) & 0x08) ? 0 : SA_SHIRQ;
 244
 245         if (request_irq(dev->irq, ei_interrupt, irq_flags, ei_status.name, dev))
 246                 return -EAGAIN;
 247
 248         outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
 249         outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
 250         outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
 251         outb(0x01, ioaddr + 6); /* Enable Interrupts. */
 252         /* Set the early receive warning level in window 0 high enough not
 253            to receive ERW interrupts. */
 254         outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
 255         outb(0xff, dev->base_addr + EN0_ERWCNT);
 256         ei_open(dev);
 257         MOD_INC_USE_COUNT;
 258         return 0;
 259 }
 260
 261 static int ultra32_close(struct net_device *dev)
 262 {
 263         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* CMDREG */
 264
 265         netif_stop_queue(dev);
 266
 267         if (ei_debug > 1)
 268                 printk("%s: Shutting down ethercard.\n", dev->name);
 269
 270         outb(0x00, ioaddr + ULTRA32_CFG6); /* Disable Interrupts. */
 271         outb(0x00, ioaddr + 6);         /* Disable interrupts. */
 272         free_irq(dev->irq, dev);
 273
 274         NS8390_init(dev, 0);
 275
 276         MOD_DEC_USE_COUNT;
 277
 278         return 0;
 279 }
 280
 281 static void ultra32_reset_8390(struct net_device *dev)
 282 {
 283         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC base addr */
 284
 285         outb(ULTRA32_RESET, ioaddr);
 286         if (ei_debug > 1) printk("resetting Ultra32, t=%ld...", jiffies);
 287         ei_status.txing = 0;
 288
 289         outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
 290         outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
 291         outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
 292         outb(0x01, ioaddr + 6); /* Enable Interrupts. */
 293         if (ei_debug > 1) printk("reset done\n");
 294         return;
 295 }
 296
 297 /* Grab the 8390 specific header. Similar to the block_input routine, but
 298    we don't need to be concerned with ring wrap as the header will be at
 299    the start of a page, so we optimize accordingly. */
 300
 301 static void ultra32_get_8390_hdr(struct net_device *dev,
 302                                  struct e8390_pkt_hdr *hdr,
 303                                  int ring_page)
 304 {
 305         unsigned long hdr_start = dev->mem_start + ((ring_page & 0x1f) << 8);
 306         unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
 307
 308         /* Select correct 8KB Window. */
 309         outb(ei_status.reg0 | ((ring_page & 0x60) >> 5), RamReg);
 310
 311 #ifdef notdef
 312         /* Officially this is what we are doing, but the readl() is faster */
 313         isa_memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 314 #else
 315         ((unsigned int*)hdr)[0] = isa_readl(hdr_start);
 316 #endif
 317 }
 318
 319 /* Block input and output are easy on shared memory ethercards, the only
 320    complication is when the ring buffer wraps, or in this case, when a
 321    packet spans an 8KB boundary. Note that the current 8KB segment is
 322    already set by the get_8390_hdr routine. */
 323
 324 static void ultra32_block_input(struct net_device *dev,
 325                                 int count,
 326                                 struct sk_buff *skb,
 327                                 int ring_offset)
 328 {
 329         unsigned long xfer_start = dev->mem_start + (ring_offset & 0x1fff);
 330         unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
 331
 332         if ((ring_offset & ~0x1fff) != ((ring_offset + count - 1) & ~0x1fff)) {
 333                 int semi_count = 8192 - (ring_offset & 0x1FFF);
 334                 isa_memcpy_fromio(skb->data, xfer_start, semi_count);
 335                 count -= semi_count;
 336                 if (ring_offset < 96*256) {
 337                         /* Select next 8KB Window. */
 338                         ring_offset += semi_count;
 339                         outb(ei_status.reg0 | ((ring_offset & 0x6000) >> 13), RamReg);
 340                         isa_memcpy_fromio(skb->data + semi_count, dev->mem_start, count);
 341                 } else {
 342                         /* Select first 8KB Window. */
 343                         outb(ei_status.reg0, RamReg);
 344                         isa_memcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
 345                 }
 346         } else {
 347                 /* Packet is in one chunk -- we can copy + cksum. */
 348                 isa_eth_io_copy_and_sum(skb, xfer_start, count, 0);
 349         }
 350 }
 351
 352 static void ultra32_block_output(struct net_device *dev,
 353                                  int count,
 354                                  const unsigned char *buf,
 355                                  int start_page)
 356 {
 357         unsigned long xfer_start = dev->mem_start + (start_page<<8);
 358         unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
 359
 360         /* Select first 8KB Window. */
 361         outb(ei_status.reg0, RamReg);
 362
 363         isa_memcpy_toio(xfer_start, buf, count);
 364 }
 365 \f
 366 #ifdef MODULE
 367 #define MAX_ULTRA32_CARDS   4   /* Max number of Ultra cards per module */
 368 static struct net_device dev_ultra[MAX_ULTRA32_CARDS] = {
 369         {
 370                 "",
 371                 0, 0, 0, 0,
 372                 0, 0,
 373                 0, 0, 0, NULL, NULL
 374         },
 375 };
 376
 377 int init_module(void)
 378 {
 379         int this_dev, found = 0;
 380
 381         if (load_8390_module("smc-ultra32.c"))
 382                 return -ENOSYS;
 383
 384         for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
 385                 struct net_device *dev = &dev_ultra[this_dev];
 386                 dev->init = ultra32_probe;
 387                 if (register_netdev(dev) != 0) {
 388                         if (found > 0) { /* Got at least one. */
 389                                 return 0;
 390                         }
 391                         unload_8390_module();
 392                         printk(KERN_WARNING "smc-ultra32.c: No SMC Ultra32 found.\n");
 393                         return -ENXIO;
 394                 }
 395                 found++;
 396         }
 397         return 0;
 398 }
 399
 400 void cleanup_module(void)
 401 {
 402         int this_dev;
 403
 404         for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
 405                 struct net_device *dev = &dev_ultra[this_dev];
 406                 if (dev->priv != NULL) {
 407                         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET;
 408                         void *priv = dev->priv;
 409                         /* NB: ultra32_close_card() does free_irq */
 410                         release_region(ioaddr, ULTRA32_IO_EXTENT);
 411                         unregister_netdev(dev);
 412                         kfree(priv);
 413                 }
 414         }
 415         unload_8390_module();
 416 }
 417 #endif /* MODULE */