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