?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / net / sonic.c
blob2f6e30984134c23e05027c204e618cd32fcd1ee8
1 /*
2 * sonic.c
3 *
4 * (C) 1996,1998 by Thomas Bogendoerfer (tsbogend@alpha.franken.de)
5 *
6 * This driver is based on work from Andreas Busse, but most of
7 * the code is rewritten.
8 *
9 * (C) 1995 by Andreas Busse (andy@waldorf-gmbh.de)
10 *
11 * Core code included by system sonic drivers
12 */
13
14 /*
15 * Sources: Olivetti M700-10 Risc Personal Computer hardware handbook,
16 * National Semiconductors data sheet for the DP83932B Sonic Ethernet
17 * controller, and the files "8390.c" and "skeleton.c" in this directory.
18 */
19
20
21
22 /*
23 * Open/initialize the SONIC controller.
24 *
25 * This routine should set everything up anew at each open, even
26 * registers that "should" only need to be set once at boot, so that
27 * there is non-reboot way to recover if something goes wrong.
28 */
29 static int sonic_open(struct net_device *dev)
30 {
31 if (sonic_debug > 2)
32 printk("sonic_open: initializing sonic driver.\n");
33
34 /*
35 * We don't need to deal with auto-irq stuff since we
36 * hardwire the sonic interrupt.
37 */
38 /*
39 * XXX Horrible work around: We install sonic_interrupt as fast interrupt.
40 * This means that during execution of the handler interrupt are disabled
41 * covering another bug otherwise corrupting data. This doesn't mean
42 * this glue works ok under all situations.
43 */
44 // if (sonic_request_irq(dev->irq, &sonic_interrupt, 0, "sonic", dev)) {
45 if (sonic_request_irq(dev->irq, &sonic_interrupt, SA_INTERRUPT,
46 "sonic", dev)) {
47 printk("\n%s: unable to get IRQ %d .\n", dev->name, dev->irq);
48 return -EAGAIN;
49 }
50
51 /*
52 * Initialize the SONIC
53 */
54 sonic_init(dev);
55
56 netif_start_queue(dev);
57
58 if (sonic_debug > 2)
59 printk("sonic_open: Initialization done.\n");
60
61 return 0;
62 }
63
64
65 /*
66 * Close the SONIC device
67 */
68 static int sonic_close(struct net_device *dev)
69 {
70 unsigned int base_addr = dev->base_addr;
71
72 if (sonic_debug > 2)
73 printk("sonic_close\n");
74
75 netif_stop_queue(dev);
76
77 /*
78 * stop the SONIC, disable interrupts
79 */
80 SONIC_WRITE(SONIC_ISR, 0x7fff);
81 SONIC_WRITE(SONIC_IMR, 0);
82 SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
83
84 sonic_free_irq(dev->irq, dev); /* release the IRQ */
85
86 return 0;
87 }
88
89 static void sonic_tx_timeout(struct net_device *dev)
90 {
91 struct sonic_local *lp = (struct sonic_local *) dev->priv;
92 printk("%s: transmit timed out.\n", dev->name);
93
94 /* Try to restart the adaptor. */
95 sonic_init(dev);
96 lp->stats.tx_errors++;
97 dev->trans_start = jiffies;
98 netif_wake_queue(dev);
99 }
100
101 /*
102 * transmit packet
103 */
104 static int sonic_send_packet(struct sk_buff *skb, struct net_device *dev)
105 {
106 struct sonic_local *lp = (struct sonic_local *) dev->priv;
107 unsigned int base_addr = dev->base_addr;
108 unsigned int laddr;
109 int entry, length;
110
111 netif_stop_queue(dev);
112
113 if (sonic_debug > 2)
114 printk("sonic_send_packet: skb=%p, dev=%p\n", skb, dev);
115
116 /*
117 * Map the packet data into the logical DMA address space
118 */
119 if ((laddr = vdma_alloc(PHYSADDR(skb->data), skb->len)) == ~0UL) {
120 printk("%s: no VDMA entry for transmit available.\n",
121 dev->name);
122 dev_kfree_skb(skb);
123 netif_start_queue(dev);
124 return 1;
125 }
126 entry = lp->cur_tx & SONIC_TDS_MASK;
127 lp->tx_laddr[entry] = laddr;
128 lp->tx_skb[entry] = skb;
129
130 length = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
131 flush_cache_all();
132
133 /*
134 * Setup the transmit descriptor and issue the transmit command.
135 */
136 lp->tda[entry].tx_status = 0; /* clear status */
137 lp->tda[entry].tx_frag_count = 1; /* single fragment */
138 lp->tda[entry].tx_pktsize = length; /* length of packet */
139 lp->tda[entry].tx_frag_ptr_l = laddr & 0xffff;
140 lp->tda[entry].tx_frag_ptr_h = laddr >> 16;
141 lp->tda[entry].tx_frag_size = length;
142 lp->cur_tx++;
143 lp->stats.tx_bytes += length;
144
145 if (sonic_debug > 2)
146 printk("sonic_send_packet: issueing Tx command\n");
147
148 SONIC_WRITE(SONIC_CMD, SONIC_CR_TXP);
149
150 dev->trans_start = jiffies;
151
152 if (lp->cur_tx < lp->dirty_tx + SONIC_NUM_TDS)
153 netif_start_queue(dev);
154 else
155 lp->tx_full = 1;
156
157 return 0;
158 }
159
160 /*
161 * The typical workload of the driver:
162 * Handle the network interface interrupts.
163 */
164 static irqreturn_t sonic_interrupt(int irq, void *dev_id, struct pt_regs *regs)
165 {
166 struct net_device *dev = (struct net_device *) dev_id;
167 unsigned int base_addr = dev->base_addr;
168 struct sonic_local *lp;
169 int status;
170
171 if (dev == NULL) {
172 printk("sonic_interrupt: irq %d for unknown device.\n", irq);
173 return IRQ_NONE;
174 }
175
176 lp = (struct sonic_local *) dev->priv;
177
178 status = SONIC_READ(SONIC_ISR);
179 SONIC_WRITE(SONIC_ISR, 0x7fff); /* clear all bits */
180
181 if (sonic_debug > 2)
182 printk("sonic_interrupt: ISR=%x\n", status);
183
184 if (status & SONIC_INT_PKTRX) {
185 sonic_rx(dev); /* got packet(s) */
186 }
187
188 if (status & SONIC_INT_TXDN) {
189 int dirty_tx = lp->dirty_tx;
190
191 while (dirty_tx < lp->cur_tx) {
192 int entry = dirty_tx & SONIC_TDS_MASK;
193 int status = lp->tda[entry].tx_status;
194
195 if (sonic_debug > 3)
196 printk
197 ("sonic_interrupt: status %d, cur_tx %d, dirty_tx %d\n",
198 status, lp->cur_tx, lp->dirty_tx);
199
200 if (status == 0) {
201 /* It still hasn't been Txed, kick the sonic again */
202 SONIC_WRITE(SONIC_CMD, SONIC_CR_TXP);
203 break;
204 }
205
206 /* put back EOL and free descriptor */
207 lp->tda[entry].tx_frag_count = 0;
208 lp->tda[entry].tx_status = 0;
209
210 if (status & 0x0001)
211 lp->stats.tx_packets++;
212 else {
213 lp->stats.tx_errors++;
214 if (status & 0x0642)
215 lp->stats.tx_aborted_errors++;
216 if (status & 0x0180)
217 lp->stats.tx_carrier_errors++;
218 if (status & 0x0020)
219 lp->stats.tx_window_errors++;
220 if (status & 0x0004)
221 lp->stats.tx_fifo_errors++;
222 }
223
224 /* We must free the original skb */
225 if (lp->tx_skb[entry]) {
226 dev_kfree_skb(lp->tx_skb[entry]);
227 lp->tx_skb[entry] = 0;
228 }
229 /* and the VDMA address */
230 vdma_free(lp->tx_laddr[entry]);
231 dirty_tx++;
232 }
233
234 if (lp->tx_full
235 && dirty_tx + SONIC_NUM_TDS > lp->cur_tx + 2) {
236 /* The ring is no longer full, clear tbusy. */
237 lp->tx_full = 0;
238 netif_wake_queue(dev);
239 }
240
241 lp->dirty_tx = dirty_tx;
242 }
243
244 /*
245 * check error conditions
246 */
247 if (status & SONIC_INT_RFO) {
248 printk("%s: receive fifo underrun\n", dev->name);
249 lp->stats.rx_fifo_errors++;
250 }
251 if (status & SONIC_INT_RDE) {
252 printk("%s: receive descriptors exhausted\n", dev->name);
253 lp->stats.rx_dropped++;
254 }
255 if (status & SONIC_INT_RBE) {
256 printk("%s: receive buffer exhausted\n", dev->name);
257 lp->stats.rx_dropped++;
258 }
259 if (status & SONIC_INT_RBAE) {
260 printk("%s: receive buffer area exhausted\n", dev->name);
261 lp->stats.rx_dropped++;
262 }
263
264 /* counter overruns; all counters are 16bit wide */
265 if (status & SONIC_INT_FAE)
266 lp->stats.rx_frame_errors += 65536;
267 if (status & SONIC_INT_CRC)
268 lp->stats.rx_crc_errors += 65536;
269 if (status & SONIC_INT_MP)
270 lp->stats.rx_missed_errors += 65536;
271
272 /* transmit error */
273 if (status & SONIC_INT_TXER)
274 lp->stats.tx_errors++;
275
276 /*
277 * clear interrupt bits and return
278 */
279 SONIC_WRITE(SONIC_ISR, status);
280 return IRQ_HANDLED;
281 }
282
283 /*
284 * We have a good packet(s), get it/them out of the buffers.
285 */
286 static void sonic_rx(struct net_device *dev)
287 {
288 unsigned int base_addr = dev->base_addr;
289 struct sonic_local *lp = (struct sonic_local *) dev->priv;
290 sonic_rd_t *rd = &lp->rda[lp->cur_rx & SONIC_RDS_MASK];
291 int status;
292
293 while (rd->in_use == 0) {
294 struct sk_buff *skb;
295 int pkt_len;
296 unsigned char *pkt_ptr;
297
298 status = rd->rx_status;
299 if (sonic_debug > 3)
300 printk("status %x, cur_rx %d, cur_rra %x\n",
301 status, lp->cur_rx, lp->cur_rra);
302 if (status & SONIC_RCR_PRX) {
303 pkt_len = rd->rx_pktlen;
304 pkt_ptr =
305 (char *)
306 sonic_chiptomem((rd->rx_pktptr_h << 16) +
307 rd->rx_pktptr_l);
308
309 if (sonic_debug > 3)
310 printk
311 ("pktptr %p (rba %p) h:%x l:%x, bsize h:%x l:%x\n",
312 pkt_ptr, lp->rba, rd->rx_pktptr_h,
313 rd->rx_pktptr_l,
314 SONIC_READ(SONIC_RBWC1),
315 SONIC_READ(SONIC_RBWC0));
316
317 /* Malloc up new buffer. */
318 skb = dev_alloc_skb(pkt_len + 2);
319 if (skb == NULL) {
320 printk
321 ("%s: Memory squeeze, dropping packet.\n",
322 dev->name);
323 lp->stats.rx_dropped++;
324 break;
325 }
326 skb->dev = dev;
327 skb_reserve(skb, 2); /* 16 byte align */
328 skb_put(skb, pkt_len); /* Make room */
329 eth_copy_and_sum(skb, pkt_ptr, pkt_len, 0);
330 skb->protocol = eth_type_trans(skb, dev);
331 netif_rx(skb); /* pass the packet to upper layers */
332 dev->last_rx = jiffies;
333 lp->stats.rx_packets++;
334 lp->stats.rx_bytes += pkt_len;
335
336 } else {
337 /* This should only happen, if we enable accepting broken packets. */
338 lp->stats.rx_errors++;
339 if (status & SONIC_RCR_FAER)
340 lp->stats.rx_frame_errors++;
341 if (status & SONIC_RCR_CRCR)
342 lp->stats.rx_crc_errors++;
343 }
344
345 rd->in_use = 1;
346 rd = &lp->rda[(++lp->cur_rx) & SONIC_RDS_MASK];
347 /* now give back the buffer to the receive buffer area */
348 if (status & SONIC_RCR_LPKT) {
349 /*
350 * this was the last packet out of the current receice buffer
351 * give the buffer back to the SONIC
352 */
353 lp->cur_rra += sizeof(sonic_rr_t);
354 if (lp->cur_rra >
355 (lp->rra_laddr +
356 (SONIC_NUM_RRS -
357 1) * sizeof(sonic_rr_t))) lp->cur_rra =
358 lp->rra_laddr;
359 SONIC_WRITE(SONIC_RWP, lp->cur_rra & 0xffff);
360 } else
361 printk
362 ("%s: rx desc without RCR_LPKT. Shouldn't happen !?\n",
363 dev->name);
364 }
365 /*
366 * If any worth-while packets have been received, dev_rint()
367 * has done a mark_bh(NET_BH) for us and will work on them
368 * when we get to the bottom-half routine.
369 */
370 }
371
372
373 /*
374 * Get the current statistics.
375 * This may be called with the device open or closed.
376 */
377 static struct net_device_stats *sonic_get_stats(struct net_device *dev)
378 {
379 struct sonic_local *lp = (struct sonic_local *) dev->priv;
380 unsigned int base_addr = dev->base_addr;
381
382 /* read the tally counter from the SONIC and reset them */
383 lp->stats.rx_crc_errors += SONIC_READ(SONIC_CRCT);
384 SONIC_WRITE(SONIC_CRCT, 0xffff);
385 lp->stats.rx_frame_errors += SONIC_READ(SONIC_FAET);
386 SONIC_WRITE(SONIC_FAET, 0xffff);
387 lp->stats.rx_missed_errors += SONIC_READ(SONIC_MPT);
388 SONIC_WRITE(SONIC_MPT, 0xffff);
389
390 return &lp->stats;
391 }
392
393
394 /*
395 * Set or clear the multicast filter for this adaptor.
396 */
397 static void sonic_multicast_list(struct net_device *dev)
398 {
399 struct sonic_local *lp = (struct sonic_local *) dev->priv;
400 unsigned int base_addr = dev->base_addr;
401 unsigned int rcr;
402 struct dev_mc_list *dmi = dev->mc_list;
403 unsigned char *addr;
404 int i;
405
406 rcr = SONIC_READ(SONIC_RCR) & ~(SONIC_RCR_PRO | SONIC_RCR_AMC);
407 rcr |= SONIC_RCR_BRD; /* accept broadcast packets */
408
409 if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
410 rcr |= SONIC_RCR_PRO;
411 } else {
412 if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 15)) {
413 rcr |= SONIC_RCR_AMC;
414 } else {
415 if (sonic_debug > 2)
416 printk
417 ("sonic_multicast_list: mc_count %d\n",
418 dev->mc_count);
419 lp->cda.cam_enable = 1; /* always enable our own address */
420 for (i = 1; i <= dev->mc_count; i++) {
421 addr = dmi->dmi_addr;
422 dmi = dmi->next;
423 lp->cda.cam_desc[i].cam_cap0 =
424 addr[1] << 8 | addr[0];
425 lp->cda.cam_desc[i].cam_cap1 =
426 addr[3] << 8 | addr[2];
427 lp->cda.cam_desc[i].cam_cap2 =
428 addr[5] << 8 | addr[4];
429 lp->cda.cam_enable |= (1 << i);
430 }
431 SONIC_WRITE(SONIC_CDC, 16);
432 /* issue Load CAM command */
433 SONIC_WRITE(SONIC_CDP, lp->cda_laddr & 0xffff);
434 SONIC_WRITE(SONIC_CMD, SONIC_CR_LCAM);
435 }
436 }
437
438 if (sonic_debug > 2)
439 printk("sonic_multicast_list: setting RCR=%x\n", rcr);
440
441 SONIC_WRITE(SONIC_RCR, rcr);
442 }
443
444
445 /*
446 * Initialize the SONIC ethernet controller.
447 */
448 static int sonic_init(struct net_device *dev)
449 {
450 unsigned int base_addr = dev->base_addr;
451 unsigned int cmd;
452 struct sonic_local *lp = (struct sonic_local *) dev->priv;
453 unsigned int rra_start;
454 unsigned int rra_end;
455 int i;
456
457 /*
458 * put the Sonic into software-reset mode and
459 * disable all interrupts
460 */
461 SONIC_WRITE(SONIC_ISR, 0x7fff);
462 SONIC_WRITE(SONIC_IMR, 0);
463 SONIC_WRITE(SONIC_CMD, SONIC_CR_RST);
464
465 /*
466 * clear software reset flag, disable receiver, clear and
467 * enable interrupts, then completely initialize the SONIC
468 */
469 SONIC_WRITE(SONIC_CMD, 0);
470 SONIC_WRITE(SONIC_CMD, SONIC_CR_RXDIS);
471
472 /*
473 * initialize the receive resource area
474 */
475 if (sonic_debug > 2)
476 printk("sonic_init: initialize receive resource area\n");
477
478 rra_start = lp->rra_laddr & 0xffff;
479 rra_end =
480 (rra_start + (SONIC_NUM_RRS * sizeof(sonic_rr_t))) & 0xffff;
481
482 for (i = 0; i < SONIC_NUM_RRS; i++) {
483 lp->rra[i].rx_bufadr_l =
484 (lp->rba_laddr + i * SONIC_RBSIZE) & 0xffff;
485 lp->rra[i].rx_bufadr_h =
486 (lp->rba_laddr + i * SONIC_RBSIZE) >> 16;
487 lp->rra[i].rx_bufsize_l = SONIC_RBSIZE >> 1;
488 lp->rra[i].rx_bufsize_h = 0;
489 }
490
491 /* initialize all RRA registers */
492 SONIC_WRITE(SONIC_RSA, rra_start);
493 SONIC_WRITE(SONIC_REA, rra_end);
494 SONIC_WRITE(SONIC_RRP, rra_start);
495 SONIC_WRITE(SONIC_RWP, rra_end);
496 SONIC_WRITE(SONIC_URRA, lp->rra_laddr >> 16);
497 SONIC_WRITE(SONIC_EOBC, (SONIC_RBSIZE - 2) >> 1);
498
499 lp->cur_rra =
500 lp->rra_laddr + (SONIC_NUM_RRS - 1) * sizeof(sonic_rr_t);
501
502 /* load the resource pointers */
503 if (sonic_debug > 3)
504 printk("sonic_init: issueing RRRA command\n");
505
506 SONIC_WRITE(SONIC_CMD, SONIC_CR_RRRA);
507 i = 0;
508 while (i++ < 100) {
509 if (SONIC_READ(SONIC_CMD) & SONIC_CR_RRRA)
510 break;
511 }
512
513 if (sonic_debug > 2)
514 printk("sonic_init: status=%x\n", SONIC_READ(SONIC_CMD));
515
516 /*
517 * Initialize the receive descriptors so that they
518 * become a circular linked list, ie. let the last
519 * descriptor point to the first again.
520 */
521 if (sonic_debug > 2)
522 printk("sonic_init: initialize receive descriptors\n");
523 for (i = 0; i < SONIC_NUM_RDS; i++) {
524 lp->rda[i].rx_status = 0;
525 lp->rda[i].rx_pktlen = 0;
526 lp->rda[i].rx_pktptr_l = 0;
527 lp->rda[i].rx_pktptr_h = 0;
528 lp->rda[i].rx_seqno = 0;
529 lp->rda[i].in_use = 1;
530 lp->rda[i].link =
531 lp->rda_laddr + (i + 1) * sizeof(sonic_rd_t);
532 }
533 /* fix last descriptor */
534 lp->rda[SONIC_NUM_RDS - 1].link = lp->rda_laddr;
535 lp->cur_rx = 0;
536 SONIC_WRITE(SONIC_URDA, lp->rda_laddr >> 16);
537 SONIC_WRITE(SONIC_CRDA, lp->rda_laddr & 0xffff);
538
539 /*
540 * initialize transmit descriptors
541 */
542 if (sonic_debug > 2)
543 printk("sonic_init: initialize transmit descriptors\n");
544 for (i = 0; i < SONIC_NUM_TDS; i++) {
545 lp->tda[i].tx_status = 0;
546 lp->tda[i].tx_config = 0;
547 lp->tda[i].tx_pktsize = 0;
548 lp->tda[i].tx_frag_count = 0;
549 lp->tda[i].link =
550 (lp->tda_laddr +
551 (i + 1) * sizeof(sonic_td_t)) | SONIC_END_OF_LINKS;
552 }
553 lp->tda[SONIC_NUM_TDS - 1].link =
554 (lp->tda_laddr & 0xffff) | SONIC_END_OF_LINKS;
555
556 SONIC_WRITE(SONIC_UTDA, lp->tda_laddr >> 16);
557 SONIC_WRITE(SONIC_CTDA, lp->tda_laddr & 0xffff);
558 lp->cur_tx = lp->dirty_tx = 0;
559
560 /*
561 * put our own address to CAM desc[0]
562 */
563 lp->cda.cam_desc[0].cam_cap0 =
564 dev->dev_addr[1] << 8 | dev->dev_addr[0];
565 lp->cda.cam_desc[0].cam_cap1 =
566 dev->dev_addr[3] << 8 | dev->dev_addr[2];
567 lp->cda.cam_desc[0].cam_cap2 =
568 dev->dev_addr[5] << 8 | dev->dev_addr[4];
569 lp->cda.cam_enable = 1;
570
571 for (i = 0; i < 16; i++)
572 lp->cda.cam_desc[i].cam_entry_pointer = i;
573
574 /*
575 * initialize CAM registers
576 */
577 SONIC_WRITE(SONIC_CDP, lp->cda_laddr & 0xffff);
578 SONIC_WRITE(SONIC_CDC, 16);
579
580 /*
581 * load the CAM
582 */
583 SONIC_WRITE(SONIC_CMD, SONIC_CR_LCAM);
584
585 i = 0;
586 while (i++ < 100) {
587 if (SONIC_READ(SONIC_ISR) & SONIC_INT_LCD)
588 break;
589 }
590 if (sonic_debug > 2) {
591 printk("sonic_init: CMD=%x, ISR=%x\n",
592 SONIC_READ(SONIC_CMD), SONIC_READ(SONIC_ISR));
593 }
594
595 /*
596 * enable receiver, disable loopback
597 * and enable all interrupts
598 */
599 SONIC_WRITE(SONIC_CMD, SONIC_CR_RXEN | SONIC_CR_STP);
600 SONIC_WRITE(SONIC_RCR, SONIC_RCR_DEFAULT);
601 SONIC_WRITE(SONIC_TCR, SONIC_TCR_DEFAULT);
602 SONIC_WRITE(SONIC_ISR, 0x7fff);
603 SONIC_WRITE(SONIC_IMR, SONIC_IMR_DEFAULT);
604
605 cmd = SONIC_READ(SONIC_CMD);
606 if ((cmd & SONIC_CR_RXEN) == 0 || (cmd & SONIC_CR_STP) == 0)
607 printk("sonic_init: failed, status=%x\n", cmd);
608
609 if (sonic_debug > 2)
610 printk("sonic_init: new status=%x\n",
611 SONIC_READ(SONIC_CMD));
612
613 return 0;
614 }
615
616 MODULE_LICENSE("GPL");
MOXA 2.6.9 from sdlinux-moxaart.tgz