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