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