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