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