drivers/net/pcmcia/axnet_cs.c

   1 /*======================================================================
   2
   3     A PCMCIA ethernet driver for Asix AX88190-based cards
   4
   5     The Asix AX88190 is a NS8390-derived chipset with a few nasty
   6     idiosyncracies that make it very inconvenient to support with a
   7     standard 8390 driver.  This driver is based on pcnet_cs, with the
   8     tweaked 8390 code grafted on the end.  Much of what I did was to
   9     clean up and update a similar driver supplied by Asix, which was
  10     adapted by William Lee, william@asix.com.tw.
  11
  12     Copyright (C) 2001 David A. Hinds -- dahinds@users.sourceforge.net
  13
  14     axnet_cs.c 1.28 2002/06/29 06:27:37
  15
  16     The network driver code is based on Donald Becker's NE2000 code:
  17
  18     Written 1992,1993 by Donald Becker.
  19     Copyright 1993 United States Government as represented by the
  20     Director, National Security Agency.  This software may be used and
  21     distributed according to the terms of the GNU General Public License,
  22     incorporated herein by reference.
  23     Donald Becker may be reached at becker@scyld.com
  24
  25 ======================================================================*/
  26
  27 #include <linux/kernel.h>
  28 #include <linux/module.h>
  29 #include <linux/init.h>
  30 #include <linux/ptrace.h>
  31 #include <linux/string.h>
  32 #include <linux/timer.h>
  33 #include <linux/delay.h>
  34 #include <linux/spinlock.h>
  35 #include <linux/ethtool.h>
  36 #include <linux/netdevice.h>
  37 #include <linux/etherdevice.h>
  38 #include <linux/crc32.h>
  39 #include <linux/mii.h>
  40 #include "../8390.h"
  41
  42 #include <pcmcia/cistpl.h>
  43 #include <pcmcia/ciscode.h>
  44 #include <pcmcia/ds.h>
  45 #include <pcmcia/cisreg.h>
  46
  47 #include <asm/io.h>
  48 #include <asm/system.h>
  49 #include <asm/byteorder.h>
  50 #include <asm/uaccess.h>
  51
  52 #define AXNET_CMD       0x00
  53 #define AXNET_DATAPORT  0x10    /* NatSemi-defined port window offset. */
  54 #define AXNET_RESET     0x1f    /* Issue a read to reset, a write to clear. */
  55 #define AXNET_MII_EEP   0x14    /* Offset of MII access port */
  56 #define AXNET_TEST      0x15    /* Offset of TEST Register port */
  57 #define AXNET_GPIO      0x17    /* Offset of General Purpose Register Port */
  58
  59 #define AXNET_START_PG  0x40    /* First page of TX buffer */
  60 #define AXNET_STOP_PG   0x80    /* Last page +1 of RX ring */
  61
  62 #define AXNET_RDC_TIMEOUT 0x02  /* Max wait in jiffies for Tx RDC */
  63
  64 #define IS_AX88190      0x0001
  65 #define IS_AX88790      0x0002
  66
  67 /*====================================================================*/
  68
  69 /* Module parameters */
  70
  71 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  72 MODULE_DESCRIPTION("Asix AX88190 PCMCIA ethernet driver");
  73 MODULE_LICENSE("GPL");
  74
  75
  76 /*====================================================================*/
  77
  78 static int axnet_config(struct pcmcia_device *link);
  79 static void axnet_release(struct pcmcia_device *link);
  80 static int axnet_open(struct net_device *dev);
  81 static int axnet_close(struct net_device *dev);
  82 static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  83 static netdev_tx_t axnet_start_xmit(struct sk_buff *skb,
  84                                           struct net_device *dev);
  85 static struct net_device_stats *get_stats(struct net_device *dev);
  86 static void set_multicast_list(struct net_device *dev);
  87 static void axnet_tx_timeout(struct net_device *dev);
  88 static const struct ethtool_ops netdev_ethtool_ops;
  89 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id);
  90 static void ei_watchdog(u_long arg);
  91 static void axnet_reset_8390(struct net_device *dev);
  92
  93 static int mdio_read(unsigned int addr, int phy_id, int loc);
  94 static void mdio_write(unsigned int addr, int phy_id, int loc, int value);
  95
  96 static void get_8390_hdr(struct net_device *,
  97                          struct e8390_pkt_hdr *, int);
  98 static void block_input(struct net_device *dev, int count,
  99                         struct sk_buff *skb, int ring_offset);
 100 static void block_output(struct net_device *dev, int count,
 101                          const u_char *buf, const int start_page);
 102
 103 static void axnet_detach(struct pcmcia_device *p_dev);
 104
 105 static void AX88190_init(struct net_device *dev, int startp);
 106 static int ax_open(struct net_device *dev);
 107 static int ax_close(struct net_device *dev);
 108 static irqreturn_t ax_interrupt(int irq, void *dev_id);
 109
 110 /*====================================================================*/
 111
 112 typedef struct axnet_dev_t {
 113         struct pcmcia_device    *p_dev;
 114     caddr_t             base;
 115     struct timer_list   watchdog;
 116     int                 stale, fast_poll;
 117     u_short             link_status;
 118     u_char              duplex_flag;
 119     int                 phy_id;
 120     int                 flags;
 121 } axnet_dev_t;
 122
 123 static inline axnet_dev_t *PRIV(struct net_device *dev)
 124 {
 125         void *p = (char *)netdev_priv(dev) + sizeof(struct ei_device);
 126         return p;
 127 }
 128
 129 static const struct net_device_ops axnet_netdev_ops = {
 130         .ndo_open               = axnet_open,
 131         .ndo_stop               = axnet_close,
 132         .ndo_do_ioctl           = axnet_ioctl,
 133         .ndo_start_xmit         = axnet_start_xmit,
 134         .ndo_tx_timeout         = axnet_tx_timeout,
 135         .ndo_get_stats          = get_stats,
 136         .ndo_set_multicast_list = set_multicast_list,
 137         .ndo_change_mtu         = eth_change_mtu,
 138         .ndo_set_mac_address    = eth_mac_addr,
 139         .ndo_validate_addr      = eth_validate_addr,
 140 };
 141
 142 /*======================================================================
 143
 144     axnet_attach() creates an "instance" of the driver, allocating
 145     local data structures for one device.  The device is registered
 146     with Card Services.
 147
 148 ======================================================================*/
 149
 150 static int axnet_probe(struct pcmcia_device *link)
 151 {
 152     axnet_dev_t *info;
 153     struct net_device *dev;
 154     struct ei_device *ei_local;
 155
 156     dev_dbg(&link->dev, "axnet_attach()\n");
 157
 158     dev = alloc_etherdev(sizeof(struct ei_device) + sizeof(axnet_dev_t));
 159     if (!dev)
 160         return -ENOMEM;
 161
 162     ei_local = netdev_priv(dev);
 163     spin_lock_init(&ei_local->page_lock);
 164
 165     info = PRIV(dev);
 166     info->p_dev = link;
 167     link->priv = dev;
 168     link->config_flags |= CONF_ENABLE_IRQ;
 169
 170     dev->netdev_ops = &axnet_netdev_ops;
 171
 172     SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 173     dev->watchdog_timeo = TX_TIMEOUT;
 174
 175     return axnet_config(link);
 176 } /* axnet_attach */
 177
 178 /*======================================================================
 179
 180     This deletes a driver "instance".  The device is de-registered
 181     with Card Services.  If it has been released, all local data
 182     structures are freed.  Otherwise, the structures will be freed
 183     when the device is released.
 184
 185 ======================================================================*/
 186
 187 static void axnet_detach(struct pcmcia_device *link)
 188 {
 189     struct net_device *dev = link->priv;
 190
 191     dev_dbg(&link->dev, "axnet_detach(0x%p)\n", link);
 192
 193     unregister_netdev(dev);
 194
 195     axnet_release(link);
 196
 197     free_netdev(dev);
 198 } /* axnet_detach */
 199
 200 /*======================================================================
 201
 202     This probes for a card's hardware address by reading the PROM.
 203
 204 ======================================================================*/
 205
 206 static int get_prom(struct pcmcia_device *link)
 207 {
 208     struct net_device *dev = link->priv;
 209     unsigned int ioaddr = dev->base_addr;
 210     int i, j;
 211
 212     /* This is based on drivers/net/ne.c */
 213     struct {
 214         u_char value, offset;
 215     } program_seq[] = {
 216         {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD}, /* Select page 0*/
 217         {0x01,  EN0_DCFG},      /* Set word-wide access. */
 218         {0x00,  EN0_RCNTLO},    /* Clear the count regs. */
 219         {0x00,  EN0_RCNTHI},
 220         {0x00,  EN0_IMR},       /* Mask completion irq. */
 221         {0xFF,  EN0_ISR},
 222         {E8390_RXOFF|0x40, EN0_RXCR},   /* 0x60  Set to monitor */
 223         {E8390_TXOFF, EN0_TXCR},        /* 0x02  and loopback mode. */
 224         {0x10,  EN0_RCNTLO},
 225         {0x00,  EN0_RCNTHI},
 226         {0x00,  EN0_RSARLO},    /* DMA starting at 0x0400. */
 227         {0x04,  EN0_RSARHI},
 228         {E8390_RREAD+E8390_START, E8390_CMD},
 229     };
 230
 231     /* Not much of a test, but the alternatives are messy */
 232     if (link->config_base != 0x03c0)
 233         return 0;
 234
 235     axnet_reset_8390(dev);
 236     mdelay(10);
 237
 238     for (i = 0; i < ARRAY_SIZE(program_seq); i++)
 239         outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
 240
 241     for (i = 0; i < 6; i += 2) {
 242         j = inw(ioaddr + AXNET_DATAPORT);
 243         dev->dev_addr[i] = j & 0xff;
 244         dev->dev_addr[i+1] = j >> 8;
 245     }
 246     return 1;
 247 } /* get_prom */
 248
 249 /*======================================================================
 250
 251     axnet_config() is scheduled to run after a CARD_INSERTION event
 252     is received, to configure the PCMCIA socket, and to make the
 253     ethernet device available to the system.
 254
 255 ======================================================================*/
 256
 257 static int try_io_port(struct pcmcia_device *link)
 258 {
 259     int j, ret;
 260     link->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
 261     link->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
 262     if (link->resource[0]->end == 32) {
 263         link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 264         /* for master/slave multifunction cards */
 265         if (link->resource[1]->end > 0)
 266             link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
 267     } else {
 268         /* This should be two 16-port windows */
 269         link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 270         link->resource[1]->flags |= IO_DATA_PATH_WIDTH_16;
 271     }
 272     if (link->resource[0]->start == 0) {
 273         for (j = 0; j < 0x400; j += 0x20) {
 274             link->resource[0]->start = j ^ 0x300;
 275             link->resource[1]->start = (j ^ 0x300) + 0x10;
 276             link->io_lines = 16;
 277             ret = pcmcia_request_io(link);
 278             if (ret == 0)
 279                     return ret;
 280         }
 281         return ret;
 282     } else {
 283         return pcmcia_request_io(link);
 284     }
 285 }
 286
 287 static int axnet_configcheck(struct pcmcia_device *p_dev, void *priv_data)
 288 {
 289         if (p_dev->config_index == 0)
 290                 return -EINVAL;
 291
 292         p_dev->config_index = 0x05;
 293         if (p_dev->resource[0]->end + p_dev->resource[1]->end < 32)
 294                 return -ENODEV;
 295
 296         return try_io_port(p_dev);
 297 }
 298
 299 static int axnet_config(struct pcmcia_device *link)
 300 {
 301     struct net_device *dev = link->priv;
 302     axnet_dev_t *info = PRIV(dev);
 303     int i, j, j2, ret;
 304
 305     dev_dbg(&link->dev, "axnet_config(0x%p)\n", link);
 306
 307     /* don't trust the CIS on this; Linksys got it wrong */
 308     link->config_regs = 0x63;
 309     link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 310     ret = pcmcia_loop_config(link, axnet_configcheck, NULL);
 311     if (ret != 0)
 312         goto failed;
 313
 314     if (!link->irq)
 315             goto failed;
 316
 317     if (resource_size(link->resource[1]) == 8)
 318         link->config_flags |= CONF_ENABLE_SPKR;
 319
 320     ret = pcmcia_enable_device(link);
 321     if (ret)
 322             goto failed;
 323
 324     dev->irq = link->irq;
 325     dev->base_addr = link->resource[0]->start;
 326
 327     if (!get_prom(link)) {
 328         printk(KERN_NOTICE "axnet_cs: this is not an AX88190 card!\n");
 329         printk(KERN_NOTICE "axnet_cs: use pcnet_cs instead.\n");
 330         goto failed;
 331     }
 332
 333     ei_status.name = "AX88190";
 334     ei_status.word16 = 1;
 335     ei_status.tx_start_page = AXNET_START_PG;
 336     ei_status.rx_start_page = AXNET_START_PG + TX_PAGES;
 337     ei_status.stop_page = AXNET_STOP_PG;
 338     ei_status.reset_8390 = &axnet_reset_8390;
 339     ei_status.get_8390_hdr = &get_8390_hdr;
 340     ei_status.block_input = &block_input;
 341     ei_status.block_output = &block_output;
 342
 343     if (inb(dev->base_addr + AXNET_TEST) != 0)
 344         info->flags |= IS_AX88790;
 345     else
 346         info->flags |= IS_AX88190;
 347
 348     if (info->flags & IS_AX88790)
 349         outb(0x10, dev->base_addr + AXNET_GPIO);  /* select Internal PHY */
 350
 351     for (i = 0; i < 32; i++) {
 352         j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
 353         j2 = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 2);
 354         if (j == j2) continue;
 355         if ((j != 0) && (j != 0xffff)) break;
 356     }
 357
 358     /* Maybe PHY is in power down mode. (PPD_SET = 1)
 359        Bit 2 of CCSR is active low. */
 360     if (i == 32) {
 361         pcmcia_write_config_byte(link, CISREG_CCSR, 0x04);
 362         for (i = 0; i < 32; i++) {
 363             j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
 364             j2 = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 2);
 365             if (j == j2) continue;
 366             if ((j != 0) && (j != 0xffff)) break;
 367         }
 368     }
 369
 370     info->phy_id = (i < 32) ? i : -1;
 371     SET_NETDEV_DEV(dev, &link->dev);
 372
 373     if (register_netdev(dev) != 0) {
 374         printk(KERN_NOTICE "axnet_cs: register_netdev() failed\n");
 375         goto failed;
 376     }
 377
 378     printk(KERN_INFO "%s: Asix AX88%d90: io %#3lx, irq %d, "
 379            "hw_addr %pM\n",
 380            dev->name, ((info->flags & IS_AX88790) ? 7 : 1),
 381            dev->base_addr, dev->irq,
 382            dev->dev_addr);
 383     if (info->phy_id != -1) {
 384         dev_dbg(&link->dev, "  MII transceiver at index %d, status %x.\n", info->phy_id, j);
 385     } else {
 386         printk(KERN_NOTICE "  No MII transceivers found!\n");
 387     }
 388     return 0;
 389
 390 failed:
 391     axnet_release(link);
 392     return -ENODEV;
 393 } /* axnet_config */
 394
 395 /*======================================================================
 396
 397     After a card is removed, axnet_release() will unregister the net
 398     device, and release the PCMCIA configuration.  If the device is
 399     still open, this will be postponed until it is closed.
 400
 401 ======================================================================*/
 402
 403 static void axnet_release(struct pcmcia_device *link)
 404 {
 405         pcmcia_disable_device(link);
 406 }
 407
 408 static int axnet_suspend(struct pcmcia_device *link)
 409 {
 410         struct net_device *dev = link->priv;
 411
 412         if (link->open)
 413                 netif_device_detach(dev);
 414
 415         return 0;
 416 }
 417
 418 static int axnet_resume(struct pcmcia_device *link)
 419 {
 420         struct net_device *dev = link->priv;
 421
 422         if (link->open) {
 423                 axnet_reset_8390(dev);
 424                 AX88190_init(dev, 1);
 425                 netif_device_attach(dev);
 426         }
 427
 428         return 0;
 429 }
 430
 431
 432 /*======================================================================
 433
 434     MII interface support
 435
 436 ======================================================================*/
 437
 438 #define MDIO_SHIFT_CLK          0x01
 439 #define MDIO_DATA_WRITE0        0x00
 440 #define MDIO_DATA_WRITE1        0x08
 441 #define MDIO_DATA_READ          0x04
 442 #define MDIO_MASK               0x0f
 443 #define MDIO_ENB_IN             0x02
 444
 445 static void mdio_sync(unsigned int addr)
 446 {
 447     int bits;
 448     for (bits = 0; bits < 32; bits++) {
 449         outb_p(MDIO_DATA_WRITE1, addr);
 450         outb_p(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
 451     }
 452 }
 453
 454 static int mdio_read(unsigned int addr, int phy_id, int loc)
 455 {
 456     u_int cmd = (0xf6<<10)|(phy_id<<5)|loc;
 457     int i, retval = 0;
 458
 459     mdio_sync(addr);
 460     for (i = 14; i >= 0; i--) {
 461         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 462         outb_p(dat, addr);
 463         outb_p(dat | MDIO_SHIFT_CLK, addr);
 464     }
 465     for (i = 19; i > 0; i--) {
 466         outb_p(MDIO_ENB_IN, addr);
 467         retval = (retval << 1) | ((inb_p(addr) & MDIO_DATA_READ) != 0);
 468         outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
 469     }
 470     return (retval>>1) & 0xffff;
 471 }
 472
 473 static void mdio_write(unsigned int addr, int phy_id, int loc, int value)
 474 {
 475     u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
 476     int i;
 477
 478     mdio_sync(addr);
 479     for (i = 31; i >= 0; i--) {
 480         int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
 481         outb_p(dat, addr);
 482         outb_p(dat | MDIO_SHIFT_CLK, addr);
 483     }
 484     for (i = 1; i >= 0; i--) {
 485         outb_p(MDIO_ENB_IN, addr);
 486         outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
 487     }
 488 }
 489
 490 /*====================================================================*/
 491
 492 static int axnet_open(struct net_device *dev)
 493 {
 494     int ret;
 495     axnet_dev_t *info = PRIV(dev);
 496     struct pcmcia_device *link = info->p_dev;
 497     unsigned int nic_base = dev->base_addr;
 498
 499     dev_dbg(&link->dev, "axnet_open('%s')\n", dev->name);
 500
 501     if (!pcmcia_dev_present(link))
 502         return -ENODEV;
 503
 504     outb_p(0xFF, nic_base + EN0_ISR); /* Clear bogus intr. */
 505     ret = request_irq(dev->irq, ei_irq_wrapper, IRQF_SHARED, "axnet_cs", dev);
 506     if (ret)
 507             return ret;
 508
 509     link->open++;
 510
 511     info->link_status = 0x00;
 512     init_timer(&info->watchdog);
 513     info->watchdog.function = &ei_watchdog;
 514     info->watchdog.data = (u_long)dev;
 515     info->watchdog.expires = jiffies + HZ;
 516     add_timer(&info->watchdog);
 517
 518     return ax_open(dev);
 519 } /* axnet_open */
 520
 521 /*====================================================================*/
 522
 523 static int axnet_close(struct net_device *dev)
 524 {
 525     axnet_dev_t *info = PRIV(dev);
 526     struct pcmcia_device *link = info->p_dev;
 527
 528     dev_dbg(&link->dev, "axnet_close('%s')\n", dev->name);
 529
 530     ax_close(dev);
 531     free_irq(dev->irq, dev);
 532
 533     link->open--;
 534     netif_stop_queue(dev);
 535     del_timer_sync(&info->watchdog);
 536
 537     return 0;
 538 } /* axnet_close */
 539
 540 /*======================================================================
 541
 542     Hard reset the card.  This used to pause for the same period that
 543     a 8390 reset command required, but that shouldn't be necessary.
 544
 545 ======================================================================*/
 546
 547 static void axnet_reset_8390(struct net_device *dev)
 548 {
 549     unsigned int nic_base = dev->base_addr;
 550     int i;
 551
 552     ei_status.txing = ei_status.dmaing = 0;
 553
 554     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, nic_base + E8390_CMD);
 555
 556     outb(inb(nic_base + AXNET_RESET), nic_base + AXNET_RESET);
 557
 558     for (i = 0; i < 100; i++) {
 559         if ((inb_p(nic_base+EN0_ISR) & ENISR_RESET) != 0)
 560             break;
 561         udelay(100);
 562     }
 563     outb_p(ENISR_RESET, nic_base + EN0_ISR); /* Ack intr. */
 564
 565     if (i == 100)
 566         printk(KERN_ERR "%s: axnet_reset_8390() did not complete.\n",
 567                dev->name);
 568
 569 } /* axnet_reset_8390 */
 570
 571 /*====================================================================*/
 572
 573 static irqreturn_t ei_irq_wrapper(int irq, void *dev_id)
 574 {
 575     struct net_device *dev = dev_id;
 576     PRIV(dev)->stale = 0;
 577     return ax_interrupt(irq, dev_id);
 578 }
 579
 580 static void ei_watchdog(u_long arg)
 581 {
 582     struct net_device *dev = (struct net_device *)(arg);
 583     axnet_dev_t *info = PRIV(dev);
 584     unsigned int nic_base = dev->base_addr;
 585     unsigned int mii_addr = nic_base + AXNET_MII_EEP;
 586     u_short link;
 587
 588     if (!netif_device_present(dev)) goto reschedule;
 589
 590     /* Check for pending interrupt with expired latency timer: with
 591        this, we can limp along even if the interrupt is blocked */
 592     if (info->stale++ && (inb_p(nic_base + EN0_ISR) & ENISR_ALL)) {
 593         if (!info->fast_poll)
 594             printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
 595         ei_irq_wrapper(dev->irq, dev);
 596         info->fast_poll = HZ;
 597     }
 598     if (info->fast_poll) {
 599         info->fast_poll--;
 600         info->watchdog.expires = jiffies + 1;
 601         add_timer(&info->watchdog);
 602         return;
 603     }
 604
 605     if (info->phy_id < 0)
 606         goto reschedule;
 607     link = mdio_read(mii_addr, info->phy_id, 1);
 608     if (!link || (link == 0xffff)) {
 609         printk(KERN_INFO "%s: MII is missing!\n", dev->name);
 610         info->phy_id = -1;
 611         goto reschedule;
 612     }
 613
 614     link &= 0x0004;
 615     if (link != info->link_status) {
 616         u_short p = mdio_read(mii_addr, info->phy_id, 5);
 617         printk(KERN_INFO "%s: %s link beat\n", dev->name,
 618                (link) ? "found" : "lost");
 619         if (link) {
 620             info->duplex_flag = (p & 0x0140) ? 0x80 : 0x00;
 621             if (p)
 622                 printk(KERN_INFO "%s: autonegotiation complete: "
 623                        "%sbaseT-%cD selected\n", dev->name,
 624                        ((p & 0x0180) ? "100" : "10"),
 625                        ((p & 0x0140) ? 'F' : 'H'));
 626             else
 627                 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
 628                        dev->name);
 629             AX88190_init(dev, 1);
 630         }
 631         info->link_status = link;
 632     }
 633
 634 reschedule:
 635     info->watchdog.expires = jiffies + HZ;
 636     add_timer(&info->watchdog);
 637 }
 638
 639 static void netdev_get_drvinfo(struct net_device *dev,
 640                                struct ethtool_drvinfo *info)
 641 {
 642         strcpy(info->driver, "axnet_cs");
 643 }
 644
 645 static const struct ethtool_ops netdev_ethtool_ops = {
 646         .get_drvinfo            = netdev_get_drvinfo,
 647 };
 648
 649 /*====================================================================*/
 650
 651 static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 652 {
 653     axnet_dev_t *info = PRIV(dev);
 654     struct mii_ioctl_data *data = if_mii(rq);
 655     unsigned int mii_addr = dev->base_addr + AXNET_MII_EEP;
 656     switch (cmd) {
 657     case SIOCGMIIPHY:
 658         data->phy_id = info->phy_id;
 659     case SIOCGMIIREG:           /* Read MII PHY register. */
 660         data->val_out = mdio_read(mii_addr, data->phy_id, data->reg_num & 0x1f);
 661         return 0;
 662     case SIOCSMIIREG:           /* Write MII PHY register. */
 663         mdio_write(mii_addr, data->phy_id, data->reg_num & 0x1f, data->val_in);
 664         return 0;
 665     }
 666     return -EOPNOTSUPP;
 667 }
 668
 669 /*====================================================================*/
 670
 671 static void get_8390_hdr(struct net_device *dev,
 672                          struct e8390_pkt_hdr *hdr,
 673                          int ring_page)
 674 {
 675     unsigned int nic_base = dev->base_addr;
 676
 677     outb_p(0, nic_base + EN0_RSARLO);           /* On page boundary */
 678     outb_p(ring_page, nic_base + EN0_RSARHI);
 679     outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
 680
 681     insw(nic_base + AXNET_DATAPORT, hdr,
 682             sizeof(struct e8390_pkt_hdr)>>1);
 683     /* Fix for big endian systems */
 684     hdr->count = le16_to_cpu(hdr->count);
 685
 686 }
 687
 688 /*====================================================================*/
 689
 690 static void block_input(struct net_device *dev, int count,
 691                         struct sk_buff *skb, int ring_offset)
 692 {
 693     unsigned int nic_base = dev->base_addr;
 694     int xfer_count = count;
 695     char *buf = skb->data;
 696
 697     if ((ei_debug > 4) && (count != 4))
 698             pr_debug("%s: [bi=%d]\n", dev->name, count+4);
 699     outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
 700     outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
 701     outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
 702
 703     insw(nic_base + AXNET_DATAPORT,buf,count>>1);
 704     if (count & 0x01)
 705         buf[count-1] = inb(nic_base + AXNET_DATAPORT), xfer_count++;
 706
 707 }
 708
 709 /*====================================================================*/
 710
 711 static void block_output(struct net_device *dev, int count,
 712                          const u_char *buf, const int start_page)
 713 {
 714     unsigned int nic_base = dev->base_addr;
 715
 716     pr_debug("%s: [bo=%d]\n", dev->name, count);
 717
 718     /* Round the count up for word writes.  Do we need to do this?
 719        What effect will an odd byte count have on the 8390?
 720        I should check someday. */
 721     if (count & 0x01)
 722         count++;
 723
 724     outb_p(0x00, nic_base + EN0_RSARLO);
 725     outb_p(start_page, nic_base + EN0_RSARHI);
 726     outb_p(E8390_RWRITE+E8390_START, nic_base + AXNET_CMD);
 727     outsw(nic_base + AXNET_DATAPORT, buf, count>>1);
 728 }
 729
 730 static struct pcmcia_device_id axnet_ids[] = {
 731         PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x016c, 0x0081),
 732         PCMCIA_DEVICE_MANF_CARD(0x018a, 0x0301),
 733         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0301),
 734         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0303),
 735         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0309),
 736         PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1106),
 737         PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab),
 738         PCMCIA_DEVICE_MANF_CARD(0x021b, 0x0202),
 739         PCMCIA_DEVICE_MANF_CARD(0xffff, 0x1090),
 740         PCMCIA_DEVICE_PROD_ID12("AmbiCom,Inc.", "Fast Ethernet PC Card(AMB8110)", 0x49b020a7, 0x119cc9fc),
 741         PCMCIA_DEVICE_PROD_ID124("Fast Ethernet", "16-bit PC Card", "AX88190", 0xb4be14e3, 0x9a12eb6a, 0xab9be5ef),
 742         PCMCIA_DEVICE_PROD_ID12("ASIX", "AX88190", 0x0959823b, 0xab9be5ef),
 743         PCMCIA_DEVICE_PROD_ID12("Billionton", "LNA-100B", 0x552ab682, 0xbc3b87e1),
 744         PCMCIA_DEVICE_PROD_ID12("CHEETAH ETHERCARD", "EN2228", 0x00fa7bc8, 0x00e990cc),
 745         PCMCIA_DEVICE_PROD_ID12("CNet", "CNF301", 0xbc477dde, 0x78c5f40b),
 746         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEther PCC-TXD", 0x5261440f, 0x436768c5),
 747         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEtherII PCC-TXD", 0x5261440f, 0x730df72e),
 748         PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEther PCC-TXM", 0x5261440f, 0x3abbd061),
 749         PCMCIA_DEVICE_PROD_ID12("Dynalink", "L100C16", 0x55632fd5, 0x66bc2a90),
 750         PCMCIA_DEVICE_PROD_ID12("IO DATA", "ETXPCM", 0x547e66dc, 0x233adac2),
 751         PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100 V3)", 0x0733cc81, 0x232019a8),
 752         PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC3-TX", 0x481e0094, 0xf91af609),
 753         PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA411", 0x9aa79dc3, 0x40fad875),
 754         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "100BASE", 0x281f1c5d, 0x7c2add04),
 755         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FastEtherCard", 0x281f1c5d, 0x7ef26116),
 756         PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FEP501", 0x281f1c5d, 0x2e272058),
 757         PCMCIA_DEVICE_PROD_ID14("Network Everywhere", "AX88190", 0x820a67b6,  0xab9be5ef),
 758         PCMCIA_DEVICE_NULL,
 759 };
 760 MODULE_DEVICE_TABLE(pcmcia, axnet_ids);
 761
 762 static struct pcmcia_driver axnet_cs_driver = {
 763         .owner          = THIS_MODULE,
 764         .drv            = {
 765                 .name   = "axnet_cs",
 766         },
 767         .probe          = axnet_probe,
 768         .remove         = axnet_detach,
 769         .id_table       = axnet_ids,
 770         .suspend        = axnet_suspend,
 771         .resume         = axnet_resume,
 772 };
 773
 774 static int __init init_axnet_cs(void)
 775 {
 776         return pcmcia_register_driver(&axnet_cs_driver);
 777 }
 778
 779 static void __exit exit_axnet_cs(void)
 780 {
 781         pcmcia_unregister_driver(&axnet_cs_driver);
 782 }
 783
 784 module_init(init_axnet_cs);
 785 module_exit(exit_axnet_cs);
 786
 787 /*====================================================================*/
 788
 789 /* 8390.c: A general NS8390 ethernet driver core for linux. */
 790 /*
 791         Written 1992-94 by Donald Becker.
 792
 793         Copyright 1993 United States Government as represented by the
 794         Director, National Security Agency.
 795
 796         This software may be used and distributed according to the terms
 797         of the GNU General Public License, incorporated herein by reference.
 798
 799         The author may be reached as becker@scyld.com, or C/O
 800         Scyld Computing Corporation
 801         410 Severn Ave., Suite 210
 802         Annapolis MD 21403
 803
 804   This is the chip-specific code for many 8390-based ethernet adaptors.
 805   This is not a complete driver, it must be combined with board-specific
 806   code such as ne.c, wd.c, 3c503.c, etc.
 807
 808   Seeing how at least eight drivers use this code, (not counting the
 809   PCMCIA ones either) it is easy to break some card by what seems like
 810   a simple innocent change. Please contact me or Donald if you think
 811   you have found something that needs changing. -- PG
 812
 813   Changelog:
 814
 815   Paul Gortmaker        : remove set_bit lock, other cleanups.
 816   Paul Gortmaker        : add ei_get_8390_hdr() so we can pass skb's to
 817                           ei_block_input() for eth_io_copy_and_sum().
 818   Paul Gortmaker        : exchange static int ei_pingpong for a #define,
 819                           also add better Tx error handling.
 820   Paul Gortmaker        : rewrite Rx overrun handling as per NS specs.
 821   Alexey Kuznetsov      : use the 8390's six bit hash multicast filter.
 822   Paul Gortmaker        : tweak ANK's above multicast changes a bit.
 823   Paul Gortmaker        : update packet statistics for v2.1.x
 824   Alan Cox              : support arbitary stupid port mappings on the
 825                           68K Macintosh. Support >16bit I/O spaces
 826   Paul Gortmaker        : add kmod support for auto-loading of the 8390
 827                           module by all drivers that require it.
 828   Alan Cox              : Spinlocking work, added 'BUG_83C690'
 829   Paul Gortmaker        : Separate out Tx timeout code from Tx path.
 830
 831   Sources:
 832   The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
 833
 834   */
 835
 836 static const char version_8390[] = KERN_INFO \
 837     "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@scyld.com)\n";
 838
 839 #include <linux/bitops.h>
 840 #include <asm/irq.h>
 841 #include <linux/fcntl.h>
 842 #include <linux/in.h>
 843 #include <linux/interrupt.h>
 844
 845 #define BUG_83C690
 846
 847 /* These are the operational function interfaces to board-specific
 848    routines.
 849         void reset_8390(struct net_device *dev)
 850                 Resets the board associated with DEV, including a hardware reset of
 851                 the 8390.  This is only called when there is a transmit timeout, and
 852                 it is always followed by 8390_init().
 853         void block_output(struct net_device *dev, int count, const unsigned char *buf,
 854                                           int start_page)
 855                 Write the COUNT bytes of BUF to the packet buffer at START_PAGE.  The
 856                 "page" value uses the 8390's 256-byte pages.
 857         void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
 858                 Read the 4 byte, page aligned 8390 header. *If* there is a
 859                 subsequent read, it will be of the rest of the packet.
 860         void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
 861                 Read COUNT bytes from the packet buffer into the skb data area. Start
 862                 reading from RING_OFFSET, the address as the 8390 sees it.  This will always
 863                 follow the read of the 8390 header.
 864 */
 865 #define ei_reset_8390 (ei_local->reset_8390)
 866 #define ei_block_output (ei_local->block_output)
 867 #define ei_block_input (ei_local->block_input)
 868 #define ei_get_8390_hdr (ei_local->get_8390_hdr)
 869
 870 /* use 0 for production, 1 for verification, >2 for debug */
 871 #ifndef ei_debug
 872 int ei_debug = 1;
 873 #endif
 874
 875 /* Index to functions. */
 876 static void ei_tx_intr(struct net_device *dev);
 877 static void ei_tx_err(struct net_device *dev);
 878 static void ei_receive(struct net_device *dev);
 879 static void ei_rx_overrun(struct net_device *dev);
 880
 881 /* Routines generic to NS8390-based boards. */
 882 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
 883                                                                 int start_page);
 884 static void do_set_multicast_list(struct net_device *dev);
 885
 886 /*
 887  *      SMP and the 8390 setup.
 888  *
 889  *      The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
 890  *      a page register that controls bank and packet buffer access. We guard
 891  *      this with ei_local->page_lock. Nobody should assume or set the page other
 892  *      than zero when the lock is not held. Lock holders must restore page 0
 893  *      before unlocking. Even pure readers must take the lock to protect in
 894  *      page 0.
 895  *
 896  *      To make life difficult the chip can also be very slow. We therefore can't
 897  *      just use spinlocks. For the longer lockups we disable the irq the device
 898  *      sits on and hold the lock. We must hold the lock because there is a dual
 899  *      processor case other than interrupts (get stats/set multicast list in
 900  *      parallel with each other and transmit).
 901  *
 902  *      Note: in theory we can just disable the irq on the card _but_ there is
 903  *      a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
 904  *      enter lock, take the queued irq. So we waddle instead of flying.
 905  *
 906  *      Finally by special arrangement for the purpose of being generally
 907  *      annoying the transmit function is called bh atomic. That places
 908  *      restrictions on the user context callers as disable_irq won't save
 909  *      them.
 910  */
 911
 912 /**
 913  * ax_open - Open/initialize the board.
 914  * @dev: network device to initialize
 915  *
 916  * This routine goes all-out, setting everything
 917  * up anew at each open, even though many of these registers should only
 918  * need to be set once at boot.
 919  */
 920 static int ax_open(struct net_device *dev)
 921 {
 922         unsigned long flags;
 923         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
 924
 925         /*
 926          *      Grab the page lock so we own the register set, then call
 927          *      the init function.
 928          */
 929
 930         spin_lock_irqsave(&ei_local->page_lock, flags);
 931         AX88190_init(dev, 1);
 932         /* Set the flag before we drop the lock, That way the IRQ arrives
 933            after its set and we get no silly warnings */
 934         netif_start_queue(dev);
 935         spin_unlock_irqrestore(&ei_local->page_lock, flags);
 936         ei_local->irqlock = 0;
 937         return 0;
 938 }
 939
 940 #define dev_lock(dev) (((struct ei_device *)netdev_priv(dev))->page_lock)
 941
 942 /**
 943  * ax_close - shut down network device
 944  * @dev: network device to close
 945  *
 946  * Opposite of ax_open(). Only used when "ifconfig <devname> down" is done.
 947  */
 948 static int ax_close(struct net_device *dev)
 949 {
 950         unsigned long flags;
 951
 952         /*
 953          *      Hold the page lock during close
 954          */
 955
 956         spin_lock_irqsave(&dev_lock(dev), flags);
 957         AX88190_init(dev, 0);
 958         spin_unlock_irqrestore(&dev_lock(dev), flags);
 959         netif_stop_queue(dev);
 960         return 0;
 961 }
 962
 963 /**
 964  * axnet_tx_timeout - handle transmit time out condition
 965  * @dev: network device which has apparently fallen asleep
 966  *
 967  * Called by kernel when device never acknowledges a transmit has
 968  * completed (or failed) - i.e. never posted a Tx related interrupt.
 969  */
 970
 971 static void axnet_tx_timeout(struct net_device *dev)
 972 {
 973         long e8390_base = dev->base_addr;
 974         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
 975         int txsr, isr, tickssofar = jiffies - dev_trans_start(dev);
 976         unsigned long flags;
 977
 978         dev->stats.tx_errors++;
 979
 980         spin_lock_irqsave(&ei_local->page_lock, flags);
 981         txsr = inb(e8390_base+EN0_TSR);
 982         isr = inb(e8390_base+EN0_ISR);
 983         spin_unlock_irqrestore(&ei_local->page_lock, flags);
 984
 985         printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
 986                 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
 987                 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
 988
 989         if (!isr && !dev->stats.tx_packets)
 990         {
 991                 /* The 8390 probably hasn't gotten on the cable yet. */
 992                 ei_local->interface_num ^= 1;   /* Try a different xcvr.  */
 993         }
 994
 995         /* Ugly but a reset can be slow, yet must be protected */
 996
 997         spin_lock_irqsave(&ei_local->page_lock, flags);
 998
 999         /* Try to restart the card.  Perhaps the user has fixed something. */
1000         ei_reset_8390(dev);
1001         AX88190_init(dev, 1);
1002
1003         spin_unlock_irqrestore(&ei_local->page_lock, flags);
1004         netif_wake_queue(dev);
1005 }
1006
1007 /**
1008  * axnet_start_xmit - begin packet transmission
1009  * @skb: packet to be sent
1010  * @dev: network device to which packet is sent
1011  *
1012  * Sends a packet to an 8390 network device.
1013  */
1014
1015 static netdev_tx_t axnet_start_xmit(struct sk_buff *skb,
1016                                           struct net_device *dev)
1017 {
1018         long e8390_base = dev->base_addr;
1019         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1020         int length, send_length, output_page;
1021         unsigned long flags;
1022         u8 packet[ETH_ZLEN];
1023
1024         netif_stop_queue(dev);
1025
1026         length = skb->len;
1027
1028         /* Mask interrupts from the ethercard.
1029            SMP: We have to grab the lock here otherwise the IRQ handler
1030            on another CPU can flip window and race the IRQ mask set. We end
1031            up trashing the mcast filter not disabling irqs if we don't lock */
1032
1033         spin_lock_irqsave(&ei_local->page_lock, flags);
1034         outb_p(0x00, e8390_base + EN0_IMR);
1035
1036         /*
1037          *      Slow phase with lock held.
1038          */
1039
1040         ei_local->irqlock = 1;
1041
1042         send_length = max(length, ETH_ZLEN);
1043
1044         /*
1045          * We have two Tx slots available for use. Find the first free
1046          * slot, and then perform some sanity checks. With two Tx bufs,
1047          * you get very close to transmitting back-to-back packets. With
1048          * only one Tx buf, the transmitter sits idle while you reload the
1049          * card, leaving a substantial gap between each transmitted packet.
1050          */
1051
1052         if (ei_local->tx1 == 0)
1053         {
1054                 output_page = ei_local->tx_start_page;
1055                 ei_local->tx1 = send_length;
1056                 if (ei_debug  &&  ei_local->tx2 > 0)
1057                         printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
1058                                 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
1059         }
1060         else if (ei_local->tx2 == 0)
1061         {
1062                 output_page = ei_local->tx_start_page + TX_PAGES/2;
1063                 ei_local->tx2 = send_length;
1064                 if (ei_debug  &&  ei_local->tx1 > 0)
1065                         printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
1066                                 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
1067         }
1068         else
1069         {       /* We should never get here. */
1070                 if (ei_debug)
1071                         printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
1072                                 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
1073                 ei_local->irqlock = 0;
1074                 netif_stop_queue(dev);
1075                 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1076                 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1077                 dev->stats.tx_errors++;
1078                 return NETDEV_TX_BUSY;
1079         }
1080
1081         /*
1082          * Okay, now upload the packet and trigger a send if the transmitter
1083          * isn't already sending. If it is busy, the interrupt handler will
1084          * trigger the send later, upon receiving a Tx done interrupt.
1085          */
1086
1087         if (length == skb->len)
1088                 ei_block_output(dev, length, skb->data, output_page);
1089         else {
1090                 memset(packet, 0, ETH_ZLEN);
1091                 skb_copy_from_linear_data(skb, packet, skb->len);
1092                 ei_block_output(dev, length, packet, output_page);
1093         }
1094
1095         if (! ei_local->txing)
1096         {
1097                 ei_local->txing = 1;
1098                 NS8390_trigger_send(dev, send_length, output_page);
1099                 dev->trans_start = jiffies;
1100                 if (output_page == ei_local->tx_start_page)
1101                 {
1102                         ei_local->tx1 = -1;
1103                         ei_local->lasttx = -1;
1104                 }
1105                 else
1106                 {
1107                         ei_local->tx2 = -1;
1108                         ei_local->lasttx = -2;
1109                 }
1110         }
1111         else ei_local->txqueue++;
1112
1113         if (ei_local->tx1  &&  ei_local->tx2)
1114                 netif_stop_queue(dev);
1115         else
1116                 netif_start_queue(dev);
1117
1118         /* Turn 8390 interrupts back on. */
1119         ei_local->irqlock = 0;
1120         outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1121
1122         spin_unlock_irqrestore(&ei_local->page_lock, flags);
1123
1124         dev_kfree_skb (skb);
1125         dev->stats.tx_bytes += send_length;
1126
1127         return NETDEV_TX_OK;
1128 }
1129
1130 /**
1131  * ax_interrupt - handle the interrupts from an 8390
1132  * @irq: interrupt number
1133  * @dev_id: a pointer to the net_device
1134  *
1135  * Handle the ether interface interrupts. We pull packets from
1136  * the 8390 via the card specific functions and fire them at the networking
1137  * stack. We also handle transmit completions and wake the transmit path if
1138  * necessary. We also update the counters and do other housekeeping as
1139  * needed.
1140  */
1141
1142 static irqreturn_t ax_interrupt(int irq, void *dev_id)
1143 {
1144         struct net_device *dev = dev_id;
1145         long e8390_base;
1146         int interrupts, nr_serviced = 0, i;
1147         struct ei_device *ei_local;
1148         int handled = 0;
1149         unsigned long flags;
1150
1151         e8390_base = dev->base_addr;
1152         ei_local = netdev_priv(dev);
1153
1154         /*
1155          *      Protect the irq test too.
1156          */
1157
1158         spin_lock_irqsave(&ei_local->page_lock, flags);
1159
1160         if (ei_local->irqlock)
1161         {
1162 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
1163                 /* The "irqlock" check is only for testing. */
1164                 printk(ei_local->irqlock
1165                            ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
1166                            : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
1167                            dev->name, inb_p(e8390_base + EN0_ISR),
1168                            inb_p(e8390_base + EN0_IMR));
1169 #endif
1170                 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1171                 return IRQ_NONE;
1172         }
1173
1174         if (ei_debug > 3)
1175                 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
1176                            inb_p(e8390_base + EN0_ISR));
1177
1178         outb_p(0x00, e8390_base + EN0_ISR);
1179         ei_local->irqlock = 1;
1180
1181         /* !!Assumption!! -- we stay in page 0.  Don't break this. */
1182         while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0 &&
1183                ++nr_serviced < MAX_SERVICE)
1184         {
1185                 if (!netif_running(dev) || (interrupts == 0xff)) {
1186                         if (ei_debug > 1)
1187                                 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
1188                         outb_p(interrupts, e8390_base + EN0_ISR);
1189                         interrupts = 0;
1190                         break;
1191                 }
1192                 handled = 1;
1193
1194                 /* AX88190 bug fix. */
1195                 outb_p(interrupts, e8390_base + EN0_ISR);
1196                 for (i = 0; i < 10; i++) {
1197                         if (!(inb(e8390_base + EN0_ISR) & interrupts))
1198                                 break;
1199                         outb_p(0, e8390_base + EN0_ISR);
1200                         outb_p(interrupts, e8390_base + EN0_ISR);
1201                 }
1202                 if (interrupts & ENISR_OVER)
1203                         ei_rx_overrun(dev);
1204                 else if (interrupts & (ENISR_RX+ENISR_RX_ERR))
1205                 {
1206                         /* Got a good (?) packet. */
1207                         ei_receive(dev);
1208                 }
1209                 /* Push the next to-transmit packet through. */
1210                 if (interrupts & ENISR_TX)
1211                         ei_tx_intr(dev);
1212                 else if (interrupts & ENISR_TX_ERR)
1213                         ei_tx_err(dev);
1214
1215                 if (interrupts & ENISR_COUNTERS)
1216                 {
1217                         dev->stats.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
1218                         dev->stats.rx_crc_errors   += inb_p(e8390_base + EN0_COUNTER1);
1219                         dev->stats.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
1220                 }
1221         }
1222
1223         if (interrupts && ei_debug > 3)
1224         {
1225                 handled = 1;
1226                 if (nr_serviced >= MAX_SERVICE)
1227                 {
1228                         /* 0xFF is valid for a card removal */
1229                         if(interrupts!=0xFF)
1230                                 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
1231                                    dev->name, interrupts);
1232                         outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
1233                 } else {
1234                         printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
1235                         outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
1236                 }
1237         }
1238
1239         /* Turn 8390 interrupts back on. */
1240         ei_local->irqlock = 0;
1241         outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1242
1243         spin_unlock_irqrestore(&ei_local->page_lock, flags);
1244         return IRQ_RETVAL(handled);
1245 }
1246
1247 /**
1248  * ei_tx_err - handle transmitter error
1249  * @dev: network device which threw the exception
1250  *
1251  * A transmitter error has happened. Most likely excess collisions (which
1252  * is a fairly normal condition). If the error is one where the Tx will
1253  * have been aborted, we try and send another one right away, instead of
1254  * letting the failed packet sit and collect dust in the Tx buffer. This
1255  * is a much better solution as it avoids kernel based Tx timeouts, and
1256  * an unnecessary card reset.
1257  *
1258  * Called with lock held.
1259  */
1260
1261 static void ei_tx_err(struct net_device *dev)
1262 {
1263         long e8390_base = dev->base_addr;
1264         unsigned char txsr = inb_p(e8390_base+EN0_TSR);
1265         unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
1266
1267 #ifdef VERBOSE_ERROR_DUMP
1268         printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
1269         if (txsr & ENTSR_ABT)
1270                 printk("excess-collisions ");
1271         if (txsr & ENTSR_ND)
1272                 printk("non-deferral ");
1273         if (txsr & ENTSR_CRS)
1274                 printk("lost-carrier ");
1275         if (txsr & ENTSR_FU)
1276                 printk("FIFO-underrun ");
1277         if (txsr & ENTSR_CDH)
1278                 printk("lost-heartbeat ");
1279         printk("\n");
1280 #endif
1281
1282         if (tx_was_aborted)
1283                 ei_tx_intr(dev);
1284         else
1285         {
1286                 dev->stats.tx_errors++;
1287                 if (txsr & ENTSR_CRS) dev->stats.tx_carrier_errors++;
1288                 if (txsr & ENTSR_CDH) dev->stats.tx_heartbeat_errors++;
1289                 if (txsr & ENTSR_OWC) dev->stats.tx_window_errors++;
1290         }
1291 }
1292
1293 /**
1294  * ei_tx_intr - transmit interrupt handler
1295  * @dev: network device for which tx intr is handled
1296  *
1297  * We have finished a transmit: check for errors and then trigger the next
1298  * packet to be sent. Called with lock held.
1299  */
1300
1301 static void ei_tx_intr(struct net_device *dev)
1302 {
1303         long e8390_base = dev->base_addr;
1304         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1305         int status = inb(e8390_base + EN0_TSR);
1306
1307         /*
1308          * There are two Tx buffers, see which one finished, and trigger
1309          * the send of another one if it exists.
1310          */
1311         ei_local->txqueue--;
1312
1313         if (ei_local->tx1 < 0)
1314         {
1315                 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
1316                         printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
1317                                 ei_local->name, ei_local->lasttx, ei_local->tx1);
1318                 ei_local->tx1 = 0;
1319                 if (ei_local->tx2 > 0)
1320                 {
1321                         ei_local->txing = 1;
1322                         NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
1323                         dev->trans_start = jiffies;
1324                         ei_local->tx2 = -1,
1325                         ei_local->lasttx = 2;
1326                 }
1327                 else ei_local->lasttx = 20, ei_local->txing = 0;
1328         }
1329         else if (ei_local->tx2 < 0)
1330         {
1331                 if (ei_local->lasttx != 2  &&  ei_local->lasttx != -2)
1332                         printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
1333                                 ei_local->name, ei_local->lasttx, ei_local->tx2);
1334                 ei_local->tx2 = 0;
1335                 if (ei_local->tx1 > 0)
1336                 {
1337                         ei_local->txing = 1;
1338                         NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
1339                         dev->trans_start = jiffies;
1340                         ei_local->tx1 = -1;
1341                         ei_local->lasttx = 1;
1342                 }
1343                 else
1344                         ei_local->lasttx = 10, ei_local->txing = 0;
1345         }
1346 //      else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
1347 //                      dev->name, ei_local->lasttx);
1348
1349         /* Minimize Tx latency: update the statistics after we restart TXing. */
1350         if (status & ENTSR_COL)
1351                 dev->stats.collisions++;
1352         if (status & ENTSR_PTX)
1353                 dev->stats.tx_packets++;
1354         else
1355         {
1356                 dev->stats.tx_errors++;
1357                 if (status & ENTSR_ABT)
1358                 {
1359                         dev->stats.tx_aborted_errors++;
1360                         dev->stats.collisions += 16;
1361                 }
1362                 if (status & ENTSR_CRS)
1363                         dev->stats.tx_carrier_errors++;
1364                 if (status & ENTSR_FU)
1365                         dev->stats.tx_fifo_errors++;
1366                 if (status & ENTSR_CDH)
1367                         dev->stats.tx_heartbeat_errors++;
1368                 if (status & ENTSR_OWC)
1369                         dev->stats.tx_window_errors++;
1370         }
1371         netif_wake_queue(dev);
1372 }
1373
1374 /**
1375  * ei_receive - receive some packets
1376  * @dev: network device with which receive will be run
1377  *
1378  * We have a good packet(s), get it/them out of the buffers.
1379  * Called with lock held.
1380  */
1381
1382 static void ei_receive(struct net_device *dev)
1383 {
1384         long e8390_base = dev->base_addr;
1385         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1386         unsigned char rxing_page, this_frame, next_frame;
1387         unsigned short current_offset;
1388         int rx_pkt_count = 0;
1389         struct e8390_pkt_hdr rx_frame;
1390
1391         while (++rx_pkt_count < 10)
1392         {
1393                 int pkt_len, pkt_stat;
1394
1395                 /* Get the rx page (incoming packet pointer). */
1396                 rxing_page = inb_p(e8390_base + EN1_CURPAG -1);
1397
1398                 /* Remove one frame from the ring.  Boundary is always a page behind. */
1399                 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
1400                 if (this_frame >= ei_local->stop_page)
1401                         this_frame = ei_local->rx_start_page;
1402
1403                 /* Someday we'll omit the previous, iff we never get this message.
1404                    (There is at least one clone claimed to have a problem.)
1405
1406                    Keep quiet if it looks like a card removal. One problem here
1407                    is that some clones crash in roughly the same way.
1408                  */
1409                 if (ei_debug > 0  &&  this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
1410                         printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
1411                                    dev->name, this_frame, ei_local->current_page);
1412
1413                 if (this_frame == rxing_page)   /* Read all the frames? */
1414                         break;                          /* Done for now */
1415
1416                 current_offset = this_frame << 8;
1417                 ei_get_8390_hdr(dev, &rx_frame, this_frame);
1418
1419                 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
1420                 pkt_stat = rx_frame.status;
1421
1422                 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
1423
1424                 if (pkt_len < 60  ||  pkt_len > 1518)
1425                 {
1426                         if (ei_debug)
1427                                 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
1428                                            dev->name, rx_frame.count, rx_frame.status,
1429                                            rx_frame.next);
1430                         dev->stats.rx_errors++;
1431                         dev->stats.rx_length_errors++;
1432                 }
1433                  else if ((pkt_stat & 0x0F) == ENRSR_RXOK)
1434                 {
1435                         struct sk_buff *skb;
1436
1437                         skb = dev_alloc_skb(pkt_len+2);
1438                         if (skb == NULL)
1439                         {
1440                                 if (ei_debug > 1)
1441                                         printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
1442                                                    dev->name, pkt_len);
1443                                 dev->stats.rx_dropped++;
1444                                 break;
1445                         }
1446                         else
1447                         {
1448                                 skb_reserve(skb,2);     /* IP headers on 16 byte boundaries */
1449                                 skb_put(skb, pkt_len);  /* Make room */
1450                                 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
1451                                 skb->protocol=eth_type_trans(skb,dev);
1452                                 netif_rx(skb);
1453                                 dev->stats.rx_packets++;
1454                                 dev->stats.rx_bytes += pkt_len;
1455                                 if (pkt_stat & ENRSR_PHY)
1456                                         dev->stats.multicast++;
1457                         }
1458                 }
1459                 else
1460                 {
1461                         if (ei_debug)
1462                                 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
1463                                            dev->name, rx_frame.status, rx_frame.next,
1464                                            rx_frame.count);
1465                         dev->stats.rx_errors++;
1466                         /* NB: The NIC counts CRC, frame and missed errors. */
1467                         if (pkt_stat & ENRSR_FO)
1468                                 dev->stats.rx_fifo_errors++;
1469                 }
1470                 next_frame = rx_frame.next;
1471
1472                 /* This _should_ never happen: it's here for avoiding bad clones. */
1473                 if (next_frame >= ei_local->stop_page) {
1474                         printk("%s: next frame inconsistency, %#2x\n", dev->name,
1475                                    next_frame);
1476                         next_frame = ei_local->rx_start_page;
1477                 }
1478                 ei_local->current_page = next_frame;
1479                 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
1480         }
1481 }
1482
1483 /**
1484  * ei_rx_overrun - handle receiver overrun
1485  * @dev: network device which threw exception
1486  *
1487  * We have a receiver overrun: we have to kick the 8390 to get it started
1488  * again. Problem is that you have to kick it exactly as NS prescribes in
1489  * the updated datasheets, or "the NIC may act in an unpredictable manner."
1490  * This includes causing "the NIC to defer indefinitely when it is stopped
1491  * on a busy network."  Ugh.
1492  * Called with lock held. Don't call this with the interrupts off or your
1493  * computer will hate you - it takes 10ms or so.
1494  */
1495
1496 static void ei_rx_overrun(struct net_device *dev)
1497 {
1498         axnet_dev_t *info = PRIV(dev);
1499         long e8390_base = dev->base_addr;
1500         unsigned char was_txing, must_resend = 0;
1501
1502         /*
1503          * Record whether a Tx was in progress and then issue the
1504          * stop command.
1505          */
1506         was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
1507         outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1508
1509         if (ei_debug > 1)
1510                 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
1511         dev->stats.rx_over_errors++;
1512
1513         /*
1514          * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
1515          * Early datasheets said to poll the reset bit, but now they say that
1516          * it "is not a reliable indicator and subsequently should be ignored."
1517          * We wait at least 10ms.
1518          */
1519
1520         mdelay(10);
1521
1522         /*
1523          * Reset RBCR[01] back to zero as per magic incantation.
1524          */
1525         outb_p(0x00, e8390_base+EN0_RCNTLO);
1526         outb_p(0x00, e8390_base+EN0_RCNTHI);
1527
1528         /*
1529          * See if any Tx was interrupted or not. According to NS, this
1530          * step is vital, and skipping it will cause no end of havoc.
1531          */
1532
1533         if (was_txing)
1534         {
1535                 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
1536                 if (!tx_completed)
1537                         must_resend = 1;
1538         }
1539
1540         /*
1541          * Have to enter loopback mode and then restart the NIC before
1542          * you are allowed to slurp packets up off the ring.
1543          */
1544         outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
1545         outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
1546
1547         /*
1548          * Clear the Rx ring of all the debris, and ack the interrupt.
1549          */
1550         ei_receive(dev);
1551
1552         /*
1553          * Leave loopback mode, and resend any packet that got stopped.
1554          */
1555         outb_p(E8390_TXCONFIG | info->duplex_flag, e8390_base + EN0_TXCR);
1556         if (must_resend)
1557                 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
1558 }
1559
1560 /*
1561  *      Collect the stats. This is called unlocked and from several contexts.
1562  */
1563
1564 static struct net_device_stats *get_stats(struct net_device *dev)
1565 {
1566         long ioaddr = dev->base_addr;
1567         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1568         unsigned long flags;
1569
1570         /* If the card is stopped, just return the present stats. */
1571         if (!netif_running(dev))
1572                 return &dev->stats;
1573
1574         spin_lock_irqsave(&ei_local->page_lock,flags);
1575         /* Read the counter registers, assuming we are in page 0. */
1576         dev->stats.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
1577         dev->stats.rx_crc_errors   += inb_p(ioaddr + EN0_COUNTER1);
1578         dev->stats.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
1579         spin_unlock_irqrestore(&ei_local->page_lock, flags);
1580
1581         return &dev->stats;
1582 }
1583
1584 /*
1585  * Form the 64 bit 8390 multicast table from the linked list of addresses
1586  * associated with this dev structure.
1587  */
1588
1589 static inline void make_mc_bits(u8 *bits, struct net_device *dev)
1590 {
1591         struct netdev_hw_addr *ha;
1592         u32 crc;
1593
1594         netdev_for_each_mc_addr(ha, dev) {
1595                 crc = ether_crc(ETH_ALEN, ha->addr);
1596                 /*
1597                  * The 8390 uses the 6 most significant bits of the
1598                  * CRC to index the multicast table.
1599                  */
1600                 bits[crc>>29] |= (1<<((crc>>26)&7));
1601         }
1602 }
1603
1604 /**
1605  * do_set_multicast_list - set/clear multicast filter
1606  * @dev: net device for which multicast filter is adjusted
1607  *
1608  *      Set or clear the multicast filter for this adaptor.
1609  *      Must be called with lock held.
1610  */
1611
1612 static void do_set_multicast_list(struct net_device *dev)
1613 {
1614         long e8390_base = dev->base_addr;
1615         int i;
1616         struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
1617
1618         if (!(dev->flags&(IFF_PROMISC|IFF_ALLMULTI))) {
1619                 memset(ei_local->mcfilter, 0, 8);
1620                 if (!netdev_mc_empty(dev))
1621                         make_mc_bits(ei_local->mcfilter, dev);
1622         } else {
1623                 /* set to accept-all */
1624                 memset(ei_local->mcfilter, 0xFF, 8);
1625         }
1626
1627         outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
1628         for(i = 0; i < 8; i++)
1629         {
1630                 outb_p(ei_local->mcfilter[i], e8390_base + EN1_MULT_SHIFT(i));
1631         }
1632         outb_p(E8390_NODMA + E8390_PAGE0, e8390_base + E8390_CMD);
1633
1634         if(dev->flags&IFF_PROMISC)
1635                 outb_p(E8390_RXCONFIG | 0x58, e8390_base + EN0_RXCR);
1636         else if (dev->flags & IFF_ALLMULTI || !netdev_mc_empty(dev))
1637                 outb_p(E8390_RXCONFIG | 0x48, e8390_base + EN0_RXCR);
1638         else
1639                 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR);
1640
1641         outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1642 }
1643
1644 /*
1645  *      Called without lock held. This is invoked from user context and may
1646  *      be parallel to just about everything else. Its also fairly quick and
1647  *      not called too often. Must protect against both bh and irq users
1648  */
1649
1650 static void set_multicast_list(struct net_device *dev)
1651 {
1652         unsigned long flags;
1653
1654         spin_lock_irqsave(&dev_lock(dev), flags);
1655         do_set_multicast_list(dev);
1656         spin_unlock_irqrestore(&dev_lock(dev), flags);
1657 }
1658
1659 /* This page of functions should be 8390 generic */
1660 /* Follow National Semi's recommendations for initializing the "NIC". */
1661
1662 /**
1663  * AX88190_init - initialize 8390 hardware
1664  * @dev: network device to initialize
1665  * @startp: boolean.  non-zero value to initiate chip processing
1666  *
1667  *      Must be called with lock held.
1668  */
1669
1670 static void AX88190_init(struct net_device *dev, int startp)
1671 {
1672         axnet_dev_t *info = PRIV(dev);
1673         long e8390_base = dev->base_addr;
1674         struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1675         int i;
1676         int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
1677
1678         if(sizeof(struct e8390_pkt_hdr)!=4)
1679                 panic("8390.c: header struct mispacked\n");
1680         /* Follow National Semi's recommendations for initing the DP83902. */
1681         outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */
1682         outb_p(endcfg, e8390_base + EN0_DCFG);  /* 0x48 or 0x49 */
1683         /* Clear the remote byte count registers. */
1684         outb_p(0x00,  e8390_base + EN0_RCNTLO);
1685         outb_p(0x00,  e8390_base + EN0_RCNTHI);
1686         /* Set to monitor and loopback mode -- this is vital!. */
1687         outb_p(E8390_RXOFF|0x40, e8390_base + EN0_RXCR); /* 0x60 */
1688         outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
1689         /* Set the transmit page and receive ring. */
1690         outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1691         ei_local->tx1 = ei_local->tx2 = 0;
1692         outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1693         outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY);       /* 3c503 says 0x3f,NS0x26*/
1694         ei_local->current_page = ei_local->rx_start_page;               /* assert boundary+1 */
1695         outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1696         /* Clear the pending interrupts and mask. */
1697         outb_p(0xFF, e8390_base + EN0_ISR);
1698         outb_p(0x00,  e8390_base + EN0_IMR);
1699
1700         /* Copy the station address into the DS8390 registers. */
1701
1702         outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */
1703         for(i = 0; i < 6; i++)
1704         {
1705                 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1706                 if(inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1707                         printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1708         }
1709
1710         outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1711         outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1712
1713         netif_start_queue(dev);
1714         ei_local->tx1 = ei_local->tx2 = 0;
1715         ei_local->txing = 0;
1716
1717         if (info->flags & IS_AX88790)   /* select Internal PHY */
1718                 outb(0x10, e8390_base + AXNET_GPIO);
1719
1720         if (startp)
1721         {
1722                 outb_p(0xff,  e8390_base + EN0_ISR);
1723                 outb_p(ENISR_ALL,  e8390_base + EN0_IMR);
1724                 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1725                 outb_p(E8390_TXCONFIG | info->duplex_flag,
1726                        e8390_base + EN0_TXCR); /* xmit on. */
1727                 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1728                 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR); /* rx on, */
1729                 do_set_multicast_list(dev);     /* (re)load the mcast table */
1730         }
1731 }
1732
1733 /* Trigger a transmit start, assuming the length is valid.
1734    Always called with the page lock held */
1735
1736 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1737                                                                 int start_page)
1738 {
1739         long e8390_base = dev->base_addr;
1740         struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) netdev_priv(dev);
1741
1742         if (inb_p(e8390_base) & E8390_TRANS)
1743         {
1744                 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1745                         dev->name);
1746                 return;
1747         }
1748         outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1749         outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1750         outb_p(start_page, e8390_base + EN0_TPSR);
1751         outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);
1752 }