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 General 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/eisa.h>
  51 #include <linux/kernel.h>
  52 #include <linux/errno.h>
  53 #include <linux/string.h>
  54 #include <linux/init.h>
  55 #include <linux/interrupt.h>
  56 #include <linux/netdevice.h>
  57 #include <linux/etherdevice.h>
  58
  59 #include <asm/io.h>
  60 #include <asm/system.h>
  61
  62 #include "8390.h"
  63
  64 #define DRV_NAME "smc-ultra32"
  65
  66 static int ultra32_probe1(struct net_device *dev, int ioaddr);
  67 static int ultra32_open(struct net_device *dev);
  68 static void ultra32_reset_8390(struct net_device *dev);
  69 static void ultra32_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  70                                  int ring_page);
  71 static void ultra32_block_input(struct net_device *dev, int count,
  72                                 struct sk_buff *skb, int ring_offset);
  73 static void ultra32_block_output(struct net_device *dev, int count,
  74                                  const unsigned char *buf,
  75                                  const int start_page);
  76 static int ultra32_close(struct net_device *dev);
  77 \f
  78 #define ULTRA32_CMDREG  0       /* Offset to ASIC command register. */
  79 #define  ULTRA32_RESET  0x80    /* Board reset, in ULTRA32_CMDREG. */
  80 #define  ULTRA32_MEMENB 0x40    /* Enable the shared memory. */
  81 #define ULTRA32_NIC_OFFSET 16   /* NIC register offset from the base_addr. */
  82 #define ULTRA32_IO_EXTENT 32
  83 #define EN0_ERWCNT              0x08    /* Early receive warning count. */
  84
  85 /*
  86  * Defines that apply only to the Ultra32 EISA card. Note that
  87  * "smc" = 10011 01101 00011 = 0x4da3, and hence !smc8010.cfg translates
  88  * into an EISA ID of 0x1080A34D
  89  */
  90 #define ULTRA32_BASE    0xca0
  91 #define ULTRA32_ID      0x1080a34d
  92 #define ULTRA32_IDPORT  (-0x20) /* 0xc80 */
  93 /* Config regs 1->7 from the EISA !SMC8010.CFG file. */
  94 #define ULTRA32_CFG1    0x04    /* 0xca4 */
  95 #define ULTRA32_CFG2    0x05    /* 0xca5 */
  96 #define ULTRA32_CFG3    (-0x18) /* 0xc88 */
  97 #define ULTRA32_CFG4    (-0x17) /* 0xc89 */
  98 #define ULTRA32_CFG5    (-0x16) /* 0xc8a */
  99 #define ULTRA32_CFG6    (-0x15) /* 0xc8b */
 100 #define ULTRA32_CFG7    0x0d    /* 0xcad */
 101
 102 static void cleanup_card(struct net_device *dev)
 103 {
 104         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET;
 105         /* NB: ultra32_close_card() does free_irq */
 106         release_region(ioaddr, ULTRA32_IO_EXTENT);
 107 }
 108
 109 /*      Probe for the Ultra32.  This looks like a 8013 with the station
 110         address PROM at I/O ports <base>+8 to <base>+13, with a checksum
 111         following.
 112 */
 113
 114 struct net_device * __init ultra32_probe(int unit)
 115 {
 116         struct net_device *dev;
 117         int base;
 118         int irq;
 119         int err = -ENODEV;
 120
 121         if (!EISA_bus)
 122                 return ERR_PTR(-ENODEV);
 123
 124         dev = alloc_ei_netdev();
 125
 126         if (!dev)
 127                 return ERR_PTR(-ENOMEM);
 128
 129         if (unit >= 0) {
 130                 sprintf(dev->name, "eth%d", unit);
 131                 netdev_boot_setup_check(dev);
 132         }
 133
 134         SET_MODULE_OWNER(dev);
 135
 136         irq = dev->irq;
 137
 138         /* EISA spec allows for up to 16 slots, but 8 is typical. */
 139         for (base = 0x1000 + ULTRA32_BASE; base < 0x9000; base += 0x1000) {
 140                 if (ultra32_probe1(dev, base) == 0)
 141                         break;
 142                 dev->irq = irq;
 143         }
 144         if (base >= 0x9000)
 145                 goto out;
 146         err = register_netdev(dev);
 147         if (err)
 148                 goto out1;
 149         return dev;
 150 out1:
 151         cleanup_card(dev);
 152 out:
 153         free_netdev(dev);
 154         return ERR_PTR(err);
 155 }
 156
 157 static int __init ultra32_probe1(struct net_device *dev, int ioaddr)
 158 {
 159         int i, edge, media, retval;
 160         int checksum = 0;
 161         const char *model_name;
 162         static unsigned version_printed;
 163         /* Values from various config regs. */
 164         unsigned char idreg;
 165         unsigned char reg4;
 166         const char *ifmap[] = {"UTP No Link", "", "UTP/AUI", "UTP/BNC"};
 167
 168         if (!request_region(ioaddr, ULTRA32_IO_EXTENT, DRV_NAME))
 169                 return -EBUSY;
 170
 171         if (inb(ioaddr + ULTRA32_IDPORT) == 0xff ||
 172             inl(ioaddr + ULTRA32_IDPORT) != ULTRA32_ID) {
 173                 retval = -ENODEV;
 174                 goto out;
 175         }
 176
 177         media = inb(ioaddr + ULTRA32_CFG7) & 0x03;
 178         edge = inb(ioaddr + ULTRA32_CFG5) & 0x08;
 179         printk("SMC Ultra32 in EISA Slot %d, Media: %s, %s IRQs.\n",
 180                 ioaddr >> 12, ifmap[media],
 181                 (edge ? "Edge Triggered" : "Level Sensitive"));
 182
 183         idreg = inb(ioaddr + 7);
 184         reg4 = inb(ioaddr + 4) & 0x7f;
 185
 186         /* Check the ID nibble. */
 187         if ((idreg & 0xf0) != 0x20) {                   /* SMC Ultra */
 188                 retval = -ENODEV;
 189                 goto out;
 190         }
 191
 192         /* Select the station address register set. */
 193         outb(reg4, ioaddr + 4);
 194
 195         for (i = 0; i < 8; i++)
 196                 checksum += inb(ioaddr + 8 + i);
 197         if ((checksum & 0xff) != 0xff) {
 198                 retval = -ENODEV;
 199                 goto out;
 200         }
 201
 202         if (ei_debug  &&  version_printed++ == 0)
 203                 printk(version);
 204
 205         model_name = "SMC Ultra32";
 206
 207         printk("%s: %s at 0x%X,", dev->name, model_name, ioaddr);
 208
 209         for (i = 0; i < 6; i++)
 210                 printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
 211
 212         /* Switch from the station address to the alternate register set and
 213            read the useful registers there. */
 214         outb(0x80 | reg4, ioaddr + 4);
 215
 216         /* Enable FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
 217         outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
 218
 219         /* Reset RAM addr. */
 220         outb(0x00, ioaddr + 0x0b);
 221
 222         /* Switch back to the station address register set so that the
 223            MS-DOS driver can find the card after a warm boot. */
 224         outb(reg4, ioaddr + 4);
 225
 226         if ((inb(ioaddr + ULTRA32_CFG5) & 0x40) == 0) {
 227                 printk("\nsmc-ultra32: Card RAM is disabled!  "
 228                        "Run EISA config utility.\n");
 229                 retval = -ENODEV;
 230                 goto out;
 231         }
 232         if ((inb(ioaddr + ULTRA32_CFG2) & 0x04) == 0)
 233                 printk("\nsmc-ultra32: Ignoring Bus-Master enable bit.  "
 234                        "Run EISA config utility.\n");
 235
 236         if (dev->irq < 2) {
 237                 unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
 238                 int irq = irqmap[inb(ioaddr + ULTRA32_CFG5) & 0x07];
 239                 if (irq == 0) {
 240                         printk(", failed to detect IRQ line.\n");
 241                         retval = -EAGAIN;
 242                         goto out;
 243                 }
 244                 dev->irq = irq;
 245         }
 246
 247         /* The 8390 isn't at the base address, so fake the offset */
 248         dev->base_addr = ioaddr + ULTRA32_NIC_OFFSET;
 249
 250         /* Save RAM address in the unused reg0 to avoid excess inb's. */
 251         ei_status.reg0 = inb(ioaddr + ULTRA32_CFG3) & 0xfc;
 252
 253         dev->mem_start =  0xc0000 + ((ei_status.reg0 & 0x7c) << 11);
 254
 255         ei_status.name = model_name;
 256         ei_status.word16 = 1;
 257         ei_status.tx_start_page = 0;
 258         ei_status.rx_start_page = TX_PAGES;
 259         /* All Ultra32 cards have 32KB memory with an 8KB window. */
 260         ei_status.stop_page = 128;
 261
 262         ei_status.rmem_start = dev->mem_start + TX_PAGES*256;
 263         dev->mem_end = ei_status.rmem_end = dev->mem_start + 0x1fff;
 264
 265         printk(", IRQ %d, 32KB memory, 8KB window at 0x%lx-0x%lx.\n",
 266                dev->irq, dev->mem_start, dev->mem_end);
 267         ei_status.block_input = &ultra32_block_input;
 268         ei_status.block_output = &ultra32_block_output;
 269         ei_status.get_8390_hdr = &ultra32_get_8390_hdr;
 270         ei_status.reset_8390 = &ultra32_reset_8390;
 271         dev->open = &ultra32_open;
 272         dev->stop = &ultra32_close;
 273 #ifdef CONFIG_NET_POLL_CONTROLLER
 274         dev->poll_controller = ei_poll;
 275 #endif
 276         NS8390_init(dev, 0);
 277
 278         return 0;
 279 out:
 280         release_region(ioaddr, ULTRA32_IO_EXTENT);
 281         return retval;
 282 }
 283
 284 static int ultra32_open(struct net_device *dev)
 285 {
 286         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC addr */
 287         int irq_flags = (inb(ioaddr + ULTRA32_CFG5) & 0x08) ? 0 : SA_SHIRQ;
 288         int retval;
 289
 290         retval = request_irq(dev->irq, ei_interrupt, irq_flags, dev->name, dev);
 291         if (retval)
 292                 return retval;
 293
 294         outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
 295         outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
 296         outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
 297         outb(0x01, ioaddr + 6); /* Enable Interrupts. */
 298         /* Set the early receive warning level in window 0 high enough not
 299            to receive ERW interrupts. */
 300         outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
 301         outb(0xff, dev->base_addr + EN0_ERWCNT);
 302         ei_open(dev);
 303         return 0;
 304 }
 305
 306 static int ultra32_close(struct net_device *dev)
 307 {
 308         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* CMDREG */
 309
 310         netif_stop_queue(dev);
 311
 312         if (ei_debug > 1)
 313                 printk("%s: Shutting down ethercard.\n", dev->name);
 314
 315         outb(0x00, ioaddr + ULTRA32_CFG6); /* Disable Interrupts. */
 316         outb(0x00, ioaddr + 6);         /* Disable interrupts. */
 317         free_irq(dev->irq, dev);
 318
 319         NS8390_init(dev, 0);
 320
 321         return 0;
 322 }
 323
 324 static void ultra32_reset_8390(struct net_device *dev)
 325 {
 326         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC base addr */
 327
 328         outb(ULTRA32_RESET, ioaddr);
 329         if (ei_debug > 1) printk("resetting Ultra32, t=%ld...", jiffies);
 330         ei_status.txing = 0;
 331
 332         outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
 333         outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
 334         outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
 335         outb(0x01, ioaddr + 6); /* Enable Interrupts. */
 336         if (ei_debug > 1) printk("reset done\n");
 337         return;
 338 }
 339
 340 /* Grab the 8390 specific header. Similar to the block_input routine, but
 341    we don't need to be concerned with ring wrap as the header will be at
 342    the start of a page, so we optimize accordingly. */
 343
 344 static void ultra32_get_8390_hdr(struct net_device *dev,
 345                                  struct e8390_pkt_hdr *hdr,
 346                                  int ring_page)
 347 {
 348         unsigned long hdr_start = dev->mem_start + ((ring_page & 0x1f) << 8);
 349         unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
 350
 351         /* Select correct 8KB Window. */
 352         outb(ei_status.reg0 | ((ring_page & 0x60) >> 5), RamReg);
 353
 354 #ifdef __BIG_ENDIAN
 355         /* Officially this is what we are doing, but the readl() is faster */
 356         /* unfortunately it isn't endian aware of the struct               */
 357         isa_memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 358         hdr->count = le16_to_cpu(hdr->count);
 359 #else
 360         ((unsigned int*)hdr)[0] = isa_readl(hdr_start);
 361 #endif
 362 }
 363
 364 /* Block input and output are easy on shared memory ethercards, the only
 365    complication is when the ring buffer wraps, or in this case, when a
 366    packet spans an 8KB boundary. Note that the current 8KB segment is
 367    already set by the get_8390_hdr routine. */
 368
 369 static void ultra32_block_input(struct net_device *dev,
 370                                 int count,
 371                                 struct sk_buff *skb,
 372                                 int ring_offset)
 373 {
 374         unsigned long xfer_start = dev->mem_start + (ring_offset & 0x1fff);
 375         unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
 376
 377         if ((ring_offset & ~0x1fff) != ((ring_offset + count - 1) & ~0x1fff)) {
 378                 int semi_count = 8192 - (ring_offset & 0x1FFF);
 379                 isa_memcpy_fromio(skb->data, xfer_start, semi_count);
 380                 count -= semi_count;
 381                 if (ring_offset < 96*256) {
 382                         /* Select next 8KB Window. */
 383                         ring_offset += semi_count;
 384                         outb(ei_status.reg0 | ((ring_offset & 0x6000) >> 13), RamReg);
 385                         isa_memcpy_fromio(skb->data + semi_count, dev->mem_start, count);
 386                 } else {
 387                         /* Select first 8KB Window. */
 388                         outb(ei_status.reg0, RamReg);
 389                         isa_memcpy_fromio(skb->data + semi_count, ei_status.rmem_start, count);
 390                 }
 391         } else {
 392                 /* Packet is in one chunk -- we can copy + cksum. */
 393                 isa_eth_io_copy_and_sum(skb, xfer_start, count, 0);
 394         }
 395 }
 396
 397 static void ultra32_block_output(struct net_device *dev,
 398                                  int count,
 399                                  const unsigned char *buf,
 400                                  int start_page)
 401 {
 402         unsigned long xfer_start = dev->mem_start + (start_page<<8);
 403         unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
 404
 405         /* Select first 8KB Window. */
 406         outb(ei_status.reg0, RamReg);
 407
 408         isa_memcpy_toio(xfer_start, buf, count);
 409 }
 410 \f
 411 #ifdef MODULE
 412 #define MAX_ULTRA32_CARDS   4   /* Max number of Ultra cards per module */
 413 static struct net_device *dev_ultra[MAX_ULTRA32_CARDS];
 414
 415 MODULE_DESCRIPTION("SMC Ultra32 EISA ethernet driver");
 416 MODULE_LICENSE("GPL");
 417
 418 int init_module(void)
 419 {
 420         int this_dev, found = 0;
 421
 422         for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
 423                 struct net_device *dev = ultra32_probe(-1);
 424                 if (IS_ERR(dev))
 425                         break;
 426                 dev_ultra[found++] = dev;
 427         }
 428         if (found)
 429                 return 0;
 430         printk(KERN_WARNING "smc-ultra32.c: No SMC Ultra32 found.\n");
 431         return -ENXIO;
 432 }
 433
 434 void cleanup_module(void)
 435 {
 436         int this_dev;
 437
 438         for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
 439                 struct net_device *dev = dev_ultra[this_dev];
 440                 if (dev) {
 441                         unregister_netdev(dev);
 442                         cleanup_card(dev);
 443                         free_netdev(dev);
 444                 }
 445         }
 446 }
 447 #endif /* MODULE */
 448