1 /* $Id: sunlance.c,v 1.88 1999/08/20 00:31:45 davem Exp $
2 * lance.c: Linux/Sparc/Lance driver
4 * Written 1995, 1996 by Miguel de Icaza
6 * The Linux depca driver
7 * The Linux lance driver.
8 * The Linux skeleton driver.
9 * The NetBSD Sparc/Lance driver.
10 * Theo de Raadt (deraadt@openbsd.org)
11 * NCR92C990 Lan Controller manual
14 * Added support to run with a ledma on the Sun4m
17 * Added multiple card detection.
19 * 4/17/96: Burst sizes and tpe selection on sun4m by Eddie C. Dost
22 * 5/15/96: auto carrier detection on sun4m by Eddie C. Dost
25 * 5/17/96: lebuffer on scsi/ether cards now work David S. Miller
26 * (davem@caip.rutgers.edu)
28 * 5/29/96: override option 'tpe-link-test?', if it is 'false', as
29 * this disables auto carrier detection on sun4m. Eddie C. Dost
33 * 6/26/96: Bug fix for multiple ledmas, miguel.
36 * Stole multicast code from depca.c, fixed lance_tx.
39 * 8/21/96: Fixed the multicast code (Pedro Roque)
41 * 8/28/96: Send fake packet in lance_open() if auto_select is true,
42 * so we can detect the carrier loss condition in time.
43 * Eddie C. Dost (ecd@skynet.be)
45 * 9/15/96: Align rx_buf so that eth_copy_and_sum() won't cause an
46 * MNA trap during chksum_partial_copy(). (ecd@skynet.be)
48 * 11/17/96: Handle LE_C0_MERR in lance_interrupt(). (ecd@skynet.be)
50 * 12/22/96: Don't loop forever in lance_rx() on incomplete packets.
51 * This was the sun4c killer. Shit, stupid bug.
55 * 1/26/97: Modularize driver. (ecd@skynet.be)
58 * 12/27/97: Added sun4d support. (jj@sunsite.mff.cuni.cz)
61 * 11/3/99: Fixed SMP race in lance_start_xmit found by davem.
62 * Anton Blanchard (anton@progsoc.uts.edu.au)
67 static char *version
=
68 "sunlance.c:v1.12 11/Mar/99 Miguel de Icaza (miguel@nuclecu.unam.mx)\n";
70 static char *lancestr
= "LANCE";
71 static char *lancedma
= "LANCE DMA";
73 #include <linux/config.h>
74 #include <linux/module.h>
76 #include <linux/kernel.h>
77 #include <linux/sched.h>
78 #include <linux/types.h>
79 #include <linux/fcntl.h>
80 #include <linux/interrupt.h>
81 #include <linux/ptrace.h>
82 #include <linux/ioport.h>
84 #include <linux/malloc.h>
85 #include <linux/string.h>
86 #include <linux/delay.h>
87 #include <linux/init.h>
88 #include <asm/system.h>
89 #include <asm/bitops.h>
92 #include <asm/pgtable.h>
93 #include <linux/errno.h>
94 #include <asm/byteorder.h> /* Used by the checksum routines */
96 /* Used for the temporal inet entries and routing */
97 #include <linux/socket.h>
98 #include <linux/route.h>
100 #include <asm/idprom.h>
101 #include <asm/sbus.h>
102 #include <asm/openprom.h>
103 #include <asm/oplib.h>
104 #include <asm/auxio.h> /* For tpe-link-test? setting */
107 #include <linux/netdevice.h>
108 #include <linux/etherdevice.h>
109 #include <linux/skbuff.h>
111 #include <asm/machines.h>
113 /* Define: 2^4 Tx buffers and 2^4 Rx buffers */
114 #ifndef LANCE_LOG_TX_BUFFERS
115 #define LANCE_LOG_TX_BUFFERS 4
116 #define LANCE_LOG_RX_BUFFERS 4
119 #define CRC_POLYNOMIAL_BE 0x04c11db7UL /* Ethernet CRC, big endian */
120 #define CRC_POLYNOMIAL_LE 0xedb88320UL /* Ethernet CRC, little endian */
127 #define LE_MO_PROM 0x8000 /* Enable promiscuous mode */
129 #define LE_C0_ERR 0x8000 /* Error: set if BAB, SQE, MISS or ME is set */
130 #define LE_C0_BABL 0x4000 /* BAB: Babble: tx timeout. */
131 #define LE_C0_CERR 0x2000 /* SQE: Signal quality error */
132 #define LE_C0_MISS 0x1000 /* MISS: Missed a packet */
133 #define LE_C0_MERR 0x0800 /* ME: Memory error */
134 #define LE_C0_RINT 0x0400 /* Received interrupt */
135 #define LE_C0_TINT 0x0200 /* Transmitter Interrupt */
136 #define LE_C0_IDON 0x0100 /* IFIN: Init finished. */
137 #define LE_C0_INTR 0x0080 /* Interrupt or error */
138 #define LE_C0_INEA 0x0040 /* Interrupt enable */
139 #define LE_C0_RXON 0x0020 /* Receiver on */
140 #define LE_C0_TXON 0x0010 /* Transmitter on */
141 #define LE_C0_TDMD 0x0008 /* Transmitter demand */
142 #define LE_C0_STOP 0x0004 /* Stop the card */
143 #define LE_C0_STRT 0x0002 /* Start the card */
144 #define LE_C0_INIT 0x0001 /* Init the card */
146 #define LE_C3_BSWP 0x4 /* SWAP */
147 #define LE_C3_ACON 0x2 /* ALE Control */
148 #define LE_C3_BCON 0x1 /* Byte control */
150 /* Receive message descriptor 1 */
151 #define LE_R1_OWN 0x80 /* Who owns the entry */
152 #define LE_R1_ERR 0x40 /* Error: if FRA, OFL, CRC or BUF is set */
153 #define LE_R1_FRA 0x20 /* FRA: Frame error */
154 #define LE_R1_OFL 0x10 /* OFL: Frame overflow */
155 #define LE_R1_CRC 0x08 /* CRC error */
156 #define LE_R1_BUF 0x04 /* BUF: Buffer error */
157 #define LE_R1_SOP 0x02 /* Start of packet */
158 #define LE_R1_EOP 0x01 /* End of packet */
159 #define LE_R1_POK 0x03 /* Packet is complete: SOP + EOP */
161 #define LE_T1_OWN 0x80 /* Lance owns the packet */
162 #define LE_T1_ERR 0x40 /* Error summary */
163 #define LE_T1_EMORE 0x10 /* Error: more than one retry needed */
164 #define LE_T1_EONE 0x08 /* Error: one retry needed */
165 #define LE_T1_EDEF 0x04 /* Error: deferred */
166 #define LE_T1_SOP 0x02 /* Start of packet */
167 #define LE_T1_EOP 0x01 /* End of packet */
168 #define LE_T1_POK 0x03 /* Packet is complete: SOP + EOP */
170 #define LE_T3_BUF 0x8000 /* Buffer error */
171 #define LE_T3_UFL 0x4000 /* Error underflow */
172 #define LE_T3_LCOL 0x1000 /* Error late collision */
173 #define LE_T3_CLOS 0x0800 /* Error carrier loss */
174 #define LE_T3_RTY 0x0400 /* Error retry */
175 #define LE_T3_TDR 0x03ff /* Time Domain Reflectometry counter */
177 #define TX_RING_SIZE (1 << (LANCE_LOG_TX_BUFFERS))
178 #define TX_RING_MOD_MASK (TX_RING_SIZE - 1)
179 #define TX_RING_LEN_BITS ((LANCE_LOG_TX_BUFFERS) << 29)
181 #define RX_RING_SIZE (1 << (LANCE_LOG_RX_BUFFERS))
182 #define RX_RING_MOD_MASK (RX_RING_SIZE - 1)
183 #define RX_RING_LEN_BITS ((LANCE_LOG_RX_BUFFERS) << 29)
185 #define PKT_BUF_SZ 1544
186 #define RX_BUFF_SIZE PKT_BUF_SZ
187 #define TX_BUFF_SIZE PKT_BUF_SZ
189 struct lance_rx_desc
{
190 unsigned short rmd0
; /* low address of packet */
191 unsigned char rmd1_bits
; /* descriptor bits */
192 unsigned char rmd1_hadr
; /* high address of packet */
193 short length
; /* This length is 2s complement (negative)!
196 unsigned short mblength
; /* This is the actual number of bytes received */
199 struct lance_tx_desc
{
200 unsigned short tmd0
; /* low address of packet */
201 unsigned char tmd1_bits
; /* descriptor bits */
202 unsigned char tmd1_hadr
; /* high address of packet */
203 short length
; /* Length is 2s complement (negative)! */
207 /* The LANCE initialization block, described in databook. */
208 /* On the Sparc, this block should be on a DMA region */
209 struct lance_init_block
{
210 unsigned short mode
; /* Pre-set mode (reg. 15) */
211 unsigned char phys_addr
[6]; /* Physical ethernet address */
212 unsigned filter
[2]; /* Multicast filter. */
214 /* Receive and transmit ring base, along with extra bits. */
215 unsigned short rx_ptr
; /* receive descriptor addr */
216 unsigned short rx_len
; /* receive len and high addr */
217 unsigned short tx_ptr
; /* transmit descriptor addr */
218 unsigned short tx_len
; /* transmit len and high addr */
220 /* The Tx and Rx ring entries must aligned on 8-byte boundaries. */
221 struct lance_rx_desc brx_ring
[RX_RING_SIZE
];
222 struct lance_tx_desc btx_ring
[TX_RING_SIZE
];
224 char tx_buf
[TX_RING_SIZE
][TX_BUFF_SIZE
];
225 char pad
[2]; /* align rx_buf for copy_and_sum(). */
226 char rx_buf
[RX_RING_SIZE
][RX_BUFF_SIZE
];
229 #define libdesc_offset(rt, elem) \
230 ((__u32)(((unsigned long)(&(((struct lance_init_block *)0)->rt[elem])))))
232 #define libbuff_offset(rt, elem) \
233 ((__u32)(((unsigned long)(&(((struct lance_init_block *)0)->rt[elem][0])))))
235 struct lance_private
{
237 volatile struct lance_regs
*ll
;
238 volatile struct lance_init_block
*init_block
;
239 __u32 init_block_dvma
;
244 struct net_device_stats stats
;
245 struct Linux_SBus_DMA
*ledma
; /* If set this points to ledma */
246 /* and arch = sun4m */
248 int tpe
; /* cable-selection is TPE */
249 int auto_select
; /* cable-selection by carrier */
250 int burst_sizes
; /* ledma SBus burst sizes */
252 unsigned short busmaster_regval
;
253 unsigned short pio_buffer
;
255 struct net_device
*dev
; /* Backpointer */
256 struct lance_private
*next_module
;
257 struct linux_sbus
*sbus
;
258 struct timer_list multicast_timer
;
261 #define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
262 lp->tx_old+TX_RING_MOD_MASK-lp->tx_new:\
263 lp->tx_old - lp->tx_new-1)
265 /* On the sparc, the lance control ports are memory mapped */
267 unsigned short rdp
; /* register data port */
268 unsigned short rap
; /* register address port */
271 int sparc_lance_debug
= 2;
273 /* The Lance uses 24 bit addresses */
274 /* On the Sun4c the DVMA will provide the remaining bytes for us */
275 /* On the Sun4m we have to instruct the ledma to provide them */
276 /* Even worse, on scsi/ether SBUS cards, the init block and the
277 * transmit/receive buffers are addresses as offsets from absolute
278 * zero on the lebuffer PIO area. -davem
281 #define LANCE_ADDR(x) ((long)(x) & ~0xff000000)
284 static struct lance_private
*root_lance_dev
= NULL
;
287 /* Load the CSR registers */
288 static void load_csrs (struct lance_private
*lp
)
290 volatile struct lance_regs
*ll
= lp
->ll
;
291 __u32 ib_dvma
= lp
->init_block_dvma
;
294 /* This is right now because when we are using a PIO buffered
295 * init block, init_block_dvma is set to zero. -DaveM
297 leptr
= LANCE_ADDR (ib_dvma
);
300 ll
->rdp
= (leptr
& 0xFFFF);
302 ll
->rdp
= leptr
>> 16;
304 ll
->rdp
= lp
->busmaster_regval
;
306 /* Point back to csr0 */
312 /* Setup the Lance Rx and Tx rings */
313 /* Sets dev->tbusy */
314 static void lance_init_ring (struct net_device
*dev
)
316 struct lance_private
*lp
= (struct lance_private
*) dev
->priv
;
317 volatile struct lance_init_block
*ib
= lp
->init_block
;
318 __u32 ib_dvma
= lp
->init_block_dvma
;
319 __u32 aib
; /* for LANCE_ADDR computations */
323 /* This is right now because when we are using a PIO buffered
324 * init block, init_block_dvma is set to zero. -DaveM
328 /* Lock out other processes while setting up hardware */
330 lp
->rx_new
= lp
->tx_new
= 0;
331 lp
->rx_old
= lp
->tx_old
= 0;
333 /* Copy the ethernet address to the lance init block
334 * Note that on the sparc you need to swap the ethernet address.
335 * Note also we want the CPU ptr of the init_block here.
337 ib
->phys_addr
[0] = dev
->dev_addr
[1];
338 ib
->phys_addr
[1] = dev
->dev_addr
[0];
339 ib
->phys_addr
[2] = dev
->dev_addr
[3];
340 ib
->phys_addr
[3] = dev
->dev_addr
[2];
341 ib
->phys_addr
[4] = dev
->dev_addr
[5];
342 ib
->phys_addr
[5] = dev
->dev_addr
[4];
345 printk ("TX rings:\n");
347 /* Setup the Tx ring entries */
348 for (i
= 0; i
<= TX_RING_SIZE
; i
++) {
349 leptr
= LANCE_ADDR(aib
+ libbuff_offset(tx_buf
, i
));
350 ib
->btx_ring
[i
].tmd0
= leptr
;
351 ib
->btx_ring
[i
].tmd1_hadr
= leptr
>> 16;
352 ib
->btx_ring
[i
].tmd1_bits
= 0;
353 ib
->btx_ring
[i
].length
= 0xf000; /* The ones required by tmd2 */
354 ib
->btx_ring
[i
].misc
= 0;
356 if (ZERO
) printk ("%d: 0x%8.8x\n", i
, leptr
);
359 /* Setup the Rx ring entries */
361 printk ("RX rings:\n");
362 for (i
= 0; i
< RX_RING_SIZE
; i
++) {
363 leptr
= LANCE_ADDR(aib
+ libbuff_offset(rx_buf
, i
));
365 ib
->brx_ring
[i
].rmd0
= leptr
;
366 ib
->brx_ring
[i
].rmd1_hadr
= leptr
>> 16;
367 ib
->brx_ring
[i
].rmd1_bits
= LE_R1_OWN
;
368 ib
->brx_ring
[i
].length
= -RX_BUFF_SIZE
| 0xf000;
369 ib
->brx_ring
[i
].mblength
= 0;
371 printk ("%d: 0x%8.8x\n", i
, leptr
);
374 /* Setup the initialization block */
376 /* Setup rx descriptor pointer */
377 leptr
= LANCE_ADDR(aib
+ libdesc_offset(brx_ring
, 0));
378 ib
->rx_len
= (LANCE_LOG_RX_BUFFERS
<< 13) | (leptr
>> 16);
381 printk ("RX ptr: %8.8x\n", leptr
);
383 /* Setup tx descriptor pointer */
384 leptr
= LANCE_ADDR(aib
+ libdesc_offset(btx_ring
, 0));
385 ib
->tx_len
= (LANCE_LOG_TX_BUFFERS
<< 13) | (leptr
>> 16);
388 printk ("TX ptr: %8.8x\n", leptr
);
391 static int init_restart_lance (struct lance_private
*lp
)
393 volatile struct lance_regs
*ll
= lp
->ll
;
397 struct sparc_dma_registers
*dregs
= lp
->ledma
->regs
;
400 if (!(dregs
->cond_reg
& DMA_HNDL_ERROR
)) {
401 /* E-Cache draining */
402 while (dregs
->cond_reg
& DMA_FIFO_ISDRAIN
)
406 creg
= dregs
->cond_reg
;
407 if (lp
->burst_sizes
& DMA_BURST32
)
408 creg
|= DMA_E_BURST8
;
410 creg
&= ~DMA_E_BURST8
;
412 creg
|= (DMA_DSBL_RD_DRN
| DMA_DSBL_WR_INV
| DMA_FIFO_INV
);
415 creg
|= DMA_EN_ENETAUI
;
417 creg
&= ~DMA_EN_ENETAUI
;
419 dregs
->cond_reg
= creg
;
424 ll
->rdp
= LE_C0_INIT
;
426 /* Wait for the lance to complete initialization */
427 for (i
= 0; (i
< 100) && !(ll
->rdp
& (LE_C0_ERR
| LE_C0_IDON
)); i
++)
429 if ((i
== 100) || (ll
->rdp
& LE_C0_ERR
)) {
430 printk ("LANCE unopened after %d ticks, csr0=%4.4x.\n", i
, ll
->rdp
);
432 printk ("dcsr=%8.8x\n",
433 (unsigned int) lp
->ledma
->regs
->cond_reg
);
437 /* Clear IDON by writing a "1", enable interrupts and start lance */
438 ll
->rdp
= LE_C0_IDON
;
439 ll
->rdp
= LE_C0_INEA
| LE_C0_STRT
;
442 lp
->ledma
->regs
->cond_reg
|= DMA_INT_ENAB
;
447 static int lance_rx (struct net_device
*dev
)
449 struct lance_private
*lp
= (struct lance_private
*) dev
->priv
;
450 volatile struct lance_init_block
*ib
= lp
->init_block
;
451 volatile struct lance_rx_desc
*rd
;
458 for (i
= 0; i
< RX_RING_SIZE
; i
++) {
461 ib
->brx_ring
[i
].rmd1_bits
& LE_R1_OWN
? "_" : "X");
464 ib
->brx_ring
[i
].rmd1_bits
& LE_R1_OWN
? "." : "1");
469 for (rd
= &ib
->brx_ring
[lp
->rx_new
];
470 !((bits
= rd
->rmd1_bits
) & LE_R1_OWN
);
471 rd
= &ib
->brx_ring
[lp
->rx_new
]) {
473 /* We got an incomplete frame? */
474 if ((bits
& LE_R1_POK
) != LE_R1_POK
) {
475 lp
->stats
.rx_over_errors
++;
476 lp
->stats
.rx_errors
++;
477 } else if (bits
& LE_R1_ERR
) {
478 /* Count only the end frame as a rx error,
481 if (bits
& LE_R1_BUF
) lp
->stats
.rx_fifo_errors
++;
482 if (bits
& LE_R1_CRC
) lp
->stats
.rx_crc_errors
++;
483 if (bits
& LE_R1_OFL
) lp
->stats
.rx_over_errors
++;
484 if (bits
& LE_R1_FRA
) lp
->stats
.rx_frame_errors
++;
485 if (bits
& LE_R1_EOP
) lp
->stats
.rx_errors
++;
487 len
= (rd
->mblength
& 0xfff) - 4;
488 skb
= dev_alloc_skb (len
+2);
491 printk ("%s: Memory squeeze, deferring packet.\n",
493 lp
->stats
.rx_dropped
++;
495 rd
->rmd1_bits
= LE_R1_OWN
;
496 lp
->rx_new
= (lp
->rx_new
+ 1) & RX_RING_MOD_MASK
;
500 lp
->stats
.rx_bytes
+= len
;
503 skb_reserve (skb
, 2); /* 16 byte align */
504 skb_put (skb
, len
); /* make room */
505 eth_copy_and_sum(skb
,
506 (unsigned char *)&(ib
->rx_buf
[lp
->rx_new
][0]),
508 skb
->protocol
= eth_type_trans (skb
, dev
);
510 lp
->stats
.rx_packets
++;
513 /* Return the packet to the pool */
515 rd
->rmd1_bits
= LE_R1_OWN
;
516 lp
->rx_new
= (lp
->rx_new
+ 1) & RX_RING_MOD_MASK
;
521 static int lance_tx (struct net_device
*dev
)
523 struct lance_private
*lp
= (struct lance_private
*) dev
->priv
;
524 volatile struct lance_init_block
*ib
= lp
->init_block
;
525 volatile struct lance_regs
*ll
= lp
->ll
;
526 volatile struct lance_tx_desc
*td
;
531 for (i
= j
; i
!= lp
->tx_new
; i
= j
) {
532 td
= &ib
->btx_ring
[i
];
534 /* If we hit a packet not owned by us, stop */
535 if (td
->tmd1_bits
& LE_T1_OWN
)
538 if (td
->tmd1_bits
& LE_T1_ERR
) {
541 lp
->stats
.tx_errors
++;
542 if (status
& LE_T3_RTY
) lp
->stats
.tx_aborted_errors
++;
543 if (status
& LE_T3_LCOL
) lp
->stats
.tx_window_errors
++;
545 if (status
& LE_T3_CLOS
) {
546 lp
->stats
.tx_carrier_errors
++;
547 if (lp
->auto_select
) {
548 lp
->tpe
= 1 - lp
->tpe
;
549 printk("%s: Carrier Lost, trying %s\n",
550 dev
->name
, lp
->tpe
?"TPE":"AUI");
553 ll
->rdp
= LE_C0_STOP
;
554 lance_init_ring (dev
);
556 init_restart_lance (lp
);
561 /* Buffer errors and underflows turn off the
562 * transmitter, restart the adapter.
564 if (status
& (LE_T3_BUF
|LE_T3_UFL
)) {
565 lp
->stats
.tx_fifo_errors
++;
567 printk ("%s: Tx: ERR_BUF|ERR_UFL, restarting\n",
571 ll
->rdp
= LE_C0_STOP
;
572 lance_init_ring (dev
);
574 init_restart_lance (lp
);
577 } else if ((td
->tmd1_bits
& LE_T1_POK
) == LE_T1_POK
) {
579 * So we don't count the packet more than once.
581 td
->tmd1_bits
&= ~(LE_T1_POK
);
583 /* One collision before packet was sent. */
584 if (td
->tmd1_bits
& LE_T1_EONE
)
585 lp
->stats
.collisions
++;
587 /* More than one collision, be optimistic. */
588 if (td
->tmd1_bits
& LE_T1_EMORE
)
589 lp
->stats
.collisions
+= 2;
591 lp
->stats
.tx_packets
++;
594 j
= (j
+ 1) & TX_RING_MOD_MASK
;
600 static void lance_interrupt (int irq
, void *dev_id
, struct pt_regs
*regs
)
602 struct net_device
*dev
= (struct net_device
*)dev_id
;
603 struct lance_private
*lp
= (struct lance_private
*)dev
->priv
;
604 volatile struct lance_regs
*ll
= lp
->ll
;
608 printk ("%s: again", dev
->name
);
615 /* Acknowledge all the interrupt sources ASAP */
616 ll
->rdp
= csr0
& (LE_C0_INTR
| LE_C0_TINT
| LE_C0_RINT
);
618 if ((csr0
& LE_C0_ERR
)) {
619 /* Clear the error condition */
620 ll
->rdp
= LE_C0_BABL
| LE_C0_ERR
| LE_C0_MISS
|
621 LE_C0_CERR
| LE_C0_MERR
;
624 if (csr0
& LE_C0_RINT
)
627 if (csr0
& LE_C0_TINT
)
630 if ((TX_BUFFS_AVAIL
>= 0) && dev
->tbusy
) {
635 if (csr0
& LE_C0_BABL
)
636 lp
->stats
.tx_errors
++;
638 if (csr0
& LE_C0_MISS
)
639 lp
->stats
.rx_errors
++;
641 if (csr0
& LE_C0_MERR
) {
642 struct sparc_dma_registers
*dregs
= lp
->ledma
->regs
;
643 unsigned long tst
= (unsigned long)dregs
->st_addr
;
645 printk ("%s: Memory error, status %04x, addr %06lx\n",
646 dev
->name
, csr0
, tst
& 0xffffff);
648 ll
->rdp
= LE_C0_STOP
;
651 lp
->ledma
->regs
->cond_reg
|= DMA_FIFO_INV
;
653 lance_init_ring (dev
);
655 init_restart_lance (lp
);
659 ll
->rdp
= LE_C0_INEA
;
663 struct net_device
*last_dev
= 0;
665 static int lance_open (struct net_device
*dev
)
667 struct lance_private
*lp
= (struct lance_private
*)dev
->priv
;
668 volatile struct lance_regs
*ll
= lp
->ll
;
669 volatile struct lance_init_block
*ib
= lp
->init_block
;
674 if (request_irq (dev
->irq
, &lance_interrupt
, SA_SHIRQ
,
675 lancestr
, (void *) dev
)) {
676 printk ("Lance: Can't get irq %s\n", __irq_itoa(dev
->irq
));
682 ll
->rdp
= LE_C0_STOP
;
684 /* On the 4m, setup the ledma to provide the upper bits for buffers */
686 lp
->ledma
->regs
->dma_test
= ((__u32
) lp
->init_block_dvma
) & 0xff000000;
688 /* Set mode and clear multicast filter only at device open,
689 so that lance_init_ring() called at any error will not
690 forget multicast filters.
692 BTW it is common bug in all lance drivers! --ANK
698 lance_init_ring (dev
);
705 status
= init_restart_lance (lp
);
707 /* To emulate SunOS, we add a route to the local network */
709 dev
->pa_addr
& ip_get_mask (dev
->pa_addr
),
710 ip_get_mask (dev
->pa_addr
),
711 0, dev
, dev
->mtu
, 0, 0);
713 if (!status
&& lp
->auto_select
) {
715 * Build a fake network packet and send it to ourselfs.
717 volatile struct lance_init_block
*ib
= lp
->init_block
;
718 volatile unsigned long flush
;
719 unsigned char packet
[ETH_ZLEN
];
720 struct ethhdr
*eth
= (struct ethhdr
*)packet
;
723 memset(packet
, 0, ETH_ZLEN
);
724 for (i
= 0; i
< 6; i
++) {
725 eth
->h_dest
[i
] = dev
->dev_addr
[i
];
726 eth
->h_source
[i
] = dev
->dev_addr
[i
];
729 entry
= lp
->tx_new
& TX_RING_MOD_MASK
;
730 ib
->btx_ring
[entry
].length
= (-ETH_ZLEN
) | 0xf000;
731 ib
->btx_ring
[entry
].misc
= 0;
733 memcpy((char *)&ib
->tx_buf
[entry
][0], packet
, ETH_ZLEN
);
734 ib
->btx_ring
[entry
].tmd1_bits
= (LE_T1_POK
|LE_T1_OWN
);
735 lp
->tx_new
= (lp
->tx_new
+ 1) & TX_RING_MOD_MASK
;
737 ll
->rdp
= LE_C0_INEA
| LE_C0_TDMD
;
747 static int lance_close (struct net_device
*dev
)
749 struct lance_private
*lp
= (struct lance_private
*) dev
->priv
;
750 volatile struct lance_regs
*ll
= lp
->ll
;
754 del_timer(&lp
->multicast_timer
);
758 ll
->rdp
= LE_C0_STOP
;
760 free_irq (dev
->irq
, (void *) dev
);
765 static inline int lance_reset (struct net_device
*dev
)
767 struct lance_private
*lp
= (struct lance_private
*)dev
->priv
;
768 volatile struct lance_regs
*ll
= lp
->ll
;
773 ll
->rdp
= LE_C0_STOP
;
775 /* On the 4m, reset the dma too */
777 printk ("resetting ledma\n");
778 lp
->ledma
->regs
->cond_reg
|= DMA_RST_ENET
;
780 lp
->ledma
->regs
->cond_reg
&= ~DMA_RST_ENET
;
781 lp
->ledma
->regs
->dma_test
= ((__u32
) lp
->init_block_dvma
) & 0xff000000;
783 lance_init_ring (dev
);
785 dev
->trans_start
= jiffies
;
789 status
= init_restart_lance (lp
);
791 printk ("Lance restart=%d\n", status
);
796 static int lance_start_xmit (struct sk_buff
*skb
, struct net_device
*dev
)
798 struct lance_private
*lp
= (struct lance_private
*)dev
->priv
;
799 volatile struct lance_regs
*ll
= lp
->ll
;
800 volatile struct lance_init_block
*ib
= lp
->init_block
;
801 volatile unsigned long flush
;
803 int entry
, skblen
, len
;
805 if (test_and_set_bit (0, (void *) &dev
->tbusy
) != 0) {
806 int tickssofar
= jiffies
- dev
->trans_start
;
808 if (tickssofar
< 100)
811 printk ("%s: transmit timed out, status %04x, reset\n",
813 lp
->stats
.tx_errors
++;
823 if (!TX_BUFFS_AVAIL
) {
824 restore_flags(flags
);
828 len
= (skblen
<= ETH_ZLEN
) ? ETH_ZLEN
: skblen
;
830 lp
->stats
.tx_bytes
+= len
;
832 entry
= lp
->tx_new
& TX_RING_MOD_MASK
;
833 ib
->btx_ring
[entry
].length
= (-len
) | 0xf000;
834 ib
->btx_ring
[entry
].misc
= 0;
836 memcpy ((char *)&ib
->tx_buf
[entry
][0], skb
->data
, skblen
);
838 /* Clear the slack of the packet, do I need this? */
839 /* For a firewall its a good idea - AC */
841 memset ((char *) &ib
->tx_buf
[entry
][skblen
], 0, len
- skblen
);
843 /* Now, give the packet to the lance */
844 ib
->btx_ring
[entry
].tmd1_bits
= (LE_T1_POK
|LE_T1_OWN
);
845 lp
->tx_new
= (lp
->tx_new
+1) & TX_RING_MOD_MASK
;
847 /* Kick the lance: transmit now */
848 ll
->rdp
= LE_C0_INEA
| LE_C0_TDMD
;
849 dev
->trans_start
= jiffies
;
855 /* Read back CSR to invalidate the E-Cache.
856 * This is needed, because DMA_DSBL_WR_INV is set. */
860 restore_flags(flags
);
864 static struct net_device_stats
*lance_get_stats (struct net_device
*dev
)
866 struct lance_private
*lp
= (struct lance_private
*) dev
->priv
;
871 /* taken from the depca driver */
872 static void lance_load_multicast (struct net_device
*dev
)
874 struct lance_private
*lp
= (struct lance_private
*) dev
->priv
;
875 volatile struct lance_init_block
*ib
= lp
->init_block
;
876 volatile u16
*mcast_table
= (u16
*)&ib
->filter
;
877 struct dev_mc_list
*dmi
=dev
->mc_list
;
880 u32 crc
, poly
= CRC_POLYNOMIAL_LE
;
882 /* set all multicast bits */
883 if (dev
->flags
& IFF_ALLMULTI
) {
884 ib
->filter
[0] = 0xffffffff;
885 ib
->filter
[1] = 0xffffffff;
888 /* clear the multicast filter */
893 for (i
= 0; i
< dev
->mc_count
; i
++) {
894 addrs
= dmi
->dmi_addr
;
897 /* multicast address? */
902 for (byte
= 0; byte
< 6; byte
++) {
903 for (bit
= *addrs
++, j
= 0; j
< 8; j
++, bit
>>= 1) {
906 test
= ((bit
^ crc
) & 0x01);
914 mcast_table
[crc
>> 4] |= 1 << (crc
& 0xf);
918 static void lance_set_multicast (struct net_device
*dev
)
920 struct lance_private
*lp
= (struct lance_private
*) dev
->priv
;
921 volatile struct lance_init_block
*ib
= lp
->init_block
;
922 volatile struct lance_regs
*ll
= lp
->ll
;
928 mod_timer(&lp
->multicast_timer
, jiffies
+ 2);
931 /* This CANNOT be correct. Chip is running
932 and dev->tbusy may change any moment.
933 It is useless to set it.
935 Generally, usage of dev->tbusy in this driver is completely
938 I protected calls to this function
939 with start_bh_atomic, so that set_multicast_list
940 and hard_start_xmit are serialized now by top level. --ANK
942 The same is true about a2065.
944 set_bit (0, (void *) &dev
->tbusy
);
946 if (lp
->tx_old
!= lp
->tx_new
) {
947 mod_timer(&lp
->multicast_timer
, jiffies
+ 4);
953 ll
->rdp
= LE_C0_STOP
;
954 lance_init_ring (dev
);
956 if (dev
->flags
& IFF_PROMISC
) {
957 ib
->mode
|= LE_MO_PROM
;
959 ib
->mode
&= ~LE_MO_PROM
;
960 lance_load_multicast (dev
);
963 init_restart_lance (lp
);
969 sparc_lance_init (struct net_device
*dev
, struct linux_sbus_device
*sdev
,
970 struct Linux_SBus_DMA
*ledma
,
971 struct linux_sbus_device
*lebuffer
)
973 static unsigned version_printed
= 0;
975 struct lance_private
*lp
;
976 volatile struct lance_regs
*ll
;
979 dev
= init_etherdev (0, sizeof (struct lance_private
) + 8);
981 dev
->priv
= kmalloc (sizeof (struct lance_private
) + 8,
983 if (dev
->priv
== NULL
)
985 memset(dev
->priv
, 0, sizeof (struct lance_private
) + 8);
987 if (sparc_lance_debug
&& version_printed
++ == 0)
990 printk ("%s: LANCE ", dev
->name
);
991 /* Fill the dev fields */
992 dev
->base_addr
= (long) sdev
;
994 /* Copy the IDPROM ethernet address to the device structure, later we
995 * will copy the address in the device structure to the lance
996 * initialization block.
998 for (i
= 0; i
< 6; i
++)
999 printk ("%2.2x%c", dev
->dev_addr
[i
] = idprom
->id_ethaddr
[i
],
1003 /* Get the IO region */
1004 prom_apply_sbus_ranges (sdev
->my_bus
, &sdev
->reg_addrs
[0],
1005 sdev
->num_registers
, sdev
);
1006 ll
= sparc_alloc_io (sdev
->reg_addrs
[0].phys_addr
, 0,
1007 sizeof (struct lance_regs
), lancestr
,
1008 sdev
->reg_addrs
[0].which_io
, 0x0);
1010 /* Make certain the data structures used by the LANCE are aligned. */
1011 dev
->priv
= (void *)(((unsigned long)dev
->priv
+ 7) & ~7);
1012 lp
= (struct lance_private
*) dev
->priv
;
1013 lp
->sbus
= sdev
->my_bus
;
1015 prom_apply_sbus_ranges (lebuffer
->my_bus
,
1016 &lebuffer
->reg_addrs
[0],
1017 lebuffer
->num_registers
,
1020 lp
->init_block
= (void *)
1021 sparc_alloc_io (lebuffer
->reg_addrs
[0].phys_addr
, 0,
1022 sizeof (struct lance_init_block
), "lebuffer",
1023 lebuffer
->reg_addrs
[0].which_io
, 0);
1024 lp
->init_block_dvma
= 0;
1028 lp
->init_block
= (void *)
1029 sparc_dvma_malloc (sizeof (struct lance_init_block
),
1030 lancedma
, &lp
->init_block_dvma
);
1033 lp
->busmaster_regval
= prom_getintdefault(sdev
->prom_node
,
1035 (LE_C3_BSWP
| LE_C3_ACON
|
1039 lp
->name
= lancestr
;
1042 lp
->burst_sizes
= 0;
1045 unsigned int sbmask
;
1047 /* Find burst-size property for ledma */
1048 lp
->burst_sizes
= prom_getintdefault(ledma
->SBus_dev
->prom_node
,
1051 /* ledma may be capable of fast bursts, but sbus may not. */
1052 sbmask
= prom_getintdefault(ledma
->SBus_dev
->my_bus
->prom_node
,
1053 "burst-sizes", DMA_BURSTBITS
);
1054 lp
->burst_sizes
&= sbmask
;
1056 /* Get the cable-selection property */
1057 memset(prop
, 0, sizeof(prop
));
1058 prom_getstring(ledma
->SBus_dev
->prom_node
, "cable-selection",
1059 prop
, sizeof(prop
));
1063 printk("%s: using auto-carrier-detection.\n",
1066 /* Is this found at /options .attributes in all
1067 * Prom versions? XXX
1069 topnd
= prom_getchild(prom_root_node
);
1071 nd
= prom_searchsiblings(topnd
, "options");
1075 if (!prom_node_has_property(nd
, "tpe-link-test?"))
1078 memset(prop
, 0, sizeof(prop
));
1079 prom_getstring(nd
, "tpe-link-test?", prop
,
1082 if (strcmp(prop
, "true")) {
1083 printk("%s: warning: overriding option "
1084 "'tpe-link-test?'\n", dev
->name
);
1085 printk("%s: warning: mail any problems "
1086 "to ecd@skynet.be\n", dev
->name
);
1087 set_auxio(AUXIO_LINK_TEST
, 0);
1090 lp
->auto_select
= 1;
1092 } else if (!strcmp(prop
, "aui")) {
1093 lp
->auto_select
= 0;
1096 lp
->auto_select
= 0;
1101 lp
->ledma
->regs
->cond_reg
|= DMA_RST_ENET
;
1103 lp
->ledma
->regs
->cond_reg
&= ~DMA_RST_ENET
;
1106 /* This should never happen. */
1107 if ((unsigned long)(lp
->init_block
->brx_ring
) & 0x07) {
1108 printk("%s: ERROR: Rx and Tx rings not on even boundary.\n",
1114 dev
->open
= &lance_open
;
1115 dev
->stop
= &lance_close
;
1116 dev
->hard_start_xmit
= &lance_start_xmit
;
1117 dev
->get_stats
= &lance_get_stats
;
1118 dev
->set_multicast_list
= &lance_set_multicast
;
1120 dev
->irq
= sdev
->irqs
[0];
1125 /* We cannot sleep if the chip is busy during a
1126 * multicast list update event, because such events
1127 * can occur from interrupts (ex. IPv6). So we
1128 * use a timer to try again later when necessary. -DaveM
1130 init_timer(&lp
->multicast_timer
);
1131 lp
->multicast_timer
.data
= (unsigned long) dev
;
1132 lp
->multicast_timer
.function
=
1133 (void (*)(unsigned long)) &lance_set_multicast
;
1136 dev
->ifindex
= dev_new_index();
1137 lp
->next_module
= root_lance_dev
;
1138 root_lance_dev
= lp
;
1143 /* On 4m, find the associated dma for the lance chip */
1144 static inline struct Linux_SBus_DMA
*
1145 find_ledma (struct linux_sbus_device
*dev
)
1147 struct Linux_SBus_DMA
*p
;
1150 if (p
->SBus_dev
== dev
)
1157 #include <asm/sun4paddr.h>
1159 /* Find all the lance cards on the system and initialize them */
1160 int __init
sparc_lance_probe (struct net_device
*dev
)
1162 static struct linux_sbus_device sdev
;
1163 static int called
= 0;
1169 if ((idprom
->id_machtype
== (SM_SUN4
|SM_4_330
)) ||
1170 (idprom
->id_machtype
== (SM_SUN4
|SM_4_470
))) {
1171 memset (&sdev
, 0, sizeof(sdev
));
1172 sdev
.reg_addrs
[0].phys_addr
= sun4_eth_physaddr
;
1174 return sparc_lance_init(dev
, &sdev
, 0, 0);
1179 #else /* !CONFIG_SUN4 */
1181 /* Find all the lance cards on the system and initialize them */
1182 int __init
sparc_lance_probe (struct net_device
*dev
)
1184 struct linux_sbus
*bus
;
1185 struct linux_sbus_device
*sdev
= 0;
1186 struct Linux_SBus_DMA
*ledma
= 0;
1187 static int called
= 0;
1194 for_each_sbus (bus
) {
1195 for_each_sbusdev (sdev
, bus
) {
1196 if (cards
) dev
= NULL
;
1197 if (strcmp (sdev
->prom_name
, "le") == 0) {
1199 if ((v
= sparc_lance_init(dev
, sdev
, 0, 0)))
1203 if (strcmp (sdev
->prom_name
, "ledma") == 0) {
1205 ledma
= find_ledma (sdev
);
1206 if ((v
= sparc_lance_init(dev
, sdev
->child
,
1211 if (strcmp (sdev
->prom_name
, "lebuffer") == 0){
1213 if ((v
= sparc_lance_init(dev
, sdev
->child
,
1218 } /* for each sbusdev */
1219 } /* for each sbus */
1224 #endif /* !CONFIG_SUN4 */
1231 root_lance_dev
= NULL
;
1232 return sparc_lance_probe(NULL
);
1236 cleanup_module(void)
1238 struct lance_private
*lp
;
1240 while (root_lance_dev
) {
1241 lp
= root_lance_dev
->next_module
;
1243 unregister_netdev(root_lance_dev
->dev
);
1244 kfree(root_lance_dev
->dev
);
1245 root_lance_dev
= lp
;