1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/init.h>
30#include <linux/ptrace.h>
31#include <linux/slab.h>
32#include <linux/string.h>
33#include <linux/timer.h>
34#include <linux/delay.h>
35#include <linux/spinlock.h>
36#include <linux/ethtool.h>
37#include <linux/netdevice.h>
38#include <linux/etherdevice.h>
39#include <linux/crc32.h>
40#include <linux/mii.h>
41#include "../8390.h"
42
43#include <pcmcia/cs_types.h>
44#include <pcmcia/cs.h>
45#include <pcmcia/cistpl.h>
46#include <pcmcia/ciscode.h>
47#include <pcmcia/ds.h>
48#include <pcmcia/cisreg.h>
49
50#include <asm/io.h>
51#include <asm/system.h>
52#include <asm/byteorder.h>
53#include <asm/uaccess.h>
54
55#define AXNET_CMD 0x00
56#define AXNET_DATAPORT 0x10
57#define AXNET_RESET 0x1f
58#define AXNET_MII_EEP 0x14
59#define AXNET_TEST 0x15
60#define AXNET_GPIO 0x17
61
62#define AXNET_START_PG 0x40
63#define AXNET_STOP_PG 0x80
64
65#define AXNET_RDC_TIMEOUT 0x02
66
67#define IS_AX88190 0x0001
68#define IS_AX88790 0x0002
69
70
71
72
73
74MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
75MODULE_DESCRIPTION("Asix AX88190 PCMCIA ethernet driver");
76MODULE_LICENSE("GPL");
77
78#ifdef PCMCIA_DEBUG
79#define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0)
80
81INT_MODULE_PARM(pc_debug, PCMCIA_DEBUG);
82#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
83static char *version =
84"axnet_cs.c 1.28 2002/06/29 06:27:37 (David Hinds)";
85#else
86#define DEBUG(n, args...)
87#endif
88
89
90
91static int axnet_config(struct pcmcia_device *link);
92static void axnet_release(struct pcmcia_device *link);
93static int axnet_open(struct net_device *dev);
94static int axnet_close(struct net_device *dev);
95static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
96static netdev_tx_t axnet_start_xmit(struct sk_buff *skb,
97 struct net_device *dev);
98static struct net_device_stats *get_stats(struct net_device *dev);
99static void set_multicast_list(struct net_device *dev);
100static void axnet_tx_timeout(struct net_device *dev);
101static const struct ethtool_ops netdev_ethtool_ops;
102static irqreturn_t ei_irq_wrapper(int irq, void *dev_id);
103static void ei_watchdog(u_long arg);
104static void axnet_reset_8390(struct net_device *dev);
105
106static int mdio_read(unsigned int addr, int phy_id, int loc);
107static void mdio_write(unsigned int addr, int phy_id, int loc, int value);
108
109static void get_8390_hdr(struct net_device *,
110 struct e8390_pkt_hdr *, int);
111static void block_input(struct net_device *dev, int count,
112 struct sk_buff *skb, int ring_offset);
113static void block_output(struct net_device *dev, int count,
114 const u_char *buf, const int start_page);
115
116static void axnet_detach(struct pcmcia_device *p_dev);
117
118static void AX88190_init(struct net_device *dev, int startp);
119static int ax_open(struct net_device *dev);
120static int ax_close(struct net_device *dev);
121static irqreturn_t ax_interrupt(int irq, void *dev_id);
122
123
124
125typedef struct axnet_dev_t {
126 struct pcmcia_device *p_dev;
127 dev_node_t node;
128 caddr_t base;
129 struct timer_list watchdog;
130 int stale, fast_poll;
131 u_short link_status;
132 u_char duplex_flag;
133 int phy_id;
134 int flags;
135} axnet_dev_t;
136
137static inline axnet_dev_t *PRIV(struct net_device *dev)
138{
139 void *p = (char *)netdev_priv(dev) + sizeof(struct ei_device);
140 return p;
141}
142
143static const struct net_device_ops axnet_netdev_ops = {
144 .ndo_open = axnet_open,
145 .ndo_stop = axnet_close,
146 .ndo_do_ioctl = axnet_ioctl,
147 .ndo_start_xmit = axnet_start_xmit,
148 .ndo_tx_timeout = axnet_tx_timeout,
149 .ndo_get_stats = get_stats,
150 .ndo_set_multicast_list = set_multicast_list,
151 .ndo_change_mtu = eth_change_mtu,
152 .ndo_set_mac_address = eth_mac_addr,
153 .ndo_validate_addr = eth_validate_addr,
154};
155
156
157
158
159
160
161
162
163
164static int axnet_probe(struct pcmcia_device *link)
165{
166 axnet_dev_t *info;
167 struct net_device *dev;
168 struct ei_device *ei_local;
169
170 DEBUG(0, "axnet_attach()\n");
171
172 dev = alloc_etherdev(sizeof(struct ei_device) + sizeof(axnet_dev_t));
173 if (!dev)
174 return -ENOMEM;
175
176 ei_local = netdev_priv(dev);
177 spin_lock_init(&ei_local->page_lock);
178
179 info = PRIV(dev);
180 info->p_dev = link;
181 link->priv = dev;
182 link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
183 link->irq.IRQInfo1 = IRQ_LEVEL_ID;
184 link->conf.Attributes = CONF_ENABLE_IRQ;
185 link->conf.IntType = INT_MEMORY_AND_IO;
186
187 dev->netdev_ops = &axnet_netdev_ops;
188
189 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
190 dev->watchdog_timeo = TX_TIMEOUT;
191
192 return axnet_config(link);
193}
194
195
196
197
198
199
200
201
202
203
204static void axnet_detach(struct pcmcia_device *link)
205{
206 struct net_device *dev = link->priv;
207
208 DEBUG(0, "axnet_detach(0x%p)\n", link);
209
210 if (link->dev_node)
211 unregister_netdev(dev);
212
213 axnet_release(link);
214
215 free_netdev(dev);
216}
217
218
219
220
221
222
223
224static int get_prom(struct pcmcia_device *link)
225{
226 struct net_device *dev = link->priv;
227 unsigned int ioaddr = dev->base_addr;
228 int i, j;
229
230
231 struct {
232 u_char value, offset;
233 } program_seq[] = {
234 {E8390_NODMA+E8390_PAGE0+E8390_STOP, E8390_CMD},
235 {0x01, EN0_DCFG},
236 {0x00, EN0_RCNTLO},
237 {0x00, EN0_RCNTHI},
238 {0x00, EN0_IMR},
239 {0xFF, EN0_ISR},
240 {E8390_RXOFF|0x40, EN0_RXCR},
241 {E8390_TXOFF, EN0_TXCR},
242 {0x10, EN0_RCNTLO},
243 {0x00, EN0_RCNTHI},
244 {0x00, EN0_RSARLO},
245 {0x04, EN0_RSARHI},
246 {E8390_RREAD+E8390_START, E8390_CMD},
247 };
248
249
250 if (link->conf.ConfigBase != 0x03c0)
251 return 0;
252
253 axnet_reset_8390(dev);
254 mdelay(10);
255
256 for (i = 0; i < ARRAY_SIZE(program_seq); i++)
257 outb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
258
259 for (i = 0; i < 6; i += 2) {
260 j = inw(ioaddr + AXNET_DATAPORT);
261 dev->dev_addr[i] = j & 0xff;
262 dev->dev_addr[i+1] = j >> 8;
263 }
264 return 1;
265}
266
267
268
269
270
271
272
273
274
275#define CS_CHECK(fn, ret) \
276do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
277
278static int try_io_port(struct pcmcia_device *link)
279{
280 int j, ret;
281 if (link->io.NumPorts1 == 32) {
282 link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
283 if (link->io.NumPorts2 > 0) {
284
285 link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
286 link->irq.Attributes =
287 IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
288 }
289 } else {
290
291 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
292 link->io.Attributes2 = IO_DATA_PATH_WIDTH_16;
293 }
294 if (link->io.BasePort1 == 0) {
295 link->io.IOAddrLines = 16;
296 for (j = 0; j < 0x400; j += 0x20) {
297 link->io.BasePort1 = j ^ 0x300;
298 link->io.BasePort2 = (j ^ 0x300) + 0x10;
299 ret = pcmcia_request_io(link, &link->io);
300 if (ret == 0)
301 return ret;
302 }
303 return ret;
304 } else {
305 return pcmcia_request_io(link, &link->io);
306 }
307}
308
309static int axnet_configcheck(struct pcmcia_device *p_dev,
310 cistpl_cftable_entry_t *cfg,
311 cistpl_cftable_entry_t *dflt,
312 unsigned int vcc,
313 void *priv_data)
314{
315 int i;
316 cistpl_io_t *io = &cfg->io;
317
318 if (cfg->index == 0 || cfg->io.nwin == 0)
319 return -ENODEV;
320
321 p_dev->conf.ConfigIndex = 0x05;
322
323
324 if (io->nwin > 1) {
325 i = (io->win[1].len > io->win[0].len);
326 p_dev->io.BasePort2 = io->win[1-i].base;
327 p_dev->io.NumPorts2 = io->win[1-i].len;
328 } else {
329 i = p_dev->io.NumPorts2 = 0;
330 }
331 p_dev->io.BasePort1 = io->win[i].base;
332 p_dev->io.NumPorts1 = io->win[i].len;
333 p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
334 if (p_dev->io.NumPorts1 + p_dev->io.NumPorts2 >= 32)
335 return try_io_port(p_dev);
336
337 return -ENODEV;
338}
339
340static int axnet_config(struct pcmcia_device *link)
341{
342 struct net_device *dev = link->priv;
343 axnet_dev_t *info = PRIV(dev);
344 int i, j, j2, last_ret, last_fn;
345
346 DEBUG(0, "axnet_config(0x%p)\n", link);
347
348
349 link->conf.Present = 0x63;
350 last_ret = pcmcia_loop_config(link, axnet_configcheck, NULL);
351 if (last_ret != 0) {
352 cs_error(link, RequestIO, last_ret);
353 goto failed;
354 }
355
356 CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
357
358 if (link->io.NumPorts2 == 8) {
359 link->conf.Attributes |= CONF_ENABLE_SPKR;
360 link->conf.Status = CCSR_AUDIO_ENA;
361 }
362
363 CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
364 dev->irq = link->irq.AssignedIRQ;
365 dev->base_addr = link->io.BasePort1;
366
367 if (!get_prom(link)) {
368 printk(KERN_NOTICE "axnet_cs: this is not an AX88190 card!\n");
369 printk(KERN_NOTICE "axnet_cs: use pcnet_cs instead.\n");
370 goto failed;
371 }
372
373 ei_status.name = "AX88190";
374 ei_status.word16 = 1;
375 ei_status.tx_start_page = AXNET_START_PG;
376 ei_status.rx_start_page = AXNET_START_PG + TX_PAGES;
377 ei_status.stop_page = AXNET_STOP_PG;
378 ei_status.reset_8390 = &axnet_reset_8390;
379 ei_status.get_8390_hdr = &get_8390_hdr;
380 ei_status.block_input = &block_input;
381 ei_status.block_output = &block_output;
382
383 if (inb(dev->base_addr + AXNET_TEST) != 0)
384 info->flags |= IS_AX88790;
385 else
386 info->flags |= IS_AX88190;
387
388 if (info->flags & IS_AX88790)
389 outb(0x10, dev->base_addr + AXNET_GPIO);
390
391 for (i = 0; i < 32; i++) {
392 j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
393 j2 = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 2);
394 if (j == j2) continue;
395 if ((j != 0) && (j != 0xffff)) break;
396 }
397
398
399
400 if (i == 32) {
401 conf_reg_t reg = { 0, CS_WRITE, CISREG_CCSR, 0x04 };
402 pcmcia_access_configuration_register(link, ®);
403 for (i = 0; i < 32; i++) {
404 j = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 1);
405 j2 = mdio_read(dev->base_addr + AXNET_MII_EEP, i, 2);
406 if (j == j2) continue;
407 if ((j != 0) && (j != 0xffff)) break;
408 }
409 }
410
411 info->phy_id = (i < 32) ? i : -1;
412 link->dev_node = &info->node;
413 SET_NETDEV_DEV(dev, &handle_to_dev(link));
414
415 if (register_netdev(dev) != 0) {
416 printk(KERN_NOTICE "axnet_cs: register_netdev() failed\n");
417 link->dev_node = NULL;
418 goto failed;
419 }
420
421 strcpy(info->node.dev_name, dev->name);
422
423 printk(KERN_INFO "%s: Asix AX88%d90: io %#3lx, irq %d, "
424 "hw_addr %pM\n",
425 dev->name, ((info->flags & IS_AX88790) ? 7 : 1),
426 dev->base_addr, dev->irq,
427 dev->dev_addr);
428 if (info->phy_id != -1) {
429 DEBUG(0, " MII transceiver at index %d, status %x.\n", info->phy_id, j);
430 } else {
431 printk(KERN_NOTICE " No MII transceivers found!\n");
432 }
433 return 0;
434
435cs_failed:
436 cs_error(link, last_fn, last_ret);
437failed:
438 axnet_release(link);
439 return -ENODEV;
440}
441
442
443
444
445
446
447
448
449
450static void axnet_release(struct pcmcia_device *link)
451{
452 pcmcia_disable_device(link);
453}
454
455static int axnet_suspend(struct pcmcia_device *link)
456{
457 struct net_device *dev = link->priv;
458
459 if (link->open)
460 netif_device_detach(dev);
461
462 return 0;
463}
464
465static int axnet_resume(struct pcmcia_device *link)
466{
467 struct net_device *dev = link->priv;
468
469 if (link->open) {
470 axnet_reset_8390(dev);
471 AX88190_init(dev, 1);
472 netif_device_attach(dev);
473 }
474
475 return 0;
476}
477
478
479
480
481
482
483
484
485#define MDIO_SHIFT_CLK 0x01
486#define MDIO_DATA_WRITE0 0x00
487#define MDIO_DATA_WRITE1 0x08
488#define MDIO_DATA_READ 0x04
489#define MDIO_MASK 0x0f
490#define MDIO_ENB_IN 0x02
491
492static void mdio_sync(unsigned int addr)
493{
494 int bits;
495 for (bits = 0; bits < 32; bits++) {
496 outb_p(MDIO_DATA_WRITE1, addr);
497 outb_p(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, addr);
498 }
499}
500
501static int mdio_read(unsigned int addr, int phy_id, int loc)
502{
503 u_int cmd = (0xf6<<10)|(phy_id<<5)|loc;
504 int i, retval = 0;
505
506 mdio_sync(addr);
507 for (i = 14; i >= 0; i--) {
508 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
509 outb_p(dat, addr);
510 outb_p(dat | MDIO_SHIFT_CLK, addr);
511 }
512 for (i = 19; i > 0; i--) {
513 outb_p(MDIO_ENB_IN, addr);
514 retval = (retval << 1) | ((inb_p(addr) & MDIO_DATA_READ) != 0);
515 outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
516 }
517 return (retval>>1) & 0xffff;
518}
519
520static void mdio_write(unsigned int addr, int phy_id, int loc, int value)
521{
522 u_int cmd = (0x05<<28)|(phy_id<<23)|(loc<<18)|(1<<17)|value;
523 int i;
524
525 mdio_sync(addr);
526 for (i = 31; i >= 0; i--) {
527 int dat = (cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
528 outb_p(dat, addr);
529 outb_p(dat | MDIO_SHIFT_CLK, addr);
530 }
531 for (i = 1; i >= 0; i--) {
532 outb_p(MDIO_ENB_IN, addr);
533 outb_p(MDIO_ENB_IN | MDIO_SHIFT_CLK, addr);
534 }
535}
536
537
538
539static int axnet_open(struct net_device *dev)
540{
541 int ret;
542 axnet_dev_t *info = PRIV(dev);
543 struct pcmcia_device *link = info->p_dev;
544 unsigned int nic_base = dev->base_addr;
545
546 DEBUG(2, "axnet_open('%s')\n", dev->name);
547
548 if (!pcmcia_dev_present(link))
549 return -ENODEV;
550
551 outb_p(0xFF, nic_base + EN0_ISR);
552 ret = request_irq(dev->irq, ei_irq_wrapper, IRQF_SHARED, "axnet_cs", dev);
553 if (ret)
554 return ret;
555
556 link->open++;
557
558 info->link_status = 0x00;
559 init_timer(&info->watchdog);
560 info->watchdog.function = &ei_watchdog;
561 info->watchdog.data = (u_long)dev;
562 info->watchdog.expires = jiffies + HZ;
563 add_timer(&info->watchdog);
564
565 return ax_open(dev);
566}
567
568
569
570static int axnet_close(struct net_device *dev)
571{
572 axnet_dev_t *info = PRIV(dev);
573 struct pcmcia_device *link = info->p_dev;
574
575 DEBUG(2, "axnet_close('%s')\n", dev->name);
576
577 ax_close(dev);
578 free_irq(dev->irq, dev);
579
580 link->open--;
581 netif_stop_queue(dev);
582 del_timer_sync(&info->watchdog);
583
584 return 0;
585}
586
587
588
589
590
591
592
593
594static void axnet_reset_8390(struct net_device *dev)
595{
596 unsigned int nic_base = dev->base_addr;
597 int i;
598
599 ei_status.txing = ei_status.dmaing = 0;
600
601 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, nic_base + E8390_CMD);
602
603 outb(inb(nic_base + AXNET_RESET), nic_base + AXNET_RESET);
604
605 for (i = 0; i < 100; i++) {
606 if ((inb_p(nic_base+EN0_ISR) & ENISR_RESET) != 0)
607 break;
608 udelay(100);
609 }
610 outb_p(ENISR_RESET, nic_base + EN0_ISR);
611
612 if (i == 100)
613 printk(KERN_ERR "%s: axnet_reset_8390() did not complete.\n",
614 dev->name);
615
616}
617
618
619
620static irqreturn_t ei_irq_wrapper(int irq, void *dev_id)
621{
622 struct net_device *dev = dev_id;
623 PRIV(dev)->stale = 0;
624 return ax_interrupt(irq, dev_id);
625}
626
627static void ei_watchdog(u_long arg)
628{
629 struct net_device *dev = (struct net_device *)(arg);
630 axnet_dev_t *info = PRIV(dev);
631 unsigned int nic_base = dev->base_addr;
632 unsigned int mii_addr = nic_base + AXNET_MII_EEP;
633 u_short link;
634
635 if (!netif_device_present(dev)) goto reschedule;
636
637
638
639 if (info->stale++ && (inb_p(nic_base + EN0_ISR) & ENISR_ALL)) {
640 if (!info->fast_poll)
641 printk(KERN_INFO "%s: interrupt(s) dropped!\n", dev->name);
642 ei_irq_wrapper(dev->irq, dev);
643 info->fast_poll = HZ;
644 }
645 if (info->fast_poll) {
646 info->fast_poll--;
647 info->watchdog.expires = jiffies + 1;
648 add_timer(&info->watchdog);
649 return;
650 }
651
652 if (info->phy_id < 0)
653 goto reschedule;
654 link = mdio_read(mii_addr, info->phy_id, 1);
655 if (!link || (link == 0xffff)) {
656 printk(KERN_INFO "%s: MII is missing!\n", dev->name);
657 info->phy_id = -1;
658 goto reschedule;
659 }
660
661 link &= 0x0004;
662 if (link != info->link_status) {
663 u_short p = mdio_read(mii_addr, info->phy_id, 5);
664 printk(KERN_INFO "%s: %s link beat\n", dev->name,
665 (link) ? "found" : "lost");
666 if (link) {
667 info->duplex_flag = (p & 0x0140) ? 0x80 : 0x00;
668 if (p)
669 printk(KERN_INFO "%s: autonegotiation complete: "
670 "%sbaseT-%cD selected\n", dev->name,
671 ((p & 0x0180) ? "100" : "10"),
672 ((p & 0x0140) ? 'F' : 'H'));
673 else
674 printk(KERN_INFO "%s: link partner did not autonegotiate\n",
675 dev->name);
676 AX88190_init(dev, 1);
677 }
678 info->link_status = link;
679 }
680
681reschedule:
682 info->watchdog.expires = jiffies + HZ;
683 add_timer(&info->watchdog);
684}
685
686static void netdev_get_drvinfo(struct net_device *dev,
687 struct ethtool_drvinfo *info)
688{
689 strcpy(info->driver, "axnet_cs");
690}
691
692static const struct ethtool_ops netdev_ethtool_ops = {
693 .get_drvinfo = netdev_get_drvinfo,
694};
695
696
697
698static int axnet_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
699{
700 axnet_dev_t *info = PRIV(dev);
701 struct mii_ioctl_data *data = if_mii(rq);
702 unsigned int mii_addr = dev->base_addr + AXNET_MII_EEP;
703 switch (cmd) {
704 case SIOCGMIIPHY:
705 data->phy_id = info->phy_id;
706 case SIOCGMIIREG:
707 data->val_out = mdio_read(mii_addr, data->phy_id, data->reg_num & 0x1f);
708 return 0;
709 case SIOCSMIIREG:
710 mdio_write(mii_addr, data->phy_id, data->reg_num & 0x1f, data->val_in);
711 return 0;
712 }
713 return -EOPNOTSUPP;
714}
715
716
717
718static void get_8390_hdr(struct net_device *dev,
719 struct e8390_pkt_hdr *hdr,
720 int ring_page)
721{
722 unsigned int nic_base = dev->base_addr;
723
724 outb_p(0, nic_base + EN0_RSARLO);
725 outb_p(ring_page, nic_base + EN0_RSARHI);
726 outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
727
728 insw(nic_base + AXNET_DATAPORT, hdr,
729 sizeof(struct e8390_pkt_hdr)>>1);
730
731 hdr->count = le16_to_cpu(hdr->count);
732
733}
734
735
736
737static void block_input(struct net_device *dev, int count,
738 struct sk_buff *skb, int ring_offset)
739{
740 unsigned int nic_base = dev->base_addr;
741 int xfer_count = count;
742 char *buf = skb->data;
743
744#ifdef PCMCIA_DEBUG
745 if ((ei_debug > 4) && (count != 4))
746 printk(KERN_DEBUG "%s: [bi=%d]\n", dev->name, count+4);
747#endif
748 outb_p(ring_offset & 0xff, nic_base + EN0_RSARLO);
749 outb_p(ring_offset >> 8, nic_base + EN0_RSARHI);
750 outb_p(E8390_RREAD+E8390_START, nic_base + AXNET_CMD);
751
752 insw(nic_base + AXNET_DATAPORT,buf,count>>1);
753 if (count & 0x01)
754 buf[count-1] = inb(nic_base + AXNET_DATAPORT), xfer_count++;
755
756}
757
758
759
760static void block_output(struct net_device *dev, int count,
761 const u_char *buf, const int start_page)
762{
763 unsigned int nic_base = dev->base_addr;
764
765#ifdef PCMCIA_DEBUG
766 if (ei_debug > 4)
767 printk(KERN_DEBUG "%s: [bo=%d]\n", dev->name, count);
768#endif
769
770
771
772
773 if (count & 0x01)
774 count++;
775
776 outb_p(0x00, nic_base + EN0_RSARLO);
777 outb_p(start_page, nic_base + EN0_RSARHI);
778 outb_p(E8390_RWRITE+E8390_START, nic_base + AXNET_CMD);
779 outsw(nic_base + AXNET_DATAPORT, buf, count>>1);
780}
781
782static struct pcmcia_device_id axnet_ids[] = {
783 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x016c, 0x0081),
784 PCMCIA_DEVICE_MANF_CARD(0x018a, 0x0301),
785 PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0301),
786 PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0303),
787 PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0309),
788 PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1106),
789 PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab),
790 PCMCIA_DEVICE_MANF_CARD(0x021b, 0x0202),
791 PCMCIA_DEVICE_MANF_CARD(0xffff, 0x1090),
792 PCMCIA_DEVICE_PROD_ID12("AmbiCom,Inc.", "Fast Ethernet PC Card(AMB8110)", 0x49b020a7, 0x119cc9fc),
793 PCMCIA_DEVICE_PROD_ID124("Fast Ethernet", "16-bit PC Card", "AX88190", 0xb4be14e3, 0x9a12eb6a, 0xab9be5ef),
794 PCMCIA_DEVICE_PROD_ID12("ASIX", "AX88190", 0x0959823b, 0xab9be5ef),
795 PCMCIA_DEVICE_PROD_ID12("Billionton", "LNA-100B", 0x552ab682, 0xbc3b87e1),
796 PCMCIA_DEVICE_PROD_ID12("CHEETAH ETHERCARD", "EN2228", 0x00fa7bc8, 0x00e990cc),
797 PCMCIA_DEVICE_PROD_ID12("CNet", "CNF301", 0xbc477dde, 0x78c5f40b),
798 PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEther PCC-TXD", 0x5261440f, 0x436768c5),
799 PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEtherII PCC-TXD", 0x5261440f, 0x730df72e),
800 PCMCIA_DEVICE_PROD_ID12("Dynalink", "L100C16", 0x55632fd5, 0x66bc2a90),
801 PCMCIA_DEVICE_PROD_ID12("IO DATA", "ETXPCM", 0x547e66dc, 0x233adac2),
802 PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100 V3)", 0x0733cc81, 0x232019a8),
803 PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC3-TX", 0x481e0094, 0xf91af609),
804 PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA411", 0x9aa79dc3, 0x40fad875),
805 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "100BASE", 0x281f1c5d, 0x7c2add04),
806 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FastEtherCard", 0x281f1c5d, 0x7ef26116),
807 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FEP501", 0x281f1c5d, 0x2e272058),
808 PCMCIA_DEVICE_PROD_ID14("Network Everywhere", "AX88190", 0x820a67b6, 0xab9be5ef),
809 PCMCIA_DEVICE_NULL,
810};
811MODULE_DEVICE_TABLE(pcmcia, axnet_ids);
812
813static struct pcmcia_driver axnet_cs_driver = {
814 .owner = THIS_MODULE,
815 .drv = {
816 .name = "axnet_cs",
817 },
818 .probe = axnet_probe,
819 .remove = axnet_detach,
820 .id_table = axnet_ids,
821 .suspend = axnet_suspend,
822 .resume = axnet_resume,
823};
824
825static int __init init_axnet_cs(void)
826{
827 return pcmcia_register_driver(&axnet_cs_driver);
828}
829
830static void __exit exit_axnet_cs(void)
831{
832 pcmcia_unregister_driver(&axnet_cs_driver);
833}
834
835module_init(init_axnet_cs);
836module_exit(exit_axnet_cs);
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887static const char version_8390[] = KERN_INFO \
888 "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@scyld.com)\n";
889
890#include <linux/bitops.h>
891#include <asm/irq.h>
892#include <linux/fcntl.h>
893#include <linux/in.h>
894#include <linux/interrupt.h>
895
896#define BUG_83C690
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916#define ei_reset_8390 (ei_local->reset_8390)
917#define ei_block_output (ei_local->block_output)
918#define ei_block_input (ei_local->block_input)
919#define ei_get_8390_hdr (ei_local->get_8390_hdr)
920
921
922#ifndef ei_debug
923int ei_debug = 1;
924#endif
925
926
927static void ei_tx_intr(struct net_device *dev);
928static void ei_tx_err(struct net_device *dev);
929static void ei_receive(struct net_device *dev);
930static void ei_rx_overrun(struct net_device *dev);
931
932
933static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
934 int start_page);
935static void do_set_multicast_list(struct net_device *dev);
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971static int ax_open(struct net_device *dev)
972{
973 unsigned long flags;
974 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
975
976
977
978
979
980
981 spin_lock_irqsave(&ei_local->page_lock, flags);
982 AX88190_init(dev, 1);
983
984
985 netif_start_queue(dev);
986 spin_unlock_irqrestore(&ei_local->page_lock, flags);
987 ei_local->irqlock = 0;
988 return 0;
989}
990
991#define dev_lock(dev) (((struct ei_device *)netdev_priv(dev))->page_lock)
992
993
994
995
996
997
998
999static int ax_close(struct net_device *dev)
1000{
1001 unsigned long flags;
1002
1003
1004
1005
1006
1007 spin_lock_irqsave(&dev_lock(dev), flags);
1008 AX88190_init(dev, 0);
1009 spin_unlock_irqrestore(&dev_lock(dev), flags);
1010 netif_stop_queue(dev);
1011 return 0;
1012}
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022static void axnet_tx_timeout(struct net_device *dev)
1023{
1024 long e8390_base = dev->base_addr;
1025 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1026 int txsr, isr, tickssofar = jiffies - dev->trans_start;
1027 unsigned long flags;
1028
1029 dev->stats.tx_errors++;
1030
1031 spin_lock_irqsave(&ei_local->page_lock, flags);
1032 txsr = inb(e8390_base+EN0_TSR);
1033 isr = inb(e8390_base+EN0_ISR);
1034 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1035
1036 printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
1037 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
1038 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
1039
1040 if (!isr && !dev->stats.tx_packets)
1041 {
1042
1043 ei_local->interface_num ^= 1;
1044 }
1045
1046
1047
1048 spin_lock_irqsave(&ei_local->page_lock, flags);
1049
1050
1051 ei_reset_8390(dev);
1052 AX88190_init(dev, 1);
1053
1054 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1055 netif_wake_queue(dev);
1056}
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066static netdev_tx_t axnet_start_xmit(struct sk_buff *skb,
1067 struct net_device *dev)
1068{
1069 long e8390_base = dev->base_addr;
1070 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1071 int length, send_length, output_page;
1072 unsigned long flags;
1073 u8 packet[ETH_ZLEN];
1074
1075 netif_stop_queue(dev);
1076
1077 length = skb->len;
1078
1079
1080
1081
1082
1083
1084 spin_lock_irqsave(&ei_local->page_lock, flags);
1085 outb_p(0x00, e8390_base + EN0_IMR);
1086 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1087
1088
1089
1090
1091
1092 spin_lock_irqsave(&ei_local->page_lock, flags);
1093
1094 ei_local->irqlock = 1;
1095
1096 send_length = max(length, ETH_ZLEN);
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106 if (ei_local->tx1 == 0)
1107 {
1108 output_page = ei_local->tx_start_page;
1109 ei_local->tx1 = send_length;
1110 if (ei_debug && ei_local->tx2 > 0)
1111 printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
1112 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
1113 }
1114 else if (ei_local->tx2 == 0)
1115 {
1116 output_page = ei_local->tx_start_page + TX_PAGES/2;
1117 ei_local->tx2 = send_length;
1118 if (ei_debug && ei_local->tx1 > 0)
1119 printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
1120 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
1121 }
1122 else
1123 {
1124 if (ei_debug)
1125 printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
1126 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
1127 ei_local->irqlock = 0;
1128 netif_stop_queue(dev);
1129 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1130 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1131 dev->stats.tx_errors++;
1132 return NETDEV_TX_BUSY;
1133 }
1134
1135
1136
1137
1138
1139
1140
1141 if (length == skb->len)
1142 ei_block_output(dev, length, skb->data, output_page);
1143 else {
1144 memset(packet, 0, ETH_ZLEN);
1145 skb_copy_from_linear_data(skb, packet, skb->len);
1146 ei_block_output(dev, length, packet, output_page);
1147 }
1148
1149 if (! ei_local->txing)
1150 {
1151 ei_local->txing = 1;
1152 NS8390_trigger_send(dev, send_length, output_page);
1153 dev->trans_start = jiffies;
1154 if (output_page == ei_local->tx_start_page)
1155 {
1156 ei_local->tx1 = -1;
1157 ei_local->lasttx = -1;
1158 }
1159 else
1160 {
1161 ei_local->tx2 = -1;
1162 ei_local->lasttx = -2;
1163 }
1164 }
1165 else ei_local->txqueue++;
1166
1167 if (ei_local->tx1 && ei_local->tx2)
1168 netif_stop_queue(dev);
1169 else
1170 netif_start_queue(dev);
1171
1172
1173 ei_local->irqlock = 0;
1174 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1175
1176 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1177
1178 dev_kfree_skb (skb);
1179 dev->stats.tx_bytes += send_length;
1180
1181 return NETDEV_TX_OK;
1182}
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196static irqreturn_t ax_interrupt(int irq, void *dev_id)
1197{
1198 struct net_device *dev = dev_id;
1199 long e8390_base;
1200 int interrupts, nr_serviced = 0, i;
1201 struct ei_device *ei_local;
1202 int handled = 0;
1203
1204 e8390_base = dev->base_addr;
1205 ei_local = netdev_priv(dev);
1206
1207
1208
1209
1210
1211 spin_lock(&ei_local->page_lock);
1212
1213 if (ei_local->irqlock)
1214 {
1215#if 1
1216
1217 printk(ei_local->irqlock
1218 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
1219 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
1220 dev->name, inb_p(e8390_base + EN0_ISR),
1221 inb_p(e8390_base + EN0_IMR));
1222#endif
1223 spin_unlock(&ei_local->page_lock);
1224 return IRQ_NONE;
1225 }
1226
1227 if (ei_debug > 3)
1228 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
1229 inb_p(e8390_base + EN0_ISR));
1230
1231 outb_p(0x00, e8390_base + EN0_ISR);
1232 ei_local->irqlock = 1;
1233
1234
1235 while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
1236 && ++nr_serviced < MAX_SERVICE)
1237 {
1238 if (!netif_running(dev) || (interrupts == 0xff)) {
1239 if (ei_debug > 1)
1240 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
1241 outb_p(interrupts, e8390_base + EN0_ISR);
1242 interrupts = 0;
1243 break;
1244 }
1245 handled = 1;
1246
1247
1248 outb_p(interrupts, e8390_base + EN0_ISR);
1249 for (i = 0; i < 10; i++) {
1250 if (!(inb(e8390_base + EN0_ISR) & interrupts))
1251 break;
1252 outb_p(0, e8390_base + EN0_ISR);
1253 outb_p(interrupts, e8390_base + EN0_ISR);
1254 }
1255 if (interrupts & ENISR_OVER)
1256 ei_rx_overrun(dev);
1257 else if (interrupts & (ENISR_RX+ENISR_RX_ERR))
1258 {
1259
1260 ei_receive(dev);
1261 }
1262
1263 if (interrupts & ENISR_TX)
1264 ei_tx_intr(dev);
1265 else if (interrupts & ENISR_TX_ERR)
1266 ei_tx_err(dev);
1267
1268 if (interrupts & ENISR_COUNTERS)
1269 {
1270 dev->stats.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
1271 dev->stats.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
1272 dev->stats.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
1273 }
1274 }
1275
1276 if (interrupts && ei_debug > 3)
1277 {
1278 handled = 1;
1279 if (nr_serviced >= MAX_SERVICE)
1280 {
1281
1282 if(interrupts!=0xFF)
1283 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
1284 dev->name, interrupts);
1285 outb_p(ENISR_ALL, e8390_base + EN0_ISR);
1286 } else {
1287 printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
1288 outb_p(0xff, e8390_base + EN0_ISR);
1289 }
1290 }
1291
1292
1293 ei_local->irqlock = 0;
1294 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1295
1296 spin_unlock(&ei_local->page_lock);
1297 return IRQ_RETVAL(handled);
1298}
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314static void ei_tx_err(struct net_device *dev)
1315{
1316 long e8390_base = dev->base_addr;
1317 unsigned char txsr = inb_p(e8390_base+EN0_TSR);
1318 unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
1319
1320#ifdef VERBOSE_ERROR_DUMP
1321 printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
1322 if (txsr & ENTSR_ABT)
1323 printk("excess-collisions ");
1324 if (txsr & ENTSR_ND)
1325 printk("non-deferral ");
1326 if (txsr & ENTSR_CRS)
1327 printk("lost-carrier ");
1328 if (txsr & ENTSR_FU)
1329 printk("FIFO-underrun ");
1330 if (txsr & ENTSR_CDH)
1331 printk("lost-heartbeat ");
1332 printk("\n");
1333#endif
1334
1335 if (tx_was_aborted)
1336 ei_tx_intr(dev);
1337 else
1338 {
1339 dev->stats.tx_errors++;
1340 if (txsr & ENTSR_CRS) dev->stats.tx_carrier_errors++;
1341 if (txsr & ENTSR_CDH) dev->stats.tx_heartbeat_errors++;
1342 if (txsr & ENTSR_OWC) dev->stats.tx_window_errors++;
1343 }
1344}
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354static void ei_tx_intr(struct net_device *dev)
1355{
1356 long e8390_base = dev->base_addr;
1357 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1358 int status = inb(e8390_base + EN0_TSR);
1359
1360
1361
1362
1363
1364 ei_local->txqueue--;
1365
1366 if (ei_local->tx1 < 0)
1367 {
1368 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
1369 printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
1370 ei_local->name, ei_local->lasttx, ei_local->tx1);
1371 ei_local->tx1 = 0;
1372 if (ei_local->tx2 > 0)
1373 {
1374 ei_local->txing = 1;
1375 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
1376 dev->trans_start = jiffies;
1377 ei_local->tx2 = -1,
1378 ei_local->lasttx = 2;
1379 }
1380 else ei_local->lasttx = 20, ei_local->txing = 0;
1381 }
1382 else if (ei_local->tx2 < 0)
1383 {
1384 if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
1385 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
1386 ei_local->name, ei_local->lasttx, ei_local->tx2);
1387 ei_local->tx2 = 0;
1388 if (ei_local->tx1 > 0)
1389 {
1390 ei_local->txing = 1;
1391 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
1392 dev->trans_start = jiffies;
1393 ei_local->tx1 = -1;
1394 ei_local->lasttx = 1;
1395 }
1396 else
1397 ei_local->lasttx = 10, ei_local->txing = 0;
1398 }
1399
1400
1401
1402
1403 if (status & ENTSR_COL)
1404 dev->stats.collisions++;
1405 if (status & ENTSR_PTX)
1406 dev->stats.tx_packets++;
1407 else
1408 {
1409 dev->stats.tx_errors++;
1410 if (status & ENTSR_ABT)
1411 {
1412 dev->stats.tx_aborted_errors++;
1413 dev->stats.collisions += 16;
1414 }
1415 if (status & ENTSR_CRS)
1416 dev->stats.tx_carrier_errors++;
1417 if (status & ENTSR_FU)
1418 dev->stats.tx_fifo_errors++;
1419 if (status & ENTSR_CDH)
1420 dev->stats.tx_heartbeat_errors++;
1421 if (status & ENTSR_OWC)
1422 dev->stats.tx_window_errors++;
1423 }
1424 netif_wake_queue(dev);
1425}
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435static void ei_receive(struct net_device *dev)
1436{
1437 long e8390_base = dev->base_addr;
1438 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1439 unsigned char rxing_page, this_frame, next_frame;
1440 unsigned short current_offset;
1441 int rx_pkt_count = 0;
1442 struct e8390_pkt_hdr rx_frame;
1443
1444 while (++rx_pkt_count < 10)
1445 {
1446 int pkt_len, pkt_stat;
1447
1448
1449 rxing_page = inb_p(e8390_base + EN1_CURPAG -1);
1450
1451
1452 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
1453 if (this_frame >= ei_local->stop_page)
1454 this_frame = ei_local->rx_start_page;
1455
1456
1457
1458
1459
1460
1461
1462 if (ei_debug > 0 && this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
1463 printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
1464 dev->name, this_frame, ei_local->current_page);
1465
1466 if (this_frame == rxing_page)
1467 break;
1468
1469 current_offset = this_frame << 8;
1470 ei_get_8390_hdr(dev, &rx_frame, this_frame);
1471
1472 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
1473 pkt_stat = rx_frame.status;
1474
1475 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
1476
1477 if (pkt_len < 60 || pkt_len > 1518)
1478 {
1479 if (ei_debug)
1480 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
1481 dev->name, rx_frame.count, rx_frame.status,
1482 rx_frame.next);
1483 dev->stats.rx_errors++;
1484 dev->stats.rx_length_errors++;
1485 }
1486 else if ((pkt_stat & 0x0F) == ENRSR_RXOK)
1487 {
1488 struct sk_buff *skb;
1489
1490 skb = dev_alloc_skb(pkt_len+2);
1491 if (skb == NULL)
1492 {
1493 if (ei_debug > 1)
1494 printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
1495 dev->name, pkt_len);
1496 dev->stats.rx_dropped++;
1497 break;
1498 }
1499 else
1500 {
1501 skb_reserve(skb,2);
1502 skb_put(skb, pkt_len);
1503 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
1504 skb->protocol=eth_type_trans(skb,dev);
1505 netif_rx(skb);
1506 dev->stats.rx_packets++;
1507 dev->stats.rx_bytes += pkt_len;
1508 if (pkt_stat & ENRSR_PHY)
1509 dev->stats.multicast++;
1510 }
1511 }
1512 else
1513 {
1514 if (ei_debug)
1515 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
1516 dev->name, rx_frame.status, rx_frame.next,
1517 rx_frame.count);
1518 dev->stats.rx_errors++;
1519
1520 if (pkt_stat & ENRSR_FO)
1521 dev->stats.rx_fifo_errors++;
1522 }
1523 next_frame = rx_frame.next;
1524
1525
1526 if (next_frame >= ei_local->stop_page) {
1527 printk("%s: next frame inconsistency, %#2x\n", dev->name,
1528 next_frame);
1529 next_frame = ei_local->rx_start_page;
1530 }
1531 ei_local->current_page = next_frame;
1532 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
1533 }
1534
1535 return;
1536}
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551static void ei_rx_overrun(struct net_device *dev)
1552{
1553 axnet_dev_t *info = PRIV(dev);
1554 long e8390_base = dev->base_addr;
1555 unsigned char was_txing, must_resend = 0;
1556
1557
1558
1559
1560
1561 was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
1562 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1563
1564 if (ei_debug > 1)
1565 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
1566 dev->stats.rx_over_errors++;
1567
1568
1569
1570
1571
1572
1573
1574
1575 mdelay(10);
1576
1577
1578
1579
1580 outb_p(0x00, e8390_base+EN0_RCNTLO);
1581 outb_p(0x00, e8390_base+EN0_RCNTHI);
1582
1583
1584
1585
1586
1587
1588 if (was_txing)
1589 {
1590 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
1591 if (!tx_completed)
1592 must_resend = 1;
1593 }
1594
1595
1596
1597
1598
1599 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
1600 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
1601
1602
1603
1604
1605 ei_receive(dev);
1606
1607
1608
1609
1610 outb_p(E8390_TXCONFIG | info->duplex_flag, e8390_base + EN0_TXCR);
1611 if (must_resend)
1612 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
1613}
1614
1615
1616
1617
1618
1619static struct net_device_stats *get_stats(struct net_device *dev)
1620{
1621 long ioaddr = dev->base_addr;
1622 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1623 unsigned long flags;
1624
1625
1626 if (!netif_running(dev))
1627 return &dev->stats;
1628
1629 spin_lock_irqsave(&ei_local->page_lock,flags);
1630
1631 dev->stats.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
1632 dev->stats.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
1633 dev->stats.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
1634 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1635
1636 return &dev->stats;
1637}
1638
1639
1640
1641
1642
1643
1644static inline void make_mc_bits(u8 *bits, struct net_device *dev)
1645{
1646 struct dev_mc_list *dmi;
1647 u32 crc;
1648
1649 for (dmi=dev->mc_list; dmi; dmi=dmi->next) {
1650
1651 crc = ether_crc(ETH_ALEN, dmi->dmi_addr);
1652
1653
1654
1655
1656 bits[crc>>29] |= (1<<((crc>>26)&7));
1657 }
1658}
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668static void do_set_multicast_list(struct net_device *dev)
1669{
1670 long e8390_base = dev->base_addr;
1671 int i;
1672 struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
1673
1674 if (!(dev->flags&(IFF_PROMISC|IFF_ALLMULTI))) {
1675 memset(ei_local->mcfilter, 0, 8);
1676 if (dev->mc_list)
1677 make_mc_bits(ei_local->mcfilter, dev);
1678 } else {
1679
1680 memset(ei_local->mcfilter, 0xFF, 8);
1681 }
1682
1683 outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
1684 for(i = 0; i < 8; i++)
1685 {
1686 outb_p(ei_local->mcfilter[i], e8390_base + EN1_MULT_SHIFT(i));
1687 }
1688 outb_p(E8390_NODMA + E8390_PAGE0, e8390_base + E8390_CMD);
1689
1690 if(dev->flags&IFF_PROMISC)
1691 outb_p(E8390_RXCONFIG | 0x58, e8390_base + EN0_RXCR);
1692 else if(dev->flags&IFF_ALLMULTI || dev->mc_list)
1693 outb_p(E8390_RXCONFIG | 0x48, e8390_base + EN0_RXCR);
1694 else
1695 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR);
1696
1697 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1698}
1699
1700
1701
1702
1703
1704
1705
1706static void set_multicast_list(struct net_device *dev)
1707{
1708 unsigned long flags;
1709
1710 spin_lock_irqsave(&dev_lock(dev), flags);
1711 do_set_multicast_list(dev);
1712 spin_unlock_irqrestore(&dev_lock(dev), flags);
1713}
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726static void AX88190_init(struct net_device *dev, int startp)
1727{
1728 axnet_dev_t *info = PRIV(dev);
1729 long e8390_base = dev->base_addr;
1730 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1731 int i;
1732 int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
1733
1734 if(sizeof(struct e8390_pkt_hdr)!=4)
1735 panic("8390.c: header struct mispacked\n");
1736
1737 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1738 outb_p(endcfg, e8390_base + EN0_DCFG);
1739
1740 outb_p(0x00, e8390_base + EN0_RCNTLO);
1741 outb_p(0x00, e8390_base + EN0_RCNTHI);
1742
1743 outb_p(E8390_RXOFF|0x40, e8390_base + EN0_RXCR);
1744 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
1745
1746 outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1747 ei_local->tx1 = ei_local->tx2 = 0;
1748 outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1749 outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY);
1750 ei_local->current_page = ei_local->rx_start_page;
1751 outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1752
1753 outb_p(0xFF, e8390_base + EN0_ISR);
1754 outb_p(0x00, e8390_base + EN0_IMR);
1755
1756
1757
1758 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD);
1759 for(i = 0; i < 6; i++)
1760 {
1761 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1762 if(inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1763 printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1764 }
1765
1766 outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1767 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1768
1769 netif_start_queue(dev);
1770 ei_local->tx1 = ei_local->tx2 = 0;
1771 ei_local->txing = 0;
1772
1773 if (info->flags & IS_AX88790)
1774 outb(0x10, e8390_base + AXNET_GPIO);
1775
1776 if (startp)
1777 {
1778 outb_p(0xff, e8390_base + EN0_ISR);
1779 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1780 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1781 outb_p(E8390_TXCONFIG | info->duplex_flag,
1782 e8390_base + EN0_TXCR);
1783
1784 outb_p(E8390_RXCONFIG | 0x40, e8390_base + EN0_RXCR);
1785 do_set_multicast_list(dev);
1786 }
1787}
1788
1789
1790
1791
1792static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1793 int start_page)
1794{
1795 long e8390_base = dev->base_addr;
1796 struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) netdev_priv(dev);
1797
1798 if (inb_p(e8390_base) & E8390_TRANS)
1799 {
1800 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1801 dev->name);
1802 return;
1803 }
1804 outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1805 outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1806 outb_p(start_page, e8390_base + EN0_TPSR);
1807 outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);
1808}
1809