drivers/net/pcmcia/axnet_cs.c

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