git.oblomov.eu Git - linux-2.6/blob - drivers/net/pcmcia/axnet_cs.c

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