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         iounmap(ei_status.mem);
 132 }
 133
 134 #ifndef MODULE
 135 struct net_device * __init ac3200_probe(int unit)
 136 {
 137         struct net_device *dev = alloc_ei_netdev();
 138         int err;
 139
 140         if (!dev)
 141                 return ERR_PTR(-ENOMEM);
 142
 143         sprintf(dev->name, "eth%d", unit);
 144         netdev_boot_setup_check(dev);
 145
 146         err = do_ac3200_probe(dev);
 147         if (err)
 148                 goto out;
 149         err = register_netdev(dev);
 150         if (err)
 151                 goto out1;
 152         return dev;
 153 out1:
 154         cleanup_card(dev);
 155 out:
 156         free_netdev(dev);
 157         return ERR_PTR(err);
 158 }
 159 #endif
 160
 161 static int __init ac_probe1(int ioaddr, struct net_device *dev)
 162 {
 163         int i, retval;
 164
 165         if (!request_region(ioaddr, AC_IO_EXTENT, DRV_NAME))
 166                 return -EBUSY;
 167
 168         if (inb_p(ioaddr + AC_ID_PORT) == 0xff) {
 169                 retval = -ENODEV;
 170                 goto out;
 171         }
 172
 173         if (inl(ioaddr + AC_ID_PORT) != AC_EISA_ID) {
 174                 retval = -ENODEV;
 175                 goto out;
 176         }
 177
 178 #ifndef final_version
 179         printk(KERN_DEBUG "AC3200 ethercard configuration register is %#02x,"
 180                    " EISA ID %02x %02x %02x %02x.\n", inb(ioaddr + AC_CONFIG),
 181                    inb(ioaddr + AC_ID_PORT + 0), inb(ioaddr + AC_ID_PORT + 1),
 182                    inb(ioaddr + AC_ID_PORT + 2), inb(ioaddr + AC_ID_PORT + 3));
 183 #endif
 184
 185         printk("AC3200 in EISA slot %d, node", ioaddr/0x1000);
 186         for(i = 0; i < 6; i++)
 187                 printk(" %02x", dev->dev_addr[i] = inb(ioaddr + AC_SA_PROM + i));
 188
 189 #if 0
 190         /* Check the vendor ID/prefix. Redundant after checking the EISA ID */
 191         if (inb(ioaddr + AC_SA_PROM + 0) != AC_ADDR0
 192                 || inb(ioaddr + AC_SA_PROM + 1) != AC_ADDR1
 193                 || inb(ioaddr + AC_SA_PROM + 2) != AC_ADDR2 ) {
 194                 printk(", not found (invalid prefix).\n");
 195                 retval = -ENODEV;
 196                 goto out;
 197         }
 198 #endif
 199
 200         /* Assign and allocate the interrupt now. */
 201         if (dev->irq == 0) {
 202                 dev->irq = config2irq(inb(ioaddr + AC_CONFIG));
 203                 printk(", using");
 204         } else {
 205                 dev->irq = irq_canonicalize(dev->irq);
 206                 printk(", assigning");
 207         }
 208
 209         retval = request_irq(dev->irq, ei_interrupt, 0, DRV_NAME, dev);
 210         if (retval) {
 211                 printk (" nothing! Unable to get IRQ %d.\n", dev->irq);
 212                 goto out1;
 213         }
 214
 215         printk(" IRQ %d, %s port\n", dev->irq, port_name[dev->if_port]);
 216
 217         dev->base_addr = ioaddr;
 218
 219 #ifdef notyet
 220         if (dev->mem_start)     {               /* Override the value from the board. */
 221                 for (i = 0; i < 7; i++)
 222                         if (addrmap[i] == dev->mem_start)
 223                                 break;
 224                 if (i >= 7)
 225                         i = 0;
 226                 outb((inb(ioaddr + AC_CONFIG) & ~7) | i, ioaddr + AC_CONFIG);
 227         }
 228 #endif
 229
 230         dev->if_port = inb(ioaddr + AC_CONFIG) >> 6;
 231         dev->mem_start = config2mem(inb(ioaddr + AC_CONFIG));
 232
 233         printk("%s: AC3200 at %#3x with %dkB memory at physical address %#lx.\n",
 234                         dev->name, ioaddr, AC_STOP_PG/4, dev->mem_start);
 235
 236         /*
 237          *  BEWARE!! Some dain-bramaged EISA SCUs will allow you to put
 238          *  the card mem within the region covered by `normal' RAM  !!!
 239          *
 240          *  ioremap() will fail in that case.
 241          */
 242         ei_status.mem = ioremap(dev->mem_start, AC_STOP_PG*0x100);
 243         if (!ei_status.mem) {
 244                 printk(KERN_ERR "ac3200.c: Unable to remap card memory above 1MB !!\n");
 245                 printk(KERN_ERR "ac3200.c: Try using EISA SCU to set memory below 1MB.\n");
 246                 printk(KERN_ERR "ac3200.c: Driver NOT installed.\n");
 247                 retval = -EINVAL;
 248                 goto out1;
 249         }
 250         printk("ac3200.c: remapped %dkB card memory to virtual address %p\n",
 251                         AC_STOP_PG/4, ei_status.mem);
 252
 253         dev->mem_start = (unsigned long)ei_status.mem;
 254         dev->mem_end = dev->mem_start + (AC_STOP_PG - AC_START_PG)*256;
 255
 256         ei_status.name = "AC3200";
 257         ei_status.tx_start_page = AC_START_PG;
 258         ei_status.rx_start_page = AC_START_PG + TX_PAGES;
 259         ei_status.stop_page = AC_STOP_PG;
 260         ei_status.word16 = 1;
 261
 262         if (ei_debug > 0)
 263                 printk(version);
 264
 265         ei_status.reset_8390 = &ac_reset_8390;
 266         ei_status.block_input = &ac_block_input;
 267         ei_status.block_output = &ac_block_output;
 268         ei_status.get_8390_hdr = &ac_get_8390_hdr;
 269
 270         dev->open = &ac_open;
 271         dev->stop = &ac_close_card;
 272 #ifdef CONFIG_NET_POLL_CONTROLLER
 273         dev->poll_controller = ei_poll;
 274 #endif
 275         NS8390_init(dev, 0);
 276         return 0;
 277 out1:
 278         free_irq(dev->irq, dev);
 279 out:
 280         release_region(ioaddr, AC_IO_EXTENT);
 281         return retval;
 282 }
 283
 284 static int ac_open(struct net_device *dev)
 285 {
 286 #ifdef notyet
 287         /* Someday we may enable the IRQ and shared memory here. */
 288         int ioaddr = dev->base_addr;
 289 #endif
 290
 291         ei_open(dev);
 292         return 0;
 293 }
 294
 295 static void ac_reset_8390(struct net_device *dev)
 296 {
 297         ushort ioaddr = dev->base_addr;
 298
 299         outb(AC_RESET, ioaddr + AC_RESET_PORT);
 300         if (ei_debug > 1) printk("resetting AC3200, t=%ld...", jiffies);
 301
 302         ei_status.txing = 0;
 303         outb(AC_ENABLE, ioaddr + AC_RESET_PORT);
 304         if (ei_debug > 1) printk("reset done\n");
 305
 306         return;
 307 }
 308
 309 /* Grab the 8390 specific header. Similar to the block_input routine, but
 310    we don't need to be concerned with ring wrap as the header will be at
 311    the start of a page, so we optimize accordingly. */
 312
 313 static void
 314 ac_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 315 {
 316         void __iomem *hdr_start = ei_status.mem + ((ring_page - AC_START_PG)<<8);
 317         memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 318 }
 319
 320 /*  Block input and output are easy on shared memory ethercards, the only
 321         complication is when the ring buffer wraps. */
 322
 323 static void ac_block_input(struct net_device *dev, int count, struct sk_buff *skb,
 324                                                   int ring_offset)
 325 {
 326         void __iomem *start = ei_status.mem + ring_offset - AC_START_PG*256;
 327
 328         if (ring_offset + count > AC_STOP_PG*256) {
 329                 /* We must wrap the input move. */
 330                 int semi_count = AC_STOP_PG*256 - ring_offset;
 331                 memcpy_fromio(skb->data, start, semi_count);
 332                 count -= semi_count;
 333                 memcpy_fromio(skb->data + semi_count,
 334                                 ei_status.mem + TX_PAGES*256, count);
 335         } else {
 336                 /* Packet is in one chunk -- we can copy + cksum. */
 337                 eth_io_copy_and_sum(skb, start, count, 0);
 338         }
 339 }
 340
 341 static void ac_block_output(struct net_device *dev, int count,
 342                                                         const unsigned char *buf, int start_page)
 343 {
 344         void __iomem *shmem = ei_status.mem + ((start_page - AC_START_PG)<<8);
 345
 346         memcpy_toio(shmem, buf, count);
 347 }
 348
 349 static int ac_close_card(struct net_device *dev)
 350 {
 351         if (ei_debug > 1)
 352                 printk("%s: Shutting down ethercard.\n", dev->name);
 353
 354 #ifdef notyet
 355         /* We should someday disable shared memory and interrupts. */
 356         outb(0x00, ioaddr + 6); /* Disable interrupts. */
 357         free_irq(dev->irq, dev);
 358 #endif
 359
 360         ei_close(dev);
 361         return 0;
 362 }
 363
 364 #ifdef MODULE
 365 #define MAX_AC32_CARDS  4       /* Max number of AC32 cards per module */
 366 static struct net_device *dev_ac32[MAX_AC32_CARDS];
 367 static int io[MAX_AC32_CARDS];
 368 static int irq[MAX_AC32_CARDS];
 369 static int mem[MAX_AC32_CARDS];
 370 module_param_array(io, int, NULL, 0);
 371 module_param_array(irq, int, NULL, 0);
 372 module_param_array(mem, int, NULL, 0);
 373 MODULE_PARM_DESC(io, "I/O base address(es)");
 374 MODULE_PARM_DESC(irq, "IRQ number(s)");
 375 MODULE_PARM_DESC(mem, "Memory base address(es)");
 376 MODULE_DESCRIPTION("Ansel AC3200 EISA ethernet driver");
 377 MODULE_LICENSE("GPL");
 378
 379 int
 380 init_module(void)
 381 {
 382         struct net_device *dev;
 383         int this_dev, found = 0;
 384
 385         for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
 386                 if (io[this_dev] == 0 && this_dev != 0)
 387                         break;
 388                 dev = alloc_ei_netdev();
 389                 if (!dev)
 390                         break;
 391                 dev->irq = irq[this_dev];
 392                 dev->base_addr = io[this_dev];
 393                 dev->mem_start = mem[this_dev];         /* Currently ignored by driver */
 394                 if (do_ac3200_probe(dev) == 0) {
 395                         if (register_netdev(dev) == 0) {
 396                                 dev_ac32[found++] = dev;
 397                                 continue;
 398                         }
 399                         cleanup_card(dev);
 400                 }
 401                 free_netdev(dev);
 402                 printk(KERN_WARNING "ac3200.c: No ac3200 card found (i/o = 0x%x).\n", io[this_dev]);
 403                 break;
 404         }
 405         if (found)
 406                 return 0;
 407         return -ENXIO;
 408 }
 409
 410 void
 411 cleanup_module(void)
 412 {
 413         int this_dev;
 414
 415         for (this_dev = 0; this_dev < MAX_AC32_CARDS; this_dev++) {
 416                 struct net_device *dev = dev_ac32[this_dev];
 417                 if (dev) {
 418                         unregister_netdev(dev);
 419                         cleanup_card(dev);
 420                         free_netdev(dev);
 421                 }
 422         }
 423 }
 424 #endif /* MODULE */