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