drivers/net/es3210.c

   1 /*
   2         es3210.c
   3
   4         Linux driver for Racal-Interlan ES3210 EISA Network Adapter
   5
   6         Copyright (C) 1996, Paul Gortmaker.
   7
   8         This software may be used and distributed according to the terms
   9         of the GNU General Public License, incorporated herein by reference.
  10
  11         Information and Code Sources:
  12
  13         1) The existing myriad of Linux 8390 drivers written by Donald Becker.
  14
  15         2) Once again Russ Nelson's asm packet driver provided additional info.
  16
  17         3) Info for getting IRQ and sh-mem gleaned from the EISA cfg files.
  18            Too bad it doesn't work -- see below.
  19
  20         The ES3210 is an EISA shared memory NS8390 implementation. Note
  21         that all memory copies to/from the board must be 32bit transfers.
  22         Which rules out using eth_io_copy_and_sum() in this driver.
  23
  24         Apparently there are two slightly different revisions of the
  25         card, since there are two distinct EISA cfg files (!rii0101.cfg
  26         and !rii0102.cfg) One has media select in the cfg file and the
  27         other doesn't. Hopefully this will work with either.
  28
  29         That is about all I can tell you about it, having never actually
  30         even seen one of these cards. :)  Try http://www.interlan.com
  31         if you want more info.
  32
  33         Thanks go to Mark Salazar for testing v0.02 of this driver.
  34
  35         Bugs, to-fix, etc:
  36
  37         1) The EISA cfg ports that are *supposed* to have the IRQ and shared
  38            mem values just read 0xff all the time. Hrrmpf. Apparently the
  39            same happens with the packet driver as the code for reading
  40            these registers is disabled there. In the meantime, boot with:
  41            ether=<IRQ>,0,0x<shared_mem_addr>,eth0 to override the IRQ and
  42            shared memory detection. (The i/o port detection is okay.)
  43
  44         2) Module support currently untested. Probably works though.
  45
  46 */
  47
  48 static const char version[] =
  49         "es3210.c: Driver revision v0.03, 14/09/96\n";
  50
  51 #include <linux/module.h>
  52 #include <linux/kernel.h>
  53 #include <linux/sched.h>
  54 #include <linux/errno.h>
  55 #include <linux/string.h>
  56 #include <linux/init.h>
  57 #include <asm/io.h>
  58 #include <asm/system.h>
  59
  60 #include <linux/netdevice.h>
  61 #include <linux/etherdevice.h>
  62 #include "8390.h"
  63
  64 int es_probe(struct net_device *dev);
  65 static int es_probe1(struct net_device *dev, int ioaddr);
  66
  67 static int es_open(struct net_device *dev);
  68 static int es_close(struct net_device *dev);
  69
  70 static void es_reset_8390(struct net_device *dev);
  71
  72 static void es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page);
  73 static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset);
  74 static void es_block_output(struct net_device *dev, int count, const unsigned char *buf, int start_page);
  75
  76 #define ES_START_PG     0x00    /* First page of TX buffer              */
  77 #define ES_STOP_PG      0x40    /* Last page +1 of RX ring              */
  78
  79 #define ES_IO_EXTENT    0x37    /* The cfg file says 0xc90 -> 0xcc7     */
  80 #define ES_ID_PORT      0xc80   /* Same for all EISA cards              */
  81 #define ES_SA_PROM      0xc90   /* Start of e'net addr.                 */
  82 #define ES_RESET_PORT   0xc84   /* From the packet driver source        */
  83 #define ES_NIC_OFFSET   0xca0   /* Hello, the 8390 is *here*            */
  84
  85 #define ES_ADDR0        0x02    /* 3 byte vendor prefix                 */
  86 #define ES_ADDR1        0x07
  87 #define ES_ADDR2        0x01
  88
  89 /*
  90  * Two card revisions. EISA ID's are always rev. minor, rev. major,, and
  91  * then the three vendor letters stored in 5 bits each, with an "a" = 1.
  92  * For eg: "rii" = 10010 01001 01001 = 0x4929, which is how the EISA
  93  * config utility determines automagically what config file(s) to use.
  94  */
  95 #define ES_EISA_ID1     0x01012949      /* !rii0101.cfg                 */
  96 #define ES_EISA_ID2     0x02012949      /* !rii0102.cfg                 */
  97
  98 #define ES_CFG1         0xcc0   /* IOPORT(1) --> IOPORT(6) in cfg file  */
  99 #define ES_CFG2         0xcc1
 100 #define ES_CFG3         0xcc2
 101 #define ES_CFG4         0xcc3
 102 #define ES_CFG5         0xcc4
 103 #define ES_CFG6         0xc84   /* NB: 0xc84 is also "reset" port.      */
 104
 105 /*
 106  *      You can OR any of the following bits together and assign it
 107  *      to ES_DEBUG to get verbose driver info during operation.
 108  *      Some of these don't do anything yet.
 109  */
 110
 111 #define ES_D_PROBE      0x01
 112 #define ES_D_RX_PKT     0x02
 113 #define ES_D_TX_PKT     0x04
 114 #define ED_D_IRQ        0x08
 115
 116 #define ES_DEBUG        0
 117
 118 static unsigned char lo_irq_map[] __initdata = {3, 4, 5, 6, 7, 9, 10};
 119 static unsigned char hi_irq_map[] __initdata = {11, 12, 0, 14, 0, 0, 0, 15};
 120
 121 /*
 122  *      Probe for the card. The best way is to read the EISA ID if it
 123  *      is known. Then we check the prefix of the station address
 124  *      PROM for a match against the Racal-Interlan assigned value.
 125  */
 126
 127 int __init es_probe(struct net_device *dev)
 128 {
 129         unsigned short ioaddr = dev->base_addr;
 130
 131         SET_MODULE_OWNER(dev);
 132
 133         if (ioaddr > 0x1ff)             /* Check a single specified location. */
 134                 return es_probe1(dev, ioaddr);
 135         else if (ioaddr > 0)            /* Don't probe at all. */
 136                 return -ENXIO;
 137
 138         if (!EISA_bus) {
 139 #if ES_DEBUG & ES_D_PROBE
 140                 printk("es3210.c: Not EISA bus. Not probing high ports.\n");
 141 #endif
 142                 return -ENXIO;
 143         }
 144
 145         /* EISA spec allows for up to 16 slots, but 8 is typical. */
 146         for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000)
 147                 if (es_probe1(dev, ioaddr) == 0)
 148                         return 0;
 149
 150         return -ENODEV;
 151 }
 152
 153 static int __init es_probe1(struct net_device *dev, int ioaddr)
 154 {
 155         int i, retval;
 156         unsigned long eisa_id;
 157
 158         if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
 159                 return -ENODEV;
 160
 161 #if ES_DEBUG & ES_D_PROBE
 162         printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
 163         printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
 164                 inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
 165                 inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
 166 #endif
 167
 168
 169 /*      Check the EISA ID of the card. */
 170         eisa_id = inl(ioaddr + ES_ID_PORT);
 171         if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
 172                 retval = -ENODEV;
 173                 goto out;
 174         }
 175
 176 /*      Check the Racal vendor ID as well. */
 177         if (inb(ioaddr + ES_SA_PROM + 0) != ES_ADDR0
 178                 || inb(ioaddr + ES_SA_PROM + 1) != ES_ADDR1
 179                 || inb(ioaddr + ES_SA_PROM + 2) != ES_ADDR2 ) {
 180                 printk("es3210.c: card not found");
 181                 for(i = 0; i < ETHER_ADDR_LEN; i++)
 182                         printk(" %02x", inb(ioaddr + ES_SA_PROM + i));
 183                 printk(" (invalid prefix).\n");
 184                 retval = -ENODEV;
 185                 goto out;
 186         }
 187
 188         printk("es3210.c: ES3210 rev. %ld at %#x, node", eisa_id>>24, ioaddr);
 189         for(i = 0; i < ETHER_ADDR_LEN; i++)
 190                 printk(" %02x", (dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i)));
 191
 192         /* Snarf the interrupt now. */
 193         if (dev->irq == 0) {
 194                 unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
 195                 unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;
 196
 197                 if (hi_irq != 0) {
 198                         dev->irq = hi_irq_map[hi_irq - 1];
 199                 } else {
 200                         int i = 0;
 201                         while (lo_irq > (1<<i)) i++;
 202                         dev->irq = lo_irq_map[i];
 203                 }
 204                 printk(" using IRQ %d", dev->irq);
 205 #if ES_DEBUG & ES_D_PROBE
 206                 printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
 207                                         hi_irq, lo_irq, dev->irq);
 208 #endif
 209         } else {
 210                 if (dev->irq == 2)
 211                         dev->irq = 9;                   /* Doh! */
 212                 printk(" assigning IRQ %d", dev->irq);
 213         }
 214
 215         if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
 216                 printk (" unable to get IRQ %d.\n", dev->irq);
 217                 retval = -EAGAIN;
 218                 goto out;
 219         }
 220
 221         if (dev->mem_start == 0) {
 222                 unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
 223                 unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;
 224
 225                 if (mem_enabled != 0x80) {
 226                         printk(" shared mem disabled - giving up\n");
 227                         retval = -ENXIO;
 228                         goto out1;
 229                 }
 230                 dev->mem_start = 0xC0000 + mem_bits*0x4000;
 231                 printk(" using ");
 232         } else {
 233                 printk(" assigning ");
 234         }
 235
 236         dev->mem_end = dev->rmem_end = dev->mem_start
 237                 + (ES_STOP_PG - ES_START_PG)*256;
 238         dev->rmem_start = dev->mem_start + TX_PAGES*256;
 239
 240         printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);
 241
 242         /* Allocate dev->priv and fill in 8390 specific dev fields. */
 243         if (ethdev_init(dev)) {
 244                 printk (" unable to allocate memory for dev->priv.\n");
 245                 retval = -ENOMEM;
 246                 goto out1;
 247         }
 248
 249 #if ES_DEBUG & ES_D_PROBE
 250         if (inb(ioaddr + ES_CFG5))
 251                 printk("es3210: Warning - DMA channel enabled, but not used here.\n");
 252 #endif
 253         /* Note, point at the 8390, and not the card... */
 254         dev->base_addr = ioaddr + ES_NIC_OFFSET;
 255
 256         ei_status.name = "ES3210";
 257         ei_status.tx_start_page = ES_START_PG;
 258         ei_status.rx_start_page = ES_START_PG + TX_PAGES;
 259         ei_status.stop_page = ES_STOP_PG;
 260         ei_status.word16 = 1;
 261
 262         if (ei_debug > 0)
 263                 printk(version);
 264
 265         ei_status.reset_8390 = &es_reset_8390;
 266         ei_status.block_input = &es_block_input;
 267         ei_status.block_output = &es_block_output;
 268         ei_status.get_8390_hdr = &es_get_8390_hdr;
 269
 270         dev->open = &es_open;
 271         dev->stop = &es_close;
 272         NS8390_init(dev, 0);
 273         return 0;
 274 out1:
 275         free_irq(dev->irq, dev);
 276 out:
 277         release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
 278         return retval;
 279 }
 280
 281 /*
 282  *      Reset as per the packet driver method. Judging by the EISA cfg
 283  *      file, this just toggles the "Board Enable" bits (bit 2 and 0).
 284  */
 285
 286 static void es_reset_8390(struct net_device *dev)
 287 {
 288         unsigned short ioaddr = dev->base_addr;
 289         unsigned long end;
 290
 291         outb(0x04, ioaddr + ES_RESET_PORT);
 292         if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);
 293
 294         end = jiffies + 2*HZ/100;
 295         while ((signed)(end - jiffies) > 0) continue;
 296
 297         ei_status.txing = 0;
 298         outb(0x01, ioaddr + ES_RESET_PORT);
 299         if (ei_debug > 1) printk("reset done\n");
 300
 301         return;
 302 }
 303
 304 /*
 305  *      Note: In the following three functions is the implicit assumption
 306  *      that the associated memcpy will only use "rep; movsl" as long as
 307  *      we keep the counts as some multiple of doublewords. This is a
 308  *      requirement of the hardware, and also prevents us from using
 309  *      eth_io_copy_and_sum() since we can't guarantee it will limit
 310  *      itself to doubleword access.
 311  */
 312
 313 /*
 314  *      Grab the 8390 specific header. Similar to the block_input routine, but
 315  *      we don't need to be concerned with ring wrap as the header will be at
 316  *      the start of a page, so we optimize accordingly. (A single doubleword.)
 317  */
 318
 319 static void
 320 es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 321 {
 322         unsigned long hdr_start = dev->mem_start + ((ring_page - ES_START_PG)<<8);
 323         isa_memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 324         hdr->count = (hdr->count + 3) & ~3;     /* Round up allocation. */
 325 }
 326
 327 /*
 328  *      Block input and output are easy on shared memory ethercards, the only
 329  *      complication is when the ring buffer wraps. The count will already
 330  *      be rounded up to a doubleword value via es_get_8390_hdr() above.
 331  */
 332
 333 static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb,
 334                                                   int ring_offset)
 335 {
 336         unsigned long xfer_start = dev->mem_start + ring_offset - (ES_START_PG<<8);
 337
 338         if (xfer_start + count > dev->rmem_end) {
 339                 /* Packet wraps over end of ring buffer. */
 340                 int semi_count = dev->rmem_end - xfer_start;
 341                 isa_memcpy_fromio(skb->data, xfer_start, semi_count);
 342                 count -= semi_count;
 343                 isa_memcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
 344         } else {
 345                 /* Packet is in one chunk. */
 346                 isa_eth_io_copy_and_sum(skb, xfer_start, count, 0);
 347         }
 348 }
 349
 350 static void es_block_output(struct net_device *dev, int count,
 351                                 const unsigned char *buf, int start_page)
 352 {
 353         unsigned long shmem = dev->mem_start + ((start_page - ES_START_PG)<<8);
 354
 355         count = (count + 3) & ~3;     /* Round up to doubleword */
 356         isa_memcpy_toio(shmem, buf, count);
 357 }
 358
 359 static int es_open(struct net_device *dev)
 360 {
 361         ei_open(dev);
 362         return 0;
 363 }
 364
 365 static int es_close(struct net_device *dev)
 366 {
 367
 368         if (ei_debug > 1)
 369                 printk("%s: Shutting down ethercard.\n", dev->name);
 370
 371         ei_close(dev);
 372         return 0;
 373 }
 374
 375 #ifdef MODULE
 376 #define MAX_ES_CARDS    4       /* Max number of ES3210 cards per module */
 377 #define NAMELEN         8       /* # of chars for storing dev->name */
 378 static struct net_device dev_es3210[MAX_ES_CARDS];
 379 static int io[MAX_ES_CARDS];
 380 static int irq[MAX_ES_CARDS];
 381 static int mem[MAX_ES_CARDS];
 382
 383 MODULE_PARM(io, "1-" __MODULE_STRING(MAX_ES_CARDS) "i");
 384 MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_ES_CARDS) "i");
 385 MODULE_PARM(mem, "1-" __MODULE_STRING(MAX_ES_CARDS) "i");
 386 MODULE_PARM_DESC(io, "I/O base address(es)");
 387 MODULE_PARM_DESC(irq, "IRQ number(s)");
 388 MODULE_PARM_DESC(mem, "memory base address(es)");
 389 MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
 390 MODULE_LICENSE("GPL");
 391
 392 int
 393 init_module(void)
 394 {
 395         int this_dev, found = 0;
 396
 397         for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
 398                 struct net_device *dev = &dev_es3210[this_dev];
 399                 dev->irq = irq[this_dev];
 400                 dev->base_addr = io[this_dev];
 401                 dev->mem_start = mem[this_dev];         /* Currently ignored by driver */
 402                 dev->init = es_probe;
 403                 /* Default is to only install one card. */
 404                 if (io[this_dev] == 0 && this_dev != 0) break;
 405                 if (register_netdev(dev) != 0) {
 406                         printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
 407                         if (found != 0) {       /* Got at least one. */
 408                                 return 0;
 409                         }
 410                         return -ENXIO;
 411                 }
 412                 found++;
 413         }
 414         return 0;
 415 }
 416
 417 void
 418 cleanup_module(void)
 419 {
 420         int this_dev;
 421
 422         for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
 423                 struct net_device *dev = &dev_es3210[this_dev];
 424                 if (dev->priv != NULL) {
 425                         void *priv = dev->priv;
 426                         free_irq(dev->irq, dev);
 427                         release_region(dev->base_addr, ES_IO_EXTENT);
 428                         unregister_netdev(dev);
 429                         kfree(priv);
 430                 }
 431         }
 432 }
 433 #endif /* MODULE */
 434