1 /*======================================================================
3 A PCMCIA ethernet driver for Asix AX88190-based cards
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.
12 Copyright (C) 2001 David A. Hinds -- dahinds@users.sourceforge.net
14 axnet_cs.c 1.28 2002/06/29 06:27:37
16 The network driver code is based on Donald Becker's NE2000 code:
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
25 ======================================================================*/
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/ptrace.h>
31 #include <linux/string.h>
32 #include <linux/timer.h>
33 #include <linux/delay.h>
34 #include <linux/spinlock.h>
35 #include <linux/ethtool.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/crc32.h>
39 #include <linux/mii.h>
42 #include <pcmcia/cistpl.h>
43 #include <pcmcia/ciscode.h>
44 #include <pcmcia/ds.h>
45 #include <pcmcia/cisreg.h>
48 #include <asm/system.h>
49 #include <asm/byteorder.h>
50 #include <asm/uaccess.h>
52 #define AXNET_CMD 0x00
53 #define AXNET_DATAPORT 0x10 /* NatSemi-defined port window offset. */
54 #define AXNET_RESET 0x1f /* Issue a read to reset, a write to clear. */
55 #define AXNET_MII_EEP 0x14 /* Offset of MII access port */
56 #define AXNET_TEST 0x15 /* Offset of TEST Register port */
57 #define AXNET_GPIO 0x17 /* Offset of General Purpose Register Port */
59 #define AXNET_START_PG 0x40 /* First page of TX buffer */
60 #define AXNET_STOP_PG 0x80 /* Last page +1 of RX ring */
62 #define AXNET_RDC_TIMEOUT 0x02 /* Max wait in jiffies for Tx RDC */
64 #define IS_AX88190 0x0001
65 #define IS_AX88790 0x0002
67 /*====================================================================*/
69 /* Module parameters */
71 MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
72 MODULE_DESCRIPTION("Asix AX88190 PCMCIA ethernet driver");
73 MODULE_LICENSE("GPL");
76 /*====================================================================*/
78 static int axnet_config(struct pcmcia_device
*link
);
79 static void axnet_release(struct pcmcia_device
*link
);
80 static int axnet_open(struct net_device
*dev
);
81 static int axnet_close(struct net_device
*dev
);
82 static int axnet_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
);
83 static netdev_tx_t
axnet_start_xmit(struct sk_buff
*skb
,
84 struct net_device
*dev
);
85 static struct net_device_stats
*get_stats(struct net_device
*dev
);
86 static void set_multicast_list(struct net_device
*dev
);
87 static void axnet_tx_timeout(struct net_device
*dev
);
88 static const struct ethtool_ops netdev_ethtool_ops
;
89 static irqreturn_t
ei_irq_wrapper(int irq
, void *dev_id
);
90 static void ei_watchdog(u_long arg
);
91 static void axnet_reset_8390(struct net_device
*dev
);
93 static int mdio_read(unsigned int addr
, int phy_id
, int loc
);
94 static void mdio_write(unsigned int addr
, int phy_id
, int loc
, int value
);
96 static void get_8390_hdr(struct net_device
*,
97 struct e8390_pkt_hdr
*, int);
98 static void block_input(struct net_device
*dev
, int count
,
99 struct sk_buff
*skb
, int ring_offset
);
100 static void block_output(struct net_device
*dev
, int count
,
101 const u_char
*buf
, const int start_page
);
103 static void axnet_detach(struct pcmcia_device
*p_dev
);
105 static void AX88190_init(struct net_device
*dev
, int startp
);
106 static int ax_open(struct net_device
*dev
);
107 static int ax_close(struct net_device
*dev
);
108 static irqreturn_t
ax_interrupt(int irq
, void *dev_id
);
110 /*====================================================================*/
112 typedef struct axnet_dev_t
{
113 struct pcmcia_device
*p_dev
;
115 struct timer_list watchdog
;
116 int stale
, fast_poll
;
123 static inline axnet_dev_t
*PRIV(struct net_device
*dev
)
125 void *p
= (char *)netdev_priv(dev
) + sizeof(struct ei_device
);
129 static const struct net_device_ops axnet_netdev_ops
= {
130 .ndo_open
= axnet_open
,
131 .ndo_stop
= axnet_close
,
132 .ndo_do_ioctl
= axnet_ioctl
,
133 .ndo_start_xmit
= axnet_start_xmit
,
134 .ndo_tx_timeout
= axnet_tx_timeout
,
135 .ndo_get_stats
= get_stats
,
136 .ndo_set_multicast_list
= set_multicast_list
,
137 .ndo_change_mtu
= eth_change_mtu
,
138 .ndo_set_mac_address
= eth_mac_addr
,
139 .ndo_validate_addr
= eth_validate_addr
,
142 /*======================================================================
144 axnet_attach() creates an "instance" of the driver, allocating
145 local data structures for one device. The device is registered
148 ======================================================================*/
150 static int axnet_probe(struct pcmcia_device
*link
)
153 struct net_device
*dev
;
154 struct ei_device
*ei_local
;
156 dev_dbg(&link
->dev
, "axnet_attach()\n");
158 dev
= alloc_etherdev(sizeof(struct ei_device
) + sizeof(axnet_dev_t
));
162 ei_local
= netdev_priv(dev
);
163 spin_lock_init(&ei_local
->page_lock
);
168 link
->config_flags
|= CONF_ENABLE_IRQ
;
170 dev
->netdev_ops
= &axnet_netdev_ops
;
172 SET_ETHTOOL_OPS(dev
, &netdev_ethtool_ops
);
173 dev
->watchdog_timeo
= TX_TIMEOUT
;
175 return axnet_config(link
);
178 /*======================================================================
180 This deletes a driver "instance". The device is de-registered
181 with Card Services. If it has been released, all local data
182 structures are freed. Otherwise, the structures will be freed
183 when the device is released.
185 ======================================================================*/
187 static void axnet_detach(struct pcmcia_device
*link
)
189 struct net_device
*dev
= link
->priv
;
191 dev_dbg(&link
->dev
, "axnet_detach(0x%p)\n", link
);
193 unregister_netdev(dev
);
200 /*======================================================================
202 This probes for a card's hardware address by reading the PROM.
204 ======================================================================*/
206 static int get_prom(struct pcmcia_device
*link
)
208 struct net_device
*dev
= link
->priv
;
209 unsigned int ioaddr
= dev
->base_addr
;
212 /* This is based on drivers/net/ne.c */
214 u_char value
, offset
;
216 {E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, E8390_CMD
}, /* Select page 0*/
217 {0x01, EN0_DCFG
}, /* Set word-wide access. */
218 {0x00, EN0_RCNTLO
}, /* Clear the count regs. */
220 {0x00, EN0_IMR
}, /* Mask completion irq. */
222 {E8390_RXOFF
|0x40, EN0_RXCR
}, /* 0x60 Set to monitor */
223 {E8390_TXOFF
, EN0_TXCR
}, /* 0x02 and loopback mode. */
226 {0x00, EN0_RSARLO
}, /* DMA starting at 0x0400. */
228 {E8390_RREAD
+E8390_START
, E8390_CMD
},
231 /* Not much of a test, but the alternatives are messy */
232 if (link
->config_base
!= 0x03c0)
235 axnet_reset_8390(dev
);
238 for (i
= 0; i
< ARRAY_SIZE(program_seq
); i
++)
239 outb_p(program_seq
[i
].value
, ioaddr
+ program_seq
[i
].offset
);
241 for (i
= 0; i
< 6; i
+= 2) {
242 j
= inw(ioaddr
+ AXNET_DATAPORT
);
243 dev
->dev_addr
[i
] = j
& 0xff;
244 dev
->dev_addr
[i
+1] = j
>> 8;
249 /*======================================================================
251 axnet_config() is scheduled to run after a CARD_INSERTION event
252 is received, to configure the PCMCIA socket, and to make the
253 ethernet device available to the system.
255 ======================================================================*/
257 static int try_io_port(struct pcmcia_device
*link
)
260 link
->resource
[0]->flags
&= ~IO_DATA_PATH_WIDTH
;
261 link
->resource
[1]->flags
&= ~IO_DATA_PATH_WIDTH
;
262 if (link
->resource
[0]->end
== 32) {
263 link
->resource
[0]->flags
|= IO_DATA_PATH_WIDTH_AUTO
;
264 /* for master/slave multifunction cards */
265 if (link
->resource
[1]->end
> 0)
266 link
->resource
[1]->flags
|= IO_DATA_PATH_WIDTH_8
;
268 /* This should be two 16-port windows */
269 link
->resource
[0]->flags
|= IO_DATA_PATH_WIDTH_8
;
270 link
->resource
[1]->flags
|= IO_DATA_PATH_WIDTH_16
;
272 if (link
->resource
[0]->start
== 0) {
273 for (j
= 0; j
< 0x400; j
+= 0x20) {
274 link
->resource
[0]->start
= j
^ 0x300;
275 link
->resource
[1]->start
= (j
^ 0x300) + 0x10;
277 ret
= pcmcia_request_io(link
);
283 return pcmcia_request_io(link
);
287 static int axnet_configcheck(struct pcmcia_device
*p_dev
, void *priv_data
)
289 if (p_dev
->config_index
== 0)
292 p_dev
->config_index
= 0x05;
293 if (p_dev
->resource
[0]->end
+ p_dev
->resource
[1]->end
< 32)
296 return try_io_port(p_dev
);
299 static int axnet_config(struct pcmcia_device
*link
)
301 struct net_device
*dev
= link
->priv
;
302 axnet_dev_t
*info
= PRIV(dev
);
305 dev_dbg(&link
->dev
, "axnet_config(0x%p)\n", link
);
307 /* don't trust the CIS on this; Linksys got it wrong */
308 link
->config_regs
= 0x63;
309 link
->config_flags
|= CONF_ENABLE_IRQ
| CONF_AUTO_SET_IO
;
310 ret
= pcmcia_loop_config(link
, axnet_configcheck
, NULL
);
317 if (resource_size(link
->resource
[1]) == 8)
318 link
->config_flags
|= CONF_ENABLE_SPKR
;
320 ret
= pcmcia_enable_device(link
);
324 dev
->irq
= link
->irq
;
325 dev
->base_addr
= link
->resource
[0]->start
;
327 if (!get_prom(link
)) {
328 printk(KERN_NOTICE
"axnet_cs: this is not an AX88190 card!\n");
329 printk(KERN_NOTICE
"axnet_cs: use pcnet_cs instead.\n");
333 ei_status
.name
= "AX88190";
334 ei_status
.word16
= 1;
335 ei_status
.tx_start_page
= AXNET_START_PG
;
336 ei_status
.rx_start_page
= AXNET_START_PG
+ TX_PAGES
;
337 ei_status
.stop_page
= AXNET_STOP_PG
;
338 ei_status
.reset_8390
= &axnet_reset_8390
;
339 ei_status
.get_8390_hdr
= &get_8390_hdr
;
340 ei_status
.block_input
= &block_input
;
341 ei_status
.block_output
= &block_output
;
343 if (inb(dev
->base_addr
+ AXNET_TEST
) != 0)
344 info
->flags
|= IS_AX88790
;
346 info
->flags
|= IS_AX88190
;
348 if (info
->flags
& IS_AX88790
)
349 outb(0x10, dev
->base_addr
+ AXNET_GPIO
); /* select Internal PHY */
351 for (i
= 0; i
< 32; i
++) {
352 j
= mdio_read(dev
->base_addr
+ AXNET_MII_EEP
, i
, 1);
353 j2
= mdio_read(dev
->base_addr
+ AXNET_MII_EEP
, i
, 2);
354 if (j
== j2
) continue;
355 if ((j
!= 0) && (j
!= 0xffff)) break;
358 /* Maybe PHY is in power down mode. (PPD_SET = 1)
359 Bit 2 of CCSR is active low. */
361 pcmcia_write_config_byte(link
, CISREG_CCSR
, 0x04);
362 for (i
= 0; i
< 32; i
++) {
363 j
= mdio_read(dev
->base_addr
+ AXNET_MII_EEP
, i
, 1);
364 j2
= mdio_read(dev
->base_addr
+ AXNET_MII_EEP
, i
, 2);
365 if (j
== j2
) continue;
366 if ((j
!= 0) && (j
!= 0xffff)) break;
370 info
->phy_id
= (i
< 32) ? i
: -1;
371 SET_NETDEV_DEV(dev
, &link
->dev
);
373 if (register_netdev(dev
) != 0) {
374 printk(KERN_NOTICE
"axnet_cs: register_netdev() failed\n");
378 printk(KERN_INFO
"%s: Asix AX88%d90: io %#3lx, irq %d, "
380 dev
->name
, ((info
->flags
& IS_AX88790
) ? 7 : 1),
381 dev
->base_addr
, dev
->irq
,
383 if (info
->phy_id
!= -1) {
384 dev_dbg(&link
->dev
, " MII transceiver at index %d, status %x.\n", info
->phy_id
, j
);
386 printk(KERN_NOTICE
" No MII transceivers found!\n");
395 /*======================================================================
397 After a card is removed, axnet_release() will unregister the net
398 device, and release the PCMCIA configuration. If the device is
399 still open, this will be postponed until it is closed.
401 ======================================================================*/
403 static void axnet_release(struct pcmcia_device
*link
)
405 pcmcia_disable_device(link
);
408 static int axnet_suspend(struct pcmcia_device
*link
)
410 struct net_device
*dev
= link
->priv
;
413 netif_device_detach(dev
);
418 static int axnet_resume(struct pcmcia_device
*link
)
420 struct net_device
*dev
= link
->priv
;
423 axnet_reset_8390(dev
);
424 AX88190_init(dev
, 1);
425 netif_device_attach(dev
);
432 /*======================================================================
434 MII interface support
436 ======================================================================*/
438 #define MDIO_SHIFT_CLK 0x01
439 #define MDIO_DATA_WRITE0 0x00
440 #define MDIO_DATA_WRITE1 0x08
441 #define MDIO_DATA_READ 0x04
442 #define MDIO_MASK 0x0f
443 #define MDIO_ENB_IN 0x02
445 static void mdio_sync(unsigned int addr
)
448 for (bits
= 0; bits
< 32; bits
++) {
449 outb_p(MDIO_DATA_WRITE1
, addr
);
450 outb_p(MDIO_DATA_WRITE1
| MDIO_SHIFT_CLK
, addr
);
454 static int mdio_read(unsigned int addr
, int phy_id
, int loc
)
456 u_int cmd
= (0xf6<<10)|(phy_id
<<5)|loc
;
460 for (i
= 14; i
>= 0; i
--) {
461 int dat
= (cmd
&(1<<i
)) ? MDIO_DATA_WRITE1
: MDIO_DATA_WRITE0
;
463 outb_p(dat
| MDIO_SHIFT_CLK
, addr
);
465 for (i
= 19; i
> 0; i
--) {
466 outb_p(MDIO_ENB_IN
, addr
);
467 retval
= (retval
<< 1) | ((inb_p(addr
) & MDIO_DATA_READ
) != 0);
468 outb_p(MDIO_ENB_IN
| MDIO_SHIFT_CLK
, addr
);
470 return (retval
>>1) & 0xffff;
473 static void mdio_write(unsigned int addr
, int phy_id
, int loc
, int value
)
475 u_int cmd
= (0x05<<28)|(phy_id
<<23)|(loc
<<18)|(1<<17)|value
;
479 for (i
= 31; i
>= 0; i
--) {
480 int dat
= (cmd
&(1<<i
)) ? MDIO_DATA_WRITE1
: MDIO_DATA_WRITE0
;
482 outb_p(dat
| MDIO_SHIFT_CLK
, addr
);
484 for (i
= 1; i
>= 0; i
--) {
485 outb_p(MDIO_ENB_IN
, addr
);
486 outb_p(MDIO_ENB_IN
| MDIO_SHIFT_CLK
, addr
);
490 /*====================================================================*/
492 static int axnet_open(struct net_device
*dev
)
495 axnet_dev_t
*info
= PRIV(dev
);
496 struct pcmcia_device
*link
= info
->p_dev
;
497 unsigned int nic_base
= dev
->base_addr
;
499 dev_dbg(&link
->dev
, "axnet_open('%s')\n", dev
->name
);
501 if (!pcmcia_dev_present(link
))
504 outb_p(0xFF, nic_base
+ EN0_ISR
); /* Clear bogus intr. */
505 ret
= request_irq(dev
->irq
, ei_irq_wrapper
, IRQF_SHARED
, "axnet_cs", dev
);
511 info
->link_status
= 0x00;
512 init_timer(&info
->watchdog
);
513 info
->watchdog
.function
= &ei_watchdog
;
514 info
->watchdog
.data
= (u_long
)dev
;
515 info
->watchdog
.expires
= jiffies
+ HZ
;
516 add_timer(&info
->watchdog
);
521 /*====================================================================*/
523 static int axnet_close(struct net_device
*dev
)
525 axnet_dev_t
*info
= PRIV(dev
);
526 struct pcmcia_device
*link
= info
->p_dev
;
528 dev_dbg(&link
->dev
, "axnet_close('%s')\n", dev
->name
);
531 free_irq(dev
->irq
, dev
);
534 netif_stop_queue(dev
);
535 del_timer_sync(&info
->watchdog
);
540 /*======================================================================
542 Hard reset the card. This used to pause for the same period that
543 a 8390 reset command required, but that shouldn't be necessary.
545 ======================================================================*/
547 static void axnet_reset_8390(struct net_device
*dev
)
549 unsigned int nic_base
= dev
->base_addr
;
552 ei_status
.txing
= ei_status
.dmaing
= 0;
554 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, nic_base
+ E8390_CMD
);
556 outb(inb(nic_base
+ AXNET_RESET
), nic_base
+ AXNET_RESET
);
558 for (i
= 0; i
< 100; i
++) {
559 if ((inb_p(nic_base
+EN0_ISR
) & ENISR_RESET
) != 0)
563 outb_p(ENISR_RESET
, nic_base
+ EN0_ISR
); /* Ack intr. */
566 printk(KERN_ERR
"%s: axnet_reset_8390() did not complete.\n",
569 } /* axnet_reset_8390 */
571 /*====================================================================*/
573 static irqreturn_t
ei_irq_wrapper(int irq
, void *dev_id
)
575 struct net_device
*dev
= dev_id
;
576 PRIV(dev
)->stale
= 0;
577 return ax_interrupt(irq
, dev_id
);
580 static void ei_watchdog(u_long arg
)
582 struct net_device
*dev
= (struct net_device
*)(arg
);
583 axnet_dev_t
*info
= PRIV(dev
);
584 unsigned int nic_base
= dev
->base_addr
;
585 unsigned int mii_addr
= nic_base
+ AXNET_MII_EEP
;
588 if (!netif_device_present(dev
)) goto reschedule
;
590 /* Check for pending interrupt with expired latency timer: with
591 this, we can limp along even if the interrupt is blocked */
592 if (info
->stale
++ && (inb_p(nic_base
+ EN0_ISR
) & ENISR_ALL
)) {
593 if (!info
->fast_poll
)
594 printk(KERN_INFO
"%s: interrupt(s) dropped!\n", dev
->name
);
595 ei_irq_wrapper(dev
->irq
, dev
);
596 info
->fast_poll
= HZ
;
598 if (info
->fast_poll
) {
600 info
->watchdog
.expires
= jiffies
+ 1;
601 add_timer(&info
->watchdog
);
605 if (info
->phy_id
< 0)
607 link
= mdio_read(mii_addr
, info
->phy_id
, 1);
608 if (!link
|| (link
== 0xffff)) {
609 printk(KERN_INFO
"%s: MII is missing!\n", dev
->name
);
615 if (link
!= info
->link_status
) {
616 u_short p
= mdio_read(mii_addr
, info
->phy_id
, 5);
617 printk(KERN_INFO
"%s: %s link beat\n", dev
->name
,
618 (link
) ? "found" : "lost");
620 info
->duplex_flag
= (p
& 0x0140) ? 0x80 : 0x00;
622 printk(KERN_INFO
"%s: autonegotiation complete: "
623 "%sbaseT-%cD selected\n", dev
->name
,
624 ((p
& 0x0180) ? "100" : "10"),
625 ((p
& 0x0140) ? 'F' : 'H'));
627 printk(KERN_INFO
"%s: link partner did not autonegotiate\n",
629 AX88190_init(dev
, 1);
631 info
->link_status
= link
;
635 info
->watchdog
.expires
= jiffies
+ HZ
;
636 add_timer(&info
->watchdog
);
639 static void netdev_get_drvinfo(struct net_device
*dev
,
640 struct ethtool_drvinfo
*info
)
642 strcpy(info
->driver
, "axnet_cs");
645 static const struct ethtool_ops netdev_ethtool_ops
= {
646 .get_drvinfo
= netdev_get_drvinfo
,
649 /*====================================================================*/
651 static int axnet_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
653 axnet_dev_t
*info
= PRIV(dev
);
654 struct mii_ioctl_data
*data
= if_mii(rq
);
655 unsigned int mii_addr
= dev
->base_addr
+ AXNET_MII_EEP
;
658 data
->phy_id
= info
->phy_id
;
659 case SIOCGMIIREG
: /* Read MII PHY register. */
660 data
->val_out
= mdio_read(mii_addr
, data
->phy_id
, data
->reg_num
& 0x1f);
662 case SIOCSMIIREG
: /* Write MII PHY register. */
663 mdio_write(mii_addr
, data
->phy_id
, data
->reg_num
& 0x1f, data
->val_in
);
669 /*====================================================================*/
671 static void get_8390_hdr(struct net_device
*dev
,
672 struct e8390_pkt_hdr
*hdr
,
675 unsigned int nic_base
= dev
->base_addr
;
677 outb_p(0, nic_base
+ EN0_RSARLO
); /* On page boundary */
678 outb_p(ring_page
, nic_base
+ EN0_RSARHI
);
679 outb_p(E8390_RREAD
+E8390_START
, nic_base
+ AXNET_CMD
);
681 insw(nic_base
+ AXNET_DATAPORT
, hdr
,
682 sizeof(struct e8390_pkt_hdr
)>>1);
683 /* Fix for big endian systems */
684 hdr
->count
= le16_to_cpu(hdr
->count
);
688 /*====================================================================*/
690 static void block_input(struct net_device
*dev
, int count
,
691 struct sk_buff
*skb
, int ring_offset
)
693 unsigned int nic_base
= dev
->base_addr
;
694 int xfer_count
= count
;
695 char *buf
= skb
->data
;
697 if ((ei_debug
> 4) && (count
!= 4))
698 pr_debug("%s: [bi=%d]\n", dev
->name
, count
+4);
699 outb_p(ring_offset
& 0xff, nic_base
+ EN0_RSARLO
);
700 outb_p(ring_offset
>> 8, nic_base
+ EN0_RSARHI
);
701 outb_p(E8390_RREAD
+E8390_START
, nic_base
+ AXNET_CMD
);
703 insw(nic_base
+ AXNET_DATAPORT
,buf
,count
>>1);
705 buf
[count
-1] = inb(nic_base
+ AXNET_DATAPORT
), xfer_count
++;
709 /*====================================================================*/
711 static void block_output(struct net_device
*dev
, int count
,
712 const u_char
*buf
, const int start_page
)
714 unsigned int nic_base
= dev
->base_addr
;
716 pr_debug("%s: [bo=%d]\n", dev
->name
, count
);
718 /* Round the count up for word writes. Do we need to do this?
719 What effect will an odd byte count have on the 8390?
720 I should check someday. */
724 outb_p(0x00, nic_base
+ EN0_RSARLO
);
725 outb_p(start_page
, nic_base
+ EN0_RSARHI
);
726 outb_p(E8390_RWRITE
+E8390_START
, nic_base
+ AXNET_CMD
);
727 outsw(nic_base
+ AXNET_DATAPORT
, buf
, count
>>1);
730 static struct pcmcia_device_id axnet_ids
[] = {
731 PCMCIA_PFC_DEVICE_MANF_CARD(0, 0x016c, 0x0081),
732 PCMCIA_DEVICE_MANF_CARD(0x018a, 0x0301),
733 PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0301),
734 PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0303),
735 PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0309),
736 PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1106),
737 PCMCIA_DEVICE_MANF_CARD(0x8a01, 0xc1ab),
738 PCMCIA_DEVICE_MANF_CARD(0x021b, 0x0202),
739 PCMCIA_DEVICE_MANF_CARD(0xffff, 0x1090),
740 PCMCIA_DEVICE_PROD_ID12("AmbiCom,Inc.", "Fast Ethernet PC Card(AMB8110)", 0x49b020a7, 0x119cc9fc),
741 PCMCIA_DEVICE_PROD_ID124("Fast Ethernet", "16-bit PC Card", "AX88190", 0xb4be14e3, 0x9a12eb6a, 0xab9be5ef),
742 PCMCIA_DEVICE_PROD_ID12("ASIX", "AX88190", 0x0959823b, 0xab9be5ef),
743 PCMCIA_DEVICE_PROD_ID12("Billionton", "LNA-100B", 0x552ab682, 0xbc3b87e1),
744 PCMCIA_DEVICE_PROD_ID12("CHEETAH ETHERCARD", "EN2228", 0x00fa7bc8, 0x00e990cc),
745 PCMCIA_DEVICE_PROD_ID12("CNet", "CNF301", 0xbc477dde, 0x78c5f40b),
746 PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEther PCC-TXD", 0x5261440f, 0x436768c5),
747 PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEtherII PCC-TXD", 0x5261440f, 0x730df72e),
748 PCMCIA_DEVICE_PROD_ID12("corega K.K.", "corega FEther PCC-TXM", 0x5261440f, 0x3abbd061),
749 PCMCIA_DEVICE_PROD_ID12("Dynalink", "L100C16", 0x55632fd5, 0x66bc2a90),
750 PCMCIA_DEVICE_PROD_ID12("IO DATA", "ETXPCM", 0x547e66dc, 0x233adac2),
751 PCMCIA_DEVICE_PROD_ID12("Linksys", "EtherFast 10/100 PC Card (PCMPC100 V3)", 0x0733cc81, 0x232019a8),
752 PCMCIA_DEVICE_PROD_ID12("MELCO", "LPC3-TX", 0x481e0094, 0xf91af609),
753 PCMCIA_DEVICE_PROD_ID12("NETGEAR", "FA411", 0x9aa79dc3, 0x40fad875),
754 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "100BASE", 0x281f1c5d, 0x7c2add04),
755 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FastEtherCard", 0x281f1c5d, 0x7ef26116),
756 PCMCIA_DEVICE_PROD_ID12("PCMCIA", "FEP501", 0x281f1c5d, 0x2e272058),
757 PCMCIA_DEVICE_PROD_ID14("Network Everywhere", "AX88190", 0x820a67b6, 0xab9be5ef),
760 MODULE_DEVICE_TABLE(pcmcia
, axnet_ids
);
762 static struct pcmcia_driver axnet_cs_driver
= {
763 .owner
= THIS_MODULE
,
765 .probe
= axnet_probe
,
766 .remove
= axnet_detach
,
767 .id_table
= axnet_ids
,
768 .suspend
= axnet_suspend
,
769 .resume
= axnet_resume
,
772 static int __init
init_axnet_cs(void)
774 return pcmcia_register_driver(&axnet_cs_driver
);
777 static void __exit
exit_axnet_cs(void)
779 pcmcia_unregister_driver(&axnet_cs_driver
);
782 module_init(init_axnet_cs
);
783 module_exit(exit_axnet_cs
);
785 /*====================================================================*/
787 /* 8390.c: A general NS8390 ethernet driver core for linux. */
789 Written 1992-94 by Donald Becker.
791 Copyright 1993 United States Government as represented by the
792 Director, National Security Agency.
794 This software may be used and distributed according to the terms
795 of the GNU General Public License, incorporated herein by reference.
797 The author may be reached as becker@scyld.com, or C/O
798 Scyld Computing Corporation
799 410 Severn Ave., Suite 210
802 This is the chip-specific code for many 8390-based ethernet adaptors.
803 This is not a complete driver, it must be combined with board-specific
804 code such as ne.c, wd.c, 3c503.c, etc.
806 Seeing how at least eight drivers use this code, (not counting the
807 PCMCIA ones either) it is easy to break some card by what seems like
808 a simple innocent change. Please contact me or Donald if you think
809 you have found something that needs changing. -- PG
813 Paul Gortmaker : remove set_bit lock, other cleanups.
814 Paul Gortmaker : add ei_get_8390_hdr() so we can pass skb's to
815 ei_block_input() for eth_io_copy_and_sum().
816 Paul Gortmaker : exchange static int ei_pingpong for a #define,
817 also add better Tx error handling.
818 Paul Gortmaker : rewrite Rx overrun handling as per NS specs.
819 Alexey Kuznetsov : use the 8390's six bit hash multicast filter.
820 Paul Gortmaker : tweak ANK's above multicast changes a bit.
821 Paul Gortmaker : update packet statistics for v2.1.x
822 Alan Cox : support arbitary stupid port mappings on the
823 68K Macintosh. Support >16bit I/O spaces
824 Paul Gortmaker : add kmod support for auto-loading of the 8390
825 module by all drivers that require it.
826 Alan Cox : Spinlocking work, added 'BUG_83C690'
827 Paul Gortmaker : Separate out Tx timeout code from Tx path.
830 The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
834 static const char version_8390
[] = KERN_INFO \
835 "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@scyld.com)\n";
837 #include <linux/bitops.h>
839 #include <linux/fcntl.h>
840 #include <linux/in.h>
841 #include <linux/interrupt.h>
845 /* These are the operational function interfaces to board-specific
847 void reset_8390(struct net_device *dev)
848 Resets the board associated with DEV, including a hardware reset of
849 the 8390. This is only called when there is a transmit timeout, and
850 it is always followed by 8390_init().
851 void block_output(struct net_device *dev, int count, const unsigned char *buf,
853 Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
854 "page" value uses the 8390's 256-byte pages.
855 void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
856 Read the 4 byte, page aligned 8390 header. *If* there is a
857 subsequent read, it will be of the rest of the packet.
858 void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
859 Read COUNT bytes from the packet buffer into the skb data area. Start
860 reading from RING_OFFSET, the address as the 8390 sees it. This will always
861 follow the read of the 8390 header.
863 #define ei_reset_8390 (ei_local->reset_8390)
864 #define ei_block_output (ei_local->block_output)
865 #define ei_block_input (ei_local->block_input)
866 #define ei_get_8390_hdr (ei_local->get_8390_hdr)
868 /* use 0 for production, 1 for verification, >2 for debug */
873 /* Index to functions. */
874 static void ei_tx_intr(struct net_device
*dev
);
875 static void ei_tx_err(struct net_device
*dev
);
876 static void ei_receive(struct net_device
*dev
);
877 static void ei_rx_overrun(struct net_device
*dev
);
879 /* Routines generic to NS8390-based boards. */
880 static void NS8390_trigger_send(struct net_device
*dev
, unsigned int length
,
882 static void do_set_multicast_list(struct net_device
*dev
);
885 * SMP and the 8390 setup.
887 * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
888 * a page register that controls bank and packet buffer access. We guard
889 * this with ei_local->page_lock. Nobody should assume or set the page other
890 * than zero when the lock is not held. Lock holders must restore page 0
891 * before unlocking. Even pure readers must take the lock to protect in
894 * To make life difficult the chip can also be very slow. We therefore can't
895 * just use spinlocks. For the longer lockups we disable the irq the device
896 * sits on and hold the lock. We must hold the lock because there is a dual
897 * processor case other than interrupts (get stats/set multicast list in
898 * parallel with each other and transmit).
900 * Note: in theory we can just disable the irq on the card _but_ there is
901 * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
902 * enter lock, take the queued irq. So we waddle instead of flying.
904 * Finally by special arrangement for the purpose of being generally
905 * annoying the transmit function is called bh atomic. That places
906 * restrictions on the user context callers as disable_irq won't save
911 * ax_open - Open/initialize the board.
912 * @dev: network device to initialize
914 * This routine goes all-out, setting everything
915 * up anew at each open, even though many of these registers should only
916 * need to be set once at boot.
918 static int ax_open(struct net_device
*dev
)
921 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
924 * Grab the page lock so we own the register set, then call
928 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
929 AX88190_init(dev
, 1);
930 /* Set the flag before we drop the lock, That way the IRQ arrives
931 after its set and we get no silly warnings */
932 netif_start_queue(dev
);
933 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
934 ei_local
->irqlock
= 0;
938 #define dev_lock(dev) (((struct ei_device *)netdev_priv(dev))->page_lock)
941 * ax_close - shut down network device
942 * @dev: network device to close
944 * Opposite of ax_open(). Only used when "ifconfig <devname> down" is done.
946 static int ax_close(struct net_device
*dev
)
951 * Hold the page lock during close
954 spin_lock_irqsave(&dev_lock(dev
), flags
);
955 AX88190_init(dev
, 0);
956 spin_unlock_irqrestore(&dev_lock(dev
), flags
);
957 netif_stop_queue(dev
);
962 * axnet_tx_timeout - handle transmit time out condition
963 * @dev: network device which has apparently fallen asleep
965 * Called by kernel when device never acknowledges a transmit has
966 * completed (or failed) - i.e. never posted a Tx related interrupt.
969 static void axnet_tx_timeout(struct net_device
*dev
)
971 long e8390_base
= dev
->base_addr
;
972 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
973 int txsr
, isr
, tickssofar
= jiffies
- dev_trans_start(dev
);
976 dev
->stats
.tx_errors
++;
978 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
979 txsr
= inb(e8390_base
+EN0_TSR
);
980 isr
= inb(e8390_base
+EN0_ISR
);
981 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
983 printk(KERN_DEBUG
"%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
984 dev
->name
, (txsr
& ENTSR_ABT
) ? "excess collisions." :
985 (isr
) ? "lost interrupt?" : "cable problem?", txsr
, isr
, tickssofar
);
987 if (!isr
&& !dev
->stats
.tx_packets
)
989 /* The 8390 probably hasn't gotten on the cable yet. */
990 ei_local
->interface_num
^= 1; /* Try a different xcvr. */
993 /* Ugly but a reset can be slow, yet must be protected */
995 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
997 /* Try to restart the card. Perhaps the user has fixed something. */
999 AX88190_init(dev
, 1);
1001 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
1002 netif_wake_queue(dev
);
1006 * axnet_start_xmit - begin packet transmission
1007 * @skb: packet to be sent
1008 * @dev: network device to which packet is sent
1010 * Sends a packet to an 8390 network device.
1013 static netdev_tx_t
axnet_start_xmit(struct sk_buff
*skb
,
1014 struct net_device
*dev
)
1016 long e8390_base
= dev
->base_addr
;
1017 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
1018 int length
, send_length
, output_page
;
1019 unsigned long flags
;
1020 u8 packet
[ETH_ZLEN
];
1022 netif_stop_queue(dev
);
1026 /* Mask interrupts from the ethercard.
1027 SMP: We have to grab the lock here otherwise the IRQ handler
1028 on another CPU can flip window and race the IRQ mask set. We end
1029 up trashing the mcast filter not disabling irqs if we don't lock */
1031 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
1032 outb_p(0x00, e8390_base
+ EN0_IMR
);
1035 * Slow phase with lock held.
1038 ei_local
->irqlock
= 1;
1040 send_length
= max(length
, ETH_ZLEN
);
1043 * We have two Tx slots available for use. Find the first free
1044 * slot, and then perform some sanity checks. With two Tx bufs,
1045 * you get very close to transmitting back-to-back packets. With
1046 * only one Tx buf, the transmitter sits idle while you reload the
1047 * card, leaving a substantial gap between each transmitted packet.
1050 if (ei_local
->tx1
== 0)
1052 output_page
= ei_local
->tx_start_page
;
1053 ei_local
->tx1
= send_length
;
1054 if (ei_debug
&& ei_local
->tx2
> 0)
1055 printk(KERN_DEBUG
"%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
1056 dev
->name
, ei_local
->tx2
, ei_local
->lasttx
, ei_local
->txing
);
1058 else if (ei_local
->tx2
== 0)
1060 output_page
= ei_local
->tx_start_page
+ TX_PAGES
/2;
1061 ei_local
->tx2
= send_length
;
1062 if (ei_debug
&& ei_local
->tx1
> 0)
1063 printk(KERN_DEBUG
"%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
1064 dev
->name
, ei_local
->tx1
, ei_local
->lasttx
, ei_local
->txing
);
1067 { /* We should never get here. */
1069 printk(KERN_DEBUG
"%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
1070 dev
->name
, ei_local
->tx1
, ei_local
->tx2
, ei_local
->lasttx
);
1071 ei_local
->irqlock
= 0;
1072 netif_stop_queue(dev
);
1073 outb_p(ENISR_ALL
, e8390_base
+ EN0_IMR
);
1074 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
1075 dev
->stats
.tx_errors
++;
1076 return NETDEV_TX_BUSY
;
1080 * Okay, now upload the packet and trigger a send if the transmitter
1081 * isn't already sending. If it is busy, the interrupt handler will
1082 * trigger the send later, upon receiving a Tx done interrupt.
1085 if (length
== skb
->len
)
1086 ei_block_output(dev
, length
, skb
->data
, output_page
);
1088 memset(packet
, 0, ETH_ZLEN
);
1089 skb_copy_from_linear_data(skb
, packet
, skb
->len
);
1090 ei_block_output(dev
, length
, packet
, output_page
);
1093 if (! ei_local
->txing
)
1095 ei_local
->txing
= 1;
1096 NS8390_trigger_send(dev
, send_length
, output_page
);
1097 dev
->trans_start
= jiffies
;
1098 if (output_page
== ei_local
->tx_start_page
)
1101 ei_local
->lasttx
= -1;
1106 ei_local
->lasttx
= -2;
1109 else ei_local
->txqueue
++;
1111 if (ei_local
->tx1
&& ei_local
->tx2
)
1112 netif_stop_queue(dev
);
1114 netif_start_queue(dev
);
1116 /* Turn 8390 interrupts back on. */
1117 ei_local
->irqlock
= 0;
1118 outb_p(ENISR_ALL
, e8390_base
+ EN0_IMR
);
1120 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
1122 dev_kfree_skb (skb
);
1123 dev
->stats
.tx_bytes
+= send_length
;
1125 return NETDEV_TX_OK
;
1129 * ax_interrupt - handle the interrupts from an 8390
1130 * @irq: interrupt number
1131 * @dev_id: a pointer to the net_device
1133 * Handle the ether interface interrupts. We pull packets from
1134 * the 8390 via the card specific functions and fire them at the networking
1135 * stack. We also handle transmit completions and wake the transmit path if
1136 * necessary. We also update the counters and do other housekeeping as
1140 static irqreturn_t
ax_interrupt(int irq
, void *dev_id
)
1142 struct net_device
*dev
= dev_id
;
1144 int interrupts
, nr_serviced
= 0, i
;
1145 struct ei_device
*ei_local
;
1147 unsigned long flags
;
1149 e8390_base
= dev
->base_addr
;
1150 ei_local
= netdev_priv(dev
);
1153 * Protect the irq test too.
1156 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
1158 if (ei_local
->irqlock
)
1160 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
1161 /* The "irqlock" check is only for testing. */
1162 printk(ei_local
->irqlock
1163 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
1164 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
1165 dev
->name
, inb_p(e8390_base
+ EN0_ISR
),
1166 inb_p(e8390_base
+ EN0_IMR
));
1168 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
1173 printk(KERN_DEBUG
"%s: interrupt(isr=%#2.2x).\n", dev
->name
,
1174 inb_p(e8390_base
+ EN0_ISR
));
1176 outb_p(0x00, e8390_base
+ EN0_ISR
);
1177 ei_local
->irqlock
= 1;
1179 /* !!Assumption!! -- we stay in page 0. Don't break this. */
1180 while ((interrupts
= inb_p(e8390_base
+ EN0_ISR
)) != 0 &&
1181 ++nr_serviced
< MAX_SERVICE
)
1183 if (!netif_running(dev
) || (interrupts
== 0xff)) {
1185 printk(KERN_WARNING
"%s: interrupt from stopped card\n", dev
->name
);
1186 outb_p(interrupts
, e8390_base
+ EN0_ISR
);
1192 /* AX88190 bug fix. */
1193 outb_p(interrupts
, e8390_base
+ EN0_ISR
);
1194 for (i
= 0; i
< 10; i
++) {
1195 if (!(inb(e8390_base
+ EN0_ISR
) & interrupts
))
1197 outb_p(0, e8390_base
+ EN0_ISR
);
1198 outb_p(interrupts
, e8390_base
+ EN0_ISR
);
1200 if (interrupts
& ENISR_OVER
)
1202 else if (interrupts
& (ENISR_RX
+ENISR_RX_ERR
))
1204 /* Got a good (?) packet. */
1207 /* Push the next to-transmit packet through. */
1208 if (interrupts
& ENISR_TX
)
1210 else if (interrupts
& ENISR_TX_ERR
)
1213 if (interrupts
& ENISR_COUNTERS
)
1215 dev
->stats
.rx_frame_errors
+= inb_p(e8390_base
+ EN0_COUNTER0
);
1216 dev
->stats
.rx_crc_errors
+= inb_p(e8390_base
+ EN0_COUNTER1
);
1217 dev
->stats
.rx_missed_errors
+= inb_p(e8390_base
+ EN0_COUNTER2
);
1221 if (interrupts
&& ei_debug
> 3)
1224 if (nr_serviced
>= MAX_SERVICE
)
1226 /* 0xFF is valid for a card removal */
1227 if(interrupts
!=0xFF)
1228 printk(KERN_WARNING
"%s: Too much work at interrupt, status %#2.2x\n",
1229 dev
->name
, interrupts
);
1230 outb_p(ENISR_ALL
, e8390_base
+ EN0_ISR
); /* Ack. most intrs. */
1232 printk(KERN_WARNING
"%s: unknown interrupt %#2x\n", dev
->name
, interrupts
);
1233 outb_p(0xff, e8390_base
+ EN0_ISR
); /* Ack. all intrs. */
1237 /* Turn 8390 interrupts back on. */
1238 ei_local
->irqlock
= 0;
1239 outb_p(ENISR_ALL
, e8390_base
+ EN0_IMR
);
1241 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
1242 return IRQ_RETVAL(handled
);
1246 * ei_tx_err - handle transmitter error
1247 * @dev: network device which threw the exception
1249 * A transmitter error has happened. Most likely excess collisions (which
1250 * is a fairly normal condition). If the error is one where the Tx will
1251 * have been aborted, we try and send another one right away, instead of
1252 * letting the failed packet sit and collect dust in the Tx buffer. This
1253 * is a much better solution as it avoids kernel based Tx timeouts, and
1254 * an unnecessary card reset.
1256 * Called with lock held.
1259 static void ei_tx_err(struct net_device
*dev
)
1261 long e8390_base
= dev
->base_addr
;
1262 unsigned char txsr
= inb_p(e8390_base
+EN0_TSR
);
1263 unsigned char tx_was_aborted
= txsr
& (ENTSR_ABT
+ENTSR_FU
);
1265 #ifdef VERBOSE_ERROR_DUMP
1266 printk(KERN_DEBUG
"%s: transmitter error (%#2x): ", dev
->name
, txsr
);
1267 if (txsr
& ENTSR_ABT
)
1268 printk("excess-collisions ");
1269 if (txsr
& ENTSR_ND
)
1270 printk("non-deferral ");
1271 if (txsr
& ENTSR_CRS
)
1272 printk("lost-carrier ");
1273 if (txsr
& ENTSR_FU
)
1274 printk("FIFO-underrun ");
1275 if (txsr
& ENTSR_CDH
)
1276 printk("lost-heartbeat ");
1284 dev
->stats
.tx_errors
++;
1285 if (txsr
& ENTSR_CRS
) dev
->stats
.tx_carrier_errors
++;
1286 if (txsr
& ENTSR_CDH
) dev
->stats
.tx_heartbeat_errors
++;
1287 if (txsr
& ENTSR_OWC
) dev
->stats
.tx_window_errors
++;
1292 * ei_tx_intr - transmit interrupt handler
1293 * @dev: network device for which tx intr is handled
1295 * We have finished a transmit: check for errors and then trigger the next
1296 * packet to be sent. Called with lock held.
1299 static void ei_tx_intr(struct net_device
*dev
)
1301 long e8390_base
= dev
->base_addr
;
1302 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
1303 int status
= inb(e8390_base
+ EN0_TSR
);
1306 * There are two Tx buffers, see which one finished, and trigger
1307 * the send of another one if it exists.
1309 ei_local
->txqueue
--;
1311 if (ei_local
->tx1
< 0)
1313 if (ei_local
->lasttx
!= 1 && ei_local
->lasttx
!= -1)
1314 printk(KERN_ERR
"%s: bogus last_tx_buffer %d, tx1=%d.\n",
1315 ei_local
->name
, ei_local
->lasttx
, ei_local
->tx1
);
1317 if (ei_local
->tx2
> 0)
1319 ei_local
->txing
= 1;
1320 NS8390_trigger_send(dev
, ei_local
->tx2
, ei_local
->tx_start_page
+ 6);
1321 dev
->trans_start
= jiffies
;
1323 ei_local
->lasttx
= 2;
1325 else ei_local
->lasttx
= 20, ei_local
->txing
= 0;
1327 else if (ei_local
->tx2
< 0)
1329 if (ei_local
->lasttx
!= 2 && ei_local
->lasttx
!= -2)
1330 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
1331 ei_local
->name
, ei_local
->lasttx
, ei_local
->tx2
);
1333 if (ei_local
->tx1
> 0)
1335 ei_local
->txing
= 1;
1336 NS8390_trigger_send(dev
, ei_local
->tx1
, ei_local
->tx_start_page
);
1337 dev
->trans_start
= jiffies
;
1339 ei_local
->lasttx
= 1;
1342 ei_local
->lasttx
= 10, ei_local
->txing
= 0;
1344 // else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
1345 // dev->name, ei_local->lasttx);
1347 /* Minimize Tx latency: update the statistics after we restart TXing. */
1348 if (status
& ENTSR_COL
)
1349 dev
->stats
.collisions
++;
1350 if (status
& ENTSR_PTX
)
1351 dev
->stats
.tx_packets
++;
1354 dev
->stats
.tx_errors
++;
1355 if (status
& ENTSR_ABT
)
1357 dev
->stats
.tx_aborted_errors
++;
1358 dev
->stats
.collisions
+= 16;
1360 if (status
& ENTSR_CRS
)
1361 dev
->stats
.tx_carrier_errors
++;
1362 if (status
& ENTSR_FU
)
1363 dev
->stats
.tx_fifo_errors
++;
1364 if (status
& ENTSR_CDH
)
1365 dev
->stats
.tx_heartbeat_errors
++;
1366 if (status
& ENTSR_OWC
)
1367 dev
->stats
.tx_window_errors
++;
1369 netif_wake_queue(dev
);
1373 * ei_receive - receive some packets
1374 * @dev: network device with which receive will be run
1376 * We have a good packet(s), get it/them out of the buffers.
1377 * Called with lock held.
1380 static void ei_receive(struct net_device
*dev
)
1382 long e8390_base
= dev
->base_addr
;
1383 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
1384 unsigned char rxing_page
, this_frame
, next_frame
;
1385 unsigned short current_offset
;
1386 int rx_pkt_count
= 0;
1387 struct e8390_pkt_hdr rx_frame
;
1389 while (++rx_pkt_count
< 10)
1391 int pkt_len
, pkt_stat
;
1393 /* Get the rx page (incoming packet pointer). */
1394 rxing_page
= inb_p(e8390_base
+ EN1_CURPAG
-1);
1396 /* Remove one frame from the ring. Boundary is always a page behind. */
1397 this_frame
= inb_p(e8390_base
+ EN0_BOUNDARY
) + 1;
1398 if (this_frame
>= ei_local
->stop_page
)
1399 this_frame
= ei_local
->rx_start_page
;
1401 /* Someday we'll omit the previous, iff we never get this message.
1402 (There is at least one clone claimed to have a problem.)
1404 Keep quiet if it looks like a card removal. One problem here
1405 is that some clones crash in roughly the same way.
1407 if (ei_debug
> 0 && this_frame
!= ei_local
->current_page
&& (this_frame
!=0x0 || rxing_page
!=0xFF))
1408 printk(KERN_ERR
"%s: mismatched read page pointers %2x vs %2x.\n",
1409 dev
->name
, this_frame
, ei_local
->current_page
);
1411 if (this_frame
== rxing_page
) /* Read all the frames? */
1412 break; /* Done for now */
1414 current_offset
= this_frame
<< 8;
1415 ei_get_8390_hdr(dev
, &rx_frame
, this_frame
);
1417 pkt_len
= rx_frame
.count
- sizeof(struct e8390_pkt_hdr
);
1418 pkt_stat
= rx_frame
.status
;
1420 next_frame
= this_frame
+ 1 + ((pkt_len
+4)>>8);
1422 if (pkt_len
< 60 || pkt_len
> 1518)
1425 printk(KERN_DEBUG
"%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
1426 dev
->name
, rx_frame
.count
, rx_frame
.status
,
1428 dev
->stats
.rx_errors
++;
1429 dev
->stats
.rx_length_errors
++;
1431 else if ((pkt_stat
& 0x0F) == ENRSR_RXOK
)
1433 struct sk_buff
*skb
;
1435 skb
= dev_alloc_skb(pkt_len
+2);
1439 printk(KERN_DEBUG
"%s: Couldn't allocate a sk_buff of size %d.\n",
1440 dev
->name
, pkt_len
);
1441 dev
->stats
.rx_dropped
++;
1446 skb_reserve(skb
,2); /* IP headers on 16 byte boundaries */
1447 skb_put(skb
, pkt_len
); /* Make room */
1448 ei_block_input(dev
, pkt_len
, skb
, current_offset
+ sizeof(rx_frame
));
1449 skb
->protocol
=eth_type_trans(skb
,dev
);
1451 dev
->stats
.rx_packets
++;
1452 dev
->stats
.rx_bytes
+= pkt_len
;
1453 if (pkt_stat
& ENRSR_PHY
)
1454 dev
->stats
.multicast
++;
1460 printk(KERN_DEBUG
"%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
1461 dev
->name
, rx_frame
.status
, rx_frame
.next
,
1463 dev
->stats
.rx_errors
++;
1464 /* NB: The NIC counts CRC, frame and missed errors. */
1465 if (pkt_stat
& ENRSR_FO
)
1466 dev
->stats
.rx_fifo_errors
++;
1468 next_frame
= rx_frame
.next
;
1470 /* This _should_ never happen: it's here for avoiding bad clones. */
1471 if (next_frame
>= ei_local
->stop_page
) {
1472 printk("%s: next frame inconsistency, %#2x\n", dev
->name
,
1474 next_frame
= ei_local
->rx_start_page
;
1476 ei_local
->current_page
= next_frame
;
1477 outb_p(next_frame
-1, e8390_base
+EN0_BOUNDARY
);
1482 * ei_rx_overrun - handle receiver overrun
1483 * @dev: network device which threw exception
1485 * We have a receiver overrun: we have to kick the 8390 to get it started
1486 * again. Problem is that you have to kick it exactly as NS prescribes in
1487 * the updated datasheets, or "the NIC may act in an unpredictable manner."
1488 * This includes causing "the NIC to defer indefinitely when it is stopped
1489 * on a busy network." Ugh.
1490 * Called with lock held. Don't call this with the interrupts off or your
1491 * computer will hate you - it takes 10ms or so.
1494 static void ei_rx_overrun(struct net_device
*dev
)
1496 axnet_dev_t
*info
= PRIV(dev
);
1497 long e8390_base
= dev
->base_addr
;
1498 unsigned char was_txing
, must_resend
= 0;
1501 * Record whether a Tx was in progress and then issue the
1504 was_txing
= inb_p(e8390_base
+E8390_CMD
) & E8390_TRANS
;
1505 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, e8390_base
+E8390_CMD
);
1508 printk(KERN_DEBUG
"%s: Receiver overrun.\n", dev
->name
);
1509 dev
->stats
.rx_over_errors
++;
1512 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
1513 * Early datasheets said to poll the reset bit, but now they say that
1514 * it "is not a reliable indicator and subsequently should be ignored."
1515 * We wait at least 10ms.
1521 * Reset RBCR[01] back to zero as per magic incantation.
1523 outb_p(0x00, e8390_base
+EN0_RCNTLO
);
1524 outb_p(0x00, e8390_base
+EN0_RCNTHI
);
1527 * See if any Tx was interrupted or not. According to NS, this
1528 * step is vital, and skipping it will cause no end of havoc.
1533 unsigned char tx_completed
= inb_p(e8390_base
+EN0_ISR
) & (ENISR_TX
+ENISR_TX_ERR
);
1539 * Have to enter loopback mode and then restart the NIC before
1540 * you are allowed to slurp packets up off the ring.
1542 outb_p(E8390_TXOFF
, e8390_base
+ EN0_TXCR
);
1543 outb_p(E8390_NODMA
+ E8390_PAGE0
+ E8390_START
, e8390_base
+ E8390_CMD
);
1546 * Clear the Rx ring of all the debris, and ack the interrupt.
1551 * Leave loopback mode, and resend any packet that got stopped.
1553 outb_p(E8390_TXCONFIG
| info
->duplex_flag
, e8390_base
+ EN0_TXCR
);
1555 outb_p(E8390_NODMA
+ E8390_PAGE0
+ E8390_START
+ E8390_TRANS
, e8390_base
+ E8390_CMD
);
1559 * Collect the stats. This is called unlocked and from several contexts.
1562 static struct net_device_stats
*get_stats(struct net_device
*dev
)
1564 long ioaddr
= dev
->base_addr
;
1565 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
1566 unsigned long flags
;
1568 /* If the card is stopped, just return the present stats. */
1569 if (!netif_running(dev
))
1572 spin_lock_irqsave(&ei_local
->page_lock
,flags
);
1573 /* Read the counter registers, assuming we are in page 0. */
1574 dev
->stats
.rx_frame_errors
+= inb_p(ioaddr
+ EN0_COUNTER0
);
1575 dev
->stats
.rx_crc_errors
+= inb_p(ioaddr
+ EN0_COUNTER1
);
1576 dev
->stats
.rx_missed_errors
+= inb_p(ioaddr
+ EN0_COUNTER2
);
1577 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
1583 * Form the 64 bit 8390 multicast table from the linked list of addresses
1584 * associated with this dev structure.
1587 static inline void make_mc_bits(u8
*bits
, struct net_device
*dev
)
1589 struct netdev_hw_addr
*ha
;
1592 netdev_for_each_mc_addr(ha
, dev
) {
1593 crc
= ether_crc(ETH_ALEN
, ha
->addr
);
1595 * The 8390 uses the 6 most significant bits of the
1596 * CRC to index the multicast table.
1598 bits
[crc
>>29] |= (1<<((crc
>>26)&7));
1603 * do_set_multicast_list - set/clear multicast filter
1604 * @dev: net device for which multicast filter is adjusted
1606 * Set or clear the multicast filter for this adaptor.
1607 * Must be called with lock held.
1610 static void do_set_multicast_list(struct net_device
*dev
)
1612 long e8390_base
= dev
->base_addr
;
1614 struct ei_device
*ei_local
= (struct ei_device
*)netdev_priv(dev
);
1616 if (!(dev
->flags
&(IFF_PROMISC
|IFF_ALLMULTI
))) {
1617 memset(ei_local
->mcfilter
, 0, 8);
1618 if (!netdev_mc_empty(dev
))
1619 make_mc_bits(ei_local
->mcfilter
, dev
);
1621 /* set to accept-all */
1622 memset(ei_local
->mcfilter
, 0xFF, 8);
1625 outb_p(E8390_NODMA
+ E8390_PAGE1
, e8390_base
+ E8390_CMD
);
1626 for(i
= 0; i
< 8; i
++)
1628 outb_p(ei_local
->mcfilter
[i
], e8390_base
+ EN1_MULT_SHIFT(i
));
1630 outb_p(E8390_NODMA
+ E8390_PAGE0
, e8390_base
+ E8390_CMD
);
1632 if(dev
->flags
&IFF_PROMISC
)
1633 outb_p(E8390_RXCONFIG
| 0x58, e8390_base
+ EN0_RXCR
);
1634 else if (dev
->flags
& IFF_ALLMULTI
|| !netdev_mc_empty(dev
))
1635 outb_p(E8390_RXCONFIG
| 0x48, e8390_base
+ EN0_RXCR
);
1637 outb_p(E8390_RXCONFIG
| 0x40, e8390_base
+ EN0_RXCR
);
1639 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_START
, e8390_base
+E8390_CMD
);
1643 * Called without lock held. This is invoked from user context and may
1644 * be parallel to just about everything else. Its also fairly quick and
1645 * not called too often. Must protect against both bh and irq users
1648 static void set_multicast_list(struct net_device
*dev
)
1650 unsigned long flags
;
1652 spin_lock_irqsave(&dev_lock(dev
), flags
);
1653 do_set_multicast_list(dev
);
1654 spin_unlock_irqrestore(&dev_lock(dev
), flags
);
1657 /* This page of functions should be 8390 generic */
1658 /* Follow National Semi's recommendations for initializing the "NIC". */
1661 * AX88190_init - initialize 8390 hardware
1662 * @dev: network device to initialize
1663 * @startp: boolean. non-zero value to initiate chip processing
1665 * Must be called with lock held.
1668 static void AX88190_init(struct net_device
*dev
, int startp
)
1670 axnet_dev_t
*info
= PRIV(dev
);
1671 long e8390_base
= dev
->base_addr
;
1672 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
1674 int endcfg
= ei_local
->word16
? (0x48 | ENDCFG_WTS
) : 0x48;
1676 if(sizeof(struct e8390_pkt_hdr
)!=4)
1677 panic("8390.c: header struct mispacked\n");
1678 /* Follow National Semi's recommendations for initing the DP83902. */
1679 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, e8390_base
+E8390_CMD
); /* 0x21 */
1680 outb_p(endcfg
, e8390_base
+ EN0_DCFG
); /* 0x48 or 0x49 */
1681 /* Clear the remote byte count registers. */
1682 outb_p(0x00, e8390_base
+ EN0_RCNTLO
);
1683 outb_p(0x00, e8390_base
+ EN0_RCNTHI
);
1684 /* Set to monitor and loopback mode -- this is vital!. */
1685 outb_p(E8390_RXOFF
|0x40, e8390_base
+ EN0_RXCR
); /* 0x60 */
1686 outb_p(E8390_TXOFF
, e8390_base
+ EN0_TXCR
); /* 0x02 */
1687 /* Set the transmit page and receive ring. */
1688 outb_p(ei_local
->tx_start_page
, e8390_base
+ EN0_TPSR
);
1689 ei_local
->tx1
= ei_local
->tx2
= 0;
1690 outb_p(ei_local
->rx_start_page
, e8390_base
+ EN0_STARTPG
);
1691 outb_p(ei_local
->stop_page
-1, e8390_base
+ EN0_BOUNDARY
); /* 3c503 says 0x3f,NS0x26*/
1692 ei_local
->current_page
= ei_local
->rx_start_page
; /* assert boundary+1 */
1693 outb_p(ei_local
->stop_page
, e8390_base
+ EN0_STOPPG
);
1694 /* Clear the pending interrupts and mask. */
1695 outb_p(0xFF, e8390_base
+ EN0_ISR
);
1696 outb_p(0x00, e8390_base
+ EN0_IMR
);
1698 /* Copy the station address into the DS8390 registers. */
1700 outb_p(E8390_NODMA
+ E8390_PAGE1
+ E8390_STOP
, e8390_base
+E8390_CMD
); /* 0x61 */
1701 for(i
= 0; i
< 6; i
++)
1703 outb_p(dev
->dev_addr
[i
], e8390_base
+ EN1_PHYS_SHIFT(i
));
1704 if(inb_p(e8390_base
+ EN1_PHYS_SHIFT(i
))!=dev
->dev_addr
[i
])
1705 printk(KERN_ERR
"Hw. address read/write mismap %d\n",i
);
1708 outb_p(ei_local
->rx_start_page
, e8390_base
+ EN1_CURPAG
);
1709 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, e8390_base
+E8390_CMD
);
1711 netif_start_queue(dev
);
1712 ei_local
->tx1
= ei_local
->tx2
= 0;
1713 ei_local
->txing
= 0;
1715 if (info
->flags
& IS_AX88790
) /* select Internal PHY */
1716 outb(0x10, e8390_base
+ AXNET_GPIO
);
1720 outb_p(0xff, e8390_base
+ EN0_ISR
);
1721 outb_p(ENISR_ALL
, e8390_base
+ EN0_IMR
);
1722 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_START
, e8390_base
+E8390_CMD
);
1723 outb_p(E8390_TXCONFIG
| info
->duplex_flag
,
1724 e8390_base
+ EN0_TXCR
); /* xmit on. */
1725 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1726 outb_p(E8390_RXCONFIG
| 0x40, e8390_base
+ EN0_RXCR
); /* rx on, */
1727 do_set_multicast_list(dev
); /* (re)load the mcast table */
1731 /* Trigger a transmit start, assuming the length is valid.
1732 Always called with the page lock held */
1734 static void NS8390_trigger_send(struct net_device
*dev
, unsigned int length
,
1737 long e8390_base
= dev
->base_addr
;
1738 struct ei_device
*ei_local
__attribute((unused
)) = (struct ei_device
*) netdev_priv(dev
);
1740 if (inb_p(e8390_base
) & E8390_TRANS
)
1742 printk(KERN_WARNING
"%s: trigger_send() called with the transmitter busy.\n",
1746 outb_p(length
& 0xff, e8390_base
+ EN0_TCNTLO
);
1747 outb_p(length
>> 8, e8390_base
+ EN0_TCNTHI
);
1748 outb_p(start_page
, e8390_base
+ EN0_TPSR
);
1749 outb_p(E8390_NODMA
+E8390_TRANS
+E8390_START
, e8390_base
+E8390_CMD
);