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