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