Add mac driver for w90p910
[linux-2.6.git] / drivers / net / arm / w90p910_ether.c
1 /*
2  * Copyright (c) 2008-2009 Nuvoton technology corporation.
3  *
4  * Wan ZongShun <mcuos.com@gmail.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation;version 2 of the License.
9  *
10  */
11
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/mii.h>
15 #include <linux/netdevice.h>
16 #include <linux/etherdevice.h>
17 #include <linux/skbuff.h>
18 #include <linux/ethtool.h>
19 #include <linux/platform_device.h>
20 #include <linux/clk.h>
21
22 #define DRV_MODULE_NAME         "w90p910-emc"
23 #define DRV_MODULE_VERSION      "0.1"
24
25 /* Ethernet MAC Registers */
26 #define REG_CAMCMR              0x00
27 #define REG_CAMEN               0x04
28 #define REG_CAMM_BASE           0x08
29 #define REG_CAML_BASE           0x0c
30 #define REG_TXDLSA              0x88
31 #define REG_RXDLSA              0x8C
32 #define REG_MCMDR               0x90
33 #define REG_MIID                0x94
34 #define REG_MIIDA               0x98
35 #define REG_FFTCR               0x9C
36 #define REG_TSDR                0xa0
37 #define REG_RSDR                0xa4
38 #define REG_DMARFC              0xa8
39 #define REG_MIEN                0xac
40 #define REG_MISTA               0xb0
41 #define REG_CTXDSA              0xcc
42 #define REG_CTXBSA              0xd0
43 #define REG_CRXDSA              0xd4
44 #define REG_CRXBSA              0xd8
45
46 /* mac controller bit */
47 #define MCMDR_RXON              0x01
48 #define MCMDR_ACP               (0x01 << 3)
49 #define MCMDR_SPCRC             (0x01 << 5)
50 #define MCMDR_TXON              (0x01 << 8)
51 #define MCMDR_FDUP              (0x01 << 18)
52 #define MCMDR_ENMDC             (0x01 << 19)
53 #define MCMDR_OPMOD             (0x01 << 20)
54 #define SWR                     (0x01 << 24)
55
56 /* cam command regiser */
57 #define CAMCMR_AUP              0x01
58 #define CAMCMR_AMP              (0x01 << 1)
59 #define CAMCMR_ABP              (0x01 << 2)
60 #define CAMCMR_CCAM             (0x01 << 3)
61 #define CAMCMR_ECMP             (0x01 << 4)
62 #define CAM0EN                  0x01
63
64 /* mac mii controller bit */
65 #define MDCCR                   (0x0a << 20)
66 #define PHYAD                   (0x01 << 8)
67 #define PHYWR                   (0x01 << 16)
68 #define PHYBUSY                 (0x01 << 17)
69 #define PHYPRESP                (0x01 << 18)
70 #define CAM_ENTRY_SIZE          0x08
71
72 /* rx and tx status */
73 #define TXDS_TXCP               (0x01 << 19)
74 #define RXDS_CRCE               (0x01 << 17)
75 #define RXDS_PTLE               (0x01 << 19)
76 #define RXDS_RXGD               (0x01 << 20)
77 #define RXDS_ALIE               (0x01 << 21)
78 #define RXDS_RP                 (0x01 << 22)
79
80 /* mac interrupt status*/
81 #define MISTA_EXDEF             (0x01 << 19)
82 #define MISTA_TXBERR            (0x01 << 24)
83 #define MISTA_TDU               (0x01 << 23)
84 #define MISTA_RDU               (0x01 << 10)
85 #define MISTA_RXBERR            (0x01 << 11)
86
87 #define ENSTART                 0x01
88 #define ENRXINTR                0x01
89 #define ENRXGD                  (0x01 << 4)
90 #define ENRXBERR                (0x01 << 11)
91 #define ENTXINTR                (0x01 << 16)
92 #define ENTXCP                  (0x01 << 18)
93 #define ENTXABT                 (0x01 << 21)
94 #define ENTXBERR                (0x01 << 24)
95 #define ENMDC                   (0x01 << 19)
96 #define PHYBUSY                 (0x01 << 17)
97 #define MDCCR_VAL               0xa00000
98
99 /* rx and tx owner bit */
100 #define RX_OWEN_DMA             (0x01 << 31)
101 #define RX_OWEN_CPU             (~(0x03 << 30))
102 #define TX_OWEN_DMA             (0x01 << 31)
103 #define TX_OWEN_CPU             (~(0x01 << 31))
104
105 /* tx frame desc controller bit */
106 #define MACTXINTEN              0x04
107 #define CRCMODE                 0x02
108 #define PADDINGMODE             0x01
109
110 /* fftcr controller bit */
111 #define TXTHD                   (0x03 << 8)
112 #define BLENGTH                 (0x01 << 20)
113
114 /* global setting for driver */
115 #define RX_DESC_SIZE            50
116 #define TX_DESC_SIZE            10
117 #define MAX_RBUFF_SZ            0x600
118 #define MAX_TBUFF_SZ            0x600
119 #define TX_TIMEOUT              50
120 #define DELAY                   1000
121 #define CAM0                    0x0
122
123 static int w90p910_mdio_read(struct net_device *dev, int phy_id, int reg);
124
125 struct w90p910_rxbd {
126         unsigned int sl;
127         unsigned int buffer;
128         unsigned int reserved;
129         unsigned int next;
130 };
131
132 struct w90p910_txbd {
133         unsigned int mode;
134         unsigned int buffer;
135         unsigned int sl;
136         unsigned int next;
137 };
138
139 struct recv_pdesc {
140         struct w90p910_rxbd desclist[RX_DESC_SIZE];
141         char recv_buf[RX_DESC_SIZE][MAX_RBUFF_SZ];
142 };
143
144 struct tran_pdesc {
145         struct w90p910_txbd desclist[TX_DESC_SIZE];
146         char tran_buf[RX_DESC_SIZE][MAX_TBUFF_SZ];
147 };
148
149 struct  w90p910_ether {
150         struct recv_pdesc *rdesc;
151         struct recv_pdesc *rdesc_phys;
152         struct tran_pdesc *tdesc;
153         struct tran_pdesc *tdesc_phys;
154         struct net_device_stats stats;
155         struct platform_device *pdev;
156         struct sk_buff *skb;
157         struct clk *clk;
158         struct clk *rmiiclk;
159         struct mii_if_info mii;
160         struct timer_list check_timer;
161         void __iomem *reg;
162         unsigned int rxirq;
163         unsigned int txirq;
164         unsigned int cur_tx;
165         unsigned int cur_rx;
166         unsigned int finish_tx;
167         unsigned int rx_packets;
168         unsigned int rx_bytes;
169         unsigned int start_tx_ptr;
170         unsigned int start_rx_ptr;
171         unsigned int linkflag;
172         spinlock_t lock;
173 };
174
175 static void update_linkspeed_register(struct net_device *dev,
176                                 unsigned int speed, unsigned int duplex)
177 {
178         struct w90p910_ether *ether = netdev_priv(dev);
179         unsigned int val;
180
181         val = __raw_readl(ether->reg + REG_MCMDR);
182
183         if (speed == SPEED_100) {
184                 /* 100 full/half duplex */
185                 if (duplex == DUPLEX_FULL) {
186                         val |= (MCMDR_OPMOD | MCMDR_FDUP);
187                 } else {
188                         val |= MCMDR_OPMOD;
189                         val &= ~MCMDR_FDUP;
190                 }
191         } else {
192                 /* 10 full/half duplex */
193                 if (duplex == DUPLEX_FULL) {
194                         val |= MCMDR_FDUP;
195                         val &= ~MCMDR_OPMOD;
196                 } else {
197                         val &= ~(MCMDR_FDUP | MCMDR_OPMOD);
198                 }
199         }
200
201         __raw_writel(val, ether->reg + REG_MCMDR);
202 }
203
204 static void update_linkspeed(struct net_device *dev)
205 {
206         struct w90p910_ether *ether = netdev_priv(dev);
207         struct platform_device *pdev;
208         unsigned int bmsr, bmcr, lpa, speed, duplex;
209
210         pdev = ether->pdev;
211
212         if (!mii_link_ok(&ether->mii)) {
213                 ether->linkflag = 0x0;
214                 netif_carrier_off(dev);
215                 dev_warn(&pdev->dev, "%s: Link down.\n", dev->name);
216                 return;
217         }
218
219         if (ether->linkflag == 1)
220                 return;
221
222         bmsr = w90p910_mdio_read(dev, ether->mii.phy_id, MII_BMSR);
223         bmcr = w90p910_mdio_read(dev, ether->mii.phy_id, MII_BMCR);
224
225         if (bmcr & BMCR_ANENABLE) {
226                 if (!(bmsr & BMSR_ANEGCOMPLETE))
227                         return;
228
229                 lpa = w90p910_mdio_read(dev, ether->mii.phy_id, MII_LPA);
230
231                 if ((lpa & LPA_100FULL) || (lpa & LPA_100HALF))
232                         speed = SPEED_100;
233                 else
234                         speed = SPEED_10;
235
236                 if ((lpa & LPA_100FULL) || (lpa & LPA_10FULL))
237                         duplex = DUPLEX_FULL;
238                 else
239                         duplex = DUPLEX_HALF;
240
241         } else {
242                 speed = (bmcr & BMCR_SPEED100) ? SPEED_100 : SPEED_10;
243                 duplex = (bmcr & BMCR_FULLDPLX) ? DUPLEX_FULL : DUPLEX_HALF;
244         }
245
246         update_linkspeed_register(dev, speed, duplex);
247
248         dev_info(&pdev->dev, "%s: Link now %i-%s\n", dev->name, speed,
249                         (duplex == DUPLEX_FULL) ? "FullDuplex" : "HalfDuplex");
250         ether->linkflag = 0x01;
251
252         netif_carrier_on(dev);
253 }
254
255 static void w90p910_check_link(unsigned long dev_id)
256 {
257         struct net_device *dev = (struct net_device *) dev_id;
258         struct w90p910_ether *ether = netdev_priv(dev);
259
260         update_linkspeed(dev);
261         mod_timer(&ether->check_timer, jiffies + msecs_to_jiffies(1000));
262 }
263
264 static void w90p910_write_cam(struct net_device *dev,
265                                 unsigned int x, unsigned char *pval)
266 {
267         struct w90p910_ether *ether = netdev_priv(dev);
268         unsigned int msw, lsw;
269
270         msw = (pval[0] << 24) | (pval[1] << 16) | (pval[2] << 8) | pval[3];
271
272         lsw = (pval[4] << 24) | (pval[5] << 16);
273
274         __raw_writel(lsw, ether->reg + REG_CAML_BASE + x * CAM_ENTRY_SIZE);
275         __raw_writel(msw, ether->reg + REG_CAMM_BASE + x * CAM_ENTRY_SIZE);
276 }
277
278 static void w90p910_init_desc(struct net_device *dev)
279 {
280         struct w90p910_ether *ether;
281         struct w90p910_txbd  *tdesc, *tdesc_phys;
282         struct w90p910_rxbd  *rdesc, *rdesc_phys;
283         unsigned int i, j;
284
285         ether = netdev_priv(dev);
286
287         ether->tdesc = (struct tran_pdesc *)
288                         dma_alloc_coherent(NULL, sizeof(struct tran_pdesc),
289                                 (dma_addr_t *) &ether->tdesc_phys, GFP_KERNEL);
290
291         ether->rdesc = (struct recv_pdesc *)
292                         dma_alloc_coherent(NULL, sizeof(struct recv_pdesc),
293                                 (dma_addr_t *) &ether->rdesc_phys, GFP_KERNEL);
294
295         for (i = 0; i < TX_DESC_SIZE; i++) {
296                 tdesc = &(ether->tdesc->desclist[i]);
297
298                 j = ((i + 1) / TX_DESC_SIZE);
299
300                 if (j != 0) {
301                         tdesc_phys = &(ether->tdesc_phys->desclist[0]);
302                         ether->start_tx_ptr = (unsigned int)tdesc_phys;
303                         tdesc->next = (unsigned int)ether->start_tx_ptr;
304                 } else {
305                         tdesc_phys = &(ether->tdesc_phys->desclist[i+1]);
306                         tdesc->next = (unsigned int)tdesc_phys;
307                 }
308
309                 tdesc->buffer = (unsigned int)ether->tdesc_phys->tran_buf[i];
310                 tdesc->sl = 0;
311                 tdesc->mode = 0;
312         }
313
314         for (i = 0; i < RX_DESC_SIZE; i++) {
315                 rdesc = &(ether->rdesc->desclist[i]);
316
317                 j = ((i + 1) / RX_DESC_SIZE);
318
319                 if (j != 0) {
320                         rdesc_phys = &(ether->rdesc_phys->desclist[0]);
321                         ether->start_rx_ptr = (unsigned int)rdesc_phys;
322                         rdesc->next = (unsigned int)ether->start_rx_ptr;
323                 } else {
324                         rdesc_phys = &(ether->rdesc_phys->desclist[i+1]);
325                         rdesc->next = (unsigned int)rdesc_phys;
326                 }
327
328                 rdesc->sl = RX_OWEN_DMA;
329                 rdesc->buffer = (unsigned int)ether->rdesc_phys->recv_buf[i];
330           }
331 }
332
333 static void w90p910_set_fifo_threshold(struct net_device *dev)
334 {
335         struct w90p910_ether *ether = netdev_priv(dev);
336         unsigned int val;
337
338         val = TXTHD | BLENGTH;
339         __raw_writel(val, ether->reg + REG_FFTCR);
340 }
341
342 static void w90p910_return_default_idle(struct net_device *dev)
343 {
344         struct w90p910_ether *ether = netdev_priv(dev);
345         unsigned int val;
346
347         val = __raw_readl(ether->reg + REG_MCMDR);
348         val |= SWR;
349         __raw_writel(val, ether->reg + REG_MCMDR);
350 }
351
352 static void w90p910_trigger_rx(struct net_device *dev)
353 {
354         struct w90p910_ether *ether = netdev_priv(dev);
355
356         __raw_writel(ENSTART, ether->reg + REG_RSDR);
357 }
358
359 static void w90p910_trigger_tx(struct net_device *dev)
360 {
361         struct w90p910_ether *ether = netdev_priv(dev);
362
363         __raw_writel(ENSTART, ether->reg + REG_TSDR);
364 }
365
366 static void w90p910_enable_mac_interrupt(struct net_device *dev)
367 {
368         struct w90p910_ether *ether = netdev_priv(dev);
369         unsigned int val;
370
371         val = ENTXINTR | ENRXINTR | ENRXGD | ENTXCP;
372         val |= ENTXBERR | ENRXBERR | ENTXABT;
373
374         __raw_writel(val, ether->reg + REG_MIEN);
375 }
376
377 static void w90p910_get_and_clear_int(struct net_device *dev,
378                                                         unsigned int *val)
379 {
380         struct w90p910_ether *ether = netdev_priv(dev);
381
382         *val = __raw_readl(ether->reg + REG_MISTA);
383         __raw_writel(*val, ether->reg + REG_MISTA);
384 }
385
386 static void w90p910_set_global_maccmd(struct net_device *dev)
387 {
388         struct w90p910_ether *ether = netdev_priv(dev);
389         unsigned int val;
390
391         val = __raw_readl(ether->reg + REG_MCMDR);
392         val |= MCMDR_SPCRC | MCMDR_ENMDC | MCMDR_ACP | ENMDC;
393         __raw_writel(val, ether->reg + REG_MCMDR);
394 }
395
396 static void w90p910_enable_cam(struct net_device *dev)
397 {
398         struct w90p910_ether *ether = netdev_priv(dev);
399         unsigned int val;
400
401         w90p910_write_cam(dev, CAM0, dev->dev_addr);
402
403         val = __raw_readl(ether->reg + REG_CAMEN);
404         val |= CAM0EN;
405         __raw_writel(val, ether->reg + REG_CAMEN);
406 }
407
408 static void w90p910_enable_cam_command(struct net_device *dev)
409 {
410         struct w90p910_ether *ether = netdev_priv(dev);
411         unsigned int val;
412
413         val = CAMCMR_ECMP | CAMCMR_ABP | CAMCMR_AMP;
414         __raw_writel(val, ether->reg + REG_CAMCMR);
415 }
416
417 static void w90p910_enable_tx(struct net_device *dev, unsigned int enable)
418 {
419         struct w90p910_ether *ether = netdev_priv(dev);
420         unsigned int val;
421
422         val = __raw_readl(ether->reg + REG_MCMDR);
423
424         if (enable)
425                 val |= MCMDR_TXON;
426         else
427                 val &= ~MCMDR_TXON;
428
429         __raw_writel(val, ether->reg + REG_MCMDR);
430 }
431
432 static void w90p910_enable_rx(struct net_device *dev, unsigned int enable)
433 {
434         struct w90p910_ether *ether = netdev_priv(dev);
435         unsigned int val;
436
437         val = __raw_readl(ether->reg + REG_MCMDR);
438
439         if (enable)
440                 val |= MCMDR_RXON;
441         else
442                 val &= ~MCMDR_RXON;
443
444         __raw_writel(val, ether->reg + REG_MCMDR);
445 }
446
447 static void w90p910_set_curdest(struct net_device *dev)
448 {
449         struct w90p910_ether *ether = netdev_priv(dev);
450
451         __raw_writel(ether->start_rx_ptr, ether->reg + REG_RXDLSA);
452         __raw_writel(ether->start_tx_ptr, ether->reg + REG_TXDLSA);
453 }
454
455 static void w90p910_reset_mac(struct net_device *dev)
456 {
457         struct w90p910_ether *ether = netdev_priv(dev);
458
459         spin_lock(&ether->lock);
460
461         w90p910_enable_tx(dev, 0);
462         w90p910_enable_rx(dev, 0);
463         w90p910_set_fifo_threshold(dev);
464         w90p910_return_default_idle(dev);
465
466         if (!netif_queue_stopped(dev))
467                 netif_stop_queue(dev);
468
469         w90p910_init_desc(dev);
470
471         dev->trans_start = jiffies;
472         ether->cur_tx = 0x0;
473         ether->finish_tx = 0x0;
474         ether->cur_rx = 0x0;
475
476         w90p910_set_curdest(dev);
477         w90p910_enable_cam(dev);
478         w90p910_enable_cam_command(dev);
479         w90p910_enable_mac_interrupt(dev);
480         w90p910_enable_tx(dev, 1);
481         w90p910_enable_rx(dev, 1);
482         w90p910_trigger_tx(dev);
483         w90p910_trigger_rx(dev);
484
485         dev->trans_start = jiffies;
486
487         if (netif_queue_stopped(dev))
488                 netif_wake_queue(dev);
489
490         spin_unlock(&ether->lock);
491 }
492
493 static void w90p910_mdio_write(struct net_device *dev,
494                                         int phy_id, int reg, int data)
495 {
496         struct w90p910_ether *ether = netdev_priv(dev);
497         struct platform_device *pdev;
498         unsigned int val, i;
499
500         pdev = ether->pdev;
501
502         __raw_writel(data, ether->reg + REG_MIID);
503
504         val = (phy_id << 0x08) | reg;
505         val |= PHYBUSY | PHYWR | MDCCR_VAL;
506         __raw_writel(val, ether->reg + REG_MIIDA);
507
508         for (i = 0; i < DELAY; i++) {
509                 if ((__raw_readl(ether->reg + REG_MIIDA) & PHYBUSY) == 0)
510                         break;
511         }
512
513         if (i == DELAY)
514                 dev_warn(&pdev->dev, "mdio write timed out\n");
515 }
516
517 static int w90p910_mdio_read(struct net_device *dev, int phy_id, int reg)
518 {
519         struct w90p910_ether *ether = netdev_priv(dev);
520         struct platform_device *pdev;
521         unsigned int val, i, data;
522
523         pdev = ether->pdev;
524
525         val = (phy_id << 0x08) | reg;
526         val |= PHYBUSY | MDCCR_VAL;
527         __raw_writel(val, ether->reg + REG_MIIDA);
528
529         for (i = 0; i < DELAY; i++) {
530                 if ((__raw_readl(ether->reg + REG_MIIDA) & PHYBUSY) == 0)
531                         break;
532         }
533
534         if (i == DELAY) {
535                 dev_warn(&pdev->dev, "mdio read timed out\n");
536                 data = 0xffff;
537         } else {
538                 data = __raw_readl(ether->reg + REG_MIID);
539         }
540
541         return data;
542 }
543
544 static int set_mac_address(struct net_device *dev, void *addr)
545 {
546         struct sockaddr *address = addr;
547
548         if (!is_valid_ether_addr(address->sa_data))
549                 return -EADDRNOTAVAIL;
550
551         memcpy(dev->dev_addr, address->sa_data, dev->addr_len);
552         w90p910_write_cam(dev, CAM0, dev->dev_addr);
553
554         return 0;
555 }
556
557 static int w90p910_ether_close(struct net_device *dev)
558 {
559         struct w90p910_ether *ether = netdev_priv(dev);
560
561         dma_free_writecombine(NULL, sizeof(struct w90p910_rxbd),
562                                 ether->rdesc, (dma_addr_t)ether->rdesc_phys);
563         dma_free_writecombine(NULL, sizeof(struct w90p910_txbd),
564                                 ether->tdesc, (dma_addr_t)ether->tdesc_phys);
565
566         netif_stop_queue(dev);
567
568         del_timer_sync(&ether->check_timer);
569         clk_disable(ether->rmiiclk);
570         clk_disable(ether->clk);
571
572         free_irq(ether->txirq, dev);
573         free_irq(ether->rxirq, dev);
574
575         return 0;
576 }
577
578 static struct net_device_stats *w90p910_ether_stats(struct net_device *dev)
579 {
580         struct w90p910_ether *ether;
581
582         ether = netdev_priv(dev);
583
584         return &ether->stats;
585 }
586
587 static int w90p910_send_frame(struct net_device *dev,
588                                         unsigned char *data, int length)
589 {
590         struct w90p910_ether *ether;
591         struct w90p910_txbd *txbd;
592         struct platform_device *pdev;
593         unsigned char *buffer;
594
595         ether = netdev_priv(dev);
596         pdev = ether->pdev;
597
598         txbd = &ether->tdesc->desclist[ether->cur_tx];
599         buffer = ether->tdesc->tran_buf[ether->cur_tx];
600         if (length > 1514) {
601                 dev_err(&pdev->dev, "send data %d bytes, check it\n", length);
602                 length = 1514;
603         }
604
605         txbd->sl = length & 0xFFFF;
606
607         memcpy(buffer, data, length);
608
609         txbd->mode = TX_OWEN_DMA | PADDINGMODE | CRCMODE | MACTXINTEN;
610
611         w90p910_enable_tx(dev, 1);
612
613         w90p910_trigger_tx(dev);
614
615         ether->cur_tx = (ether->cur_tx+1) % TX_DESC_SIZE;
616         txbd = &ether->tdesc->desclist[ether->cur_tx];
617
618         dev->trans_start = jiffies;
619
620         if (txbd->mode & TX_OWEN_DMA)
621                 netif_stop_queue(dev);
622
623         return 0;
624 }
625
626 static int w90p910_ether_start_xmit(struct sk_buff *skb, struct net_device *dev)
627 {
628         struct w90p910_ether *ether = netdev_priv(dev);
629
630         if (!(w90p910_send_frame(dev, skb->data, skb->len))) {
631                 ether->skb = skb;
632                 dev_kfree_skb_irq(skb);
633                 return 0;
634         }
635         return -1;
636 }
637
638 static irqreturn_t w90p910_tx_interrupt(int irq, void *dev_id)
639 {
640         struct w90p910_ether *ether;
641         struct w90p910_txbd  *txbd;
642         struct platform_device *pdev;
643         struct tran_pdesc *tran_pdesc;
644         struct net_device *dev;
645         unsigned int cur_entry, entry, status;
646
647         dev = (struct net_device *)dev_id;
648         ether = netdev_priv(dev);
649         pdev = ether->pdev;
650
651         spin_lock(&ether->lock);
652
653         w90p910_get_and_clear_int(dev, &status);
654
655         cur_entry = __raw_readl(ether->reg + REG_CTXDSA);
656
657         tran_pdesc = ether->tdesc_phys;
658         entry = (unsigned int)(&tran_pdesc->desclist[ether->finish_tx]);
659
660         while (entry != cur_entry) {
661                 txbd = &ether->tdesc->desclist[ether->finish_tx];
662
663                 ether->finish_tx = (ether->finish_tx + 1) % TX_DESC_SIZE;
664
665                 if (txbd->sl & TXDS_TXCP) {
666                         ether->stats.tx_packets++;
667                         ether->stats.tx_bytes += txbd->sl & 0xFFFF;
668                 } else {
669                         ether->stats.tx_errors++;
670                 }
671
672                 txbd->sl = 0x0;
673                 txbd->mode = 0x0;
674
675                 if (netif_queue_stopped(dev))
676                         netif_wake_queue(dev);
677
678                 entry = (unsigned int)(&tran_pdesc->desclist[ether->finish_tx]);
679         }
680
681         if (status & MISTA_EXDEF) {
682                 dev_err(&pdev->dev, "emc defer exceed interrupt\n");
683         } else if (status & MISTA_TXBERR) {
684                         dev_err(&pdev->dev, "emc bus error interrupt\n");
685                         w90p910_reset_mac(dev);
686                 } else if (status & MISTA_TDU) {
687                                 if (netif_queue_stopped(dev))
688                                         netif_wake_queue(dev);
689                         }
690
691         spin_unlock(&ether->lock);
692
693         return IRQ_HANDLED;
694 }
695
696 static void netdev_rx(struct net_device *dev)
697 {
698         struct w90p910_ether *ether;
699         struct w90p910_rxbd *rxbd;
700         struct platform_device *pdev;
701         struct recv_pdesc *rdesc_phys;
702         struct sk_buff *skb;
703         unsigned char *data;
704         unsigned int length, status, val, entry;
705
706         ether = netdev_priv(dev);
707         pdev = ether->pdev;
708         rdesc_phys = ether->rdesc_phys;
709
710         rxbd = &ether->rdesc->desclist[ether->cur_rx];
711
712         do {
713                 val = __raw_readl(ether->reg + REG_CRXDSA);
714                 entry = (unsigned int)&rdesc_phys->desclist[ether->cur_rx];
715
716                 if (val == entry)
717                         break;
718
719                 status = rxbd->sl;
720                 length = status & 0xFFFF;
721
722                 if (status & RXDS_RXGD) {
723                         data = ether->rdesc->recv_buf[ether->cur_rx];
724                         skb = dev_alloc_skb(length+2);
725                         if (!skb) {
726                                 dev_err(&pdev->dev, "get skb buffer error\n");
727                                 ether->stats.rx_dropped++;
728                                 return;
729                         }
730
731                         skb->dev = dev;
732                         skb_reserve(skb, 2);
733                         skb_put(skb, length);
734                         skb_copy_to_linear_data(skb, data, length);
735                         skb->protocol = eth_type_trans(skb, dev);
736                         ether->stats.rx_packets++;
737                         ether->stats.rx_bytes += length;
738                         netif_rx(skb);
739                 } else {
740                         ether->stats.rx_errors++;
741
742                         if (status & RXDS_RP) {
743                                 dev_err(&pdev->dev, "rx runt err\n");
744                                 ether->stats.rx_length_errors++;
745                         } else if (status & RXDS_CRCE) {
746                                         dev_err(&pdev->dev, "rx crc err\n");
747                                         ether->stats.rx_crc_errors++;
748                                 }
749
750                         if (status & RXDS_ALIE) {
751                                 dev_err(&pdev->dev, "rx aligment err\n");
752                                 ether->stats.rx_frame_errors++;
753                         } else if (status & RXDS_PTLE) {
754                                         dev_err(&pdev->dev, "rx longer err\n");
755                                         ether->stats.rx_over_errors++;
756                                 }
757                         }
758
759                 rxbd->sl = RX_OWEN_DMA;
760                 rxbd->reserved = 0x0;
761                 ether->cur_rx = (ether->cur_rx+1) % RX_DESC_SIZE;
762                 rxbd = &ether->rdesc->desclist[ether->cur_rx];
763
764                 dev->last_rx = jiffies;
765         } while (1);
766 }
767
768 static irqreturn_t w90p910_rx_interrupt(int irq, void *dev_id)
769 {
770         struct net_device *dev;
771         struct w90p910_ether  *ether;
772         struct platform_device *pdev;
773         unsigned int status;
774
775         dev = (struct net_device *)dev_id;
776         ether = netdev_priv(dev);
777         pdev = ether->pdev;
778
779         spin_lock(&ether->lock);
780
781         w90p910_get_and_clear_int(dev, &status);
782
783         if (status & MISTA_RDU) {
784                 netdev_rx(dev);
785
786                 w90p910_trigger_rx(dev);
787
788                 spin_unlock(&ether->lock);
789                 return IRQ_HANDLED;
790         } else if (status & MISTA_RXBERR) {
791                         dev_err(&pdev->dev, "emc rx bus error\n");
792                         w90p910_reset_mac(dev);
793                 }
794
795         netdev_rx(dev);
796         spin_unlock(&ether->lock);
797         return IRQ_HANDLED;
798 }
799
800 static int w90p910_ether_open(struct net_device *dev)
801 {
802         struct w90p910_ether *ether;
803         struct platform_device *pdev;
804
805         ether = netdev_priv(dev);
806         pdev = ether->pdev;
807
808         w90p910_reset_mac(dev);
809         w90p910_set_fifo_threshold(dev);
810         w90p910_set_curdest(dev);
811         w90p910_enable_cam(dev);
812         w90p910_enable_cam_command(dev);
813         w90p910_enable_mac_interrupt(dev);
814         w90p910_set_global_maccmd(dev);
815         w90p910_enable_rx(dev, 1);
816
817         ether->rx_packets = 0x0;
818         ether->rx_bytes = 0x0;
819
820         if (request_irq(ether->txirq, w90p910_tx_interrupt,
821                                                 0x0, pdev->name, dev)) {
822                 dev_err(&pdev->dev, "register irq tx failed\n");
823                 return -EAGAIN;
824         }
825
826         if (request_irq(ether->rxirq, w90p910_rx_interrupt,
827                                                 0x0, pdev->name, dev)) {
828                 dev_err(&pdev->dev, "register irq rx failed\n");
829                 return -EAGAIN;
830         }
831
832         mod_timer(&ether->check_timer, jiffies + msecs_to_jiffies(1000));
833         netif_start_queue(dev);
834         w90p910_trigger_rx(dev);
835
836         dev_info(&pdev->dev, "%s is OPENED\n", dev->name);
837
838         return 0;
839 }
840
841 static void w90p910_ether_set_multicast_list(struct net_device *dev)
842 {
843         struct w90p910_ether *ether;
844         unsigned int rx_mode;
845
846         ether = netdev_priv(dev);
847
848         if (dev->flags & IFF_PROMISC)
849                 rx_mode = CAMCMR_AUP | CAMCMR_AMP | CAMCMR_ABP | CAMCMR_ECMP;
850         else if ((dev->flags & IFF_ALLMULTI) || dev->mc_list)
851                         rx_mode = CAMCMR_AMP | CAMCMR_ABP | CAMCMR_ECMP;
852                 else
853                                 rx_mode = CAMCMR_ECMP | CAMCMR_ABP;
854         __raw_writel(rx_mode, ether->reg + REG_CAMCMR);
855 }
856
857 static int w90p910_ether_ioctl(struct net_device *dev,
858                                                 struct ifreq *ifr, int cmd)
859 {
860         struct w90p910_ether *ether = netdev_priv(dev);
861         struct mii_ioctl_data *data = if_mii(ifr);
862
863         return generic_mii_ioctl(&ether->mii, data, cmd, NULL);
864 }
865
866 static void w90p910_get_drvinfo(struct net_device *dev,
867                                         struct ethtool_drvinfo *info)
868 {
869         strcpy(info->driver, DRV_MODULE_NAME);
870         strcpy(info->version, DRV_MODULE_VERSION);
871 }
872
873 static int w90p910_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
874 {
875         struct w90p910_ether *ether = netdev_priv(dev);
876         return mii_ethtool_gset(&ether->mii, cmd);
877 }
878
879 static int w90p910_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
880 {
881         struct w90p910_ether *ether = netdev_priv(dev);
882         return mii_ethtool_sset(&ether->mii, cmd);
883 }
884
885 static int w90p910_nway_reset(struct net_device *dev)
886 {
887         struct w90p910_ether *ether = netdev_priv(dev);
888         return mii_nway_restart(&ether->mii);
889 }
890
891 static u32 w90p910_get_link(struct net_device *dev)
892 {
893         struct w90p910_ether *ether = netdev_priv(dev);
894         return mii_link_ok(&ether->mii);
895 }
896
897 static const struct ethtool_ops w90p910_ether_ethtool_ops = {
898         .get_settings   = w90p910_get_settings,
899         .set_settings   = w90p910_set_settings,
900         .get_drvinfo    = w90p910_get_drvinfo,
901         .nway_reset     = w90p910_nway_reset,
902         .get_link       = w90p910_get_link,
903 };
904
905 static const struct net_device_ops w90p910_ether_netdev_ops = {
906         .ndo_open               = w90p910_ether_open,
907         .ndo_stop               = w90p910_ether_close,
908         .ndo_start_xmit         = w90p910_ether_start_xmit,
909         .ndo_get_stats          = w90p910_ether_stats,
910         .ndo_set_multicast_list = w90p910_ether_set_multicast_list,
911         .ndo_set_mac_address    = set_mac_address,
912         .ndo_do_ioctl           = w90p910_ether_ioctl,
913         .ndo_validate_addr      = eth_validate_addr,
914         .ndo_change_mtu         = eth_change_mtu,
915 };
916
917 static void __init get_mac_address(struct net_device *dev)
918 {
919         struct w90p910_ether *ether = netdev_priv(dev);
920         struct platform_device *pdev;
921         char addr[6];
922
923         pdev = ether->pdev;
924
925         addr[0] = 0x00;
926         addr[1] = 0x02;
927         addr[2] = 0xac;
928         addr[3] = 0x55;
929         addr[4] = 0x88;
930         addr[5] = 0xa8;
931
932         if (is_valid_ether_addr(addr))
933                 memcpy(dev->dev_addr, &addr, 0x06);
934         else
935                 dev_err(&pdev->dev, "invalid mac address\n");
936 }
937
938 static int w90p910_ether_setup(struct net_device *dev)
939 {
940         struct w90p910_ether *ether = netdev_priv(dev);
941
942         ether_setup(dev);
943         dev->netdev_ops = &w90p910_ether_netdev_ops;
944         dev->ethtool_ops = &w90p910_ether_ethtool_ops;
945
946         dev->tx_queue_len = 16;
947         dev->dma = 0x0;
948         dev->watchdog_timeo = TX_TIMEOUT;
949
950         get_mac_address(dev);
951
952         spin_lock_init(&ether->lock);
953
954         ether->cur_tx = 0x0;
955         ether->cur_rx = 0x0;
956         ether->finish_tx = 0x0;
957         ether->linkflag = 0x0;
958         ether->mii.phy_id = 0x01;
959         ether->mii.phy_id_mask = 0x1f;
960         ether->mii.reg_num_mask = 0x1f;
961         ether->mii.dev = dev;
962         ether->mii.mdio_read = w90p910_mdio_read;
963         ether->mii.mdio_write = w90p910_mdio_write;
964
965         setup_timer(&ether->check_timer, w90p910_check_link,
966                                                 (unsigned long)dev);
967
968         return 0;
969 }
970
971 static int __devinit w90p910_ether_probe(struct platform_device *pdev)
972 {
973         struct w90p910_ether *ether;
974         struct net_device *dev;
975         struct resource *res;
976         int error;
977
978         dev = alloc_etherdev(sizeof(struct w90p910_ether));
979         if (!dev)
980                 return -ENOMEM;
981
982         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
983         if (res == NULL) {
984                 dev_err(&pdev->dev, "failed to get I/O memory\n");
985                 error = -ENXIO;
986                 goto failed_free;
987         }
988
989         res = request_mem_region(res->start, resource_size(res), pdev->name);
990         if (res == NULL) {
991                 dev_err(&pdev->dev, "failed to request I/O memory\n");
992                 error = -EBUSY;
993                 goto failed_free;
994         }
995
996         ether = netdev_priv(dev);
997
998         ether->reg = ioremap(res->start, resource_size(res));
999         if (ether->reg == NULL) {
1000                 dev_err(&pdev->dev, "failed to remap I/O memory\n");
1001                 error = -ENXIO;
1002                 goto failed_free_mem;
1003         }
1004
1005         ether->txirq = platform_get_irq(pdev, 0);
1006         if (ether->txirq < 0) {
1007                 dev_err(&pdev->dev, "failed to get ether tx irq\n");
1008                 error = -ENXIO;
1009                 goto failed_free_io;
1010         }
1011
1012         ether->rxirq = platform_get_irq(pdev, 1);
1013         if (ether->rxirq < 0) {
1014                 dev_err(&pdev->dev, "failed to get ether rx irq\n");
1015                 error = -ENXIO;
1016                 goto failed_free_txirq;
1017         }
1018
1019         platform_set_drvdata(pdev, dev);
1020
1021         ether->clk = clk_get(&pdev->dev, NULL);
1022         if (IS_ERR(ether->clk)) {
1023                 dev_err(&pdev->dev, "failed to get ether clock\n");
1024                 error = PTR_ERR(ether->clk);
1025                 goto failed_free_rxirq;
1026         }
1027
1028         ether->rmiiclk = clk_get(&pdev->dev, "RMII");
1029         if (IS_ERR(ether->rmiiclk)) {
1030                 dev_err(&pdev->dev, "failed to get ether clock\n");
1031                 error = PTR_ERR(ether->rmiiclk);
1032                 goto failed_put_clk;
1033         }
1034
1035         ether->pdev = pdev;
1036
1037         w90p910_ether_setup(dev);
1038
1039         error = register_netdev(dev);
1040         if (error != 0) {
1041                 dev_err(&pdev->dev, "Regiter EMC w90p910 FAILED\n");
1042                 error = -ENODEV;
1043                 goto failed_put_rmiiclk;
1044         }
1045
1046         return 0;
1047 failed_put_rmiiclk:
1048         clk_put(ether->rmiiclk);
1049 failed_put_clk:
1050         clk_put(ether->clk);
1051 failed_free_rxirq:
1052         free_irq(ether->rxirq, pdev);
1053         platform_set_drvdata(pdev, NULL);
1054 failed_free_txirq:
1055         free_irq(ether->txirq, pdev);
1056 failed_free_io:
1057         iounmap(ether->reg);
1058 failed_free_mem:
1059         release_mem_region(res->start, resource_size(res));
1060 failed_free:
1061         free_netdev(dev);
1062         return error;
1063 }
1064
1065 static int __devexit w90p910_ether_remove(struct platform_device *pdev)
1066 {
1067         struct net_device *dev = platform_get_drvdata(pdev);
1068         struct w90p910_ether *ether = netdev_priv(dev);
1069
1070         unregister_netdev(dev);
1071         clk_put(ether->rmiiclk);
1072         clk_put(ether->clk);
1073         del_timer_sync(&ether->check_timer);
1074         platform_set_drvdata(pdev, NULL);
1075         free_netdev(dev);
1076         return 0;
1077 }
1078
1079 static struct platform_driver w90p910_ether_driver = {
1080         .probe          = w90p910_ether_probe,
1081         .remove         = __devexit_p(w90p910_ether_remove),
1082         .driver         = {
1083                 .name   = "w90p910-emc",
1084                 .owner  = THIS_MODULE,
1085         },
1086 };
1087
1088 static int __init w90p910_ether_init(void)
1089 {
1090         return platform_driver_register(&w90p910_ether_driver);
1091 }
1092
1093 static void __exit w90p910_ether_exit(void)
1094 {
1095         platform_driver_unregister(&w90p910_ether_driver);
1096 }
1097
1098 module_init(w90p910_ether_init);
1099 module_exit(w90p910_ether_exit);
1100
1101 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
1102 MODULE_DESCRIPTION("w90p910 MAC driver!");
1103 MODULE_LICENSE("GPL");
1104 MODULE_ALIAS("platform:w90p910-emc");
1105