drivers/net/pcmcia/axnet_cs.c

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