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