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