kernel/2.6.29.6-aldebaran-rt/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         for (i = 0; i < 6; i++)
 207                 dev->dev_addr[i] = inb(ioaddr + 8 + i);
 208
 209         printk("%s: %s at 0x%X, %pM",
 210                dev->name, model_name, ioaddr, dev->dev_addr);
 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.mem = ioremap(dev->mem_start, 0x2000);
 263         if (!ei_status.mem) {
 264                 printk(", failed to ioremap.\n");
 265                 retval = -ENOMEM;
 266                 goto out;
 267         }
 268         dev->mem_end = dev->mem_start + 0x1fff;
 269
 270         printk(", IRQ %d, 32KB memory, 8KB window at 0x%lx-0x%lx.\n",
 271                dev->irq, dev->mem_start, dev->mem_end);
 272         ei_status.block_input = &ultra32_block_input;
 273         ei_status.block_output = &ultra32_block_output;
 274         ei_status.get_8390_hdr = &ultra32_get_8390_hdr;
 275         ei_status.reset_8390 = &ultra32_reset_8390;
 276         dev->open = &ultra32_open;
 277         dev->stop = &ultra32_close;
 278 #ifdef CONFIG_NET_POLL_CONTROLLER
 279         dev->poll_controller = ei_poll;
 280 #endif
 281         NS8390_init(dev, 0);
 282
 283         return 0;
 284 out:
 285         release_region(ioaddr, ULTRA32_IO_EXTENT);
 286         return retval;
 287 }
 288
 289 static int ultra32_open(struct net_device *dev)
 290 {
 291         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC addr */
 292         int irq_flags = (inb(ioaddr + ULTRA32_CFG5) & 0x08) ? 0 : IRQF_SHARED;
 293         int retval;
 294
 295         retval = request_irq(dev->irq, ei_interrupt, irq_flags, dev->name, dev);
 296         if (retval)
 297                 return retval;
 298
 299         outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
 300         outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
 301         outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
 302         outb(0x01, ioaddr + 6); /* Enable Interrupts. */
 303         /* Set the early receive warning level in window 0 high enough not
 304            to receive ERW interrupts. */
 305         outb_p(E8390_NODMA+E8390_PAGE0, dev->base_addr);
 306         outb(0xff, dev->base_addr + EN0_ERWCNT);
 307         ei_open(dev);
 308         return 0;
 309 }
 310
 311 static int ultra32_close(struct net_device *dev)
 312 {
 313         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* CMDREG */
 314
 315         netif_stop_queue(dev);
 316
 317         if (ei_debug > 1)
 318                 printk("%s: Shutting down ethercard.\n", dev->name);
 319
 320         outb(0x00, ioaddr + ULTRA32_CFG6); /* Disable Interrupts. */
 321         outb(0x00, ioaddr + 6);         /* Disable interrupts. */
 322         free_irq(dev->irq, dev);
 323
 324         NS8390_init(dev, 0);
 325
 326         return 0;
 327 }
 328
 329 static void ultra32_reset_8390(struct net_device *dev)
 330 {
 331         int ioaddr = dev->base_addr - ULTRA32_NIC_OFFSET; /* ASIC base addr */
 332
 333         outb(ULTRA32_RESET, ioaddr);
 334         if (ei_debug > 1) printk("resetting Ultra32, t=%ld...", jiffies);
 335         ei_status.txing = 0;
 336
 337         outb(ULTRA32_MEMENB, ioaddr); /* Enable Shared Memory. */
 338         outb(0x80, ioaddr + ULTRA32_CFG6); /* Enable Interrupts. */
 339         outb(0x84, ioaddr + 5); /* Enable MEM16 & Disable Bus Master. */
 340         outb(0x01, ioaddr + 6); /* Enable Interrupts. */
 341         if (ei_debug > 1) printk("reset done\n");
 342         return;
 343 }
 344
 345 /* Grab the 8390 specific header. Similar to the block_input routine, but
 346    we don't need to be concerned with ring wrap as the header will be at
 347    the start of a page, so we optimize accordingly. */
 348
 349 static void ultra32_get_8390_hdr(struct net_device *dev,
 350                                  struct e8390_pkt_hdr *hdr,
 351                                  int ring_page)
 352 {
 353         void __iomem *hdr_start = ei_status.mem + ((ring_page & 0x1f) << 8);
 354         unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
 355
 356         /* Select correct 8KB Window. */
 357         outb(ei_status.reg0 | ((ring_page & 0x60) >> 5), RamReg);
 358
 359 #ifdef __BIG_ENDIAN
 360         /* Officially this is what we are doing, but the readl() is faster */
 361         /* unfortunately it isn't endian aware of the struct               */
 362         memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 363         hdr->count = le16_to_cpu(hdr->count);
 364 #else
 365         ((unsigned int*)hdr)[0] = readl(hdr_start);
 366 #endif
 367 }
 368
 369 /* Block input and output are easy on shared memory ethercards, the only
 370    complication is when the ring buffer wraps, or in this case, when a
 371    packet spans an 8KB boundary. Note that the current 8KB segment is
 372    already set by the get_8390_hdr routine. */
 373
 374 static void ultra32_block_input(struct net_device *dev,
 375                                 int count,
 376                                 struct sk_buff *skb,
 377                                 int ring_offset)
 378 {
 379         void __iomem *xfer_start = ei_status.mem + (ring_offset & 0x1fff);
 380         unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
 381
 382         if ((ring_offset & ~0x1fff) != ((ring_offset + count - 1) & ~0x1fff)) {
 383                 int semi_count = 8192 - (ring_offset & 0x1FFF);
 384                 memcpy_fromio(skb->data, xfer_start, semi_count);
 385                 count -= semi_count;
 386                 if (ring_offset < 96*256) {
 387                         /* Select next 8KB Window. */
 388                         ring_offset += semi_count;
 389                         outb(ei_status.reg0 | ((ring_offset & 0x6000) >> 13), RamReg);
 390                         memcpy_fromio(skb->data + semi_count, ei_status.mem, count);
 391                 } else {
 392                         /* Select first 8KB Window. */
 393                         outb(ei_status.reg0, RamReg);
 394                         memcpy_fromio(skb->data + semi_count, ei_status.mem + TX_PAGES * 256, count);
 395                 }
 396         } else {
 397                 memcpy_fromio(skb->data, xfer_start, count);
 398         }
 399 }
 400
 401 static void ultra32_block_output(struct net_device *dev,
 402                                  int count,
 403                                  const unsigned char *buf,
 404                                  int start_page)
 405 {
 406         void __iomem *xfer_start = ei_status.mem + (start_page<<8);
 407         unsigned int RamReg = dev->base_addr - ULTRA32_NIC_OFFSET + ULTRA32_CFG3;
 408
 409         /* Select first 8KB Window. */
 410         outb(ei_status.reg0, RamReg);
 411
 412         memcpy_toio(xfer_start, buf, count);
 413 }
 414
 415 #ifdef MODULE
 416 #define MAX_ULTRA32_CARDS   4   /* Max number of Ultra cards per module */
 417 static struct net_device *dev_ultra[MAX_ULTRA32_CARDS];
 418
 419 MODULE_DESCRIPTION("SMC Ultra32 EISA ethernet driver");
 420 MODULE_LICENSE("GPL");
 421
 422 int __init init_module(void)
 423 {
 424         int this_dev, found = 0;
 425
 426         for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
 427                 struct net_device *dev = ultra32_probe(-1);
 428                 if (IS_ERR(dev))
 429                         break;
 430                 dev_ultra[found++] = dev;
 431         }
 432         if (found)
 433                 return 0;
 434         printk(KERN_WARNING "smc-ultra32.c: No SMC Ultra32 found.\n");
 435         return -ENXIO;
 436 }
 437
 438 void __exit cleanup_module(void)
 439 {
 440         int this_dev;
 441
 442         for (this_dev = 0; this_dev < MAX_ULTRA32_CARDS; this_dev++) {
 443                 struct net_device *dev = dev_ultra[this_dev];
 444                 if (dev) {
 445                         unregister_netdev(dev);
 446                         cleanup_card(dev);
 447                         free_netdev(dev);
 448                 }
 449         }
 450 }
 451 #endif /* MODULE */
 452