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