projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[NET]: Make NAPI polling independent of struct net_device objects.
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / fec_8xx / fec_main.c
1 /*
2 * Fast Ethernet Controller (FEC) driver for Motorola MPC8xx.
3 *
4 * Copyright (c) 2003 Intracom S.A.
5 * by Pantelis Antoniou <panto@intracom.gr>
6 *
7 * Heavily based on original FEC driver by Dan Malek <dan@embeddededge.com>
8 * and modifications by Joakim Tjernlund <joakim.tjernlund@lumentis.se>
9 *
10 * Released under the GPL
11 */
12
13 #include <linux/module.h>
14 #include <linux/kernel.h>
15 #include <linux/types.h>
16 #include <linux/string.h>
17 #include <linux/ptrace.h>
18 #include <linux/errno.h>
19 #include <linux/ioport.h>
20 #include <linux/slab.h>
21 #include <linux/interrupt.h>
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/netdevice.h>
25 #include <linux/etherdevice.h>
26 #include <linux/skbuff.h>
27 #include <linux/spinlock.h>
28 #include <linux/mii.h>
29 #include <linux/ethtool.h>
30 #include <linux/bitops.h>
31 #include <linux/dma-mapping.h>
32
33 #include <asm/8xx_immap.h>
34 #include <asm/pgtable.h>
35 #include <asm/mpc8xx.h>
36 #include <asm/irq.h>
37 #include <asm/uaccess.h>
38 #include <asm/commproc.h>
39
40 #include "fec_8xx.h"
41
42 /*************************************************/
43
44 #define FEC_MAX_MULTICAST_ADDRS 64
45
46 /*************************************************/
47
48 static char version[] __devinitdata =
49 DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")" "\n";
50
51 MODULE_AUTHOR("Pantelis Antoniou <panto@intracom.gr>");
52 MODULE_DESCRIPTION("Motorola 8xx FEC ethernet driver");
53 MODULE_LICENSE("GPL");
54
55 int fec_8xx_debug = -1; /* -1 == use FEC_8XX_DEF_MSG_ENABLE as value */
56 module_param(fec_8xx_debug, int, 0);
57 MODULE_PARM_DESC(fec_8xx_debug,
58 "FEC 8xx bitmapped debugging message enable value");
59
60
61 /*************************************************/
62
63 /*
64 * Delay to wait for FEC reset command to complete (in us)
65 */
66 #define FEC_RESET_DELAY 50
67
68 /*****************************************************************************************/
69
70 static void fec_whack_reset(fec_t * fecp)
71 {
72 int i;
73
74 /*
75 * Whack a reset. We should wait for this.
76 */
77 FW(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_RESET);
78 for (i = 0;
79 (FR(fecp, ecntrl) & FEC_ECNTRL_RESET) != 0 && i < FEC_RESET_DELAY;
80 i++)
81 udelay(1);
82
83 if (i == FEC_RESET_DELAY)
84 printk(KERN_WARNING "FEC Reset timeout!\n");
85
86 }
87
88 /****************************************************************************/
89
90 /*
91 * Transmitter timeout.
92 */
93 #define TX_TIMEOUT (2*HZ)
94
95 /****************************************************************************/
96
97 /*
98 * Returns the CRC needed when filling in the hash table for
99 * multicast group filtering
100 * pAddr must point to a MAC address (6 bytes)
101 */
102 static __u32 fec_mulicast_calc_crc(char *pAddr)
103 {
104 u8 byte;
105 int byte_count;
106 int bit_count;
107 __u32 crc = 0xffffffff;
108 u8 msb;
109
110 for (byte_count = 0; byte_count < 6; byte_count++) {
111 byte = pAddr[byte_count];
112 for (bit_count = 0; bit_count < 8; bit_count++) {
113 msb = crc >> 31;
114 crc <<= 1;
115 if (msb ^ (byte & 0x1)) {
116 crc ^= FEC_CRC_POLY;
117 }
118 byte >>= 1;
119 }
120 }
121 return (crc);
122 }
123
124 /*
125 * Set or clear the multicast filter for this adaptor.
126 * Skeleton taken from sunlance driver.
127 * The CPM Ethernet implementation allows Multicast as well as individual
128 * MAC address filtering. Some of the drivers check to make sure it is
129 * a group multicast address, and discard those that are not. I guess I
130 * will do the same for now, but just remove the test if you want
131 * individual filtering as well (do the upper net layers want or support
132 * this kind of feature?).
133 */
134 static void fec_set_multicast_list(struct net_device *dev)
135 {
136 struct fec_enet_private *fep = netdev_priv(dev);
137 fec_t *fecp = fep->fecp;
138 struct dev_mc_list *pmc;
139 __u32 crc;
140 int temp;
141 __u32 csrVal;
142 int hash_index;
143 __u32 hthi, htlo;
144 unsigned long flags;
145
146
147 if ((dev->flags & IFF_PROMISC) != 0) {
148
149 spin_lock_irqsave(&fep->lock, flags);
150 FS(fecp, r_cntrl, FEC_RCNTRL_PROM);
151 spin_unlock_irqrestore(&fep->lock, flags);
152
153 /*
154 * Log any net taps.
155 */
156 printk(KERN_WARNING DRV_MODULE_NAME
157 ": %s: Promiscuous mode enabled.\n", dev->name);
158 return;
159
160 }
161
162 if ((dev->flags & IFF_ALLMULTI) != 0 ||
163 dev->mc_count > FEC_MAX_MULTICAST_ADDRS) {
164 /*
165 * Catch all multicast addresses, set the filter to all 1's.
166 */
167 hthi = 0xffffffffU;
168 htlo = 0xffffffffU;
169 } else {
170 hthi = 0;
171 htlo = 0;
172
173 /*
174 * Now populate the hash table
175 */
176 for (pmc = dev->mc_list; pmc != NULL; pmc = pmc->next) {
177 crc = fec_mulicast_calc_crc(pmc->dmi_addr);
178 temp = (crc & 0x3f) >> 1;
179 hash_index = ((temp & 0x01) << 4) |
180 ((temp & 0x02) << 2) |
181 ((temp & 0x04)) |
182 ((temp & 0x08) >> 2) |
183 ((temp & 0x10) >> 4);
184 csrVal = (1 << hash_index);
185 if (crc & 1)
186 hthi |= csrVal;
187 else
188 htlo |= csrVal;
189 }
190 }
191
192 spin_lock_irqsave(&fep->lock, flags);
193 FC(fecp, r_cntrl, FEC_RCNTRL_PROM);
194 FW(fecp, hash_table_high, hthi);
195 FW(fecp, hash_table_low, htlo);
196 spin_unlock_irqrestore(&fep->lock, flags);
197 }
198
199 static int fec_set_mac_address(struct net_device *dev, void *addr)
200 {
201 struct sockaddr *mac = addr;
202 struct fec_enet_private *fep = netdev_priv(dev);
203 struct fec *fecp = fep->fecp;
204 int i;
205 __u32 addrhi, addrlo;
206 unsigned long flags;
207
208 /* Get pointer to SCC area in parameter RAM. */
209 for (i = 0; i < 6; i++)
210 dev->dev_addr[i] = mac->sa_data[i];
211
212 /*
213 * Set station address.
214 */
215 addrhi = ((__u32) dev->dev_addr[0] << 24) |
216 ((__u32) dev->dev_addr[1] << 16) |
217 ((__u32) dev->dev_addr[2] << 8) |
218 (__u32) dev->dev_addr[3];
219 addrlo = ((__u32) dev->dev_addr[4] << 24) |
220 ((__u32) dev->dev_addr[5] << 16);
221
222 spin_lock_irqsave(&fep->lock, flags);
223 FW(fecp, addr_low, addrhi);
224 FW(fecp, addr_high, addrlo);
225 spin_unlock_irqrestore(&fep->lock, flags);
226
227 return 0;
228 }
229
230 /*
231 * This function is called to start or restart the FEC during a link
232 * change. This only happens when switching between half and full
233 * duplex.
234 */
235 void fec_restart(struct net_device *dev, int duplex, int speed)
236 {
237 #ifdef CONFIG_DUET
238 immap_t *immap = (immap_t *) IMAP_ADDR;
239 __u32 cptr;
240 #endif
241 struct fec_enet_private *fep = netdev_priv(dev);
242 struct fec *fecp = fep->fecp;
243 const struct fec_platform_info *fpi = fep->fpi;
244 cbd_t *bdp;
245 struct sk_buff *skb;
246 int i;
247 __u32 addrhi, addrlo;
248
249 fec_whack_reset(fep->fecp);
250
251 /*
252 * Set station address.
253 */
254 addrhi = ((__u32) dev->dev_addr[0] << 24) |
255 ((__u32) dev->dev_addr[1] << 16) |
256 ((__u32) dev->dev_addr[2] << 8) |
257 (__u32) dev->dev_addr[3];
258 addrlo = ((__u32) dev->dev_addr[4] << 24) |
259 ((__u32) dev->dev_addr[5] << 16);
260 FW(fecp, addr_low, addrhi);
261 FW(fecp, addr_high, addrlo);
262
263 /*
264 * Reset all multicast.
265 */
266 FW(fecp, hash_table_high, 0);
267 FW(fecp, hash_table_low, 0);
268
269 /*
270 * Set maximum receive buffer size.
271 */
272 FW(fecp, r_buff_size, PKT_MAXBLR_SIZE);
273 FW(fecp, r_hash, PKT_MAXBUF_SIZE);
274
275 /*
276 * Set receive and transmit descriptor base.
277 */
278 FW(fecp, r_des_start, iopa((__u32) (fep->rx_bd_base)));
279 FW(fecp, x_des_start, iopa((__u32) (fep->tx_bd_base)));
280
281 fep->dirty_tx = fep->cur_tx = fep->tx_bd_base;
282 fep->tx_free = fep->tx_ring;
283 fep->cur_rx = fep->rx_bd_base;
284
285 /*
286 * Reset SKB receive buffers
287 */
288 for (i = 0; i < fep->rx_ring; i++) {
289 if ((skb = fep->rx_skbuff[i]) == NULL)
290 continue;
291 fep->rx_skbuff[i] = NULL;
292 dev_kfree_skb(skb);
293 }
294
295 /*
296 * Initialize the receive buffer descriptors.
297 */
298 for (i = 0, bdp = fep->rx_bd_base; i < fep->rx_ring; i++, bdp++) {
299 skb = dev_alloc_skb(ENET_RX_FRSIZE);
300 if (skb == NULL) {
301 printk(KERN_WARNING DRV_MODULE_NAME
302 ": %s Memory squeeze, unable to allocate skb\n",
303 dev->name);
304 fep->stats.rx_dropped++;
305 break;
306 }
307 fep->rx_skbuff[i] = skb;
308 skb->dev = dev;
309 CBDW_BUFADDR(bdp, dma_map_single(NULL, skb->data,
310 L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
311 DMA_FROM_DEVICE));
312 CBDW_DATLEN(bdp, 0); /* zero */
313 CBDW_SC(bdp, BD_ENET_RX_EMPTY |
314 ((i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP));
315 }
316 /*
317 * if we failed, fillup remainder
318 */
319 for (; i < fep->rx_ring; i++, bdp++) {
320 fep->rx_skbuff[i] = NULL;
321 CBDW_SC(bdp, (i < fep->rx_ring - 1) ? 0 : BD_SC_WRAP);
322 }
323
324 /*
325 * Reset SKB transmit buffers.
326 */
327 for (i = 0; i < fep->tx_ring; i++) {
328 if ((skb = fep->tx_skbuff[i]) == NULL)
329 continue;
330 fep->tx_skbuff[i] = NULL;
331 dev_kfree_skb(skb);
332 }
333
334 /*
335 * ...and the same for transmit.
336 */
337 for (i = 0, bdp = fep->tx_bd_base; i < fep->tx_ring; i++, bdp++) {
338 fep->tx_skbuff[i] = NULL;
339 CBDW_BUFADDR(bdp, virt_to_bus(NULL));
340 CBDW_DATLEN(bdp, 0);
341 CBDW_SC(bdp, (i < fep->tx_ring - 1) ? 0 : BD_SC_WRAP);
342 }
343
344 /*
345 * Enable big endian and don't care about SDMA FC.
346 */
347 FW(fecp, fun_code, 0x78000000);
348
349 /*
350 * Set MII speed.
351 */
352 FW(fecp, mii_speed, fep->fec_phy_speed);
353
354 /*
355 * Clear any outstanding interrupt.
356 */
357 FW(fecp, ievent, 0xffc0);
358 FW(fecp, ivec, (fpi->fec_irq / 2) << 29);
359
360 /*
361 * adjust to speed (only for DUET & RMII)
362 */
363 #ifdef CONFIG_DUET
364 cptr = in_be32(&immap->im_cpm.cp_cptr);
365 switch (fpi->fec_no) {
366 case 0:
367 /*
368 * check if in RMII mode
369 */
370 if ((cptr & 0x100) == 0)
371 break;
372
373 if (speed == 10)
374 cptr |= 0x0000010;
375 else if (speed == 100)
376 cptr &= ~0x0000010;
377 break;
378 case 1:
379 /*
380 * check if in RMII mode
381 */
382 if ((cptr & 0x80) == 0)
383 break;
384
385 if (speed == 10)
386 cptr |= 0x0000008;
387 else if (speed == 100)
388 cptr &= ~0x0000008;
389 break;
390 default:
391 break;
392 }
393 out_be32(&immap->im_cpm.cp_cptr, cptr);
394 #endif
395
396 FW(fecp, r_cntrl, FEC_RCNTRL_MII_MODE); /* MII enable */
397 /*
398 * adjust to duplex mode
399 */
400 if (duplex) {
401 FC(fecp, r_cntrl, FEC_RCNTRL_DRT);
402 FS(fecp, x_cntrl, FEC_TCNTRL_FDEN); /* FD enable */
403 } else {
404 FS(fecp, r_cntrl, FEC_RCNTRL_DRT);
405 FC(fecp, x_cntrl, FEC_TCNTRL_FDEN); /* FD disable */
406 }
407
408 /*
409 * Enable interrupts we wish to service.
410 */
411 FW(fecp, imask, FEC_ENET_TXF | FEC_ENET_TXB |
412 FEC_ENET_RXF | FEC_ENET_RXB);
413
414 /*
415 * And last, enable the transmit and receive processing.
416 */
417 FW(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
418 FW(fecp, r_des_active, 0x01000000);
419 }
420
421 void fec_stop(struct net_device *dev)
422 {
423 struct fec_enet_private *fep = netdev_priv(dev);
424 fec_t *fecp = fep->fecp;
425 struct sk_buff *skb;
426 int i;
427
428 if ((FR(fecp, ecntrl) & FEC_ECNTRL_ETHER_EN) == 0)
429 return; /* already down */
430
431 FW(fecp, x_cntrl, 0x01); /* Graceful transmit stop */
432 for (i = 0; ((FR(fecp, ievent) & 0x10000000) == 0) &&
433 i < FEC_RESET_DELAY; i++)
434 udelay(1);
435
436 if (i == FEC_RESET_DELAY)
437 printk(KERN_WARNING DRV_MODULE_NAME
438 ": %s FEC timeout on graceful transmit stop\n",
439 dev->name);
440 /*
441 * Disable FEC. Let only MII interrupts.
442 */
443 FW(fecp, imask, 0);
444 FW(fecp, ecntrl, ~FEC_ECNTRL_ETHER_EN);
445
446 /*
447 * Reset SKB transmit buffers.
448 */
449 for (i = 0; i < fep->tx_ring; i++) {
450 if ((skb = fep->tx_skbuff[i]) == NULL)
451 continue;
452 fep->tx_skbuff[i] = NULL;
453 dev_kfree_skb(skb);
454 }
455
456 /*
457 * Reset SKB receive buffers
458 */
459 for (i = 0; i < fep->rx_ring; i++) {
460 if ((skb = fep->rx_skbuff[i]) == NULL)
461 continue;
462 fep->rx_skbuff[i] = NULL;
463 dev_kfree_skb(skb);
464 }
465 }
466
467 /* common receive function */
468 static int fec_enet_rx_common(struct fec_enet_private *ep,
469 struct net_device *dev, int budget)
470 {
471 fec_t *fecp = fep->fecp;
472 const struct fec_platform_info *fpi = fep->fpi;
473 cbd_t *bdp;
474 struct sk_buff *skb, *skbn, *skbt;
475 int received = 0;
476 __u16 pkt_len, sc;
477 int curidx;
478
479 if (fpi->use_napi) {
480 if (!netif_running(dev))
481 return 0;
482 }
483
484 /*
485 * First, grab all of the stats for the incoming packet.
486 * These get messed up if we get called due to a busy condition.
487 */
488 bdp = fep->cur_rx;
489
490 /* clear RX status bits for napi*/
491 if (fpi->use_napi)
492 FW(fecp, ievent, FEC_ENET_RXF | FEC_ENET_RXB);
493
494 while (((sc = CBDR_SC(bdp)) & BD_ENET_RX_EMPTY) == 0) {
495
496 curidx = bdp - fep->rx_bd_base;
497
498 /*
499 * Since we have allocated space to hold a complete frame,
500 * the last indicator should be set.
501 */
502 if ((sc & BD_ENET_RX_LAST) == 0)
503 printk(KERN_WARNING DRV_MODULE_NAME
504 ": %s rcv is not +last\n",
505 dev->name);
506
507 /*
508 * Check for errors.
509 */
510 if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH | BD_ENET_RX_CL |
511 BD_ENET_RX_NO | BD_ENET_RX_CR | BD_ENET_RX_OV)) {
512 fep->stats.rx_errors++;
513 /* Frame too long or too short. */
514 if (sc & (BD_ENET_RX_LG | BD_ENET_RX_SH))
515 fep->stats.rx_length_errors++;
516 /* Frame alignment */
517 if (sc & (BD_ENET_RX_NO | BD_ENET_RX_CL))
518 fep->stats.rx_frame_errors++;
519 /* CRC Error */
520 if (sc & BD_ENET_RX_CR)
521 fep->stats.rx_crc_errors++;
522 /* FIFO overrun */
523 if (sc & BD_ENET_RX_OV)
524 fep->stats.rx_crc_errors++;
525
526 skbn = fep->rx_skbuff[curidx];
527 BUG_ON(skbn == NULL);
528
529 } else {
530 skb = fep->rx_skbuff[curidx];
531 BUG_ON(skb == NULL);
532
533 /*
534 * Process the incoming frame.
535 */
536 fep->stats.rx_packets++;
537 pkt_len = CBDR_DATLEN(bdp) - 4; /* remove CRC */
538 fep->stats.rx_bytes += pkt_len + 4;
539
540 if (pkt_len <= fpi->rx_copybreak) {
541 /* +2 to make IP header L1 cache aligned */
542 skbn = dev_alloc_skb(pkt_len + 2);
543 if (skbn != NULL) {
544 skb_reserve(skbn, 2); /* align IP header */
545 skb_copy_from_linear_data(skb,
546 skbn->data,
547 pkt_len);
548 /* swap */
549 skbt = skb;
550 skb = skbn;
551 skbn = skbt;
552 }
553 } else
554 skbn = dev_alloc_skb(ENET_RX_FRSIZE);
555
556 if (skbn != NULL) {
557 skb_put(skb, pkt_len); /* Make room */
558 skb->protocol = eth_type_trans(skb, dev);
559 received++;
560 if (!fpi->use_napi)
561 netif_rx(skb);
562 else
563 netif_receive_skb(skb);
564 } else {
565 printk(KERN_WARNING DRV_MODULE_NAME
566 ": %s Memory squeeze, dropping packet.\n",
567 dev->name);
568 fep->stats.rx_dropped++;
569 skbn = skb;
570 }
571 }
572
573 fep->rx_skbuff[curidx] = skbn;
574 CBDW_BUFADDR(bdp, dma_map_single(NULL, skbn->data,
575 L1_CACHE_ALIGN(PKT_MAXBUF_SIZE),
576 DMA_FROM_DEVICE));
577 CBDW_DATLEN(bdp, 0);
578 CBDW_SC(bdp, (sc & ~BD_ENET_RX_STATS) | BD_ENET_RX_EMPTY);
579
580 /*
581 * Update BD pointer to next entry.
582 */
583 if ((sc & BD_ENET_RX_WRAP) == 0)
584 bdp++;
585 else
586 bdp = fep->rx_bd_base;
587
588 /*
589 * Doing this here will keep the FEC running while we process
590 * incoming frames. On a heavily loaded network, we should be
591 * able to keep up at the expense of system resources.
592 */
593 FW(fecp, r_des_active, 0x01000000);
594
595 if (received >= budget)
596 break;
597
598 }
599
600 fep->cur_rx = bdp;
601
602 if (fpi->use_napi) {
603 if (received < budget) {
604 netif_rx_complete(dev, &fep->napi);
605
606 /* enable RX interrupt bits */
607 FS(fecp, imask, FEC_ENET_RXF | FEC_ENET_RXB);
608 }
609 }
610
611 return received;
612 }
613
614 static void fec_enet_tx(struct net_device *dev)
615 {
616 struct fec_enet_private *fep = netdev_priv(dev);
617 cbd_t *bdp;
618 struct sk_buff *skb;
619 int dirtyidx, do_wake;
620 __u16 sc;
621
622 spin_lock(&fep->lock);
623 bdp = fep->dirty_tx;
624
625 do_wake = 0;
626 while (((sc = CBDR_SC(bdp)) & BD_ENET_TX_READY) == 0) {
627
628 dirtyidx = bdp - fep->tx_bd_base;
629
630 if (fep->tx_free == fep->tx_ring)
631 break;
632
633 skb = fep->tx_skbuff[dirtyidx];
634
635 /*
636 * Check for errors.
637 */
638 if (sc & (BD_ENET_TX_HB | BD_ENET_TX_LC |
639 BD_ENET_TX_RL | BD_ENET_TX_UN | BD_ENET_TX_CSL)) {
640 fep->stats.tx_errors++;
641 if (sc & BD_ENET_TX_HB) /* No heartbeat */
642 fep->stats.tx_heartbeat_errors++;
643 if (sc & BD_ENET_TX_LC) /* Late collision */
644 fep->stats.tx_window_errors++;
645 if (sc & BD_ENET_TX_RL) /* Retrans limit */
646 fep->stats.tx_aborted_errors++;
647 if (sc & BD_ENET_TX_UN) /* Underrun */
648 fep->stats.tx_fifo_errors++;
649 if (sc & BD_ENET_TX_CSL) /* Carrier lost */
650 fep->stats.tx_carrier_errors++;
651 } else
652 fep->stats.tx_packets++;
653
654 if (sc & BD_ENET_TX_READY)
655 printk(KERN_WARNING DRV_MODULE_NAME
656 ": %s HEY! Enet xmit interrupt and TX_READY.\n",
657 dev->name);
658
659 /*
660 * Deferred means some collisions occurred during transmit,
661 * but we eventually sent the packet OK.
662 */
663 if (sc & BD_ENET_TX_DEF)
664 fep->stats.collisions++;
665
666 /*
667 * Free the sk buffer associated with this last transmit.
668 */
669 dev_kfree_skb_irq(skb);
670 fep->tx_skbuff[dirtyidx] = NULL;
671
672 /*
673 * Update pointer to next buffer descriptor to be transmitted.
674 */
675 if ((sc & BD_ENET_TX_WRAP) == 0)
676 bdp++;
677 else
678 bdp = fep->tx_bd_base;
679
680 /*
681 * Since we have freed up a buffer, the ring is no longer
682 * full.
683 */
684 if (!fep->tx_free++)
685 do_wake = 1;
686 }
687
688 fep->dirty_tx = bdp;
689
690 spin_unlock(&fep->lock);
691
692 if (do_wake && netif_queue_stopped(dev))
693 netif_wake_queue(dev);
694 }
695
696 /*
697 * The interrupt handler.
698 * This is called from the MPC core interrupt.
699 */
700 static irqreturn_t
701 fec_enet_interrupt(int irq, void *dev_id)
702 {
703 struct net_device *dev = dev_id;
704 struct fec_enet_private *fep;
705 const struct fec_platform_info *fpi;
706 fec_t *fecp;
707 __u32 int_events;
708 __u32 int_events_napi;
709
710 if (unlikely(dev == NULL))
711 return IRQ_NONE;
712
713 fep = netdev_priv(dev);
714 fecp = fep->fecp;
715 fpi = fep->fpi;
716
717 /*
718 * Get the interrupt events that caused us to be here.
719 */
720 while ((int_events = FR(fecp, ievent) & FR(fecp, imask)) != 0) {
721
722 if (!fpi->use_napi)
723 FW(fecp, ievent, int_events);
724 else {
725 int_events_napi = int_events & ~(FEC_ENET_RXF | FEC_ENET_RXB);
726 FW(fecp, ievent, int_events_napi);
727 }
728
729 if ((int_events & (FEC_ENET_HBERR | FEC_ENET_BABR |
730 FEC_ENET_BABT | FEC_ENET_EBERR)) != 0)
731 printk(KERN_WARNING DRV_MODULE_NAME
732 ": %s FEC ERROR(s) 0x%x\n",
733 dev->name, int_events);
734
735 if ((int_events & FEC_ENET_RXF) != 0) {
736 if (!fpi->use_napi)
737 fec_enet_rx_common(fep, dev, ~0);
738 else {
739 if (netif_rx_schedule_prep(dev, &fep->napi)) {
740 /* disable rx interrupts */
741 FC(fecp, imask, FEC_ENET_RXF | FEC_ENET_RXB);
742 __netif_rx_schedule(dev, &fep->napi);
743 } else {
744 printk(KERN_ERR DRV_MODULE_NAME
745 ": %s driver bug! interrupt while in poll!\n",
746 dev->name);
747 FC(fecp, imask, FEC_ENET_RXF | FEC_ENET_RXB);
748 }
749 }
750 }
751
752 if ((int_events & FEC_ENET_TXF) != 0)
753 fec_enet_tx(dev);
754 }
755
756 return IRQ_HANDLED;
757 }
758
759 /* This interrupt occurs when the PHY detects a link change. */
760 static irqreturn_t
761 fec_mii_link_interrupt(int irq, void *dev_id)
762 {
763 struct net_device *dev = dev_id;
764 struct fec_enet_private *fep;
765 const struct fec_platform_info *fpi;
766
767 if (unlikely(dev == NULL))
768 return IRQ_NONE;
769
770 fep = netdev_priv(dev);
771 fpi = fep->fpi;
772
773 if (!fpi->use_mdio)
774 return IRQ_NONE;
775
776 /*
777 * Acknowledge the interrupt if possible. If we have not
778 * found the PHY yet we can't process or acknowledge the
779 * interrupt now. Instead we ignore this interrupt for now,
780 * which we can do since it is edge triggered. It will be
781 * acknowledged later by fec_enet_open().
782 */
783 if (!fep->phy)
784 return IRQ_NONE;
785
786 fec_mii_ack_int(dev);
787 fec_mii_link_status_change_check(dev, 0);
788
789 return IRQ_HANDLED;
790 }
791
792
793 /**********************************************************************************/
794
795 static int fec_enet_start_xmit(struct sk_buff *skb, struct net_device *dev)
796 {
797 struct fec_enet_private *fep = netdev_priv(dev);
798 fec_t *fecp = fep->fecp;
799 cbd_t *bdp;
800 int curidx;
801 unsigned long flags;
802
803 spin_lock_irqsave(&fep->tx_lock, flags);
804
805 /*
806 * Fill in a Tx ring entry
807 */
808 bdp = fep->cur_tx;
809
810 if (!fep->tx_free || (CBDR_SC(bdp) & BD_ENET_TX_READY)) {
811 netif_stop_queue(dev);
812 spin_unlock_irqrestore(&fep->tx_lock, flags);
813
814 /*
815 * Ooops. All transmit buffers are full. Bail out.
816 * This should not happen, since the tx queue should be stopped.
817 */
818 printk(KERN_WARNING DRV_MODULE_NAME
819 ": %s tx queue full!.\n", dev->name);
820 return 1;
821 }
822
823 curidx = bdp - fep->tx_bd_base;
824 /*
825 * Clear all of the status flags.
826 */
827 CBDC_SC(bdp, BD_ENET_TX_STATS);
828
829 /*
830 * Save skb pointer.
831 */
832 fep->tx_skbuff[curidx] = skb;
833
834 fep->stats.tx_bytes += skb->len;
835
836 /*
837 * Push the data cache so the CPM does not get stale memory data.
838 */
839 CBDW_BUFADDR(bdp, dma_map_single(NULL, skb->data,
840 skb->len, DMA_TO_DEVICE));
841 CBDW_DATLEN(bdp, skb->len);
842
843 dev->trans_start = jiffies;
844
845 /*
846 * If this was the last BD in the ring, start at the beginning again.
847 */
848 if ((CBDR_SC(bdp) & BD_ENET_TX_WRAP) == 0)
849 fep->cur_tx++;
850 else
851 fep->cur_tx = fep->tx_bd_base;
852
853 if (!--fep->tx_free)
854 netif_stop_queue(dev);
855
856 /*
857 * Trigger transmission start
858 */
859 CBDS_SC(bdp, BD_ENET_TX_READY | BD_ENET_TX_INTR |
860 BD_ENET_TX_LAST | BD_ENET_TX_TC);
861 FW(fecp, x_des_active, 0x01000000);
862
863 spin_unlock_irqrestore(&fep->tx_lock, flags);
864
865 return 0;
866 }
867
868 static void fec_timeout(struct net_device *dev)
869 {
870 struct fec_enet_private *fep = netdev_priv(dev);
871
872 fep->stats.tx_errors++;
873
874 if (fep->tx_free)
875 netif_wake_queue(dev);
876
877 /* check link status again */
878 fec_mii_link_status_change_check(dev, 0);
879 }
880
881 static int fec_enet_open(struct net_device *dev)
882 {
883 struct fec_enet_private *fep = netdev_priv(dev);
884 const struct fec_platform_info *fpi = fep->fpi;
885 unsigned long flags;
886
887 napi_enable(&fep->napi);
888
889 /* Install our interrupt handler. */
890 if (request_irq(fpi->fec_irq, fec_enet_interrupt, 0, "fec", dev) != 0) {
891 printk(KERN_ERR DRV_MODULE_NAME
892 ": %s Could not allocate FEC IRQ!", dev->name);
893 napi_disable(&fep->napi);
894 return -EINVAL;
895 }
896
897 /* Install our phy interrupt handler */
898 if (fpi->phy_irq != -1 &&
899 request_irq(fpi->phy_irq, fec_mii_link_interrupt, 0, "fec-phy",
900 dev) != 0) {
901 printk(KERN_ERR DRV_MODULE_NAME
902 ": %s Could not allocate PHY IRQ!", dev->name);
903 free_irq(fpi->fec_irq, dev);
904 napi_disable(&fep->napi);
905 return -EINVAL;
906 }
907
908 if (fpi->use_mdio) {
909 fec_mii_startup(dev);
910 netif_carrier_off(dev);
911 fec_mii_link_status_change_check(dev, 1);
912 } else {
913 spin_lock_irqsave(&fep->lock, flags);
914 fec_restart(dev, 1, 100); /* XXX this sucks */
915 spin_unlock_irqrestore(&fep->lock, flags);
916
917 netif_carrier_on(dev);
918 netif_start_queue(dev);
919 }
920 return 0;
921 }
922
923 static int fec_enet_close(struct net_device *dev)
924 {
925 struct fec_enet_private *fep = netdev_priv(dev);
926 const struct fec_platform_info *fpi = fep->fpi;
927 unsigned long flags;
928
929 netif_stop_queue(dev);
930 napi_disable(&fep->napi);
931 netif_carrier_off(dev);
932
933 if (fpi->use_mdio)
934 fec_mii_shutdown(dev);
935
936 spin_lock_irqsave(&fep->lock, flags);
937 fec_stop(dev);
938 spin_unlock_irqrestore(&fep->lock, flags);
939
940 /* release any irqs */
941 if (fpi->phy_irq != -1)
942 free_irq(fpi->phy_irq, dev);
943 free_irq(fpi->fec_irq, dev);
944
945 return 0;
946 }
947
948 static struct net_device_stats *fec_enet_get_stats(struct net_device *dev)
949 {
950 struct fec_enet_private *fep = netdev_priv(dev);
951 return &fep->stats;
952 }
953
954 static int fec_enet_poll(struct napi_struct *napi, int budget)
955 {
956 struct fec_enet_private *fep = container_of(napi, struct fec_enet_private, napi);
957 struct net_device *dev = fep->dev;
958
959 return fec_enet_rx_common(fep, dev, budget);
960 }
961
962 /*************************************************************************/
963
964 static void fec_get_drvinfo(struct net_device *dev,
965 struct ethtool_drvinfo *info)
966 {
967 strcpy(info->driver, DRV_MODULE_NAME);
968 strcpy(info->version, DRV_MODULE_VERSION);
969 }
970
971 static int fec_get_regs_len(struct net_device *dev)
972 {
973 return sizeof(fec_t);
974 }
975
976 static void fec_get_regs(struct net_device *dev, struct ethtool_regs *regs,
977 void *p)
978 {
979 struct fec_enet_private *fep = netdev_priv(dev);
980 unsigned long flags;
981
982 if (regs->len < sizeof(fec_t))
983 return;
984
985 regs->version = 0;
986 spin_lock_irqsave(&fep->lock, flags);
987 memcpy_fromio(p, fep->fecp, sizeof(fec_t));
988 spin_unlock_irqrestore(&fep->lock, flags);
989 }
990
991 static int fec_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
992 {
993 struct fec_enet_private *fep = netdev_priv(dev);
994 unsigned long flags;
995 int rc;
996
997 spin_lock_irqsave(&fep->lock, flags);
998 rc = mii_ethtool_gset(&fep->mii_if, cmd);
999 spin_unlock_irqrestore(&fep->lock, flags);
1000
1001 return rc;
1002 }
1003
1004 static int fec_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1005 {
1006 struct fec_enet_private *fep = netdev_priv(dev);
1007 unsigned long flags;
1008 int rc;
1009
1010 spin_lock_irqsave(&fep->lock, flags);
1011 rc = mii_ethtool_sset(&fep->mii_if, cmd);
1012 spin_unlock_irqrestore(&fep->lock, flags);
1013
1014 return rc;
1015 }
1016
1017 static int fec_nway_reset(struct net_device *dev)
1018 {
1019 struct fec_enet_private *fep = netdev_priv(dev);
1020 return mii_nway_restart(&fep->mii_if);
1021 }
1022
1023 static __u32 fec_get_msglevel(struct net_device *dev)
1024 {
1025 struct fec_enet_private *fep = netdev_priv(dev);
1026 return fep->msg_enable;
1027 }
1028
1029 static void fec_set_msglevel(struct net_device *dev, __u32 value)
1030 {
1031 struct fec_enet_private *fep = netdev_priv(dev);
1032 fep->msg_enable = value;
1033 }
1034
1035 static const struct ethtool_ops fec_ethtool_ops = {
1036 .get_drvinfo = fec_get_drvinfo,
1037 .get_regs_len = fec_get_regs_len,
1038 .get_settings = fec_get_settings,
1039 .set_settings = fec_set_settings,
1040 .nway_reset = fec_nway_reset,
1041 .get_link = ethtool_op_get_link,
1042 .get_msglevel = fec_get_msglevel,
1043 .set_msglevel = fec_set_msglevel,
1044 .get_tx_csum = ethtool_op_get_tx_csum,
1045 .set_tx_csum = ethtool_op_set_tx_csum, /* local! */
1046 .get_sg = ethtool_op_get_sg,
1047 .set_sg = ethtool_op_set_sg,
1048 .get_regs = fec_get_regs,
1049 };
1050
1051 static int fec_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1052 {
1053 struct fec_enet_private *fep = netdev_priv(dev);
1054 struct mii_ioctl_data *mii = (struct mii_ioctl_data *)&rq->ifr_data;
1055 unsigned long flags;
1056 int rc;
1057
1058 if (!netif_running(dev))
1059 return -EINVAL;
1060
1061 spin_lock_irqsave(&fep->lock, flags);
1062 rc = generic_mii_ioctl(&fep->mii_if, mii, cmd, NULL);
1063 spin_unlock_irqrestore(&fep->lock, flags);
1064 return rc;
1065 }
1066
1067 int fec_8xx_init_one(const struct fec_platform_info *fpi,
1068 struct net_device **devp)
1069 {
1070 immap_t *immap = (immap_t *) IMAP_ADDR;
1071 static int fec_8xx_version_printed = 0;
1072 struct net_device *dev = NULL;
1073 struct fec_enet_private *fep = NULL;
1074 fec_t *fecp = NULL;
1075 int i;
1076 int err = 0;
1077 int registered = 0;
1078 __u32 siel;
1079
1080 *devp = NULL;
1081
1082 switch (fpi->fec_no) {
1083 case 0:
1084 fecp = &((immap_t *) IMAP_ADDR)->im_cpm.cp_fec;
1085 break;
1086 #ifdef CONFIG_DUET
1087 case 1:
1088 fecp = &((immap_t *) IMAP_ADDR)->im_cpm.cp_fec2;
1089 break;
1090 #endif
1091 default:
1092 return -EINVAL;
1093 }
1094
1095 if (fec_8xx_version_printed++ == 0)
1096 printk(KERN_INFO "%s", version);
1097
1098 i = sizeof(*fep) + (sizeof(struct sk_buff **) *
1099 (fpi->rx_ring + fpi->tx_ring));
1100
1101 dev = alloc_etherdev(i);
1102 if (!dev) {
1103 err = -ENOMEM;
1104 goto err;
1105 }
1106 SET_MODULE_OWNER(dev);
1107
1108 fep = netdev_priv(dev);
1109 fep->dev = dev;
1110
1111 /* partial reset of FEC */
1112 fec_whack_reset(fecp);
1113
1114 /* point rx_skbuff, tx_skbuff */
1115 fep->rx_skbuff = (struct sk_buff **)&fep[1];
1116 fep->tx_skbuff = fep->rx_skbuff + fpi->rx_ring;
1117
1118 fep->fecp = fecp;
1119 fep->fpi = fpi;
1120
1121 /* init locks */
1122 spin_lock_init(&fep->lock);
1123 spin_lock_init(&fep->tx_lock);
1124
1125 /*
1126 * Set the Ethernet address.
1127 */
1128 for (i = 0; i < 6; i++)
1129 dev->dev_addr[i] = fpi->macaddr[i];
1130
1131 fep->ring_base = dma_alloc_coherent(NULL,
1132 (fpi->tx_ring + fpi->rx_ring) *
1133 sizeof(cbd_t), &fep->ring_mem_addr,
1134 GFP_KERNEL);
1135 if (fep->ring_base == NULL) {
1136 printk(KERN_ERR DRV_MODULE_NAME
1137 ": %s dma alloc failed.\n", dev->name);
1138 err = -ENOMEM;
1139 goto err;
1140 }
1141
1142 /*
1143 * Set receive and transmit descriptor base.
1144 */
1145 fep->rx_bd_base = fep->ring_base;
1146 fep->tx_bd_base = fep->rx_bd_base + fpi->rx_ring;
1147
1148 /* initialize ring size variables */
1149 fep->tx_ring = fpi->tx_ring;
1150 fep->rx_ring = fpi->rx_ring;
1151
1152 /* SIU interrupt */
1153 if (fpi->phy_irq != -1 &&
1154 (fpi->phy_irq >= SIU_IRQ0 && fpi->phy_irq < SIU_LEVEL7)) {
1155
1156 siel = in_be32(&immap->im_siu_conf.sc_siel);
1157 if ((fpi->phy_irq & 1) == 0)
1158 siel |= (0x80000000 >> fpi->phy_irq);
1159 else
1160 siel &= ~(0x80000000 >> (fpi->phy_irq & ~1));
1161 out_be32(&immap->im_siu_conf.sc_siel, siel);
1162 }
1163
1164 /*
1165 * The FEC Ethernet specific entries in the device structure.
1166 */
1167 dev->open = fec_enet_open;
1168 dev->hard_start_xmit = fec_enet_start_xmit;
1169 dev->tx_timeout = fec_timeout;
1170 dev->watchdog_timeo = TX_TIMEOUT;
1171 dev->stop = fec_enet_close;
1172 dev->get_stats = fec_enet_get_stats;
1173 dev->set_multicast_list = fec_set_multicast_list;
1174 dev->set_mac_address = fec_set_mac_address;
1175 netif_napi_add(dev, &fec->napi,
1176 fec_enet_poll, fpi->napi_weight);
1177
1178 dev->ethtool_ops = &fec_ethtool_ops;
1179 dev->do_ioctl = fec_ioctl;
1180
1181 fep->fec_phy_speed =
1182 ((((fpi->sys_clk + 4999999) / 2500000) / 2) & 0x3F) << 1;
1183
1184 init_timer(&fep->phy_timer_list);
1185
1186 /* partial reset of FEC so that only MII works */
1187 FW(fecp, mii_speed, fep->fec_phy_speed);
1188 FW(fecp, ievent, 0xffc0);
1189 FW(fecp, ivec, (fpi->fec_irq / 2) << 29);
1190 FW(fecp, imask, 0);
1191 FW(fecp, r_cntrl, FEC_RCNTRL_MII_MODE); /* MII enable */
1192 FW(fecp, ecntrl, FEC_ECNTRL_PINMUX | FEC_ECNTRL_ETHER_EN);
1193
1194 netif_carrier_off(dev);
1195
1196 err = register_netdev(dev);
1197 if (err != 0)
1198 goto err;
1199 registered = 1;
1200
1201 if (fpi->use_mdio) {
1202 fep->mii_if.dev = dev;
1203 fep->mii_if.mdio_read = fec_mii_read;
1204 fep->mii_if.mdio_write = fec_mii_write;
1205 fep->mii_if.phy_id_mask = 0x1f;
1206 fep->mii_if.reg_num_mask = 0x1f;
1207 fep->mii_if.phy_id = fec_mii_phy_id_detect(dev);
1208 }
1209
1210 *devp = dev;
1211
1212 return 0;
1213
1214 err:
1215 if (dev != NULL) {
1216 if (fecp != NULL)
1217 fec_whack_reset(fecp);
1218
1219 if (registered)
1220 unregister_netdev(dev);
1221
1222 if (fep != NULL) {
1223 if (fep->ring_base)
1224 dma_free_coherent(NULL,
1225 (fpi->tx_ring +
1226 fpi->rx_ring) *
1227 sizeof(cbd_t), fep->ring_base,
1228 fep->ring_mem_addr);
1229 }
1230 free_netdev(dev);
1231 }
1232 return err;
1233 }
1234
1235 int fec_8xx_cleanup_one(struct net_device *dev)
1236 {
1237 struct fec_enet_private *fep = netdev_priv(dev);
1238 fec_t *fecp = fep->fecp;
1239 const struct fec_platform_info *fpi = fep->fpi;
1240
1241 fec_whack_reset(fecp);
1242
1243 unregister_netdev(dev);
1244
1245 dma_free_coherent(NULL, (fpi->tx_ring + fpi->rx_ring) * sizeof(cbd_t),
1246 fep->ring_base, fep->ring_mem_addr);
1247
1248 free_netdev(dev);
1249
1250 return 0;
1251 }
1252
1253 /**************************************************************************************/
1254 /**************************************************************************************/
1255 /**************************************************************************************/
1256
1257 static int __init fec_8xx_init(void)
1258 {
1259 return fec_8xx_platform_init();
1260 }
1261
1262 static void __exit fec_8xx_cleanup(void)
1263 {
1264 fec_8xx_platform_cleanup();
1265 }
1266
1267 /**************************************************************************************/
1268 /**************************************************************************************/
1269 /**************************************************************************************/
1270
1271 module_init(fec_8xx_init);
1272 module_exit(fec_8xx_cleanup);
kernel source for telekom puls (alcatel/mediatek)