2 * linux/drivers/acorn/net/ether1.c
4 * Copyright (C) 1996-2000 Russell King
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * Acorn ether1 driver (82586 chip) for Acorn machines
12 * We basically keep two queues in the cards memory - one for transmit
13 * and one for receive. Each has a head and a tail. The head is where
14 * we/the chip adds packets to be transmitted/received, and the tail
15 * is where the transmitter has got to/where the receiver will stop.
16 * Both of these queues are circular, and since the chip is running
17 * all the time, we have to be careful when we modify the pointers etc
18 * so that the buffer memory contents is valid all the time.
22 * 1.01 RMK 19/03/1996 Transfers the last odd byte onto/off of the card now.
23 * 1.02 RMK 25/05/1997 Added code to restart RU if it goes not ready
24 * 1.03 RMK 14/09/1997 Cleaned up the handling of a reset during the TX interrupt.
25 * Should prevent lockup.
26 * 1.04 RMK 17/09/1997 Added more info when initialsation of chip goes wrong.
27 * TDR now only reports failure when chip reports non-zero
29 * 1.05 RMK 31/12/1997 Removed calls to dev_tint for 2.1
30 * 1.06 RMK 10/02/2000 Updated for 2.3.43
31 * 1.07 RMK 13/05/2000 Updated for 2.3.99-pre8
34 #include <linux/module.h>
35 #include <linux/kernel.h>
36 #include <linux/sched.h>
37 #include <linux/types.h>
38 #include <linux/fcntl.h>
39 #include <linux/interrupt.h>
40 #include <linux/ptrace.h>
41 #include <linux/ioport.h>
43 #include <linux/slab.h>
44 #include <linux/string.h>
45 #include <linux/errno.h>
46 #include <linux/device.h>
47 #include <linux/init.h>
48 #include <linux/netdevice.h>
49 #include <linux/etherdevice.h>
50 #include <linux/skbuff.h>
52 #include <asm/system.h>
53 #include <asm/bitops.h>
56 #include <asm/ecard.h>
61 static unsigned int net_debug
= NET_DEBUG
;
63 #define BUFFER_SIZE 0x10000
64 #define TX_AREA_START 0x00100
65 #define TX_AREA_END 0x05000
66 #define RX_AREA_START 0x05000
67 #define RX_AREA_END 0x0fc00
69 static int ether1_open(struct net_device
*dev
);
70 static int ether1_sendpacket(struct sk_buff
*skb
, struct net_device
*dev
);
71 static void ether1_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
);
72 static int ether1_close(struct net_device
*dev
);
73 static struct net_device_stats
*ether1_getstats(struct net_device
*dev
);
74 static void ether1_setmulticastlist(struct net_device
*dev
);
75 static void ether1_timeout(struct net_device
*dev
);
77 /* ------------------------------------------------------------------------- */
79 static char version
[] __initdata
= "ether1 ethernet driver (c) 2000 Russell King v1.07\n";
84 /* ------------------------------------------------------------------------- */
89 #define ether1_inw(dev, addr, type, offset, svflgs) ether1_inw_p (dev, addr + (int)(&((type *)0)->offset), svflgs)
90 #define ether1_outw(dev, val, addr, type, offset, svflgs) ether1_outw_p (dev, val, addr + (int)(&((type *)0)->offset), svflgs)
92 static inline unsigned short
93 ether1_inw_p (struct net_device
*dev
, int addr
, int svflgs
)
99 local_irq_save (flags
);
101 outb (addr
>> 12, REG_PAGE
);
102 ret
= inw (ETHER1_RAM
+ ((addr
& 4095) >> 1));
104 local_irq_restore (flags
);
109 ether1_outw_p (struct net_device
*dev
, unsigned short val
, int addr
, int svflgs
)
114 local_irq_save (flags
);
116 outb (addr
>> 12, REG_PAGE
);
117 outw (val
, ETHER1_RAM
+ ((addr
& 4095) >> 1));
119 local_irq_restore (flags
);
123 * Some inline assembler to allow fast transfers on to/off of the card.
124 * Since this driver depends on some features presented by the ARM
125 * specific architecture, and that you can't configure this driver
126 * without specifiing ARM mode, this is not a problem.
128 * This routine is essentially an optimised memcpy from the card's
129 * onboard RAM to kernel memory.
132 ether1_writebuffer (struct net_device
*dev
, void *data
, unsigned int start
, unsigned int length
)
134 unsigned int page
, thislen
, offset
, addr
;
136 offset
= start
& 4095;
138 addr
= ioaddr(ETHER1_RAM
+ (offset
>> 1));
140 if (offset
+ length
> 4096)
141 thislen
= 4096 - offset
;
148 outb(page
, REG_PAGE
);
151 __asm__
__volatile__(
156 orr %0, %0, %0, lsr #16
162 orr %0, %0, %0, lsr #16
168 orr %0, %0, %0, lsr #16
174 orr %0, %0, %0, lsr #16
181 : "=&r" (used
), "=&r" (data
)
182 : "r" (addr
), "r" (thislen
), "1" (data
));
184 addr
= ioaddr(ETHER1_RAM
);
194 ether1_readbuffer (struct net_device
*dev
, void *data
, unsigned int start
, unsigned int length
)
196 unsigned int page
, thislen
, offset
, addr
;
198 offset
= start
& 4095;
200 addr
= ioaddr(ETHER1_RAM
+ (offset
>> 1));
202 if (offset
+ length
> 4096)
203 thislen
= 4096 - offset
;
210 outb(page
, REG_PAGE
);
213 __asm__
__volatile__(
243 : "=&r" (used
), "=&r" (data
)
244 : "r" (addr
), "r" (thislen
), "1" (data
));
246 addr
= ioaddr(ETHER1_RAM
);
256 ether1_ramtest(struct net_device
*dev
, unsigned char byte
)
258 unsigned char *buffer
= kmalloc (BUFFER_SIZE
, GFP_KERNEL
);
259 int i
, ret
= BUFFER_SIZE
;
267 memset (buffer
, byte
, BUFFER_SIZE
);
268 ether1_writebuffer (dev
, buffer
, 0, BUFFER_SIZE
);
269 memset (buffer
, byte
^ 0xff, BUFFER_SIZE
);
270 ether1_readbuffer (dev
, buffer
, 0, BUFFER_SIZE
);
272 for (i
= 0; i
< BUFFER_SIZE
; i
++) {
273 if (buffer
[i
] != byte
) {
274 if (max_errors
>= 0 && bad
!= buffer
[i
]) {
277 printk (KERN_CRIT
"%s: RAM failed with (%02X instead of %02X) at 0x%04X",
278 dev
->name
, buffer
[i
], byte
, i
);
286 if (bad_start
== i
- 1)
289 printk (" - 0x%04X\n", i
- 1);
296 printk (" - 0x%04X\n", BUFFER_SIZE
);
303 ether1_reset (struct net_device
*dev
)
305 outb (CTRL_RST
|CTRL_ACK
, REG_CONTROL
);
310 ether1_init_2(struct net_device
*dev
)
315 i
= ether1_ramtest (dev
, 0x5a);
318 i
= ether1_ramtest (dev
, 0x1e);
328 * These are the structures that are loaded into the ether RAM card to
329 * initialise the 82586
333 #define NOP_ADDR (TX_AREA_START)
334 #define NOP_SIZE (0x06)
335 static nop_t init_nop
= {
342 #define TDR_ADDR (0x003a)
343 #define TDR_SIZE (0x08)
344 static tdr_t init_tdr
= {
352 #define MC_ADDR (0x002e)
353 #define MC_SIZE (0x0c)
354 static mc_t init_mc
= {
363 #define SA_ADDR (0x0022)
364 #define SA_SIZE (0x0c)
365 static sa_t init_sa
= {
373 #define CFG_ADDR (0x0010)
374 #define CFG_SIZE (0x12)
375 static cfg_t init_cfg
= {
382 CFG9_PREAMB8
| CFG9_ADDRLENBUF
| CFG9_ADDRLEN(6),
386 CFG13_RETRY(15) | CFG13_SLOTH(2),
391 #define SCB_ADDR (0x0000)
392 #define SCB_SIZE (0x10)
393 static scb_t init_scb
= {
395 SCB_CMDACKRNR
| SCB_CMDACKCNA
| SCB_CMDACKFR
| SCB_CMDACKCX
,
405 #define ISCP_ADDR (0xffee)
406 #define ISCP_SIZE (0x08)
407 static iscp_t init_iscp
= {
415 #define SCP_ADDR (0xfff6)
416 #define SCP_SIZE (0x0a)
417 static scp_t init_scp
= {
424 #define RFD_SIZE (0x16)
425 static rfd_t init_rfd
= {
435 #define RBD_SIZE (0x0a)
436 static rbd_t init_rbd
= {
444 #define TX_SIZE (0x08)
445 #define TBD_SIZE (0x08)
448 ether1_init_for_open (struct net_device
*dev
)
450 struct ether1_priv
*priv
= (struct ether1_priv
*)dev
->priv
;
451 int i
, status
, addr
, next
, next2
;
454 outb (CTRL_RST
|CTRL_ACK
, REG_CONTROL
);
456 for (i
= 0; i
< 6; i
++)
457 init_sa
.sa_addr
[i
] = dev
->dev_addr
[i
];
459 /* load data structures into ether1 RAM */
460 ether1_writebuffer (dev
, &init_scp
, SCP_ADDR
, SCP_SIZE
);
461 ether1_writebuffer (dev
, &init_iscp
, ISCP_ADDR
, ISCP_SIZE
);
462 ether1_writebuffer (dev
, &init_scb
, SCB_ADDR
, SCB_SIZE
);
463 ether1_writebuffer (dev
, &init_cfg
, CFG_ADDR
, CFG_SIZE
);
464 ether1_writebuffer (dev
, &init_sa
, SA_ADDR
, SA_SIZE
);
465 ether1_writebuffer (dev
, &init_mc
, MC_ADDR
, MC_SIZE
);
466 ether1_writebuffer (dev
, &init_tdr
, TDR_ADDR
, TDR_SIZE
);
467 ether1_writebuffer (dev
, &init_nop
, NOP_ADDR
, NOP_SIZE
);
469 if (ether1_inw (dev
, CFG_ADDR
, cfg_t
, cfg_command
, NORMALIRQS
) != CMD_CONFIG
) {
470 printk (KERN_ERR
"%s: detected either RAM fault or compiler bug\n",
476 * setup circularly linked list of { rfd, rbd, buffer }, with
477 * all rfds circularly linked, rbds circularly linked.
478 * First rfd is linked to scp, first rbd is linked to first
479 * rfd. Last rbd has a suspend command.
481 addr
= RX_AREA_START
;
483 next
= addr
+ RFD_SIZE
+ RBD_SIZE
+ ETH_FRAME_LEN
+ 10;
484 next2
= next
+ RFD_SIZE
+ RBD_SIZE
+ ETH_FRAME_LEN
+ 10;
486 if (next2
>= RX_AREA_END
) {
487 next
= RX_AREA_START
;
488 init_rfd
.rfd_command
= RFD_CMDEL
| RFD_CMDSUSPEND
;
489 priv
->rx_tail
= addr
;
491 init_rfd
.rfd_command
= 0;
492 if (addr
== RX_AREA_START
)
493 init_rfd
.rfd_rbdoffset
= addr
+ RFD_SIZE
;
495 init_rfd
.rfd_rbdoffset
= 0;
496 init_rfd
.rfd_link
= next
;
497 init_rbd
.rbd_link
= next
+ RFD_SIZE
;
498 init_rbd
.rbd_bufl
= addr
+ RFD_SIZE
+ RBD_SIZE
;
500 ether1_writebuffer (dev
, &init_rfd
, addr
, RFD_SIZE
);
501 ether1_writebuffer (dev
, &init_rbd
, addr
+ RFD_SIZE
, RBD_SIZE
);
503 } while (next2
< RX_AREA_END
);
505 priv
->tx_link
= NOP_ADDR
;
506 priv
->tx_head
= NOP_ADDR
+ NOP_SIZE
;
507 priv
->tx_tail
= TDR_ADDR
;
508 priv
->rx_head
= RX_AREA_START
;
510 /* release reset & give 586 a prod */
512 priv
->initialising
= 1;
513 outb (CTRL_RST
, REG_CONTROL
);
514 outb (0, REG_CONTROL
);
515 outb (CTRL_CA
, REG_CONTROL
);
517 /* 586 should now unset iscp.busy */
519 while (ether1_inw (dev
, ISCP_ADDR
, iscp_t
, iscp_busy
, DISABLEIRQS
) == 1) {
520 if (time_after(jiffies
, i
)) {
521 printk (KERN_WARNING
"%s: can't initialise 82586: iscp is busy\n", dev
->name
);
526 /* check status of commands that we issued */
528 while (((status
= ether1_inw (dev
, CFG_ADDR
, cfg_t
, cfg_status
, DISABLEIRQS
))
529 & STAT_COMPLETE
) == 0) {
530 if (time_after(jiffies
, i
))
534 if ((status
& (STAT_COMPLETE
| STAT_OK
)) != (STAT_COMPLETE
| STAT_OK
)) {
535 printk (KERN_WARNING
"%s: can't initialise 82586: config status %04X\n", dev
->name
, status
);
536 printk (KERN_DEBUG
"%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev
->name
,
537 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_status
, NORMALIRQS
),
538 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_command
, NORMALIRQS
),
539 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_cbl_offset
, NORMALIRQS
),
540 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_rfa_offset
, NORMALIRQS
));
545 while (((status
= ether1_inw (dev
, SA_ADDR
, sa_t
, sa_status
, DISABLEIRQS
))
546 & STAT_COMPLETE
) == 0) {
547 if (time_after(jiffies
, i
))
551 if ((status
& (STAT_COMPLETE
| STAT_OK
)) != (STAT_COMPLETE
| STAT_OK
)) {
552 printk (KERN_WARNING
"%s: can't initialise 82586: set address status %04X\n", dev
->name
, status
);
553 printk (KERN_DEBUG
"%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev
->name
,
554 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_status
, NORMALIRQS
),
555 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_command
, NORMALIRQS
),
556 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_cbl_offset
, NORMALIRQS
),
557 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_rfa_offset
, NORMALIRQS
));
562 while (((status
= ether1_inw (dev
, MC_ADDR
, mc_t
, mc_status
, DISABLEIRQS
))
563 & STAT_COMPLETE
) == 0) {
564 if (time_after(jiffies
, i
))
568 if ((status
& (STAT_COMPLETE
| STAT_OK
)) != (STAT_COMPLETE
| STAT_OK
)) {
569 printk (KERN_WARNING
"%s: can't initialise 82586: set multicast status %04X\n", dev
->name
, status
);
570 printk (KERN_DEBUG
"%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev
->name
,
571 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_status
, NORMALIRQS
),
572 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_command
, NORMALIRQS
),
573 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_cbl_offset
, NORMALIRQS
),
574 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_rfa_offset
, NORMALIRQS
));
579 while (((status
= ether1_inw (dev
, TDR_ADDR
, tdr_t
, tdr_status
, DISABLEIRQS
))
580 & STAT_COMPLETE
) == 0) {
581 if (time_after(jiffies
, i
))
585 if ((status
& (STAT_COMPLETE
| STAT_OK
)) != (STAT_COMPLETE
| STAT_OK
)) {
586 printk (KERN_WARNING
"%s: can't tdr (ignored)\n", dev
->name
);
587 printk (KERN_DEBUG
"%s: SCB=[STS=%04X CMD=%04X CBL=%04X RFA=%04X]\n", dev
->name
,
588 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_status
, NORMALIRQS
),
589 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_command
, NORMALIRQS
),
590 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_cbl_offset
, NORMALIRQS
),
591 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_rfa_offset
, NORMALIRQS
));
593 status
= ether1_inw (dev
, TDR_ADDR
, tdr_t
, tdr_result
, DISABLEIRQS
);
594 if (status
& TDR_XCVRPROB
)
595 printk (KERN_WARNING
"%s: i/f failed tdr: transceiver problem\n", dev
->name
);
596 else if ((status
& (TDR_SHORT
|TDR_OPEN
)) && (status
& TDR_TIME
)) {
598 printk (KERN_WARNING
"%s: i/f failed tdr: cable %s %d.%d us away\n", dev
->name
,
599 status
& TDR_SHORT
? "short" : "open", (status
& TDR_TIME
) / 10,
600 (status
& TDR_TIME
) % 10);
602 printk (KERN_WARNING
"%s: i/f failed tdr: cable %s %d clks away\n", dev
->name
,
603 status
& TDR_SHORT
? "short" : "open", (status
& TDR_TIME
));
610 return failures
? 1 : 0;
613 /* ------------------------------------------------------------------------- */
616 ether1_txalloc (struct net_device
*dev
, int size
)
618 struct ether1_priv
*priv
= (struct ether1_priv
*)dev
->priv
;
621 size
= (size
+ 1) & ~1;
622 tail
= priv
->tx_tail
;
624 if (priv
->tx_head
+ size
> TX_AREA_END
) {
625 if (tail
> priv
->tx_head
)
627 start
= TX_AREA_START
;
628 if (start
+ size
> tail
)
630 priv
->tx_head
= start
+ size
;
632 if (priv
->tx_head
< tail
&& (priv
->tx_head
+ size
) > tail
)
634 start
= priv
->tx_head
;
635 priv
->tx_head
+= size
;
642 ether1_open (struct net_device
*dev
)
644 struct ether1_priv
*priv
= (struct ether1_priv
*)dev
->priv
;
646 if (!is_valid_ether_addr(dev
->dev_addr
)) {
647 printk(KERN_WARNING
"%s: invalid ethernet MAC address\n",
652 if (request_irq(dev
->irq
, ether1_interrupt
, 0, "ether1", dev
))
655 memset (&priv
->stats
, 0, sizeof (struct net_device_stats
));
657 if (ether1_init_for_open (dev
)) {
658 free_irq (dev
->irq
, dev
);
662 netif_start_queue(dev
);
668 ether1_timeout(struct net_device
*dev
)
670 struct ether1_priv
*priv
= (struct ether1_priv
*)dev
->priv
;
672 printk(KERN_WARNING
"%s: transmit timeout, network cable problem?\n",
674 printk(KERN_WARNING
"%s: resetting device\n", dev
->name
);
678 if (ether1_init_for_open (dev
))
679 printk (KERN_ERR
"%s: unable to restart interface\n", dev
->name
);
681 priv
->stats
.tx_errors
++;
682 netif_wake_queue(dev
);
686 ether1_sendpacket (struct sk_buff
*skb
, struct net_device
*dev
)
688 struct ether1_priv
*priv
= (struct ether1_priv
*)dev
->priv
;
689 int len
= (ETH_ZLEN
< skb
->len
) ? skb
->len
: ETH_ZLEN
;
690 int tmp
, tst
, nopaddr
, txaddr
, tbdaddr
, dataddr
;
697 printk(KERN_WARNING
"%s: resetting device\n", dev
->name
);
701 if (ether1_init_for_open(dev
))
702 printk(KERN_ERR
"%s: unable to restart interface\n", dev
->name
);
708 * insert packet followed by a nop
710 txaddr
= ether1_txalloc (dev
, TX_SIZE
);
711 tbdaddr
= ether1_txalloc (dev
, TBD_SIZE
);
712 dataddr
= ether1_txalloc (dev
, len
);
713 nopaddr
= ether1_txalloc (dev
, NOP_SIZE
);
716 tx
.tx_command
= CMD_TX
| CMD_INTR
;
717 tx
.tx_link
= nopaddr
;
718 tx
.tx_tbdoffset
= tbdaddr
;
719 tbd
.tbd_opts
= TBD_EOL
| len
;
720 tbd
.tbd_link
= I82586_NULL
;
721 tbd
.tbd_bufl
= dataddr
;
724 nop
.nop_command
= CMD_NOP
;
725 nop
.nop_link
= nopaddr
;
727 local_irq_save(flags
);
728 ether1_writebuffer (dev
, &tx
, txaddr
, TX_SIZE
);
729 ether1_writebuffer (dev
, &tbd
, tbdaddr
, TBD_SIZE
);
730 ether1_writebuffer (dev
, skb
->data
, dataddr
, len
);
731 ether1_writebuffer (dev
, &nop
, nopaddr
, NOP_SIZE
);
733 priv
->tx_link
= nopaddr
;
735 /* now reset the previous nop pointer */
736 ether1_outw (dev
, txaddr
, tmp
, nop_t
, nop_link
, NORMALIRQS
);
738 local_irq_restore(flags
);
740 /* handle transmit */
741 dev
->trans_start
= jiffies
;
743 /* check to see if we have room for a full sized ether frame */
745 tst
= ether1_txalloc (dev
, TX_SIZE
+ TBD_SIZE
+ NOP_SIZE
+ ETH_FRAME_LEN
);
750 netif_stop_queue(dev
);
756 ether1_xmit_done (struct net_device
*dev
)
758 struct ether1_priv
*priv
= (struct ether1_priv
*)dev
->priv
;
762 caddr
= priv
->tx_tail
;
765 ether1_readbuffer (dev
, &nop
, caddr
, NOP_SIZE
);
767 switch (nop
.nop_command
& CMD_MASK
) {
770 if (ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_cbl_offset
, NORMALIRQS
)
771 != (unsigned short)I82586_NULL
) {
772 ether1_outw(dev
, SCB_CMDCUCSTART
| SCB_CMDRXSTART
, SCB_ADDR
, scb_t
,
773 scb_command
, NORMALIRQS
);
774 outb (CTRL_CA
, REG_CONTROL
);
776 priv
->tx_tail
= NOP_ADDR
;
780 if (nop
.nop_link
== caddr
) {
781 if (priv
->initialising
== 0)
782 printk (KERN_WARNING
"%s: strange command complete with no tx command!\n", dev
->name
);
784 priv
->initialising
= 0;
787 if (caddr
== nop
.nop_link
)
789 caddr
= nop
.nop_link
;
793 if (nop
.nop_status
& STAT_COMPLETE
)
795 printk (KERN_ERR
"%s: strange command complete without completed command\n", dev
->name
);
800 printk (KERN_WARNING
"%s: strange command %d complete! (offset %04X)", dev
->name
,
801 nop
.nop_command
& CMD_MASK
, caddr
);
806 while (nop
.nop_status
& STAT_COMPLETE
) {
807 if (nop
.nop_status
& STAT_OK
) {
808 priv
->stats
.tx_packets
++;
809 priv
->stats
.collisions
+= (nop
.nop_status
& STAT_COLLISIONS
);
811 priv
->stats
.tx_errors
++;
813 if (nop
.nop_status
& STAT_COLLAFTERTX
)
814 priv
->stats
.collisions
++;
815 if (nop
.nop_status
& STAT_NOCARRIER
)
816 priv
->stats
.tx_carrier_errors
++;
817 if (nop
.nop_status
& STAT_TXLOSTCTS
)
818 printk (KERN_WARNING
"%s: cts lost\n", dev
->name
);
819 if (nop
.nop_status
& STAT_TXSLOWDMA
)
820 priv
->stats
.tx_fifo_errors
++;
821 if (nop
.nop_status
& STAT_COLLEXCESSIVE
)
822 priv
->stats
.collisions
+= 16;
825 if (nop
.nop_link
== caddr
) {
826 printk (KERN_ERR
"%s: tx buffer chaining error: tx command points to itself\n", dev
->name
);
830 caddr
= nop
.nop_link
;
831 ether1_readbuffer (dev
, &nop
, caddr
, NOP_SIZE
);
832 if ((nop
.nop_command
& CMD_MASK
) != CMD_NOP
) {
833 printk (KERN_ERR
"%s: tx buffer chaining error: no nop after tx command\n", dev
->name
);
837 if (caddr
== nop
.nop_link
)
840 caddr
= nop
.nop_link
;
841 ether1_readbuffer (dev
, &nop
, caddr
, NOP_SIZE
);
842 if ((nop
.nop_command
& CMD_MASK
) != CMD_TX
) {
843 printk (KERN_ERR
"%s: tx buffer chaining error: no tx command after nop\n", dev
->name
);
847 priv
->tx_tail
= caddr
;
849 caddr
= priv
->tx_head
;
850 tst
= ether1_txalloc (dev
, TX_SIZE
+ TBD_SIZE
+ NOP_SIZE
+ ETH_FRAME_LEN
);
851 priv
->tx_head
= caddr
;
853 netif_wake_queue(dev
);
857 ether1_recv_done (struct net_device
*dev
)
859 struct ether1_priv
*priv
= (struct ether1_priv
*)dev
->priv
;
861 int nexttail
, rbdaddr
;
865 status
= ether1_inw (dev
, priv
->rx_head
, rfd_t
, rfd_status
, NORMALIRQS
);
866 if ((status
& RFD_COMPLETE
) == 0)
869 rbdaddr
= ether1_inw (dev
, priv
->rx_head
, rfd_t
, rfd_rbdoffset
, NORMALIRQS
);
870 ether1_readbuffer (dev
, &rbd
, rbdaddr
, RBD_SIZE
);
872 if ((rbd
.rbd_status
& (RBD_EOF
| RBD_ACNTVALID
)) == (RBD_EOF
| RBD_ACNTVALID
)) {
873 int length
= rbd
.rbd_status
& RBD_ACNT
;
876 length
= (length
+ 1) & ~1;
877 skb
= dev_alloc_skb (length
+ 2);
881 skb_reserve (skb
, 2);
883 ether1_readbuffer (dev
, skb_put (skb
, length
), rbd
.rbd_bufl
, length
);
885 skb
->protocol
= eth_type_trans (skb
, dev
);
887 priv
->stats
.rx_packets
++;
889 priv
->stats
.rx_dropped
++;
891 printk(KERN_WARNING
"%s: %s\n", dev
->name
,
892 (rbd
.rbd_status
& RBD_EOF
) ? "oversized packet" : "acnt not valid");
893 priv
->stats
.rx_dropped
++;
896 nexttail
= ether1_inw (dev
, priv
->rx_tail
, rfd_t
, rfd_link
, NORMALIRQS
);
897 /* nexttail should be rx_head */
898 if (nexttail
!= priv
->rx_head
)
899 printk(KERN_ERR
"%s: receiver buffer chaining error (%04X != %04X)\n",
900 dev
->name
, nexttail
, priv
->rx_head
);
901 ether1_outw (dev
, RFD_CMDEL
| RFD_CMDSUSPEND
, nexttail
, rfd_t
, rfd_command
, NORMALIRQS
);
902 ether1_outw (dev
, 0, priv
->rx_tail
, rfd_t
, rfd_command
, NORMALIRQS
);
903 ether1_outw (dev
, 0, priv
->rx_tail
, rfd_t
, rfd_status
, NORMALIRQS
);
904 ether1_outw (dev
, 0, priv
->rx_tail
, rfd_t
, rfd_rbdoffset
, NORMALIRQS
);
906 priv
->rx_tail
= nexttail
;
907 priv
->rx_head
= ether1_inw (dev
, priv
->rx_head
, rfd_t
, rfd_link
, NORMALIRQS
);
912 ether1_interrupt (int irq
, void *dev_id
, struct pt_regs
*regs
)
914 struct net_device
*dev
= (struct net_device
*)dev_id
;
915 struct ether1_priv
*priv
= (struct ether1_priv
*)dev
->priv
;
918 status
= ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_status
, NORMALIRQS
);
921 ether1_outw(dev
, status
& (SCB_STRNR
| SCB_STCNA
| SCB_STFR
| SCB_STCX
),
922 SCB_ADDR
, scb_t
, scb_command
, NORMALIRQS
);
923 outb (CTRL_CA
| CTRL_ACK
, REG_CONTROL
);
924 if (status
& SCB_STCX
) {
925 ether1_xmit_done (dev
);
927 if (status
& SCB_STCNA
) {
928 if (priv
->resetting
== 0)
929 printk (KERN_WARNING
"%s: CU went not ready ???\n", dev
->name
);
931 priv
->resetting
+= 1;
932 if (ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_cbl_offset
, NORMALIRQS
)
933 != (unsigned short)I82586_NULL
) {
934 ether1_outw (dev
, SCB_CMDCUCSTART
, SCB_ADDR
, scb_t
, scb_command
, NORMALIRQS
);
935 outb (CTRL_CA
, REG_CONTROL
);
937 if (priv
->resetting
== 2)
940 if (status
& SCB_STFR
) {
941 ether1_recv_done (dev
);
943 if (status
& SCB_STRNR
) {
944 if (ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_status
, NORMALIRQS
) & SCB_STRXSUSP
) {
945 printk (KERN_WARNING
"%s: RU went not ready: RU suspended\n", dev
->name
);
946 ether1_outw (dev
, SCB_CMDRXRESUME
, SCB_ADDR
, scb_t
, scb_command
, NORMALIRQS
);
947 outb (CTRL_CA
, REG_CONTROL
);
948 priv
->stats
.rx_dropped
++; /* we suspended due to lack of buffer space */
950 printk(KERN_WARNING
"%s: RU went not ready: %04X\n", dev
->name
,
951 ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_status
, NORMALIRQS
));
952 printk (KERN_WARNING
"RU ptr = %04X\n", ether1_inw (dev
, SCB_ADDR
, scb_t
, scb_rfa_offset
,
956 outb (CTRL_ACK
, REG_CONTROL
);
960 ether1_close (struct net_device
*dev
)
964 free_irq(dev
->irq
, dev
);
969 static struct net_device_stats
*
970 ether1_getstats (struct net_device
*dev
)
972 struct ether1_priv
*priv
= (struct ether1_priv
*)dev
->priv
;
977 ether1_set_mac_address(struct net_device
*dev
, void *p
)
979 struct sockaddr
*addr
= p
;
981 if (netif_running(dev
))
984 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
987 * We'll set the MAC address on the chip when we open it.
994 * Set or clear the multicast filter for this adaptor.
995 * num_addrs == -1 Promiscuous mode, receive all packets.
996 * num_addrs == 0 Normal mode, clear multicast list.
997 * num_addrs > 0 Multicast mode, receive normal and MC packets, and do
998 * best-effort filtering.
1001 ether1_setmulticastlist (struct net_device
*dev
)
1005 /* ------------------------------------------------------------------------- */
1007 static void __init
ether1_banner(void)
1009 static unsigned int version_printed
= 0;
1011 if (net_debug
&& version_printed
++ == 0)
1012 printk(KERN_INFO
"%s", version
);
1015 static int __devinit
1016 ether1_probe(struct expansion_card
*ec
, const struct ecard_id
*id
)
1018 struct net_device
*dev
;
1019 struct ether1_priv
*priv
;
1024 dev
= init_etherdev(NULL
, sizeof(struct ether1_priv
));
1030 SET_MODULE_OWNER(dev
);
1032 dev
->base_addr
= ecard_address(ec
, ECARD_IOC
, ECARD_FAST
);
1036 * these will not fail - the nature of the bus ensures this
1038 request_region(dev
->base_addr
, 16, dev
->name
);
1039 request_region(dev
->base_addr
+ 0x800, 4096, dev
->name
);
1041 priv
= (struct ether1_priv
*)dev
->priv
;
1042 if ((priv
->bus_type
= ether1_reset(dev
)) == 0) {
1047 printk(KERN_INFO
"%s: ether1 in slot %d, ",
1048 dev
->name
, ec
->slot_no
);
1050 for (i
= 0; i
< 6; i
++) {
1051 dev
->dev_addr
[i
] = inb(IDPROM_ADDRESS
+ i
);
1052 printk ("%2.2x%c", dev
->dev_addr
[i
], i
== 5 ? '\n' : ':');
1055 if (ether1_init_2(dev
)) {
1060 dev
->open
= ether1_open
;
1061 dev
->stop
= ether1_close
;
1062 dev
->hard_start_xmit
= ether1_sendpacket
;
1063 dev
->get_stats
= ether1_getstats
;
1064 dev
->set_multicast_list
= ether1_setmulticastlist
;
1065 dev
->set_mac_address
= ether1_set_mac_address
;
1066 dev
->tx_timeout
= ether1_timeout
;
1067 dev
->watchdog_timeo
= 5 * HZ
/ 100;
1069 ecard_set_drvdata(ec
, dev
);
1073 release_region(dev
->base_addr
, 16);
1074 release_region(dev
->base_addr
+ 0x800, 4096);
1075 unregister_netdev(dev
);
1081 static void __devexit
ether1_remove(struct expansion_card
*ec
)
1083 struct net_device
*dev
= ecard_get_drvdata(ec
);
1085 ecard_set_drvdata(ec
, NULL
);
1087 unregister_netdev(dev
);
1089 release_region(dev
->base_addr
, 16);
1090 release_region(dev
->base_addr
+ 0x800, 4096);
1094 static const struct ecard_id ether1_ids
[] = {
1095 { MANU_ACORN
, PROD_ACORN_ETHER1
},
1099 static struct ecard_driver ether1_driver
= {
1100 .probe
= ether1_probe
,
1101 .remove
= __devexit_p(ether1_remove
),
1102 .id_table
= ether1_ids
,
1108 static int __init
ether1_init(void)
1110 return ecard_register_driver(ðer1_driver
);
1113 static void __exit
ether1_exit(void)
1115 ecard_remove_driver(ðer1_driver
);
1118 module_init(ether1_init
);
1119 module_exit(ether1_exit
);
1121 MODULE_LICENSE("GPL");