1 /* $Id: sunlance.c,v 1.112 2002/01/15 06:48:55 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)
63 * 2.00: 11/9/99: Massive overhaul and port to new SBUS driver interfaces.
64 * David S. Miller (davem@redhat.com)
66 * 11/08/01: Use library crc32 functions (Matt_Domsch@dell.com)
72 static char lancestr
[] = "LANCE";
74 #include <linux/config.h>
75 #include <linux/module.h>
76 #include <linux/kernel.h>
77 #include <linux/types.h>
78 #include <linux/fcntl.h>
79 #include <linux/interrupt.h>
80 #include <linux/ioport.h>
82 #include <linux/slab.h>
83 #include <linux/string.h>
84 #include <linux/delay.h>
85 #include <linux/init.h>
86 #include <linux/crc32.h>
87 #include <linux/errno.h>
88 #include <linux/socket.h> /* Used for the temporal inet entries and routing */
89 #include <linux/route.h>
90 #include <linux/netdevice.h>
91 #include <linux/etherdevice.h>
92 #include <linux/skbuff.h>
93 #include <linux/ethtool.h>
94 #include <linux/bitops.h>
96 #include <asm/system.h>
99 #include <asm/pgtable.h>
100 #include <asm/byteorder.h> /* Used by the checksum routines */
101 #include <asm/idprom.h>
102 #include <asm/sbus.h>
103 #include <asm/openprom.h>
104 #include <asm/oplib.h>
105 #include <asm/auxio.h> /* For tpe-link-test? setting */
108 #define DRV_NAME "sunlance"
109 #define DRV_VERSION "2.02"
110 #define DRV_RELDATE "8/24/03"
111 #define DRV_AUTHOR "Miguel de Icaza (miguel@nuclecu.unam.mx)"
113 static char version
[] =
114 DRV_NAME
".c:v" DRV_VERSION
" " DRV_RELDATE
" " DRV_AUTHOR
"\n";
116 MODULE_VERSION(DRV_VERSION
);
117 MODULE_AUTHOR(DRV_AUTHOR
);
118 MODULE_DESCRIPTION("Sun Lance ethernet driver");
119 MODULE_LICENSE("GPL");
121 /* Define: 2^4 Tx buffers and 2^4 Rx buffers */
122 #ifndef LANCE_LOG_TX_BUFFERS
123 #define LANCE_LOG_TX_BUFFERS 4
124 #define LANCE_LOG_RX_BUFFERS 4
132 #define LE_MO_PROM 0x8000 /* Enable promiscuous mode */
134 #define LE_C0_ERR 0x8000 /* Error: set if BAB, SQE, MISS or ME is set */
135 #define LE_C0_BABL 0x4000 /* BAB: Babble: tx timeout. */
136 #define LE_C0_CERR 0x2000 /* SQE: Signal quality error */
137 #define LE_C0_MISS 0x1000 /* MISS: Missed a packet */
138 #define LE_C0_MERR 0x0800 /* ME: Memory error */
139 #define LE_C0_RINT 0x0400 /* Received interrupt */
140 #define LE_C0_TINT 0x0200 /* Transmitter Interrupt */
141 #define LE_C0_IDON 0x0100 /* IFIN: Init finished. */
142 #define LE_C0_INTR 0x0080 /* Interrupt or error */
143 #define LE_C0_INEA 0x0040 /* Interrupt enable */
144 #define LE_C0_RXON 0x0020 /* Receiver on */
145 #define LE_C0_TXON 0x0010 /* Transmitter on */
146 #define LE_C0_TDMD 0x0008 /* Transmitter demand */
147 #define LE_C0_STOP 0x0004 /* Stop the card */
148 #define LE_C0_STRT 0x0002 /* Start the card */
149 #define LE_C0_INIT 0x0001 /* Init the card */
151 #define LE_C3_BSWP 0x4 /* SWAP */
152 #define LE_C3_ACON 0x2 /* ALE Control */
153 #define LE_C3_BCON 0x1 /* Byte control */
155 /* Receive message descriptor 1 */
156 #define LE_R1_OWN 0x80 /* Who owns the entry */
157 #define LE_R1_ERR 0x40 /* Error: if FRA, OFL, CRC or BUF is set */
158 #define LE_R1_FRA 0x20 /* FRA: Frame error */
159 #define LE_R1_OFL 0x10 /* OFL: Frame overflow */
160 #define LE_R1_CRC 0x08 /* CRC error */
161 #define LE_R1_BUF 0x04 /* BUF: Buffer error */
162 #define LE_R1_SOP 0x02 /* Start of packet */
163 #define LE_R1_EOP 0x01 /* End of packet */
164 #define LE_R1_POK 0x03 /* Packet is complete: SOP + EOP */
166 #define LE_T1_OWN 0x80 /* Lance owns the packet */
167 #define LE_T1_ERR 0x40 /* Error summary */
168 #define LE_T1_EMORE 0x10 /* Error: more than one retry needed */
169 #define LE_T1_EONE 0x08 /* Error: one retry needed */
170 #define LE_T1_EDEF 0x04 /* Error: deferred */
171 #define LE_T1_SOP 0x02 /* Start of packet */
172 #define LE_T1_EOP 0x01 /* End of packet */
173 #define LE_T1_POK 0x03 /* Packet is complete: SOP + EOP */
175 #define LE_T3_BUF 0x8000 /* Buffer error */
176 #define LE_T3_UFL 0x4000 /* Error underflow */
177 #define LE_T3_LCOL 0x1000 /* Error late collision */
178 #define LE_T3_CLOS 0x0800 /* Error carrier loss */
179 #define LE_T3_RTY 0x0400 /* Error retry */
180 #define LE_T3_TDR 0x03ff /* Time Domain Reflectometry counter */
182 #define TX_RING_SIZE (1 << (LANCE_LOG_TX_BUFFERS))
183 #define TX_RING_MOD_MASK (TX_RING_SIZE - 1)
184 #define TX_RING_LEN_BITS ((LANCE_LOG_TX_BUFFERS) << 29)
185 #define TX_NEXT(__x) (((__x)+1) & TX_RING_MOD_MASK)
187 #define RX_RING_SIZE (1 << (LANCE_LOG_RX_BUFFERS))
188 #define RX_RING_MOD_MASK (RX_RING_SIZE - 1)
189 #define RX_RING_LEN_BITS ((LANCE_LOG_RX_BUFFERS) << 29)
190 #define RX_NEXT(__x) (((__x)+1) & RX_RING_MOD_MASK)
192 #define PKT_BUF_SZ 1544
193 #define RX_BUFF_SIZE PKT_BUF_SZ
194 #define TX_BUFF_SIZE PKT_BUF_SZ
196 struct lance_rx_desc
{
197 u16 rmd0
; /* low address of packet */
198 u8 rmd1_bits
; /* descriptor bits */
199 u8 rmd1_hadr
; /* high address of packet */
200 s16 length
; /* This length is 2s complement (negative)!
203 u16 mblength
; /* This is the actual number of bytes received */
206 struct lance_tx_desc
{
207 u16 tmd0
; /* low address of packet */
208 u8 tmd1_bits
; /* descriptor bits */
209 u8 tmd1_hadr
; /* high address of packet */
210 s16 length
; /* Length is 2s complement (negative)! */
214 /* The LANCE initialization block, described in databook. */
215 /* On the Sparc, this block should be on a DMA region */
216 struct lance_init_block
{
217 u16 mode
; /* Pre-set mode (reg. 15) */
218 u8 phys_addr
[6]; /* Physical ethernet address */
219 u32 filter
[2]; /* Multicast filter. */
221 /* Receive and transmit ring base, along with extra bits. */
222 u16 rx_ptr
; /* receive descriptor addr */
223 u16 rx_len
; /* receive len and high addr */
224 u16 tx_ptr
; /* transmit descriptor addr */
225 u16 tx_len
; /* transmit len and high addr */
227 /* The Tx and Rx ring entries must aligned on 8-byte boundaries. */
228 struct lance_rx_desc brx_ring
[RX_RING_SIZE
];
229 struct lance_tx_desc btx_ring
[TX_RING_SIZE
];
231 u8 tx_buf
[TX_RING_SIZE
][TX_BUFF_SIZE
];
232 u8 pad
[2]; /* align rx_buf for copy_and_sum(). */
233 u8 rx_buf
[RX_RING_SIZE
][RX_BUFF_SIZE
];
236 #define libdesc_offset(rt, elem) \
237 ((__u32)(((unsigned long)(&(((struct lance_init_block *)0)->rt[elem])))))
239 #define libbuff_offset(rt, elem) \
240 ((__u32)(((unsigned long)(&(((struct lance_init_block *)0)->rt[elem][0])))))
242 struct lance_private
{
243 void __iomem
*lregs
; /* Lance RAP/RDP regs. */
244 void __iomem
*dregs
; /* DMA controller regs. */
245 struct lance_init_block __iomem
*init_block_iomem
;
246 struct lance_init_block
*init_block_mem
;
253 struct net_device_stats stats
;
254 struct sbus_dma
*ledma
; /* If set this points to ledma */
255 char tpe
; /* cable-selection is TPE */
256 char auto_select
; /* cable-selection by carrier */
257 char burst_sizes
; /* ledma SBus burst sizes */
258 char pio_buffer
; /* init block in PIO space? */
260 unsigned short busmaster_regval
;
262 void (*init_ring
)(struct net_device
*);
263 void (*rx
)(struct net_device
*);
264 void (*tx
)(struct net_device
*);
267 dma_addr_t init_block_dvma
;
268 struct net_device
*dev
; /* Backpointer */
269 struct sbus_dev
*sdev
;
270 struct timer_list multicast_timer
;
273 #define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
274 lp->tx_old+TX_RING_MOD_MASK-lp->tx_new:\
275 lp->tx_old - lp->tx_new-1)
277 /* Lance registers. */
278 #define RDP 0x00UL /* register data port */
279 #define RAP 0x02UL /* register address port */
280 #define LANCE_REG_SIZE 0x04UL
282 #define STOP_LANCE(__lp) \
283 do { void __iomem *__base = (__lp)->lregs; \
284 sbus_writew(LE_CSR0, __base + RAP); \
285 sbus_writew(LE_C0_STOP, __base + RDP); \
288 int sparc_lance_debug
= 2;
290 /* The Lance uses 24 bit addresses */
291 /* On the Sun4c the DVMA will provide the remaining bytes for us */
292 /* On the Sun4m we have to instruct the ledma to provide them */
293 /* Even worse, on scsi/ether SBUS cards, the init block and the
294 * transmit/receive buffers are addresses as offsets from absolute
295 * zero on the lebuffer PIO area. -DaveM
298 #define LANCE_ADDR(x) ((long)(x) & ~0xff000000)
300 /* Load the CSR registers */
301 static void load_csrs(struct lance_private
*lp
)
308 leptr
= LANCE_ADDR(lp
->init_block_dvma
);
310 sbus_writew(LE_CSR1
, lp
->lregs
+ RAP
);
311 sbus_writew(leptr
& 0xffff, lp
->lregs
+ RDP
);
312 sbus_writew(LE_CSR2
, lp
->lregs
+ RAP
);
313 sbus_writew(leptr
>> 16, lp
->lregs
+ RDP
);
314 sbus_writew(LE_CSR3
, lp
->lregs
+ RAP
);
315 sbus_writew(lp
->busmaster_regval
, lp
->lregs
+ RDP
);
317 /* Point back to csr0 */
318 sbus_writew(LE_CSR0
, lp
->lregs
+ RAP
);
321 /* Setup the Lance Rx and Tx rings */
322 static void lance_init_ring_dvma(struct net_device
*dev
)
324 struct lance_private
*lp
= netdev_priv(dev
);
325 struct lance_init_block
*ib
= lp
->init_block_mem
;
326 dma_addr_t aib
= lp
->init_block_dvma
;
330 /* Lock out other processes while setting up hardware */
331 netif_stop_queue(dev
);
332 lp
->rx_new
= lp
->tx_new
= 0;
333 lp
->rx_old
= lp
->tx_old
= 0;
335 /* Copy the ethernet address to the lance init block
336 * Note that on the sparc you need to swap the ethernet address.
338 ib
->phys_addr
[0] = dev
->dev_addr
[1];
339 ib
->phys_addr
[1] = dev
->dev_addr
[0];
340 ib
->phys_addr
[2] = dev
->dev_addr
[3];
341 ib
->phys_addr
[3] = dev
->dev_addr
[2];
342 ib
->phys_addr
[4] = dev
->dev_addr
[5];
343 ib
->phys_addr
[5] = dev
->dev_addr
[4];
345 /* Setup the Tx ring entries */
346 for (i
= 0; i
<= TX_RING_SIZE
; i
++) {
347 leptr
= LANCE_ADDR(aib
+ libbuff_offset(tx_buf
, i
));
348 ib
->btx_ring
[i
].tmd0
= leptr
;
349 ib
->btx_ring
[i
].tmd1_hadr
= leptr
>> 16;
350 ib
->btx_ring
[i
].tmd1_bits
= 0;
351 ib
->btx_ring
[i
].length
= 0xf000; /* The ones required by tmd2 */
352 ib
->btx_ring
[i
].misc
= 0;
355 /* Setup the Rx ring entries */
356 for (i
= 0; i
< RX_RING_SIZE
; i
++) {
357 leptr
= LANCE_ADDR(aib
+ libbuff_offset(rx_buf
, i
));
359 ib
->brx_ring
[i
].rmd0
= leptr
;
360 ib
->brx_ring
[i
].rmd1_hadr
= leptr
>> 16;
361 ib
->brx_ring
[i
].rmd1_bits
= LE_R1_OWN
;
362 ib
->brx_ring
[i
].length
= -RX_BUFF_SIZE
| 0xf000;
363 ib
->brx_ring
[i
].mblength
= 0;
366 /* Setup the initialization block */
368 /* Setup rx descriptor pointer */
369 leptr
= LANCE_ADDR(aib
+ libdesc_offset(brx_ring
, 0));
370 ib
->rx_len
= (LANCE_LOG_RX_BUFFERS
<< 13) | (leptr
>> 16);
373 /* Setup tx descriptor pointer */
374 leptr
= LANCE_ADDR(aib
+ libdesc_offset(btx_ring
, 0));
375 ib
->tx_len
= (LANCE_LOG_TX_BUFFERS
<< 13) | (leptr
>> 16);
379 static void lance_init_ring_pio(struct net_device
*dev
)
381 struct lance_private
*lp
= netdev_priv(dev
);
382 struct lance_init_block __iomem
*ib
= lp
->init_block_iomem
;
386 /* Lock out other processes while setting up hardware */
387 netif_stop_queue(dev
);
388 lp
->rx_new
= lp
->tx_new
= 0;
389 lp
->rx_old
= lp
->tx_old
= 0;
391 /* Copy the ethernet address to the lance init block
392 * Note that on the sparc you need to swap the ethernet address.
394 sbus_writeb(dev
->dev_addr
[1], &ib
->phys_addr
[0]);
395 sbus_writeb(dev
->dev_addr
[0], &ib
->phys_addr
[1]);
396 sbus_writeb(dev
->dev_addr
[3], &ib
->phys_addr
[2]);
397 sbus_writeb(dev
->dev_addr
[2], &ib
->phys_addr
[3]);
398 sbus_writeb(dev
->dev_addr
[5], &ib
->phys_addr
[4]);
399 sbus_writeb(dev
->dev_addr
[4], &ib
->phys_addr
[5]);
401 /* Setup the Tx ring entries */
402 for (i
= 0; i
<= TX_RING_SIZE
; i
++) {
403 leptr
= libbuff_offset(tx_buf
, i
);
404 sbus_writew(leptr
, &ib
->btx_ring
[i
].tmd0
);
405 sbus_writeb(leptr
>> 16,&ib
->btx_ring
[i
].tmd1_hadr
);
406 sbus_writeb(0, &ib
->btx_ring
[i
].tmd1_bits
);
408 /* The ones required by tmd2 */
409 sbus_writew(0xf000, &ib
->btx_ring
[i
].length
);
410 sbus_writew(0, &ib
->btx_ring
[i
].misc
);
413 /* Setup the Rx ring entries */
414 for (i
= 0; i
< RX_RING_SIZE
; i
++) {
415 leptr
= libbuff_offset(rx_buf
, i
);
417 sbus_writew(leptr
, &ib
->brx_ring
[i
].rmd0
);
418 sbus_writeb(leptr
>> 16,&ib
->brx_ring
[i
].rmd1_hadr
);
419 sbus_writeb(LE_R1_OWN
, &ib
->brx_ring
[i
].rmd1_bits
);
420 sbus_writew(-RX_BUFF_SIZE
|0xf000,
421 &ib
->brx_ring
[i
].length
);
422 sbus_writew(0, &ib
->brx_ring
[i
].mblength
);
425 /* Setup the initialization block */
427 /* Setup rx descriptor pointer */
428 leptr
= libdesc_offset(brx_ring
, 0);
429 sbus_writew((LANCE_LOG_RX_BUFFERS
<< 13) | (leptr
>> 16),
431 sbus_writew(leptr
, &ib
->rx_ptr
);
433 /* Setup tx descriptor pointer */
434 leptr
= libdesc_offset(btx_ring
, 0);
435 sbus_writew((LANCE_LOG_TX_BUFFERS
<< 13) | (leptr
>> 16),
437 sbus_writew(leptr
, &ib
->tx_ptr
);
440 static void init_restart_ledma(struct lance_private
*lp
)
442 u32 csr
= sbus_readl(lp
->dregs
+ DMA_CSR
);
444 if (!(csr
& DMA_HNDL_ERROR
)) {
445 /* E-Cache draining */
446 while (sbus_readl(lp
->dregs
+ DMA_CSR
) & DMA_FIFO_ISDRAIN
)
450 csr
= sbus_readl(lp
->dregs
+ DMA_CSR
);
451 csr
&= ~DMA_E_BURSTS
;
452 if (lp
->burst_sizes
& DMA_BURST32
)
453 csr
|= DMA_E_BURST32
;
455 csr
|= DMA_E_BURST16
;
457 csr
|= (DMA_DSBL_RD_DRN
| DMA_DSBL_WR_INV
| DMA_FIFO_INV
);
460 csr
|= DMA_EN_ENETAUI
;
462 csr
&= ~DMA_EN_ENETAUI
;
464 sbus_writel(csr
, lp
->dregs
+ DMA_CSR
);
468 static int init_restart_lance(struct lance_private
*lp
)
474 init_restart_ledma(lp
);
476 sbus_writew(LE_CSR0
, lp
->lregs
+ RAP
);
477 sbus_writew(LE_C0_INIT
, lp
->lregs
+ RDP
);
479 /* Wait for the lance to complete initialization */
480 for (i
= 0; i
< 100; i
++) {
481 regval
= sbus_readw(lp
->lregs
+ RDP
);
483 if (regval
& (LE_C0_ERR
| LE_C0_IDON
))
487 if (i
== 100 || (regval
& LE_C0_ERR
)) {
488 printk(KERN_ERR
"LANCE unopened after %d ticks, csr0=%4.4x.\n",
491 printk("dcsr=%8.8x\n", sbus_readl(lp
->dregs
+ DMA_CSR
));
495 /* Clear IDON by writing a "1", enable interrupts and start lance */
496 sbus_writew(LE_C0_IDON
, lp
->lregs
+ RDP
);
497 sbus_writew(LE_C0_INEA
| LE_C0_STRT
, lp
->lregs
+ RDP
);
500 u32 csr
= sbus_readl(lp
->dregs
+ DMA_CSR
);
503 sbus_writel(csr
, lp
->dregs
+ DMA_CSR
);
509 static void lance_rx_dvma(struct net_device
*dev
)
511 struct lance_private
*lp
= netdev_priv(dev
);
512 struct lance_init_block
*ib
= lp
->init_block_mem
;
513 struct lance_rx_desc
*rd
;
515 int len
, entry
= lp
->rx_new
;
518 for (rd
= &ib
->brx_ring
[entry
];
519 !((bits
= rd
->rmd1_bits
) & LE_R1_OWN
);
520 rd
= &ib
->brx_ring
[entry
]) {
522 /* We got an incomplete frame? */
523 if ((bits
& LE_R1_POK
) != LE_R1_POK
) {
524 lp
->stats
.rx_over_errors
++;
525 lp
->stats
.rx_errors
++;
526 } else if (bits
& LE_R1_ERR
) {
527 /* Count only the end frame as a rx error,
530 if (bits
& LE_R1_BUF
) lp
->stats
.rx_fifo_errors
++;
531 if (bits
& LE_R1_CRC
) lp
->stats
.rx_crc_errors
++;
532 if (bits
& LE_R1_OFL
) lp
->stats
.rx_over_errors
++;
533 if (bits
& LE_R1_FRA
) lp
->stats
.rx_frame_errors
++;
534 if (bits
& LE_R1_EOP
) lp
->stats
.rx_errors
++;
536 len
= (rd
->mblength
& 0xfff) - 4;
537 skb
= dev_alloc_skb(len
+ 2);
540 printk(KERN_INFO
"%s: Memory squeeze, deferring packet.\n",
542 lp
->stats
.rx_dropped
++;
544 rd
->rmd1_bits
= LE_R1_OWN
;
545 lp
->rx_new
= RX_NEXT(entry
);
549 lp
->stats
.rx_bytes
+= len
;
552 skb_reserve(skb
, 2); /* 16 byte align */
553 skb_put(skb
, len
); /* make room */
554 eth_copy_and_sum(skb
,
555 (unsigned char *)&(ib
->rx_buf
[entry
][0]),
557 skb
->protocol
= eth_type_trans(skb
, dev
);
559 dev
->last_rx
= jiffies
;
560 lp
->stats
.rx_packets
++;
563 /* Return the packet to the pool */
565 rd
->rmd1_bits
= LE_R1_OWN
;
566 entry
= RX_NEXT(entry
);
572 static void lance_tx_dvma(struct net_device
*dev
)
574 struct lance_private
*lp
= netdev_priv(dev
);
575 struct lance_init_block
*ib
= lp
->init_block_mem
;
578 spin_lock(&lp
->lock
);
581 for (i
= j
; i
!= lp
->tx_new
; i
= j
) {
582 struct lance_tx_desc
*td
= &ib
->btx_ring
[i
];
583 u8 bits
= td
->tmd1_bits
;
585 /* If we hit a packet not owned by us, stop */
586 if (bits
& LE_T1_OWN
)
589 if (bits
& LE_T1_ERR
) {
590 u16 status
= td
->misc
;
592 lp
->stats
.tx_errors
++;
593 if (status
& LE_T3_RTY
) lp
->stats
.tx_aborted_errors
++;
594 if (status
& LE_T3_LCOL
) lp
->stats
.tx_window_errors
++;
596 if (status
& LE_T3_CLOS
) {
597 lp
->stats
.tx_carrier_errors
++;
598 if (lp
->auto_select
) {
599 lp
->tpe
= 1 - lp
->tpe
;
600 printk(KERN_NOTICE
"%s: Carrier Lost, trying %s\n",
601 dev
->name
, lp
->tpe
?"TPE":"AUI");
605 init_restart_lance(lp
);
610 /* Buffer errors and underflows turn off the
611 * transmitter, restart the adapter.
613 if (status
& (LE_T3_BUF
|LE_T3_UFL
)) {
614 lp
->stats
.tx_fifo_errors
++;
616 printk(KERN_ERR
"%s: Tx: ERR_BUF|ERR_UFL, restarting\n",
621 init_restart_lance(lp
);
624 } else if ((bits
& LE_T1_POK
) == LE_T1_POK
) {
626 * So we don't count the packet more than once.
628 td
->tmd1_bits
= bits
& ~(LE_T1_POK
);
630 /* One collision before packet was sent. */
631 if (bits
& LE_T1_EONE
)
632 lp
->stats
.collisions
++;
634 /* More than one collision, be optimistic. */
635 if (bits
& LE_T1_EMORE
)
636 lp
->stats
.collisions
+= 2;
638 lp
->stats
.tx_packets
++;
645 if (netif_queue_stopped(dev
) &&
647 netif_wake_queue(dev
);
649 spin_unlock(&lp
->lock
);
652 static void lance_piocopy_to_skb(struct sk_buff
*skb
, void __iomem
*piobuf
, int len
)
654 u16
*p16
= (u16
*) skb
->data
;
657 void __iomem
*pbuf
= piobuf
;
659 /* We know here that both src and dest are on a 16bit boundary. */
660 *p16
++ = sbus_readw(pbuf
);
666 *p32
++ = sbus_readl(pbuf
);
673 *p16
++ = sbus_readw(pbuf
);
679 *p8
= sbus_readb(pbuf
);
682 static void lance_rx_pio(struct net_device
*dev
)
684 struct lance_private
*lp
= netdev_priv(dev
);
685 struct lance_init_block __iomem
*ib
= lp
->init_block_iomem
;
686 struct lance_rx_desc __iomem
*rd
;
692 for (rd
= &ib
->brx_ring
[entry
];
693 !((bits
= sbus_readb(&rd
->rmd1_bits
)) & LE_R1_OWN
);
694 rd
= &ib
->brx_ring
[entry
]) {
696 /* We got an incomplete frame? */
697 if ((bits
& LE_R1_POK
) != LE_R1_POK
) {
698 lp
->stats
.rx_over_errors
++;
699 lp
->stats
.rx_errors
++;
700 } else if (bits
& LE_R1_ERR
) {
701 /* Count only the end frame as a rx error,
704 if (bits
& LE_R1_BUF
) lp
->stats
.rx_fifo_errors
++;
705 if (bits
& LE_R1_CRC
) lp
->stats
.rx_crc_errors
++;
706 if (bits
& LE_R1_OFL
) lp
->stats
.rx_over_errors
++;
707 if (bits
& LE_R1_FRA
) lp
->stats
.rx_frame_errors
++;
708 if (bits
& LE_R1_EOP
) lp
->stats
.rx_errors
++;
710 len
= (sbus_readw(&rd
->mblength
) & 0xfff) - 4;
711 skb
= dev_alloc_skb(len
+ 2);
714 printk(KERN_INFO
"%s: Memory squeeze, deferring packet.\n",
716 lp
->stats
.rx_dropped
++;
717 sbus_writew(0, &rd
->mblength
);
718 sbus_writeb(LE_R1_OWN
, &rd
->rmd1_bits
);
719 lp
->rx_new
= RX_NEXT(entry
);
723 lp
->stats
.rx_bytes
+= len
;
726 skb_reserve (skb
, 2); /* 16 byte align */
727 skb_put(skb
, len
); /* make room */
728 lance_piocopy_to_skb(skb
, &(ib
->rx_buf
[entry
][0]), len
);
729 skb
->protocol
= eth_type_trans(skb
, dev
);
731 dev
->last_rx
= jiffies
;
732 lp
->stats
.rx_packets
++;
735 /* Return the packet to the pool */
736 sbus_writew(0, &rd
->mblength
);
737 sbus_writeb(LE_R1_OWN
, &rd
->rmd1_bits
);
738 entry
= RX_NEXT(entry
);
744 static void lance_tx_pio(struct net_device
*dev
)
746 struct lance_private
*lp
= netdev_priv(dev
);
747 struct lance_init_block __iomem
*ib
= lp
->init_block_iomem
;
750 spin_lock(&lp
->lock
);
753 for (i
= j
; i
!= lp
->tx_new
; i
= j
) {
754 struct lance_tx_desc __iomem
*td
= &ib
->btx_ring
[i
];
755 u8 bits
= sbus_readb(&td
->tmd1_bits
);
757 /* If we hit a packet not owned by us, stop */
758 if (bits
& LE_T1_OWN
)
761 if (bits
& LE_T1_ERR
) {
762 u16 status
= sbus_readw(&td
->misc
);
764 lp
->stats
.tx_errors
++;
765 if (status
& LE_T3_RTY
) lp
->stats
.tx_aborted_errors
++;
766 if (status
& LE_T3_LCOL
) lp
->stats
.tx_window_errors
++;
768 if (status
& LE_T3_CLOS
) {
769 lp
->stats
.tx_carrier_errors
++;
770 if (lp
->auto_select
) {
771 lp
->tpe
= 1 - lp
->tpe
;
772 printk(KERN_NOTICE
"%s: Carrier Lost, trying %s\n",
773 dev
->name
, lp
->tpe
?"TPE":"AUI");
777 init_restart_lance(lp
);
782 /* Buffer errors and underflows turn off the
783 * transmitter, restart the adapter.
785 if (status
& (LE_T3_BUF
|LE_T3_UFL
)) {
786 lp
->stats
.tx_fifo_errors
++;
788 printk(KERN_ERR
"%s: Tx: ERR_BUF|ERR_UFL, restarting\n",
793 init_restart_lance(lp
);
796 } else if ((bits
& LE_T1_POK
) == LE_T1_POK
) {
798 * So we don't count the packet more than once.
800 sbus_writeb(bits
& ~(LE_T1_POK
), &td
->tmd1_bits
);
802 /* One collision before packet was sent. */
803 if (bits
& LE_T1_EONE
)
804 lp
->stats
.collisions
++;
806 /* More than one collision, be optimistic. */
807 if (bits
& LE_T1_EMORE
)
808 lp
->stats
.collisions
+= 2;
810 lp
->stats
.tx_packets
++;
817 if (netif_queue_stopped(dev
) &&
819 netif_wake_queue(dev
);
821 spin_unlock(&lp
->lock
);
824 static irqreturn_t
lance_interrupt(int irq
, void *dev_id
, struct pt_regs
*regs
)
826 struct net_device
*dev
= (struct net_device
*)dev_id
;
827 struct lance_private
*lp
= netdev_priv(dev
);
830 sbus_writew(LE_CSR0
, lp
->lregs
+ RAP
);
831 csr0
= sbus_readw(lp
->lregs
+ RDP
);
833 /* Acknowledge all the interrupt sources ASAP */
834 sbus_writew(csr0
& (LE_C0_INTR
| LE_C0_TINT
| LE_C0_RINT
),
837 if ((csr0
& LE_C0_ERR
) != 0) {
838 /* Clear the error condition */
839 sbus_writew((LE_C0_BABL
| LE_C0_ERR
| LE_C0_MISS
|
840 LE_C0_CERR
| LE_C0_MERR
),
844 if (csr0
& LE_C0_RINT
)
847 if (csr0
& LE_C0_TINT
)
850 if (csr0
& LE_C0_BABL
)
851 lp
->stats
.tx_errors
++;
853 if (csr0
& LE_C0_MISS
)
854 lp
->stats
.rx_errors
++;
856 if (csr0
& LE_C0_MERR
) {
858 u32 addr
= sbus_readl(lp
->dregs
+ DMA_ADDR
);
860 printk(KERN_ERR
"%s: Memory error, status %04x, addr %06x\n",
861 dev
->name
, csr0
, addr
& 0xffffff);
863 printk(KERN_ERR
"%s: Memory error, status %04x\n",
867 sbus_writew(LE_C0_STOP
, lp
->lregs
+ RDP
);
870 u32 dma_csr
= sbus_readl(lp
->dregs
+ DMA_CSR
);
872 dma_csr
|= DMA_FIFO_INV
;
873 sbus_writel(dma_csr
, lp
->dregs
+ DMA_CSR
);
878 init_restart_lance(lp
);
879 netif_wake_queue(dev
);
882 sbus_writew(LE_C0_INEA
, lp
->lregs
+ RDP
);
887 /* Build a fake network packet and send it to ourselves. */
888 static void build_fake_packet(struct lance_private
*lp
)
890 struct net_device
*dev
= lp
->dev
;
893 entry
= lp
->tx_new
& TX_RING_MOD_MASK
;
894 if (lp
->pio_buffer
) {
895 struct lance_init_block __iomem
*ib
= lp
->init_block_iomem
;
896 u16 __iomem
*packet
= (u16 __iomem
*) &(ib
->tx_buf
[entry
][0]);
897 struct ethhdr __iomem
*eth
= (struct ethhdr __iomem
*) packet
;
898 for (i
= 0; i
< (ETH_ZLEN
/ sizeof(u16
)); i
++)
899 sbus_writew(0, &packet
[i
]);
900 for (i
= 0; i
< 6; i
++) {
901 sbus_writeb(dev
->dev_addr
[i
], ð
->h_dest
[i
]);
902 sbus_writeb(dev
->dev_addr
[i
], ð
->h_source
[i
]);
904 sbus_writew((-ETH_ZLEN
) | 0xf000, &ib
->btx_ring
[entry
].length
);
905 sbus_writew(0, &ib
->btx_ring
[entry
].misc
);
906 sbus_writeb(LE_T1_POK
|LE_T1_OWN
, &ib
->btx_ring
[entry
].tmd1_bits
);
908 struct lance_init_block
*ib
= lp
->init_block_mem
;
909 u16
*packet
= (u16
*) &(ib
->tx_buf
[entry
][0]);
910 struct ethhdr
*eth
= (struct ethhdr
*) packet
;
911 memset(packet
, 0, ETH_ZLEN
);
912 for (i
= 0; i
< 6; i
++) {
913 eth
->h_dest
[i
] = dev
->dev_addr
[i
];
914 eth
->h_source
[i
] = dev
->dev_addr
[i
];
916 ib
->btx_ring
[entry
].length
= (-ETH_ZLEN
) | 0xf000;
917 ib
->btx_ring
[entry
].misc
= 0;
918 ib
->btx_ring
[entry
].tmd1_bits
= (LE_T1_POK
|LE_T1_OWN
);
920 lp
->tx_new
= TX_NEXT(entry
);
923 struct net_device
*last_dev
;
925 static int lance_open(struct net_device
*dev
)
927 struct lance_private
*lp
= netdev_priv(dev
);
934 if (request_irq(dev
->irq
, &lance_interrupt
, SA_SHIRQ
,
935 lancestr
, (void *) dev
)) {
936 printk(KERN_ERR
"Lance: Can't get irq %d\n", dev
->irq
);
940 /* On the 4m, setup the ledma to provide the upper bits for buffers */
942 u32 regval
= lp
->init_block_dvma
& 0xff000000;
944 sbus_writel(regval
, lp
->dregs
+ DMA_TEST
);
947 /* Set mode and clear multicast filter only at device open,
948 * so that lance_init_ring() called at any error will not
949 * forget multicast filters.
951 * BTW it is common bug in all lance drivers! --ANK
953 if (lp
->pio_buffer
) {
954 struct lance_init_block __iomem
*ib
= lp
->init_block_iomem
;
955 sbus_writew(0, &ib
->mode
);
956 sbus_writel(0, &ib
->filter
[0]);
957 sbus_writel(0, &ib
->filter
[1]);
959 struct lance_init_block
*ib
= lp
->init_block_mem
;
968 netif_start_queue(dev
);
970 status
= init_restart_lance(lp
);
971 if (!status
&& lp
->auto_select
) {
972 build_fake_packet(lp
);
973 sbus_writew(LE_C0_INEA
| LE_C0_TDMD
, lp
->lregs
+ RDP
);
979 static int lance_close(struct net_device
*dev
)
981 struct lance_private
*lp
= netdev_priv(dev
);
983 netif_stop_queue(dev
);
984 del_timer_sync(&lp
->multicast_timer
);
988 free_irq(dev
->irq
, (void *) dev
);
992 static int lance_reset(struct net_device
*dev
)
994 struct lance_private
*lp
= netdev_priv(dev
);
999 /* On the 4m, reset the dma too */
1003 printk(KERN_ERR
"resetting ledma\n");
1004 csr
= sbus_readl(lp
->dregs
+ DMA_CSR
);
1005 sbus_writel(csr
| DMA_RST_ENET
, lp
->dregs
+ DMA_CSR
);
1007 sbus_writel(csr
& ~DMA_RST_ENET
, lp
->dregs
+ DMA_CSR
);
1009 addr
= lp
->init_block_dvma
& 0xff000000;
1010 sbus_writel(addr
, lp
->dregs
+ DMA_TEST
);
1014 dev
->trans_start
= jiffies
;
1015 status
= init_restart_lance(lp
);
1019 static void lance_piocopy_from_skb(void __iomem
*dest
, unsigned char *src
, int len
)
1021 void __iomem
*piobuf
= dest
;
1026 switch ((unsigned long)src
& 0x3) {
1030 sbus_writel(*p32
, piobuf
);
1047 sbus_writel(val
, piobuf
);
1057 u32 val
= p16
[0]<<16 | p16
[1];
1058 sbus_writel(val
, piobuf
);
1067 u16 val
= src
[0] << 8 | src
[1];
1068 sbus_writew(val
, piobuf
);
1074 sbus_writeb(src
[0], piobuf
);
1077 static void lance_piozero(void __iomem
*dest
, int len
)
1079 void __iomem
*piobuf
= dest
;
1081 if ((unsigned long)piobuf
& 1) {
1082 sbus_writeb(0, piobuf
);
1089 sbus_writeb(0, piobuf
);
1092 if ((unsigned long)piobuf
& 2) {
1093 sbus_writew(0, piobuf
);
1100 sbus_writel(0, piobuf
);
1105 sbus_writew(0, piobuf
);
1110 sbus_writeb(0, piobuf
);
1113 static void lance_tx_timeout(struct net_device
*dev
)
1115 struct lance_private
*lp
= netdev_priv(dev
);
1117 printk(KERN_ERR
"%s: transmit timed out, status %04x, reset\n",
1118 dev
->name
, sbus_readw(lp
->lregs
+ RDP
));
1120 netif_wake_queue(dev
);
1123 static int lance_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1125 struct lance_private
*lp
= netdev_priv(dev
);
1126 int entry
, skblen
, len
;
1130 len
= (skblen
<= ETH_ZLEN
) ? ETH_ZLEN
: skblen
;
1132 spin_lock_irq(&lp
->lock
);
1134 lp
->stats
.tx_bytes
+= len
;
1136 entry
= lp
->tx_new
& TX_RING_MOD_MASK
;
1137 if (lp
->pio_buffer
) {
1138 struct lance_init_block __iomem
*ib
= lp
->init_block_iomem
;
1139 sbus_writew((-len
) | 0xf000, &ib
->btx_ring
[entry
].length
);
1140 sbus_writew(0, &ib
->btx_ring
[entry
].misc
);
1141 lance_piocopy_from_skb(&ib
->tx_buf
[entry
][0], skb
->data
, skblen
);
1143 lance_piozero(&ib
->tx_buf
[entry
][skblen
], len
- skblen
);
1144 sbus_writeb(LE_T1_POK
| LE_T1_OWN
, &ib
->btx_ring
[entry
].tmd1_bits
);
1146 struct lance_init_block
*ib
= lp
->init_block_mem
;
1147 ib
->btx_ring
[entry
].length
= (-len
) | 0xf000;
1148 ib
->btx_ring
[entry
].misc
= 0;
1149 memcpy((char *)&ib
->tx_buf
[entry
][0], skb
->data
, skblen
);
1151 memset((char *) &ib
->tx_buf
[entry
][skblen
], 0, len
- skblen
);
1152 ib
->btx_ring
[entry
].tmd1_bits
= (LE_T1_POK
| LE_T1_OWN
);
1155 lp
->tx_new
= TX_NEXT(entry
);
1157 if (TX_BUFFS_AVAIL
<= 0)
1158 netif_stop_queue(dev
);
1160 /* Kick the lance: transmit now */
1161 sbus_writew(LE_C0_INEA
| LE_C0_TDMD
, lp
->lregs
+ RDP
);
1163 /* Read back CSR to invalidate the E-Cache.
1164 * This is needed, because DMA_DSBL_WR_INV is set.
1167 sbus_readw(lp
->lregs
+ RDP
);
1169 spin_unlock_irq(&lp
->lock
);
1171 dev
->trans_start
= jiffies
;
1177 static struct net_device_stats
*lance_get_stats(struct net_device
*dev
)
1179 struct lance_private
*lp
= netdev_priv(dev
);
1184 /* taken from the depca driver */
1185 static void lance_load_multicast(struct net_device
*dev
)
1187 struct lance_private
*lp
= netdev_priv(dev
);
1188 struct dev_mc_list
*dmi
= dev
->mc_list
;
1194 /* set all multicast bits */
1195 if (dev
->flags
& IFF_ALLMULTI
)
1200 if (lp
->pio_buffer
) {
1201 struct lance_init_block __iomem
*ib
= lp
->init_block_iomem
;
1202 sbus_writel(val
, &ib
->filter
[0]);
1203 sbus_writel(val
, &ib
->filter
[1]);
1205 struct lance_init_block
*ib
= lp
->init_block_mem
;
1206 ib
->filter
[0] = val
;
1207 ib
->filter
[1] = val
;
1210 if (dev
->flags
& IFF_ALLMULTI
)
1214 for (i
= 0; i
< dev
->mc_count
; i
++) {
1215 addrs
= dmi
->dmi_addr
;
1218 /* multicast address? */
1221 crc
= ether_crc_le(6, addrs
);
1223 if (lp
->pio_buffer
) {
1224 struct lance_init_block __iomem
*ib
= lp
->init_block_iomem
;
1225 u16 __iomem
*mcast_table
= (u16 __iomem
*) &ib
->filter
;
1226 u16 tmp
= sbus_readw(&mcast_table
[crc
>>4]);
1227 tmp
|= 1 << (crc
& 0xf);
1228 sbus_writew(tmp
, &mcast_table
[crc
>>4]);
1230 struct lance_init_block
*ib
= lp
->init_block_mem
;
1231 u16
*mcast_table
= (u16
*) &ib
->filter
;
1232 mcast_table
[crc
>> 4] |= 1 << (crc
& 0xf);
1237 static void lance_set_multicast(struct net_device
*dev
)
1239 struct lance_private
*lp
= netdev_priv(dev
);
1240 struct lance_init_block
*ib_mem
= lp
->init_block_mem
;
1241 struct lance_init_block __iomem
*ib_iomem
= lp
->init_block_iomem
;
1244 if (!netif_running(dev
))
1247 if (lp
->tx_old
!= lp
->tx_new
) {
1248 mod_timer(&lp
->multicast_timer
, jiffies
+ 4);
1249 netif_wake_queue(dev
);
1253 netif_stop_queue(dev
);
1259 mode
= sbus_readw(&ib_iomem
->mode
);
1261 mode
= ib_mem
->mode
;
1262 if (dev
->flags
& IFF_PROMISC
) {
1265 sbus_writew(mode
, &ib_iomem
->mode
);
1267 ib_mem
->mode
= mode
;
1269 mode
&= ~LE_MO_PROM
;
1271 sbus_writew(mode
, &ib_iomem
->mode
);
1273 ib_mem
->mode
= mode
;
1274 lance_load_multicast(dev
);
1277 init_restart_lance(lp
);
1278 netif_wake_queue(dev
);
1281 static void lance_set_multicast_retry(unsigned long _opaque
)
1283 struct net_device
*dev
= (struct net_device
*) _opaque
;
1285 lance_set_multicast(dev
);
1288 static void lance_free_hwresources(struct lance_private
*lp
)
1291 sbus_iounmap(lp
->lregs
, LANCE_REG_SIZE
);
1292 if (lp
->init_block_iomem
) {
1293 sbus_iounmap(lp
->init_block_iomem
,
1294 sizeof(struct lance_init_block
));
1295 } else if (lp
->init_block_mem
) {
1296 sbus_free_consistent(lp
->sdev
,
1297 sizeof(struct lance_init_block
),
1299 lp
->init_block_dvma
);
1303 /* Ethtool support... */
1304 static void sparc_lance_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
1306 struct lance_private
*lp
= netdev_priv(dev
);
1308 strcpy(info
->driver
, "sunlance");
1309 strcpy(info
->version
, "2.02");
1310 sprintf(info
->bus_info
, "SBUS:%d",
1314 static u32
sparc_lance_get_link(struct net_device
*dev
)
1316 /* We really do not keep track of this, but this
1317 * is better than not reporting anything at all.
1322 static struct ethtool_ops sparc_lance_ethtool_ops
= {
1323 .get_drvinfo
= sparc_lance_get_drvinfo
,
1324 .get_link
= sparc_lance_get_link
,
1327 static int __init
sparc_lance_probe_one(struct sbus_dev
*sdev
,
1328 struct sbus_dma
*ledma
,
1329 struct sbus_dev
*lebuffer
)
1331 static unsigned version_printed
;
1332 struct net_device
*dev
;
1333 struct lance_private
*lp
;
1336 dev
= alloc_etherdev(sizeof(struct lance_private
) + 8);
1340 lp
= netdev_priv(dev
);
1341 memset(lp
, 0, sizeof(*lp
));
1343 if (sparc_lance_debug
&& version_printed
++ == 0)
1344 printk (KERN_INFO
"%s", version
);
1346 spin_lock_init(&lp
->lock
);
1348 /* Copy the IDPROM ethernet address to the device structure, later we
1349 * will copy the address in the device structure to the lance
1350 * initialization block.
1352 for (i
= 0; i
< 6; i
++)
1353 dev
->dev_addr
[i
] = idprom
->id_ethaddr
[i
];
1355 /* Get the IO region */
1356 lp
->lregs
= sbus_ioremap(&sdev
->resource
[0], 0,
1357 LANCE_REG_SIZE
, lancestr
);
1359 printk(KERN_ERR
"SunLance: Cannot map registers.\n");
1366 if (lebuffer
->resource
[0].start
& 7) {
1367 printk(KERN_ERR
"SunLance: ERROR: Rx and Tx rings not on even boundary.\n");
1370 lp
->init_block_iomem
=
1371 sbus_ioremap(&lebuffer
->resource
[0], 0,
1372 sizeof(struct lance_init_block
), "lebuffer");
1373 if (!lp
->init_block_iomem
) {
1374 printk(KERN_ERR
"SunLance: Cannot map PIO buffer.\n");
1377 lp
->init_block_dvma
= 0;
1379 lp
->init_ring
= lance_init_ring_pio
;
1380 lp
->rx
= lance_rx_pio
;
1381 lp
->tx
= lance_tx_pio
;
1383 lp
->init_block_mem
=
1384 sbus_alloc_consistent(sdev
, sizeof(struct lance_init_block
),
1385 &lp
->init_block_dvma
);
1386 if (!lp
->init_block_mem
|| lp
->init_block_dvma
== 0) {
1387 printk(KERN_ERR
"SunLance: Cannot allocate consistent DMA memory.\n");
1391 lp
->init_ring
= lance_init_ring_dvma
;
1392 lp
->rx
= lance_rx_dvma
;
1393 lp
->tx
= lance_tx_dvma
;
1395 lp
->busmaster_regval
= prom_getintdefault(sdev
->prom_node
,
1397 (LE_C3_BSWP
| LE_C3_ACON
|
1400 lp
->name
= lancestr
;
1403 lp
->burst_sizes
= 0;
1406 unsigned int sbmask
;
1409 /* Find burst-size property for ledma */
1410 lp
->burst_sizes
= prom_getintdefault(ledma
->sdev
->prom_node
,
1413 /* ledma may be capable of fast bursts, but sbus may not. */
1414 sbmask
= prom_getintdefault(ledma
->sdev
->bus
->prom_node
,
1415 "burst-sizes", DMA_BURSTBITS
);
1416 lp
->burst_sizes
&= sbmask
;
1418 /* Get the cable-selection property */
1419 memset(prop
, 0, sizeof(prop
));
1420 prom_getstring(ledma
->sdev
->prom_node
, "cable-selection",
1421 prop
, sizeof(prop
));
1425 printk(KERN_INFO
"SunLance: using auto-carrier-detection.\n");
1427 /* Is this found at /options .attributes in all
1428 * Prom versions? XXX
1430 topnd
= prom_getchild(prom_root_node
);
1432 nd
= prom_searchsiblings(topnd
, "options");
1436 if (!prom_node_has_property(nd
, "tpe-link-test?"))
1439 memset(prop
, 0, sizeof(prop
));
1440 prom_getstring(nd
, "tpe-link-test?", prop
,
1443 if (strcmp(prop
, "true")) {
1444 printk(KERN_NOTICE
"SunLance: warning: overriding option "
1445 "'tpe-link-test?'\n");
1446 printk(KERN_NOTICE
"SunLance: warning: mail any problems "
1447 "to ecd@skynet.be\n");
1448 auxio_set_lte(AUXIO_LTE_ON
);
1451 lp
->auto_select
= 1;
1453 } else if (!strcmp(prop
, "aui")) {
1454 lp
->auto_select
= 0;
1457 lp
->auto_select
= 0;
1461 lp
->dregs
= ledma
->regs
;
1464 csr
= sbus_readl(lp
->dregs
+ DMA_CSR
);
1465 sbus_writel(csr
| DMA_RST_ENET
, lp
->dregs
+ DMA_CSR
);
1467 sbus_writel(csr
& ~DMA_RST_ENET
, lp
->dregs
+ DMA_CSR
);
1472 SET_MODULE_OWNER(dev
);
1473 SET_NETDEV_DEV(dev
, &sdev
->ofdev
.dev
);
1474 dev
->open
= &lance_open
;
1475 dev
->stop
= &lance_close
;
1476 dev
->hard_start_xmit
= &lance_start_xmit
;
1477 dev
->tx_timeout
= &lance_tx_timeout
;
1478 dev
->watchdog_timeo
= 5*HZ
;
1479 dev
->get_stats
= &lance_get_stats
;
1480 dev
->set_multicast_list
= &lance_set_multicast
;
1481 dev
->ethtool_ops
= &sparc_lance_ethtool_ops
;
1483 dev
->irq
= sdev
->irqs
[0];
1487 /* We cannot sleep if the chip is busy during a
1488 * multicast list update event, because such events
1489 * can occur from interrupts (ex. IPv6). So we
1490 * use a timer to try again later when necessary. -DaveM
1492 init_timer(&lp
->multicast_timer
);
1493 lp
->multicast_timer
.data
= (unsigned long) dev
;
1494 lp
->multicast_timer
.function
= &lance_set_multicast_retry
;
1496 if (register_netdev(dev
)) {
1497 printk(KERN_ERR
"SunLance: Cannot register device.\n");
1501 dev_set_drvdata(&sdev
->ofdev
.dev
, lp
);
1503 printk(KERN_INFO
"%s: LANCE ", dev
->name
);
1505 for (i
= 0; i
< 6; i
++)
1506 printk("%2.2x%c", dev
->dev_addr
[i
],
1513 lance_free_hwresources(lp
);
1518 /* On 4m, find the associated dma for the lance chip */
1519 static inline struct sbus_dma
*find_ledma(struct sbus_dev
*sdev
)
1524 if (p
->sdev
== sdev
)
1532 #include <asm/sun4paddr.h>
1533 #include <asm/machines.h>
1535 /* Find all the lance cards on the system and initialize them */
1536 static struct sbus_dev sun4_sdev
;
1537 static int __init
sparc_lance_init(void)
1539 if ((idprom
->id_machtype
== (SM_SUN4
|SM_4_330
)) ||
1540 (idprom
->id_machtype
== (SM_SUN4
|SM_4_470
))) {
1541 memset(&sun4_sdev
, 0, sizeof(sdev
));
1542 sun4_sdev
.reg_addrs
[0].phys_addr
= sun4_eth_physaddr
;
1543 sun4_sdev
.irqs
[0] = 6;
1544 return sparc_lance_probe_one(&sun4_sdev
, NULL
, NULL
);
1549 static int __exit
sunlance_sun4_remove(void)
1551 struct lance_private
*lp
= dev_get_drvdata(&sun4_sdev
->dev
);
1552 struct net_device
*net_dev
= lp
->dev
;
1554 unregister_netdevice(net_dev
);
1556 lance_free_hwresources(root_lance_dev
);
1558 free_netdev(net_dev
);
1560 dev_set_drvdata(&sun4_sdev
->dev
, NULL
);
1565 #else /* !CONFIG_SUN4 */
1567 static int __devinit
sunlance_sbus_probe(struct of_device
*dev
, const struct of_device_id
*match
)
1569 struct sbus_dev
*sdev
= to_sbus_device(&dev
->dev
);
1570 struct device_node
*dp
= dev
->node
;
1573 if (!strcmp(dp
->name
, "le")) {
1574 err
= sparc_lance_probe_one(sdev
, NULL
, NULL
);
1575 } else if (!strcmp(dp
->name
, "ledma")) {
1576 struct sbus_dma
*ledma
= find_ledma(sdev
);
1578 err
= sparc_lance_probe_one(sdev
->child
, ledma
, NULL
);
1580 BUG_ON(strcmp(dp
->name
, "lebuffer"));
1582 err
= sparc_lance_probe_one(sdev
->child
, NULL
, sdev
);
1588 static int __devexit
sunlance_sbus_remove(struct of_device
*dev
)
1590 struct lance_private
*lp
= dev_get_drvdata(&dev
->dev
);
1591 struct net_device
*net_dev
= lp
->dev
;
1593 unregister_netdevice(net_dev
);
1595 lance_free_hwresources(lp
);
1597 free_netdev(net_dev
);
1599 dev_set_drvdata(&dev
->dev
, NULL
);
1604 static struct of_device_id sunlance_sbus_match
[] = {
1617 MODULE_DEVICE_TABLE(of
, sunlance_sbus_match
);
1619 static struct of_platform_driver sunlance_sbus_driver
= {
1621 .match_table
= sunlance_sbus_match
,
1622 .probe
= sunlance_sbus_probe
,
1623 .remove
= __devexit_p(sunlance_sbus_remove
),
1627 /* Find all the lance cards on the system and initialize them */
1628 static int __init
sparc_lance_init(void)
1630 return of_register_driver(&sunlance_sbus_driver
, &sbus_bus_type
);
1632 #endif /* !CONFIG_SUN4 */
1634 static void __exit
sparc_lance_exit(void)
1637 sunlance_sun4_remove();
1639 of_unregister_driver(&sunlance_sbus_driver
);
1643 module_init(sparc_lance_init
);
1644 module_exit(sparc_lance_exit
);