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