?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.18pre1
[davej-history.git] / drivers / net / sunlance.c
blobae9fb9a63aecf7811055ce5dfc3250af339f7ccf
1 /* $Id: sunlance.c,v 1.88 1999/08/20 00:31:45 davem Exp $
2 * lance.c: Linux/Sparc/Lance driver
3 *
4 * Written 1995, 1996 by Miguel de Icaza
5 * Sources:
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
12 *
13 * 1.4:
14 * Added support to run with a ledma on the Sun4m
15 *
16 * 1.5:
17 * Added multiple card detection.
18 *
19 * 4/17/96: Burst sizes and tpe selection on sun4m by Eddie C. Dost
20 * (ecd@skynet.be)
21 *
22 * 5/15/96: auto carrier detection on sun4m by Eddie C. Dost
23 * (ecd@skynet.be)
24 *
25 * 5/17/96: lebuffer on scsi/ether cards now work David S. Miller
26 * (davem@caip.rutgers.edu)
27 *
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
30 * (ecd@skynet.be)
31 *
32 * 1.7:
33 * 6/26/96: Bug fix for multiple ledmas, miguel.
34 *
35 * 1.8:
36 * Stole multicast code from depca.c, fixed lance_tx.
37 *
38 * 1.9:
39 * 8/21/96: Fixed the multicast code (Pedro Roque)
40 *
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)
44 *
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)
47 *
48 * 11/17/96: Handle LE_C0_MERR in lance_interrupt(). (ecd@skynet.be)
49 *
50 * 12/22/96: Don't loop forever in lance_rx() on incomplete packets.
51 * This was the sun4c killer. Shit, stupid bug.
52 * (ecd@skynet.be)
53 *
54 * 1.10:
55 * 1/26/97: Modularize driver. (ecd@skynet.be)
56 *
57 * 1.11:
58 * 12/27/97: Added sun4d support. (jj@sunsite.mff.cuni.cz)
59 *
60 * 1.12:
61 * 11/3/99: Fixed SMP race in lance_start_xmit found by davem.
62 * Anton Blanchard (anton@progsoc.uts.edu.au)
63 */
64
65 #undef DEBUG_DRIVER
66
67 static char *version =
68 "sunlance.c:v1.12 11/Mar/99 Miguel de Icaza (miguel@nuclecu.unam.mx)\n";
69
70 static char *lancestr = "LANCE";
71 static char *lancedma = "LANCE DMA";
72
73 #include <linux/config.h>
74 #include <linux/module.h>
75
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>
83 #include <linux/in.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>
90 #include <asm/io.h>
91 #include <asm/dma.h>
92 #include <asm/pgtable.h>
93 #include <linux/errno.h>
94 #include <asm/byteorder.h> /* Used by the checksum routines */
95
96 /* Used for the temporal inet entries and routing */
97 #include <linux/socket.h>
98 #include <linux/route.h>
99
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 */
105 #include <asm/irq.h>
106
107 #include <linux/netdevice.h>
108 #include <linux/etherdevice.h>
109 #include <linux/skbuff.h>
110
111 #include <asm/machines.h>
112
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
117 #endif
118
119 #define CRC_POLYNOMIAL_BE 0x04c11db7UL /* Ethernet CRC, big endian */
120 #define CRC_POLYNOMIAL_LE 0xedb88320UL /* Ethernet CRC, little endian */
121
122 #define LE_CSR0 0
123 #define LE_CSR1 1
124 #define LE_CSR2 2
125 #define LE_CSR3 3
126
127 #define LE_MO_PROM 0x8000 /* Enable promiscuous mode */
128
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 */
145
146 #define LE_C3_BSWP 0x4 /* SWAP */
147 #define LE_C3_ACON 0x2 /* ALE Control */
148 #define LE_C3_BCON 0x1 /* Byte control */
149
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 */
160
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 */
169
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 */
176
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)
180
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)
184
185 #define PKT_BUF_SZ 1544
186 #define RX_BUFF_SIZE PKT_BUF_SZ
187 #define TX_BUFF_SIZE PKT_BUF_SZ
188
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)!
194 * Buffer length
195 */
196 unsigned short mblength; /* This is the actual number of bytes received */
197 };
198
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)! */
204 unsigned short misc;
205 };
206
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. */
213
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 */
219
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];
223
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];
227 };
228
229 #define libdesc_offset(rt, elem) \
230 ((__u32)(((unsigned long)(&(((struct lance_init_block *)0)->rt[elem])))))
231
232 #define libbuff_offset(rt, elem) \
233 ((__u32)(((unsigned long)(&(((struct lance_init_block *)0)->rt[elem][0])))))
234
235 struct lance_private {
236 char *name;
237 volatile struct lance_regs *ll;
238 volatile struct lance_init_block *init_block;
239 __u32 init_block_dvma;
240
241 int rx_new, tx_new;
242 int rx_old, tx_old;
243
244 struct net_device_stats stats;
245 struct Linux_SBus_DMA *ledma; /* If set this points to ledma */
246 /* and arch = sun4m */
247
248 int tpe; /* cable-selection is TPE */
249 int auto_select; /* cable-selection by carrier */
250 int burst_sizes; /* ledma SBus burst sizes */
251
252 unsigned short busmaster_regval;
253 unsigned short pio_buffer;
254
255 struct net_device *dev; /* Backpointer */
256 struct lance_private *next_module;
257 struct linux_sbus *sbus;
258 struct timer_list multicast_timer;
259 };
260
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)
264
265 /* On the sparc, the lance control ports are memory mapped */
266 struct lance_regs {
267 unsigned short rdp; /* register data port */
268 unsigned short rap; /* register address port */
269 };
270
271 int sparc_lance_debug = 2;
272
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
279 */
280
281 #define LANCE_ADDR(x) ((long)(x) & ~0xff000000)
282
283 #ifdef MODULE
284 static struct lance_private *root_lance_dev = NULL;
285 #endif
286
287 /* Load the CSR registers */
288 static void load_csrs (struct lance_private *lp)
289 {
290 volatile struct lance_regs *ll = lp->ll;
291 __u32 ib_dvma = lp->init_block_dvma;
292 int leptr;
293
294 /* This is right now because when we are using a PIO buffered
295 * init block, init_block_dvma is set to zero. -DaveM
296 */
297 leptr = LANCE_ADDR (ib_dvma);
298
299 ll->rap = LE_CSR1;
300 ll->rdp = (leptr & 0xFFFF);
301 ll->rap = LE_CSR2;
302 ll->rdp = leptr >> 16;
303 ll->rap = LE_CSR3;
304 ll->rdp = lp->busmaster_regval;
305
306 /* Point back to csr0 */
307 ll->rap = LE_CSR0;
308 }
309
310 #define ZERO 0
311
312 /* Setup the Lance Rx and Tx rings */
313 /* Sets dev->tbusy */
314 static void lance_init_ring (struct net_device *dev)
315 {
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 */
320 int leptr;
321 int i;
322
323 /* This is right now because when we are using a PIO buffered
324 * init block, init_block_dvma is set to zero. -DaveM
325 */
326 aib = ib_dvma;
327
328 /* Lock out other processes while setting up hardware */
329 dev->tbusy = 1;
330 lp->rx_new = lp->tx_new = 0;
331 lp->rx_old = lp->tx_old = 0;
332
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.
336 */
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];
343
344 if (ZERO)
345 printk ("TX rings:\n");
346
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;
355 if (i < 3)
356 if (ZERO) printk ("%d: 0x%8.8x\n", i, leptr);
357 }
358
359 /* Setup the Rx ring entries */
360 if (ZERO)
361 printk ("RX rings:\n");
362 for (i = 0; i < RX_RING_SIZE; i++) {
363 leptr = LANCE_ADDR(aib + libbuff_offset(rx_buf, i));
364
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;
370 if (i < 3 && ZERO)
371 printk ("%d: 0x%8.8x\n", i, leptr);
372 }
373
374 /* Setup the initialization block */
375
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);
379 ib->rx_ptr = leptr;
380 if (ZERO)
381 printk ("RX ptr: %8.8x\n", leptr);
382
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);
386 ib->tx_ptr = leptr;
387 if (ZERO)
388 printk ("TX ptr: %8.8x\n", leptr);
389 }
390
391 static int init_restart_lance (struct lance_private *lp)
392 {
393 volatile struct lance_regs *ll = lp->ll;
394 int i;
395
396 if (lp->ledma) {
397 struct sparc_dma_registers *dregs = lp->ledma->regs;
398 unsigned long creg;
399
400 if (!(dregs->cond_reg & DMA_HNDL_ERROR)) {
401 /* E-Cache draining */
402 while (dregs->cond_reg & DMA_FIFO_ISDRAIN)
403 barrier();
404 }
405
406 creg = dregs->cond_reg;
407 if (lp->burst_sizes & DMA_BURST32)
408 creg |= DMA_E_BURST8;
409 else
410 creg &= ~DMA_E_BURST8;
411
412 creg |= (DMA_DSBL_RD_DRN | DMA_DSBL_WR_INV | DMA_FIFO_INV);
413
414 if (lp->tpe)
415 creg |= DMA_EN_ENETAUI;
416 else
417 creg &= ~DMA_EN_ENETAUI;
418 udelay(20);
419 dregs->cond_reg = creg;
420 udelay(200);
421 }
422
423 ll->rap = LE_CSR0;
424 ll->rdp = LE_C0_INIT;
425
426 /* Wait for the lance to complete initialization */
427 for (i = 0; (i < 100) && !(ll->rdp & (LE_C0_ERR | LE_C0_IDON)); i++)
428 barrier();
429 if ((i == 100) || (ll->rdp & LE_C0_ERR)) {
430 printk ("LANCE unopened after %d ticks, csr0=%4.4x.\n", i, ll->rdp);
431 if (lp->ledma)
432 printk ("dcsr=%8.8x\n",
433 (unsigned int) lp->ledma->regs->cond_reg);
434 return -1;
435 }
436
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;
440
441 if (lp->ledma)
442 lp->ledma->regs->cond_reg |= DMA_INT_ENAB;
443
444 return 0;
445 }
446
447 static int lance_rx (struct net_device *dev)
448 {
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;
452 unsigned char bits;
453 int len;
454 struct sk_buff *skb;
455
456 #ifdef TEST_HITS
457 printk ("[");
458 for (i = 0; i < RX_RING_SIZE; i++) {
459 if (i == lp->rx_new)
460 printk ("%s",
461 ib->brx_ring [i].rmd1_bits & LE_R1_OWN ? "_" : "X");
462 else
463 printk ("%s",
464 ib->brx_ring [i].rmd1_bits & LE_R1_OWN ? "." : "1");
465 }
466 printk ("]");
467 #endif
468
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]) {
472
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,
479 * not the beginning
480 */
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++;
486 } else {
487 len = (rd->mblength & 0xfff) - 4;
488 skb = dev_alloc_skb (len+2);
489
490 if (skb == 0) {
491 printk ("%s: Memory squeeze, deferring packet.\n",
492 dev->name);
493 lp->stats.rx_dropped++;
494 rd->mblength = 0;
495 rd->rmd1_bits = LE_R1_OWN;
496 lp->rx_new = (lp->rx_new + 1) & RX_RING_MOD_MASK;
497 return 0;
498 }
499
500 lp->stats.rx_bytes += len;
501
502 skb->dev = dev;
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]),
507 len, 0);
508 skb->protocol = eth_type_trans (skb, dev);
509 netif_rx (skb);
510 lp->stats.rx_packets++;
511 }
512
513 /* Return the packet to the pool */
514 rd->mblength = 0;
515 rd->rmd1_bits = LE_R1_OWN;
516 lp->rx_new = (lp->rx_new + 1) & RX_RING_MOD_MASK;
517 }
518 return 0;
519 }
520
521 static int lance_tx (struct net_device *dev)
522 {
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;
527 int i, j;
528 int status;
529
530 j = lp->tx_old;
531 for (i = j; i != lp->tx_new; i = j) {
532 td = &ib->btx_ring [i];
533
534 /* If we hit a packet not owned by us, stop */
535 if (td->tmd1_bits & LE_T1_OWN)
536 break;
537
538 if (td->tmd1_bits & LE_T1_ERR) {
539 status = td->misc;
540
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++;
544
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");
551 /* Stop the lance */
552 ll->rap = LE_CSR0;
553 ll->rdp = LE_C0_STOP;
554 lance_init_ring (dev);
555 load_csrs (lp);
556 init_restart_lance (lp);
557 return 0;
558 }
559 }
560
561 /* Buffer errors and underflows turn off the
562 * transmitter, restart the adapter.
563 */
564 if (status & (LE_T3_BUF|LE_T3_UFL)) {
565 lp->stats.tx_fifo_errors++;
566
567 printk ("%s: Tx: ERR_BUF|ERR_UFL, restarting\n",
568 dev->name);
569 /* Stop the lance */
570 ll->rap = LE_CSR0;
571 ll->rdp = LE_C0_STOP;
572 lance_init_ring (dev);
573 load_csrs (lp);
574 init_restart_lance (lp);
575 return 0;
576 }
577 } else if ((td->tmd1_bits & LE_T1_POK) == LE_T1_POK) {
578 /*
579 * So we don't count the packet more than once.
580 */
581 td->tmd1_bits &= ~(LE_T1_POK);
582
583 /* One collision before packet was sent. */
584 if (td->tmd1_bits & LE_T1_EONE)
585 lp->stats.collisions++;
586
587 /* More than one collision, be optimistic. */
588 if (td->tmd1_bits & LE_T1_EMORE)
589 lp->stats.collisions += 2;
590
591 lp->stats.tx_packets++;
592 }
593
594 j = (j + 1) & TX_RING_MOD_MASK;
595 }
596 lp->tx_old = j;
597 return 0;
598 }
599
600 static void lance_interrupt (int irq, void *dev_id, struct pt_regs *regs)
601 {
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;
605 int csr0;
606
607 if (dev->interrupt)
608 printk ("%s: again", dev->name);
609
610 dev->interrupt = 1;
611
612 ll->rap = LE_CSR0;
613 csr0 = ll->rdp;
614
615 /* Acknowledge all the interrupt sources ASAP */
616 ll->rdp = csr0 & (LE_C0_INTR | LE_C0_TINT | LE_C0_RINT);
617
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;
622 }
623
624 if (csr0 & LE_C0_RINT)
625 lance_rx (dev);
626
627 if (csr0 & LE_C0_TINT)
628 lance_tx (dev);
629
630 if ((TX_BUFFS_AVAIL >= 0) && dev->tbusy) {
631 dev->tbusy = 0;
632 mark_bh (NET_BH);
633 }
634
635 if (csr0 & LE_C0_BABL)
636 lp->stats.tx_errors++;
637
638 if (csr0 & LE_C0_MISS)
639 lp->stats.rx_errors++;
640
641 if (csr0 & LE_C0_MERR) {
642 struct sparc_dma_registers *dregs = lp->ledma->regs;
643 unsigned long tst = (unsigned long)dregs->st_addr;
644
645 printk ("%s: Memory error, status %04x, addr %06lx\n",
646 dev->name, csr0, tst & 0xffffff);
647
648 ll->rdp = LE_C0_STOP;
649
650 if (lp->ledma)
651 lp->ledma->regs->cond_reg |= DMA_FIFO_INV;
652
653 lance_init_ring (dev);
654 load_csrs (lp);
655 init_restart_lance (lp);
656 dev->tbusy = 0;
657 }
658
659 ll->rdp = LE_C0_INEA;
660 dev->interrupt = 0;
661 }
662
663 struct net_device *last_dev = 0;
664
665 static int lance_open (struct net_device *dev)
666 {
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;
670 int status = 0;
671
672 last_dev = dev;
673
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));
677 return -EAGAIN;
678 }
679
680 /* Stop the Lance */
681 ll->rap = LE_CSR0;
682 ll->rdp = LE_C0_STOP;
683
684 /* On the 4m, setup the ledma to provide the upper bits for buffers */
685 if (lp->ledma)
686 lp->ledma->regs->dma_test = ((__u32) lp->init_block_dvma) & 0xff000000;
687
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.
691
692 BTW it is common bug in all lance drivers! --ANK
693 */
694 ib->mode = 0;
695 ib->filter [0] = 0;
696 ib->filter [1] = 0;
697
698 lance_init_ring (dev);
699 load_csrs (lp);
700
701 dev->tbusy = 0;
702 dev->interrupt = 0;
703 dev->start = 1;
704
705 status = init_restart_lance (lp);
706 #if 0
707 /* To emulate SunOS, we add a route to the local network */
708 rt_add (RTF_UP,
709 dev->pa_addr & ip_get_mask (dev->pa_addr),
710 ip_get_mask (dev->pa_addr),
711 0, dev, dev->mtu, 0, 0);
712 #endif
713 if (!status && lp->auto_select) {
714 /*
715 * Build a fake network packet and send it to ourselfs.
716 */
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;
721 int i, entry;
722
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];
727 }
728
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;
732
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;
736
737 ll->rdp = LE_C0_INEA | LE_C0_TDMD;
738 flush = ll->rdp;
739 }
740
741 if (!status)
742 MOD_INC_USE_COUNT;
743
744 return status;
745 }
746
747 static int lance_close (struct net_device *dev)
748 {
749 struct lance_private *lp = (struct lance_private *) dev->priv;
750 volatile struct lance_regs *ll = lp->ll;
751
752 dev->start = 0;
753 dev->tbusy = 1;
754 del_timer(&lp->multicast_timer);
755
756 /* Stop the card */
757 ll->rap = LE_CSR0;
758 ll->rdp = LE_C0_STOP;
759
760 free_irq (dev->irq, (void *) dev);
761 MOD_DEC_USE_COUNT;
762 return 0;
763 }
764
765 static inline int lance_reset (struct net_device *dev)
766 {
767 struct lance_private *lp = (struct lance_private *)dev->priv;
768 volatile struct lance_regs *ll = lp->ll;
769 int status;
770
771 /* Stop the lance */
772 ll->rap = LE_CSR0;
773 ll->rdp = LE_C0_STOP;
774
775 /* On the 4m, reset the dma too */
776 if (lp->ledma) {
777 printk ("resetting ledma\n");
778 lp->ledma->regs->cond_reg |= DMA_RST_ENET;
779 udelay (200);
780 lp->ledma->regs->cond_reg &= ~DMA_RST_ENET;
781 lp->ledma->regs->dma_test = ((__u32) lp->init_block_dvma) & 0xff000000;
782 }
783 lance_init_ring (dev);
784 load_csrs (lp);
785 dev->trans_start = jiffies;
786 dev->interrupt = 0;
787 dev->start = 1;
788 dev->tbusy = 0;
789 status = init_restart_lance (lp);
790 #ifdef DEBUG_DRIVER
791 printk ("Lance restart=%d\n", status);
792 #endif
793 return status;
794 }
795
796 static int lance_start_xmit (struct sk_buff *skb, struct net_device *dev)
797 {
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;
802 unsigned long flags;
803 int entry, skblen, len;
804
805 if (test_and_set_bit (0, (void *) &dev->tbusy) != 0) {
806 int tickssofar = jiffies - dev->trans_start;
807
808 if (tickssofar < 100)
809 return 1;
810
811 printk ("%s: transmit timed out, status %04x, reset\n",
812 dev->name, ll->rdp);
813 lp->stats.tx_errors++;
814 lance_reset (dev);
815
816 return 1;
817 }
818
819 skblen = skb->len;
820
821 save_and_cli(flags);
822
823 if (!TX_BUFFS_AVAIL) {
824 restore_flags(flags);
825 return 1;
826 }
827
828 len = (skblen <= ETH_ZLEN) ? ETH_ZLEN : skblen;
829
830 lp->stats.tx_bytes += len;
831
832 entry = lp->tx_new & TX_RING_MOD_MASK;
833 ib->btx_ring [entry].length = (-len) | 0xf000;
834 ib->btx_ring [entry].misc = 0;
835
836 memcpy ((char *)&ib->tx_buf [entry][0], skb->data, skblen);
837
838 /* Clear the slack of the packet, do I need this? */
839 /* For a firewall its a good idea - AC */
840 if (len != skblen)
841 memset ((char *) &ib->tx_buf [entry][skblen], 0, len - skblen);
842
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;
846
847 /* Kick the lance: transmit now */
848 ll->rdp = LE_C0_INEA | LE_C0_TDMD;
849 dev->trans_start = jiffies;
850 dev_kfree_skb (skb);
851
852 if (TX_BUFFS_AVAIL)
853 dev->tbusy = 0;
854
855 /* Read back CSR to invalidate the E-Cache.
856 * This is needed, because DMA_DSBL_WR_INV is set. */
857 if (lp->ledma)
858 flush = ll->rdp;
859
860 restore_flags(flags);
861 return 0;
862 }
863
864 static struct net_device_stats *lance_get_stats (struct net_device *dev)
865 {
866 struct lance_private *lp = (struct lance_private *) dev->priv;
867
868 return &lp->stats;
869 }
870
871 /* taken from the depca driver */
872 static void lance_load_multicast (struct net_device *dev)
873 {
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;
878 char *addrs;
879 int i, j, bit, byte;
880 u32 crc, poly = CRC_POLYNOMIAL_LE;
881
882 /* set all multicast bits */
883 if (dev->flags & IFF_ALLMULTI) {
884 ib->filter [0] = 0xffffffff;
885 ib->filter [1] = 0xffffffff;
886 return;
887 }
888 /* clear the multicast filter */
889 ib->filter [0] = 0;
890 ib->filter [1] = 0;
891
892 /* Add addresses */
893 for (i = 0; i < dev->mc_count; i++) {
894 addrs = dmi->dmi_addr;
895 dmi = dmi->next;
896
897 /* multicast address? */
898 if (!(*addrs & 1))
899 continue;
900
901 crc = 0xffffffff;
902 for (byte = 0; byte < 6; byte++) {
903 for (bit = *addrs++, j = 0; j < 8; j++, bit >>= 1) {
904 int test;
905
906 test = ((bit ^ crc) & 0x01);
907 crc >>= 1;
908
909 if (test)
910 crc = crc ^ poly;
911 }
912 }
913 crc = crc >> 26;
914 mcast_table [crc >> 4] |= 1 << (crc & 0xf);
915 }
916 }
917
918 static void lance_set_multicast (struct net_device *dev)
919 {
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;
923
924 if (!dev->start)
925 return;
926
927 if (dev->tbusy) {
928 mod_timer(&lp->multicast_timer, jiffies + 2);
929 return;
930 }
931 /* This CANNOT be correct. Chip is running
932 and dev->tbusy may change any moment.
933 It is useless to set it.
934
935 Generally, usage of dev->tbusy in this driver is completely
936 wrong.
937
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
941
942 The same is true about a2065.
943 */
944 set_bit (0, (void *) &dev->tbusy);
945
946 if (lp->tx_old != lp->tx_new) {
947 mod_timer(&lp->multicast_timer, jiffies + 4);
948 dev->tbusy = 0;
949 return;
950 }
951
952 ll->rap = LE_CSR0;
953 ll->rdp = LE_C0_STOP;
954 lance_init_ring (dev);
955
956 if (dev->flags & IFF_PROMISC) {
957 ib->mode |= LE_MO_PROM;
958 } else {
959 ib->mode &= ~LE_MO_PROM;
960 lance_load_multicast (dev);
961 }
962 load_csrs (lp);
963 init_restart_lance (lp);
964 dev->tbusy = 0;
965 mark_bh(NET_BH);
966 }
967
968 static int __init
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)
972 {
973 static unsigned version_printed = 0;
974 int i;
975 struct lance_private *lp;
976 volatile struct lance_regs *ll;
977
978 if (dev == NULL) {
979 dev = init_etherdev (0, sizeof (struct lance_private) + 8);
980 } else {
981 dev->priv = kmalloc (sizeof (struct lance_private) + 8,
982 GFP_KERNEL);
983 if (dev->priv == NULL)
984 return -ENOMEM;
985 memset(dev->priv, 0, sizeof (struct lance_private) + 8);
986 }
987 if (sparc_lance_debug && version_printed++ == 0)
988 printk (version);
989
990 printk ("%s: LANCE ", dev->name);
991 /* Fill the dev fields */
992 dev->base_addr = (long) sdev;
993
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.
997 */
998 for (i = 0; i < 6; i++)
999 printk ("%2.2x%c", dev->dev_addr[i] = idprom->id_ethaddr[i],
1000 i == 5 ? ' ': ':');
1001 printk("\n");
1002
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);
1009
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;
1014 if (lebuffer){
1015 prom_apply_sbus_ranges (lebuffer->my_bus,
1016 &lebuffer->reg_addrs [0],
1017 lebuffer->num_registers,
1018 lebuffer);
1019
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;
1025
1026 lp->pio_buffer = 1;
1027 } else {
1028 lp->init_block = (void *)
1029 sparc_dvma_malloc (sizeof (struct lance_init_block),
1030 lancedma, &lp->init_block_dvma);
1031 lp->pio_buffer = 0;
1032 }
1033 lp->busmaster_regval = prom_getintdefault(sdev->prom_node,
1034 "busmaster-regval",
1035 (LE_C3_BSWP | LE_C3_ACON |
1036 LE_C3_BCON));
1037
1038 lp->ll = ll;
1039 lp->name = lancestr;
1040 lp->ledma = ledma;
1041
1042 lp->burst_sizes = 0;
1043 if (lp->ledma) {
1044 char prop[6];
1045 unsigned int sbmask;
1046
1047 /* Find burst-size property for ledma */
1048 lp->burst_sizes = prom_getintdefault(ledma->SBus_dev->prom_node,
1049 "burst-sizes", 0);
1050
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;
1055
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));
1060 if (prop[0] == 0) {
1061 int topnd, nd;
1062
1063 printk("%s: using auto-carrier-detection.\n",
1064 dev->name);
1065
1066 /* Is this found at /options .attributes in all
1067 * Prom versions? XXX
1068 */
1069 topnd = prom_getchild(prom_root_node);
1070
1071 nd = prom_searchsiblings(topnd, "options");
1072 if (!nd)
1073 goto no_link_test;
1074
1075 if (!prom_node_has_property(nd, "tpe-link-test?"))
1076 goto no_link_test;
1077
1078 memset(prop, 0, sizeof(prop));
1079 prom_getstring(nd, "tpe-link-test?", prop,
1080 sizeof(prop));
1081
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);
1088 }
1089 no_link_test:
1090 lp->auto_select = 1;
1091 lp->tpe = 0;
1092 } else if (!strcmp(prop, "aui")) {
1093 lp->auto_select = 0;
1094 lp->tpe = 0;
1095 } else {
1096 lp->auto_select = 0;
1097 lp->tpe = 1;
1098 }
1099
1100 /* Reset ledma */
1101 lp->ledma->regs->cond_reg |= DMA_RST_ENET;
1102 udelay (200);
1103 lp->ledma->regs->cond_reg &= ~DMA_RST_ENET;
1104 }
1105
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",
1109 dev->name);
1110 return ENODEV;
1111 }
1112
1113 lp->dev = dev;
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;
1119
1120 dev->irq = sdev->irqs[0];
1121
1122 dev->dma = 0;
1123 ether_setup (dev);
1124
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
1129 */
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;
1134
1135 #ifdef MODULE
1136 dev->ifindex = dev_new_index();
1137 lp->next_module = root_lance_dev;
1138 root_lance_dev = lp;
1139 #endif
1140 return 0;
1141 }
1142
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)
1146 {
1147 struct Linux_SBus_DMA *p;
1148
1149 for_each_dvma(p)
1150 if (p->SBus_dev == dev)
1151 return p;
1152 return 0;
1153 }
1154
1155 #ifdef CONFIG_SUN4
1156
1157 #include <asm/sun4paddr.h>
1158
1159 /* Find all the lance cards on the system and initialize them */
1160 int __init sparc_lance_probe (struct net_device *dev)
1161 {
1162 static struct linux_sbus_device sdev;
1163 static int called = 0;
1164
1165 if(called)
1166 return ENODEV;
1167 called++;
1168
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;
1173 sdev.irqs[0] = 6;
1174 return sparc_lance_init(dev, &sdev, 0, 0);
1175 }
1176 return ENODEV;
1177 }
1178
1179 #else /* !CONFIG_SUN4 */
1180
1181 /* Find all the lance cards on the system and initialize them */
1182 int __init sparc_lance_probe (struct net_device *dev)
1183 {
1184 struct linux_sbus *bus;
1185 struct linux_sbus_device *sdev = 0;
1186 struct Linux_SBus_DMA *ledma = 0;
1187 static int called = 0;
1188 int cards = 0, v;
1189
1190 if(called)
1191 return ENODEV;
1192 called++;
1193
1194 for_each_sbus (bus) {
1195 for_each_sbusdev (sdev, bus) {
1196 if (cards) dev = NULL;
1197 if (strcmp (sdev->prom_name, "le") == 0) {
1198 cards++;
1199 if ((v = sparc_lance_init(dev, sdev, 0, 0)))
1200 return v;
1201 continue;
1202 }
1203 if (strcmp (sdev->prom_name, "ledma") == 0) {
1204 cards++;
1205 ledma = find_ledma (sdev);
1206 if ((v = sparc_lance_init(dev, sdev->child,
1207 ledma, 0)))
1208 return v;
1209 continue;
1210 }
1211 if (strcmp (sdev->prom_name, "lebuffer") == 0){
1212 cards++;
1213 if ((v = sparc_lance_init(dev, sdev->child,
1214 0, sdev)))
1215 return v;
1216 continue;
1217 }
1218 } /* for each sbusdev */
1219 } /* for each sbus */
1220 if (!cards)
1221 return ENODEV;
1222 return 0;
1223 }
1224 #endif /* !CONFIG_SUN4 */
1225
1226 #ifdef MODULE
1227
1228 int
1229 init_module(void)
1230 {
1231 root_lance_dev = NULL;
1232 return sparc_lance_probe(NULL);
1233 }
1234
1235 void
1236 cleanup_module(void)
1237 {
1238 struct lance_private *lp;
1239
1240 while (root_lance_dev) {
1241 lp = root_lance_dev->next_module;
1242
1243 unregister_netdev(root_lance_dev->dev);
1244 kfree(root_lance_dev->dev);
1245 root_lance_dev = lp;
1246 }
1247 }
1248
1249 #endif /* MODULE */
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux