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