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/eisa.h>
  53 #include <linux/kernel.h>
  54 #include <linux/errno.h>
  55 #include <linux/string.h>
  56 #include <linux/init.h>
  57 #include <linux/netdevice.h>
  58 #include <linux/etherdevice.h>
  59
  60 #include <asm/io.h>
  61 #include <asm/system.h>
  62
  63 #include "8390.h"
  64
  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 static int __init do_es_probe(struct net_device *dev)
 128 {
 129         unsigned short ioaddr = dev->base_addr;
 130         int irq = dev->irq;
 131         int mem_start = dev->mem_start;
 132
 133         SET_MODULE_OWNER(dev);
 134
 135         if (ioaddr > 0x1ff)             /* Check a single specified location. */
 136                 return es_probe1(dev, ioaddr);
 137         else if (ioaddr > 0)            /* Don't probe at all. */
 138                 return -ENXIO;
 139
 140         if (!EISA_bus) {
 141 #if ES_DEBUG & ES_D_PROBE
 142                 printk("es3210.c: Not EISA bus. Not probing high ports.\n");
 143 #endif
 144                 return -ENXIO;
 145         }
 146
 147         /* EISA spec allows for up to 16 slots, but 8 is typical. */
 148         for (ioaddr = 0x1000; ioaddr < 0x9000; ioaddr += 0x1000) {
 149                 if (es_probe1(dev, ioaddr) == 0)
 150                         return 0;
 151                 dev->irq = irq;
 152                 dev->mem_start = mem_start;
 153         }
 154
 155         return -ENODEV;
 156 }
 157
 158 static void cleanup_card(struct net_device *dev)
 159 {
 160         free_irq(dev->irq, dev);
 161         release_region(dev->base_addr, ES_IO_EXTENT);
 162 }
 163
 164 #ifndef MODULE
 165 struct net_device * __init es_probe(int unit)
 166 {
 167         struct net_device *dev = alloc_ei_netdev();
 168         int err;
 169
 170         if (!dev)
 171                 return ERR_PTR(-ENOMEM);
 172
 173         sprintf(dev->name, "eth%d", unit);
 174         netdev_boot_setup_check(dev);
 175
 176         err = do_es_probe(dev);
 177         if (err)
 178                 goto out;
 179         err = register_netdev(dev);
 180         if (err)
 181                 goto out1;
 182         return dev;
 183 out1:
 184         cleanup_card(dev);
 185 out:
 186         free_netdev(dev);
 187         return ERR_PTR(err);
 188 }
 189 #endif
 190
 191 static int __init es_probe1(struct net_device *dev, int ioaddr)
 192 {
 193         int i, retval;
 194         unsigned long eisa_id;
 195
 196         if (!request_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT, "es3210"))
 197                 return -ENODEV;
 198
 199 #if ES_DEBUG & ES_D_PROBE
 200         printk("es3210.c: probe at %#x, ID %#8x\n", ioaddr, inl(ioaddr + ES_ID_PORT));
 201         printk("es3210.c: config regs: %#x %#x %#x %#x %#x %#x\n",
 202                 inb(ioaddr + ES_CFG1), inb(ioaddr + ES_CFG2), inb(ioaddr + ES_CFG3),
 203                 inb(ioaddr + ES_CFG4), inb(ioaddr + ES_CFG5), inb(ioaddr + ES_CFG6));
 204 #endif
 205
 206
 207 /*      Check the EISA ID of the card. */
 208         eisa_id = inl(ioaddr + ES_ID_PORT);
 209         if ((eisa_id != ES_EISA_ID1) && (eisa_id != ES_EISA_ID2)) {
 210                 retval = -ENODEV;
 211                 goto out;
 212         }
 213
 214 /*      Check the Racal vendor ID as well. */
 215         if (inb(ioaddr + ES_SA_PROM + 0) != ES_ADDR0
 216                 || inb(ioaddr + ES_SA_PROM + 1) != ES_ADDR1
 217                 || inb(ioaddr + ES_SA_PROM + 2) != ES_ADDR2 ) {
 218                 printk("es3210.c: card not found");
 219                 for(i = 0; i < ETHER_ADDR_LEN; i++)
 220                         printk(" %02x", inb(ioaddr + ES_SA_PROM + i));
 221                 printk(" (invalid prefix).\n");
 222                 retval = -ENODEV;
 223                 goto out;
 224         }
 225
 226         printk("es3210.c: ES3210 rev. %ld at %#x, node", eisa_id>>24, ioaddr);
 227         for(i = 0; i < ETHER_ADDR_LEN; i++)
 228                 printk(" %02x", (dev->dev_addr[i] = inb(ioaddr + ES_SA_PROM + i)));
 229
 230         /* Snarf the interrupt now. */
 231         if (dev->irq == 0) {
 232                 unsigned char hi_irq = inb(ioaddr + ES_CFG2) & 0x07;
 233                 unsigned char lo_irq = inb(ioaddr + ES_CFG1) & 0xfe;
 234
 235                 if (hi_irq != 0) {
 236                         dev->irq = hi_irq_map[hi_irq - 1];
 237                 } else {
 238                         int i = 0;
 239                         while (lo_irq > (1<<i)) i++;
 240                         dev->irq = lo_irq_map[i];
 241                 }
 242                 printk(" using IRQ %d", dev->irq);
 243 #if ES_DEBUG & ES_D_PROBE
 244                 printk("es3210.c: hi_irq %#x, lo_irq %#x, dev->irq = %d\n",
 245                                         hi_irq, lo_irq, dev->irq);
 246 #endif
 247         } else {
 248                 if (dev->irq == 2)
 249                         dev->irq = 9;                   /* Doh! */
 250                 printk(" assigning IRQ %d", dev->irq);
 251         }
 252
 253         if (request_irq(dev->irq, ei_interrupt, 0, "es3210", dev)) {
 254                 printk (" unable to get IRQ %d.\n", dev->irq);
 255                 retval = -EAGAIN;
 256                 goto out;
 257         }
 258
 259         if (dev->mem_start == 0) {
 260                 unsigned char mem_enabled = inb(ioaddr + ES_CFG2) & 0xc0;
 261                 unsigned char mem_bits = inb(ioaddr + ES_CFG3) & 0x07;
 262
 263                 if (mem_enabled != 0x80) {
 264                         printk(" shared mem disabled - giving up\n");
 265                         retval = -ENXIO;
 266                         goto out1;
 267                 }
 268                 dev->mem_start = 0xC0000 + mem_bits*0x4000;
 269                 printk(" using ");
 270         } else {
 271                 printk(" assigning ");
 272         }
 273
 274         dev->mem_end = ei_status.rmem_end = dev->mem_start
 275                 + (ES_STOP_PG - ES_START_PG)*256;
 276         ei_status.rmem_start = dev->mem_start + TX_PAGES*256;
 277
 278         printk("mem %#lx-%#lx\n", dev->mem_start, dev->mem_end-1);
 279
 280 #if ES_DEBUG & ES_D_PROBE
 281         if (inb(ioaddr + ES_CFG5))
 282                 printk("es3210: Warning - DMA channel enabled, but not used here.\n");
 283 #endif
 284         /* Note, point at the 8390, and not the card... */
 285         dev->base_addr = ioaddr + ES_NIC_OFFSET;
 286
 287         ei_status.name = "ES3210";
 288         ei_status.tx_start_page = ES_START_PG;
 289         ei_status.rx_start_page = ES_START_PG + TX_PAGES;
 290         ei_status.stop_page = ES_STOP_PG;
 291         ei_status.word16 = 1;
 292
 293         if (ei_debug > 0)
 294                 printk(version);
 295
 296         ei_status.reset_8390 = &es_reset_8390;
 297         ei_status.block_input = &es_block_input;
 298         ei_status.block_output = &es_block_output;
 299         ei_status.get_8390_hdr = &es_get_8390_hdr;
 300
 301         dev->open = &es_open;
 302         dev->stop = &es_close;
 303 #ifdef CONFIG_NET_POLL_CONTROLLER
 304         dev->poll_controller = ei_poll;
 305 #endif
 306         NS8390_init(dev, 0);
 307         return 0;
 308 out1:
 309         free_irq(dev->irq, dev);
 310 out:
 311         release_region(ioaddr + ES_SA_PROM, ES_IO_EXTENT);
 312         return retval;
 313 }
 314
 315 /*
 316  *      Reset as per the packet driver method. Judging by the EISA cfg
 317  *      file, this just toggles the "Board Enable" bits (bit 2 and 0).
 318  */
 319
 320 static void es_reset_8390(struct net_device *dev)
 321 {
 322         unsigned short ioaddr = dev->base_addr;
 323         unsigned long end;
 324
 325         outb(0x04, ioaddr + ES_RESET_PORT);
 326         if (ei_debug > 1) printk("%s: resetting the ES3210...", dev->name);
 327
 328         end = jiffies + 2*HZ/100;
 329         while ((signed)(end - jiffies) > 0) continue;
 330
 331         ei_status.txing = 0;
 332         outb(0x01, ioaddr + ES_RESET_PORT);
 333         if (ei_debug > 1) printk("reset done\n");
 334
 335         return;
 336 }
 337
 338 /*
 339  *      Note: In the following three functions is the implicit assumption
 340  *      that the associated memcpy will only use "rep; movsl" as long as
 341  *      we keep the counts as some multiple of doublewords. This is a
 342  *      requirement of the hardware, and also prevents us from using
 343  *      eth_io_copy_and_sum() since we can't guarantee it will limit
 344  *      itself to doubleword access.
 345  */
 346
 347 /*
 348  *      Grab the 8390 specific header. Similar to the block_input routine, but
 349  *      we don't need to be concerned with ring wrap as the header will be at
 350  *      the start of a page, so we optimize accordingly. (A single doubleword.)
 351  */
 352
 353 static void
 354 es_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
 355 {
 356         unsigned long hdr_start = dev->mem_start + ((ring_page - ES_START_PG)<<8);
 357         isa_memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
 358         hdr->count = (hdr->count + 3) & ~3;     /* Round up allocation. */
 359 }
 360
 361 /*
 362  *      Block input and output are easy on shared memory ethercards, the only
 363  *      complication is when the ring buffer wraps. The count will already
 364  *      be rounded up to a doubleword value via es_get_8390_hdr() above.
 365  */
 366
 367 static void es_block_input(struct net_device *dev, int count, struct sk_buff *skb,
 368                                                   int ring_offset)
 369 {
 370         unsigned long xfer_start = dev->mem_start + ring_offset - (ES_START_PG<<8);
 371
 372         if (xfer_start + count > ei_status.rmem_end) {
 373                 /* Packet wraps over end of ring buffer. */
 374                 int semi_count = ei_status.rmem_end - xfer_start;
 375                 isa_memcpy_fromio(skb->data, xfer_start, semi_count);
 376                 count -= semi_count;
 377                 isa_memcpy_fromio(skb->data + semi_count, ei_status.rmem_start, count);
 378         } else {
 379                 /* Packet is in one chunk. */
 380                 isa_eth_io_copy_and_sum(skb, xfer_start, count, 0);
 381         }
 382 }
 383
 384 static void es_block_output(struct net_device *dev, int count,
 385                                 const unsigned char *buf, int start_page)
 386 {
 387         unsigned long shmem = dev->mem_start + ((start_page - ES_START_PG)<<8);
 388
 389         count = (count + 3) & ~3;     /* Round up to doubleword */
 390         isa_memcpy_toio(shmem, buf, count);
 391 }
 392
 393 static int es_open(struct net_device *dev)
 394 {
 395         ei_open(dev);
 396         return 0;
 397 }
 398
 399 static int es_close(struct net_device *dev)
 400 {
 401
 402         if (ei_debug > 1)
 403                 printk("%s: Shutting down ethercard.\n", dev->name);
 404
 405         ei_close(dev);
 406         return 0;
 407 }
 408
 409 #ifdef MODULE
 410 #define MAX_ES_CARDS    4       /* Max number of ES3210 cards per module */
 411 #define NAMELEN         8       /* # of chars for storing dev->name */
 412 static struct net_device *dev_es3210[MAX_ES_CARDS];
 413 static int io[MAX_ES_CARDS];
 414 static int irq[MAX_ES_CARDS];
 415 static int mem[MAX_ES_CARDS];
 416
 417 module_param_array(io, int, NULL, 0);
 418 module_param_array(irq, int, NULL, 0);
 419 module_param_array(mem, int, NULL, 0);
 420 MODULE_PARM_DESC(io, "I/O base address(es)");
 421 MODULE_PARM_DESC(irq, "IRQ number(s)");
 422 MODULE_PARM_DESC(mem, "memory base address(es)");
 423 MODULE_DESCRIPTION("Racal-Interlan ES3210 EISA ethernet driver");
 424 MODULE_LICENSE("GPL");
 425
 426 int
 427 init_module(void)
 428 {
 429         struct net_device *dev;
 430         int this_dev, found = 0;
 431
 432         for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
 433                 if (io[this_dev] == 0 && this_dev != 0)
 434                         break;
 435                 dev = alloc_ei_netdev();
 436                 if (!dev)
 437                         break;
 438                 dev->irq = irq[this_dev];
 439                 dev->base_addr = io[this_dev];
 440                 dev->mem_start = mem[this_dev];
 441                 if (do_es_probe(dev) == 0) {
 442                         if (register_netdev(dev) == 0) {
 443                                 dev_es3210[found++] = dev;
 444                                 continue;
 445                         }
 446                         cleanup_card(dev);
 447                 }
 448                 free_netdev(dev);
 449                 printk(KERN_WARNING "es3210.c: No es3210 card found (i/o = 0x%x).\n", io[this_dev]);
 450                 break;
 451         }
 452         if (found)
 453                 return 0;
 454         return -ENXIO;
 455 }
 456
 457 void
 458 cleanup_module(void)
 459 {
 460         int this_dev;
 461
 462         for (this_dev = 0; this_dev < MAX_ES_CARDS; this_dev++) {
 463                 struct net_device *dev = dev_es3210[this_dev];
 464                 if (dev) {
 465                         unregister_netdev(dev);
 466                         cleanup_card(dev);
 467                         free_netdev(dev);
 468                 }
 469         }
 470 }
 471 #endif /* MODULE */
 472