drivers/net/ac3200.c

   1 /* ac3200.c: A driver for the Ansel Communications EISA ethernet adaptor. */
   2 /*
   3         Written 1993, 1994 by Donald Becker.
   4         Copyright 1993 United States Government as represented by the Director,
   5         National Security Agency.  This software may only be used and distributed
   6         according to the terms of the GNU General Public License as modified by SRC,
   7         incorporated herein by reference.
   8
   9         The author may be reached as becker@scyld.com, or C/O
  10         Scyld Computing Corporation
  11         410 Severn Ave., Suite 210
  12         Annapolis MD 21403
  13
  14         This is driver for the Ansel Communications Model 3200 EISA Ethernet LAN
  15         Adapter.  The programming information is from the users manual, as related
  16         by glee@ardnassak.math.clemson.edu.
  17
  18         Changelog:
  19
  20         Paul Gortmaker 05/98    : add support for shared mem above 1MB.
  21
  22   */
  23
  24 static const char version[] =
  25         "ac3200.c:v1.01 7/1/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
  26
  27 #include <linux/module.h>
  28 #include <linux/eisa.h>
  29 #include <linux/kernel.h>
  30 #include <linux/errno.h>
  31 #include <linux/string.h>
  32 #include <linux/netdevice.h>
  33 #include <linux/etherdevice.h>
  34 #include <linux/init.h>
  35
  36 #include <asm/system.h>
  37 #include <asm/io.h>
  38 #include <asm/irq.h>
  39
  40 #include "8390.h"
  41
  42 #define DRV_NAME        "ac3200"
  43
  44 /* Offsets from the base address. */
  45 #define AC_NIC_BASE     0x00
  46 #define AC_SA_PROM      0x16                    /* The station address PROM. */
  47 #define AC_ADDR0        0x00                    /* Prefix station address values. */
  48 #define AC_ADDR1        0x40
  49 #define AC_ADDR2        0x90
  50 #define AC_ID_PORT      0xC80
  51 #define AC_EISA_ID      0x0110d305
  52 #define AC_RESET_PORT   0xC84
  53 #define AC_RESET        0x00
  54 #define AC_ENABLE       0x01
  55 #define AC_CONFIG       0xC90   /* The configuration port. */
  56
  57 #define AC_IO_EXTENT 0x20
  58                                 /* Actually accessed is:
  59                                                                  * AC_NIC_BASE (0-15)
  60                                                                  * AC_SA_PROM (0-5)
  61                                                                  * AC_ID_PORT (0-3)
  62                                                                  * AC_RESET_PORT
  63                                                                  * AC_CONFIG
  64                                                                  */
  65
  66 /* Decoding of the configuration register. */
  67 static unsigned char config2irqmap[8] __initdata = {15, 12, 11, 10, 9, 7, 5, 3};
  68 static int addrmap[8] =
  69 {0xFF0000, 0xFE0000, 0xFD0000, 0xFFF0000, 0xFFE0000, 0xFFC0000,  0xD0000, 0 };
  70 static const char *port_name[4] = { "10baseT", "invalid", "AUI", "10base2"};
  71
  72 #define config2irq(configval)   config2irqmap[((configval) >> 3) & 7]
  73 #define config2mem(configval)   addrmap[(configval) & 7]
  74 #define config2name(configval)  port_name[((configval) >> 6) & 3]
  75
  76 /* First and last 8390 pages. */
  77 #define AC_START_PG             0x00    /* First page of 8390 TX buffer */
  78 #define AC_STOP_PG              0x80    /* Last page +1 of the 8390 RX ring */
  79
  80 static int ac_probe1(int ioaddr, struct net_device *dev);
  81
  82 static int ac_open(struct net_device *dev);
  83 static void ac_reset_8390(struct net_device *dev);
  84 static void ac_block_input(struct net_device *dev, int count,
  85                                         struct sk_buff *skb, int ring_offset);
  86 static void ac_block_output(struct net_device *dev, const int count,
  87                                                         const unsigned char *buf, const int start_page);
  88 static void ac_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
  89                                         int ring_page);
  90
  91 static int ac_close_card(struct net_device *dev);
  92 \f
  93
  94 /*      Probe for the AC3200.
  95
  96         The AC3200 can be identified by either the EISA configuration registers,
  97         or the unique value in the station address PROM.
  98         */
  99
 100 static int __init do_ac3200_probe(struct net_device *dev)
 101 {
 102         unsigned short ioaddr = dev->base_addr;
 103         int irq = dev->irq;
 104         int mem_start = dev->mem_start;
 105
 106         SET_MODULE_OWNER(dev);
 107
 108         if (ioaddr > 0x1ff)             /* Check a single specified location. */
 109                 return ac_probe1(ioaddr, dev);
 110         else if (ioaddr > 0)            /* Don't probe at all. */
 111                 return -ENXIO;
 112
 113         if ( ! EISA_bus)
 114                 return -ENXIO;
 115
 116         for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
 117                 if (ac_probe1(ioaddr, dev) == 0)
 118                         return 0;
 119                 dev->irq = irq;
 120                 dev->mem_start = mem_start;
 121         }
 122
 123         return -ENODEV;
 124 }
 125
 126 static void cleanup_card(struct net_device *dev)
 127 {
 128         /* Someday free_irq may be in ac_close_card() */
 129         free_irq(dev->irq, dev);
 130         release_region(dev->base_addr, AC_IO_EXTENT);
 131         if (ei_status.reg0)
 132                 iounmap((void *)dev->mem_start);
 133 }
 134
 135 #ifndef MODULE
 136 struct net_device * __init ac3200_probe(int unit)
 137 {
 138         struct net_device *dev = alloc_ei_netdev();
 139         int err;
 140
 141         if (!dev)
 142                 return ERR_PTR(-ENOMEM);
 143
 144         sprintf(dev->name, "eth%d", unit);
 145         netdev_boot_setup_check(dev);
 146
 147         err = do_ac3200_probe(dev);
 148         if (err)
 149                 goto out;
 150         err = register_netdev(dev);
 151         if (err)
 152                 goto out1;
 153         return dev;
 154 out1:
 155         cleanup_card(dev);
 156 out:
 157         free_netdev(dev);
 158         return ERR_PTR(err);
 159 }
 160 #endif
 161
 162 static int __init ac_probe1(int ioaddr, struct net_device *dev)
 163 {
 164         int i, retval;
 165
 166         if (!request_region(ioaddr, AC_IO_EXTENT, DRV_NAME))
 167                 return -EBUSY;
 168
 169         if (inb_p(ioaddr + AC_ID_PORT) == 0xff) {
 170                 retval = -ENODEV;
 171                 goto out;
 172         }
 173
 174         if (inl(ioaddr + AC_ID_PORT) != AC_EISA_ID) {
 175                 retval = -ENODEV;
 176                 goto out;
 177         }
 178
 179 #ifndef final_version
 180         printk(KERN_DEBUG "AC3200 ethercard configuration register is %#02x,"
 181                    " EISA ID %02x %02x %02x %02x.\n", inb(ioaddr + AC_CONFIG),
 182                    inb(ioaddr + AC_ID_PORT + 0), inb(ioaddr + AC_ID_PORT + 1),
 183                    inb(ioaddr + AC_ID_PORT + 2), inb(ioaddr + AC_ID_PORT + 3));
 184 #endif
 185
 186         printk("AC3200 in EISA slot %d, node", ioaddr/0x1000);
 187         for(i = 0; i < 6; i++)
 188                 printk(" %02x", dev->dev_addr[i] = inb(ioaddr + AC_SA_PROM + i));
 189
 190 #if 0
 191         /* Check the vendor ID/prefix. Redundant after checking the EISA ID */
 192         if (inb(ioaddr + AC_SA_PROM + 0) != AC_ADDR0
 193                 || inb(ioaddr + AC_SA_PROM + 1) != AC_ADDR1
 194                 || inb(ioaddr + AC_SA_PROM + 2) != AC_ADDR2 ) {
 195                 printk(", not found (invalid prefix).\n");
 196                 retval = -ENODEV;
 197                 goto out;
 198         }
 199 #endif
 200
 201         /* Assign and allocate the interrupt now. */
 202         if (dev->irq == 0) {
 203                 dev->irq = config2irq(inb(ioaddr + AC_CONFIG));
 204                 printk(", using");
 205         } else {
 206                 dev->irq = irq_canonicalize(dev->irq);
 207                 printk(", assigning");
 208         }
 209
 210         retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
 211         if (retval) {
 212                 printk (" nothing! Unable to get IRQ %d.\n", dev->irq);
 213                 goto out1;
 214         }
 215
 216         printk(" IRQ %d, %s port\n", dev->irq, port_name[dev->if_port]);
 217
 218         dev->base_addr = ioaddr;
 219
 220 #ifdef notyet
 221         if (dev->mem_start)     {               /* Override the value from the board. */
 222                 for (i = 0; i < 7; i++)
 223                         if (addrmap[i] == dev->mem_start)
 224                                 break;
 225                 if (i >= 7)
 226                         i = 0;
 227                 outb((inb(ioaddr + AC_CONFIG) & ~7) | i, ioaddr + AC_CONFIG);
 228         }
 229 #endif
 230
 231         dev->if_port = inb(ioaddr + AC_CONFIG) >> 6;
 232         dev->mem_start = config2mem(inb(ioaddr + AC_CONFIG));
 233
 234         printk("%s: AC3200 at %#3x with %dkB memory at physical address %#lx.\n",
 235                         dev->name, ioaddr, AC_STOP_PG/4, dev->mem_start);
 236
 237         /*
 238          *  BEWARE!! Some dain-bramaged EISA SCUs will allow you to put
 239          *  the card mem within the region covered by `normal' RAM  !!!
 240          */
 241         if (dev->mem_start > 1024*1024) {       /* phys addr > 1MB */
 242                 if (dev->mem_start < virt_to_phys(high_memory)) {
 243                         printk(KERN_CRIT "ac3200.c: Card RAM overlaps with normal memory!!!\n");
 244                         printk(KERN_CRIT "ac3200.c: Use EISA SCU to set card memory below 1MB,\n");
 245                         printk(KERN_CRIT "ac3200.c: or to an address above 0x%lx.\n", virt_to_phys(high_memory));
 246                         printk(KERN_CRIT "ac3200.c: Driver NOT installed.\n");
 247                         retval = -EINVAL;
 248                         goto out1;
 249                 }
 250                 dev->mem_start = (unsigned long)ioremap(dev->mem_start, AC_STOP_PG*0x100);
 251                 if (dev->mem_start == 0) {
 252                         printk(KERN_ERR "ac3200.c: Unable to remap card memory above 1MB !!\n");
 253                         printk(KERN_ERR "ac3200.c: Try using EISA SCU to set memory below 1MB.\n");
 254                         printk(KERN_ERR "ac3200.c: Driver NOT installed.\n");
 255                         retval = -EINVAL;
 256                         goto out1;
 257                 }
 258                 ei_status.reg0 = 1;     /* Use as remap flag */
 259                 printk("ac3200.c: remapped %dkB card memory to virtual address %#lx\n",
 260                                 AC_STOP_PG/4, dev->mem_start);
 261         }
 262
 263         ei_status.rmem_start = dev->mem_start + TX_PAGES*256;
 264         dev->mem_end = ei_status.rmem_end = dev->mem_start
 265                 + (AC_STOP_PG - AC_START_PG)*256;
 266
 267         ei_status.name = "AC3200";
 268         ei_status.tx_start_page = AC_START_PG;
 269         ei_status.rx_start_page = AC_START_PG + TX_PAGES;
 270         ei_status.stop_page = AC_STOP_PG;
 271         ei_status.word16 = 1;
 272
 273         if (ei_debug > 0)
 274                 printk(version);
 275
 276         ei_status.reset_8390 = &ac_reset_8390;
 277         ei_status.block_input = &ac_block_input;
 278         ei_status.block_output = &ac_block_output;
 279         ei_status.get_8390_hdr = &ac_get_8390_hdr;
 280
 281         dev->open = &ac_open;
 282         dev->stop = &ac_close_card;
 283 #ifdef CONFIG_NET_POLL_CONTROLLER
 284         dev->poll_controller = ei_poll;
 285 #endif
 286         NS8390_init(dev, 0);
 287         return 0;
 288 out1:
 289         free_irq(dev->irq, dev);
 290 out:
 291         release_region(ioaddr, AC_IO_EXTENT);
 292         return retval;
 293 }
 294
 295 static int ac_open(struct net_device *dev)
 296 {
 297 #ifdef notyet
 298         /* Someday we may enable the IRQ and shared memory here. */
 299         int ioaddr = dev->base_addr;
 300 #endif
 301
 302         ei_open(dev);
 303         return 0;
 304 }
 305
 306 static void ac_reset_8390(struct net_device *dev)
 307 {
 308         ushort ioaddr = dev->base_addr;
 309
 310         outb(AC_RESET, ioaddr + AC_RESET_PORT);
 311         if (ei_debug > 1) printk("resetting AC3200, t=%ld...", jiffies);
 312
 313         ei_status.txing = 0;
 314         outb(AC_ENABLE, ioaddr + AC_RESET_PORT);
 315         if (ei_debug > 1) printk("reset done\n");
 316
 317         return;
 318 }
 319
 320 /* Grab the 8390 specific header. Similar to the block_input routine, but
 321    we don't need to be concerned with ring wrap as the header will be at
 322    the start of a page, so we optimize accordingly. */
 323
 324 static void
 325 ac_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 326 {
 327         unsigned long hdr_start = dev->mem_start + ((ring_page - AC_START_PG)<<8);
 328         isa_memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 329 }
 330
 331 /*  Block input and output are easy on shared memory ethercards, the only
 332         complication is when the ring buffer wraps. */
 333
 334 static void ac_block_input(struct net_device *dev, int count, struct sk_buff *skb,
 335                                                   int ring_offset)
 336 {
 337         unsigned long xfer_start = dev->mem_start + ring_offset - (AC_START_PG<<8);
 338
 339         if (xfer_start + count > ei_status.rmem_end) {
 340                 /* We must wrap the input move. */
 341                 int semi_count = ei_status.rmem_end - xfer_start;
 342                 isa_memcpy_fromio(skb->data, xfer_start, semi_count);
 343                 count -= semi_count;
 344                 isa_memcpy_fromio(skb->data + semi_count, ei_status.rmem_start, count);
 345         } else {
 346                 /* Packet is in one chunk -- we can copy + cksum. */
 347                 isa_eth_io_copy_and_sum(skb, xfer_start, count, 0);
 348         }
 349 }
 350
 351 static void ac_block_output(struct net_device *dev, int count,
 352                                                         const unsigned char *buf, int start_page)
 353 {
 354         unsigned long shmem = dev->mem_start + ((start_page - AC_START_PG)<<8);
 355
 356         isa_memcpy_toio(shmem, buf, count);
 357 }
 358
 359 static int ac_close_card(struct net_device *dev)
 360 {
 361         if (ei_debug > 1)
 362                 printk("%s: Shutting down ethercard.\n", dev->name);
 363
 364 #ifdef notyet
 365         /* We should someday disable shared memory and interrupts. */
 366         outb(0x00, ioaddr + 6); /* Disable interrupts. */
 367         free_irq(dev->irq, dev);
 368 #endif
 369
 370         ei_close(dev);
 371         return 0;
 372 }
 373
 374 #ifdef MODULE
 375 #define MAX_AC32_CARDS  4       /* Max number of AC32 cards per module */
 376 static struct net_device *dev_ac32[MAX_AC32_CARDS];
 377 static int io[MAX_AC32_CARDS];
 378 static int irq[MAX_AC32_CARDS];
 379 static int mem[MAX_AC32_CARDS];
 380 MODULE_PARM(io, "1-" __MODULE_STRING(MAX_AC32_CARDS) "i");
 381 MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_AC32_CARDS) "i");
 382 MODULE_PARM(mem, "1-" __MODULE_STRING(MAX_AC32_CARDS) "i");
 383 MODULE_PARM_DESC(io, "I/O base address(es)");
 384 MODULE_PARM_DESC(irq, "IRQ number(s)");
 385 MODULE_PARM_DESC(mem, "Memory base address(es)");
 386 MODULE_DESCRIPTION("Ansel AC3200 EISA ethernet driver");
 387 MODULE_LICENSE("GPL");
 388
 389 int
 390 init_module(void)
 391 {
 392         struct net_device *dev;
 393         int this_dev, found = 0;
 394
 395         for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
 396                 if (io[this_dev] == 0 && this_dev != 0)
 397                         break;
 398                 dev = alloc_ei_netdev();
 399                 if (!dev)
 400                         break;
 401                 dev->irq = irq[this_dev];
 402                 dev->base_addr = io[this_dev];
 403                 dev->mem_start = mem[this_dev];         /* Currently ignored by driver */
 404                 if (do_ac3200_probe(dev) == 0) {
 405                         if (register_netdev(dev) == 0) {
 406                                 dev_ac32[found++] = dev;
 407                                 continue;
 408                         }
 409                         cleanup_card(dev);
 410                 }
 411                 free_netdev(dev);
 412                 printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]);
 413                 break;
 414         }
 415         if (found)
 416                 return 0;
 417         return -ENXIO;
 418 }
 419
 420 void
 421 cleanup_module(void)
 422 {
 423         int this_dev;
 424
 425         for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
 426                 struct net_device *dev = dev_ac32[this_dev];
 427                 if (dev) {
 428                         unregister_netdev(dev);
 429                         cleanup_card(dev);
 430                         free_netdev(dev);
 431                 }
 432         }
 433 }
 434 #endif /* MODULE */