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