projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
move linux/switch.h to generic files/ instead of the kernel version specific directories
[openwrt.git] / target / linux / atheros / files / drivers / net / ar2313 / ar2313.c
1 /*
2 * ar2313.c: Linux driver for the Atheros AR231x Ethernet device.
3 *
4 * Copyright (C) 2004 by Sameer Dekate <sdekate@arubanetworks.com>
5 * Copyright (C) 2006 Imre Kaloz <kaloz@openwrt.org>
6 * Copyright (C) 2006-2007 Felix Fietkau <nbd@openwrt.org>
7 *
8 * Thanks to Atheros for providing hardware and documentation
9 * enabling me to write this driver.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * Additional credits:
17 * This code is taken from John Taylor's Sibyte driver and then
18 * modified for the AR2313.
19 */
20
21 #include <linux/autoconf.h>
22 #include <linux/module.h>
23 #include <linux/version.h>
24 #include <linux/types.h>
25 #include <linux/errno.h>
26 #include <linux/ioport.h>
27 #include <linux/pci.h>
28 #include <linux/netdevice.h>
29 #include <linux/etherdevice.h>
30 #include <linux/skbuff.h>
31 #include <linux/init.h>
32 #include <linux/delay.h>
33 #include <linux/mm.h>
34 #include <linux/highmem.h>
35 #include <linux/sockios.h>
36 #include <linux/pkt_sched.h>
37 #include <linux/compile.h>
38 #include <linux/mii.h>
39 #include <linux/phy.h>
40 #include <linux/ethtool.h>
41 #include <linux/ctype.h>
42 #include <linux/platform_device.h>
43
44 #include <net/sock.h>
45 #include <net/ip.h>
46
47 #include <asm/system.h>
48 #include <asm/io.h>
49 #include <asm/irq.h>
50 #include <asm/byteorder.h>
51 #include <asm/uaccess.h>
52 #include <asm/bootinfo.h>
53
54 #define AR2313_MTU 1692
55 #define AR2313_PRIOS 1
56 #define AR2313_QUEUES (2*AR2313_PRIOS)
57 #define AR2313_DESCR_ENTRIES 64
58
59 #undef INDEX_DEBUG
60 #define DEBUG 0
61 #define DEBUG_TX 0
62 #define DEBUG_RX 0
63 #define DEBUG_INT 0
64 #define DEBUG_MC 0
65 #define DEBUG_ERR 1
66
67 #ifndef min
68 #define min(a,b) (((a)<(b))?(a):(b))
69 #endif
70
71 #ifndef SMP_CACHE_BYTES
72 #define SMP_CACHE_BYTES L1_CACHE_BYTES
73 #endif
74
75 #define AR2313_MBOX_SET_BIT 0x8
76
77 #define BOARD_IDX_STATIC 0
78 #define BOARD_IDX_OVERFLOW -1
79
80 #include "dma.h"
81 #include "ar2313.h"
82
83 /*
84 * New interrupt handler strategy:
85 *
86 * An old interrupt handler worked using the traditional method of
87 * replacing an skbuff with a new one when a packet arrives. However
88 * the rx rings do not need to contain a static number of buffer
89 * descriptors, thus it makes sense to move the memory allocation out
90 * of the main interrupt handler and do it in a bottom half handler
91 * and only allocate new buffers when the number of buffers in the
92 * ring is below a certain threshold. In order to avoid starving the
93 * NIC under heavy load it is however necessary to force allocation
94 * when hitting a minimum threshold. The strategy for alloction is as
95 * follows:
96 *
97 * RX_LOW_BUF_THRES - allocate buffers in the bottom half
98 * RX_PANIC_LOW_THRES - we are very low on buffers, allocate
99 * the buffers in the interrupt handler
100 * RX_RING_THRES - maximum number of buffers in the rx ring
101 *
102 * One advantagous side effect of this allocation approach is that the
103 * entire rx processing can be done without holding any spin lock
104 * since the rx rings and registers are totally independent of the tx
105 * ring and its registers. This of course includes the kmalloc's of
106 * new skb's. Thus start_xmit can run in parallel with rx processing
107 * and the memory allocation on SMP systems.
108 *
109 * Note that running the skb reallocation in a bottom half opens up
110 * another can of races which needs to be handled properly. In
111 * particular it can happen that the interrupt handler tries to run
112 * the reallocation while the bottom half is either running on another
113 * CPU or was interrupted on the same CPU. To get around this the
114 * driver uses bitops to prevent the reallocation routines from being
115 * reentered.
116 *
117 * TX handling can also be done without holding any spin lock, wheee
118 * this is fun! since tx_csm is only written to by the interrupt
119 * handler.
120 */
121
122 /*
123 * Threshold values for RX buffer allocation - the low water marks for
124 * when to start refilling the rings are set to 75% of the ring
125 * sizes. It seems to make sense to refill the rings entirely from the
126 * intrrupt handler once it gets below the panic threshold, that way
127 * we don't risk that the refilling is moved to another CPU when the
128 * one running the interrupt handler just got the slab code hot in its
129 * cache.
130 */
131 #define RX_RING_SIZE AR2313_DESCR_ENTRIES
132 #define RX_PANIC_THRES (RX_RING_SIZE/4)
133 #define RX_LOW_THRES ((3*RX_RING_SIZE)/4)
134 #define CRC_LEN 4
135 #define RX_OFFSET 2
136
137 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
138 #define VLAN_HDR 4
139 #else
140 #define VLAN_HDR 0
141 #endif
142
143 #define AR2313_BUFSIZE (AR2313_MTU + VLAN_HDR + ETH_HLEN + CRC_LEN + RX_OFFSET)
144
145 #ifdef MODULE
146 MODULE_LICENSE("GPL");
147 MODULE_AUTHOR("Sameer Dekate <sdekate@arubanetworks.com>, Imre Kaloz <kaloz@openwrt.org>, Felix Fietkau <nbd@openwrt.org>");
148 MODULE_DESCRIPTION("AR2313 Ethernet driver");
149 #endif
150
151 #define virt_to_phys(x) ((u32)(x) & 0x1fffffff)
152
153 // prototypes
154 #ifdef TX_TIMEOUT
155 static void ar2313_tx_timeout(struct net_device *dev);
156 #endif
157 static void ar2313_halt(struct net_device *dev);
158 static void rx_tasklet_func(unsigned long data);
159 static void rx_tasklet_cleanup(struct net_device *dev);
160 static void ar2313_multicast_list(struct net_device *dev);
161
162 static int mdiobus_read(struct mii_bus *bus, int phy_addr, int regnum);
163 static int mdiobus_write(struct mii_bus *bus, int phy_addr, int regnum, u16 value);
164 static int mdiobus_reset(struct mii_bus *bus);
165 static int mdiobus_probe (struct net_device *dev);
166 static void ar2313_adjust_link(struct net_device *dev);
167
168 #ifndef ERR
169 #define ERR(fmt, args...) printk("%s: " fmt, __func__, ##args)
170 #endif
171
172
173 int __init ar2313_probe(struct platform_device *pdev)
174 {
175 struct net_device *dev;
176 struct ar2313_private *sp;
177 struct resource *res;
178 unsigned long ar_eth_base;
179 char buf[64];
180
181 dev = alloc_etherdev(sizeof(struct ar2313_private));
182
183 if (dev == NULL) {
184 printk(KERN_ERR
185 "ar2313: Unable to allocate net_device structure!\n");
186 return -ENOMEM;
187 }
188
189 platform_set_drvdata(pdev, dev);
190
191 sp = netdev_priv(dev);
192 sp->dev = dev;
193 sp->cfg = pdev->dev.platform_data;
194
195 sprintf(buf, "eth%d_membase", pdev->id);
196 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, buf);
197 if (!res)
198 return -ENODEV;
199
200 sp->link = 0;
201 ar_eth_base = res->start;
202 sp->phy = sp->cfg->phy;
203
204 sprintf(buf, "eth%d_irq", pdev->id);
205 dev->irq = platform_get_irq_byname(pdev, buf);
206
207 spin_lock_init(&sp->lock);
208
209 /* initialize func pointers */
210 dev->open = &ar2313_open;
211 dev->stop = &ar2313_close;
212 dev->hard_start_xmit = &ar2313_start_xmit;
213
214 dev->set_multicast_list = &ar2313_multicast_list;
215 #ifdef TX_TIMEOUT
216 dev->tx_timeout = ar2313_tx_timeout;
217 dev->watchdog_timeo = AR2313_TX_TIMEOUT;
218 #endif
219 dev->do_ioctl = &ar2313_ioctl;
220
221 // SAMEER: do we need this?
222 dev->features |= NETIF_F_HIGHDMA;
223
224 tasklet_init(&sp->rx_tasklet, rx_tasklet_func, (unsigned long) dev);
225 tasklet_disable(&sp->rx_tasklet);
226
227 sp->eth_regs =
228 ioremap_nocache(virt_to_phys(ar_eth_base), sizeof(*sp->eth_regs));
229 if (!sp->eth_regs) {
230 printk("Can't remap eth registers\n");
231 return (-ENXIO);
232 }
233
234 /*
235 * When there's only one MAC, PHY regs are typically on ENET0,
236 * even though the MAC might be on ENET1.
237 * Needto remap PHY regs separately in this case
238 */
239 if (virt_to_phys(ar_eth_base) == virt_to_phys(sp->phy_regs))
240 sp->phy_regs = sp->eth_regs;
241 else {
242 sp->phy_regs =
243 ioremap_nocache(virt_to_phys(sp->cfg->phy_base),
244 sizeof(*sp->phy_regs));
245 if (!sp->phy_regs) {
246 printk("Can't remap phy registers\n");
247 return (-ENXIO);
248 }
249 }
250
251 sp->dma_regs =
252 ioremap_nocache(virt_to_phys(ar_eth_base + 0x1000),
253 sizeof(*sp->dma_regs));
254 dev->base_addr = (unsigned int) sp->dma_regs;
255 if (!sp->dma_regs) {
256 printk("Can't remap DMA registers\n");
257 return (-ENXIO);
258 }
259
260 sp->int_regs = ioremap_nocache(virt_to_phys(sp->cfg->reset_base), 4);
261 if (!sp->int_regs) {
262 printk("Can't remap INTERRUPT registers\n");
263 return (-ENXIO);
264 }
265
266 strncpy(sp->name, "Atheros AR231x", sizeof(sp->name) - 1);
267 sp->name[sizeof(sp->name) - 1] = '\0';
268 memcpy(dev->dev_addr, sp->cfg->macaddr, 6);
269 sp->board_idx = BOARD_IDX_STATIC;
270
271 if (ar2313_init(dev)) {
272 /*
273 * ar2313_init() calls ar2313_init_cleanup() on error.
274 */
275 kfree(dev);
276 return -ENODEV;
277 }
278
279 if (register_netdev(dev)) {
280 printk("%s: register_netdev failed\n", __func__);
281 return -1;
282 }
283
284 printk("%s: %s: %02x:%02x:%02x:%02x:%02x:%02x, irq %d\n",
285 dev->name, sp->name,
286 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
287 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5], dev->irq);
288
289 sp->mii_bus.priv = dev;
290 sp->mii_bus.read = mdiobus_read;
291 sp->mii_bus.write = mdiobus_write;
292 sp->mii_bus.reset = mdiobus_reset;
293 sp->mii_bus.name = "ar2313_eth_mii";
294 sp->mii_bus.id = 0;
295 sp->mii_bus.irq = kmalloc(sizeof(int), GFP_KERNEL);
296 *sp->mii_bus.irq = PHY_POLL;
297
298 mdiobus_register(&sp->mii_bus);
299
300 if (mdiobus_probe(dev) != 0) {
301 printk(KERN_ERR "ar2313: mdiobus_probe failed");
302 rx_tasklet_cleanup(dev);
303 ar2313_init_cleanup(dev);
304 unregister_netdev(dev);
305 kfree(dev);
306 } else {
307 /* start link poll timer */
308 ar2313_setup_timer(dev);
309 }
310
311 return 0;
312 }
313
314 #if 0
315 static void ar2313_dump_regs(struct net_device *dev)
316 {
317 unsigned int *ptr, i;
318 struct ar2313_private *sp = netdev_priv(dev);
319
320 ptr = (unsigned int *) sp->eth_regs;
321 for (i = 0; i < (sizeof(ETHERNET_STRUCT) / sizeof(unsigned int));
322 i++, ptr++) {
323 printk("ENET: %08x = %08x\n", (int) ptr, *ptr);
324 }
325
326 ptr = (unsigned int *) sp->dma_regs;
327 for (i = 0; i < (sizeof(DMA) / sizeof(unsigned int)); i++, ptr++) {
328 printk("DMA: %08x = %08x\n", (int) ptr, *ptr);
329 }
330
331 ptr = (unsigned int *) sp->int_regs;
332 for (i = 0; i < (sizeof(INTERRUPT) / sizeof(unsigned int)); i++, ptr++) {
333 printk("INT: %08x = %08x\n", (int) ptr, *ptr);
334 }
335
336 for (i = 0; i < AR2313_DESCR_ENTRIES; i++) {
337 ar2313_descr_t *td = &sp->tx_ring[i];
338 printk("Tx desc %2d: %08x %08x %08x %08x\n", i,
339 td->status, td->devcs, td->addr, td->descr);
340 }
341 }
342 #endif
343
344 #ifdef TX_TIMEOUT
345 static void ar2313_tx_timeout(struct net_device *dev)
346 {
347 struct ar2313_private *sp = netdev_priv(dev);
348 unsigned long flags;
349
350 #if DEBUG_TX
351 printk("Tx timeout\n");
352 #endif
353 spin_lock_irqsave(&sp->lock, flags);
354 ar2313_restart(dev);
355 spin_unlock_irqrestore(&sp->lock, flags);
356 }
357 #endif
358
359 #if DEBUG_MC
360 static void printMcList(struct net_device *dev)
361 {
362 struct dev_mc_list *list = dev->mc_list;
363 int num = 0, i;
364 while (list) {
365 printk("%d MC ADDR ", num);
366 for (i = 0; i < list->dmi_addrlen; i++) {
367 printk(":%02x", list->dmi_addr[i]);
368 }
369 list = list->next;
370 printk("\n");
371 }
372 }
373 #endif
374
375 /*
376 * Set or clear the multicast filter for this adaptor.
377 * THIS IS ABSOLUTE CRAP, disabled
378 */
379 static void ar2313_multicast_list(struct net_device *dev)
380 {
381 /*
382 * Always listen to broadcasts and
383 * treat IFF bits independently
384 */
385 struct ar2313_private *sp = netdev_priv(dev);
386 unsigned int recognise;
387
388 recognise = sp->eth_regs->mac_control;
389
390 if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
391 recognise |= MAC_CONTROL_PR;
392 } else {
393 recognise &= ~MAC_CONTROL_PR;
394 }
395
396 if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 15)) {
397 #if DEBUG_MC
398 printMcList(dev);
399 printk("%s: all MULTICAST mc_count %d\n", __FUNCTION__,
400 dev->mc_count);
401 #endif
402 recognise |= MAC_CONTROL_PM; /* all multicast */
403 } else if (dev->mc_count > 0) {
404 #if DEBUG_MC
405 printMcList(dev);
406 printk("%s: mc_count %d\n", __FUNCTION__, dev->mc_count);
407 #endif
408 recognise |= MAC_CONTROL_PM; /* for the time being */
409 }
410 #if DEBUG_MC
411 printk("%s: setting %08x to %08x\n", __FUNCTION__, (int) sp->eth_regs,
412 recognise);
413 #endif
414
415 sp->eth_regs->mac_control = recognise;
416 }
417
418 static void rx_tasklet_cleanup(struct net_device *dev)
419 {
420 struct ar2313_private *sp = netdev_priv(dev);
421
422 /*
423 * Tasklet may be scheduled. Need to get it removed from the list
424 * since we're about to free the struct.
425 */
426
427 sp->unloading = 1;
428 tasklet_enable(&sp->rx_tasklet);
429 tasklet_kill(&sp->rx_tasklet);
430 }
431
432 static int __exit ar2313_remove(struct platform_device *pdev)
433 {
434 struct net_device *dev = platform_get_drvdata(pdev);
435 rx_tasklet_cleanup(dev);
436 ar2313_init_cleanup(dev);
437 unregister_netdev(dev);
438 kfree(dev);
439 return 0;
440 }
441
442
443 /*
444 * Restart the AR2313 ethernet controller.
445 */
446 static int ar2313_restart(struct net_device *dev)
447 {
448 /* disable interrupts */
449 disable_irq(dev->irq);
450
451 /* stop mac */
452 ar2313_halt(dev);
453
454 /* initialize */
455 ar2313_init(dev);
456
457 /* enable interrupts */
458 enable_irq(dev->irq);
459
460 return 0;
461 }
462
463 static struct platform_driver ar2313_driver = {
464 .driver.name = "ar531x-eth",
465 .probe = ar2313_probe,
466 .remove = ar2313_remove,
467 };
468
469 int __init ar2313_module_init(void)
470 {
471 return platform_driver_register(&ar2313_driver);
472 }
473
474 void __exit ar2313_module_cleanup(void)
475 {
476 platform_driver_unregister(&ar2313_driver);
477 }
478
479 module_init(ar2313_module_init);
480 module_exit(ar2313_module_cleanup);
481
482
483 static void ar2313_free_descriptors(struct net_device *dev)
484 {
485 struct ar2313_private *sp = netdev_priv(dev);
486 if (sp->rx_ring != NULL) {
487 kfree((void *) KSEG0ADDR(sp->rx_ring));
488 sp->rx_ring = NULL;
489 sp->tx_ring = NULL;
490 }
491 }
492
493
494 static int ar2313_allocate_descriptors(struct net_device *dev)
495 {
496 struct ar2313_private *sp = netdev_priv(dev);
497 int size;
498 int j;
499 ar2313_descr_t *space;
500
501 if (sp->rx_ring != NULL) {
502 printk("%s: already done.\n", __FUNCTION__);
503 return 0;
504 }
505
506 size =
507 (sizeof(ar2313_descr_t) * (AR2313_DESCR_ENTRIES * AR2313_QUEUES));
508 space = kmalloc(size, GFP_KERNEL);
509 if (space == NULL)
510 return 1;
511
512 /* invalidate caches */
513 dma_cache_inv((unsigned int) space, size);
514
515 /* now convert pointer to KSEG1 */
516 space = (ar2313_descr_t *) KSEG1ADDR(space);
517
518 memset((void *) space, 0, size);
519
520 sp->rx_ring = space;
521 space += AR2313_DESCR_ENTRIES;
522
523 sp->tx_ring = space;
524 space += AR2313_DESCR_ENTRIES;
525
526 /* Initialize the transmit Descriptors */
527 for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
528 ar2313_descr_t *td = &sp->tx_ring[j];
529 td->status = 0;
530 td->devcs = DMA_TX1_CHAINED;
531 td->addr = 0;
532 td->descr =
533 virt_to_phys(&sp->
534 tx_ring[(j + 1) & (AR2313_DESCR_ENTRIES - 1)]);
535 }
536
537 return 0;
538 }
539
540
541 /*
542 * Generic cleanup handling data allocated during init. Used when the
543 * module is unloaded or if an error occurs during initialization
544 */
545 static void ar2313_init_cleanup(struct net_device *dev)
546 {
547 struct ar2313_private *sp = netdev_priv(dev);
548 struct sk_buff *skb;
549 int j;
550
551 ar2313_free_descriptors(dev);
552
553 if (sp->eth_regs)
554 iounmap((void *) sp->eth_regs);
555 if (sp->dma_regs)
556 iounmap((void *) sp->dma_regs);
557
558 if (sp->rx_skb) {
559 for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
560 skb = sp->rx_skb[j];
561 if (skb) {
562 sp->rx_skb[j] = NULL;
563 dev_kfree_skb(skb);
564 }
565 }
566 kfree(sp->rx_skb);
567 sp->rx_skb = NULL;
568 }
569
570 if (sp->tx_skb) {
571 for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
572 skb = sp->tx_skb[j];
573 if (skb) {
574 sp->tx_skb[j] = NULL;
575 dev_kfree_skb(skb);
576 }
577 }
578 kfree(sp->tx_skb);
579 sp->tx_skb = NULL;
580 }
581 }
582
583 static int ar2313_setup_timer(struct net_device *dev)
584 {
585 struct ar2313_private *sp = netdev_priv(dev);
586
587 init_timer(&sp->link_timer);
588
589 sp->link_timer.function = ar2313_link_timer_fn;
590 sp->link_timer.data = (int) dev;
591 sp->link_timer.expires = jiffies + HZ;
592
593 add_timer(&sp->link_timer);
594 return 0;
595
596 }
597
598 static void ar2313_link_timer_fn(unsigned long data)
599 {
600 struct net_device *dev = (struct net_device *) data;
601 struct ar2313_private *sp = netdev_priv(dev);
602
603 // see if the link status changed
604 // This was needed to make sure we set the PHY to the
605 // autonegotiated value of half or full duplex.
606 ar2313_check_link(dev);
607
608 // Loop faster when we don't have link.
609 // This was needed to speed up the AP bootstrap time.
610 if (sp->link == 0) {
611 mod_timer(&sp->link_timer, jiffies + HZ / 2);
612 } else {
613 mod_timer(&sp->link_timer, jiffies + LINK_TIMER);
614 }
615 }
616
617 static void ar2313_check_link(struct net_device *dev)
618 {
619 struct ar2313_private *sp = netdev_priv(dev);
620 u16 phyData;
621
622 phyData = mdiobus_read(&sp->mii_bus, sp->phy, MII_BMSR);
623 if (sp->phyData != phyData) {
624 if (phyData & BMSR_LSTATUS) {
625 /* link is present, ready link partner ability to deterine
626 duplexity */
627 int duplex = 0;
628 u16 reg;
629
630 sp->link = 1;
631 reg = mdiobus_read(&sp->mii_bus, sp->phy, MII_BMCR);
632 if (reg & BMCR_ANENABLE) {
633 /* auto neg enabled */
634 reg = mdiobus_read(&sp->mii_bus, sp->phy, MII_LPA);
635 duplex = (reg & (LPA_100FULL | LPA_10FULL)) ? 1 : 0;
636 } else {
637 /* no auto neg, just read duplex config */
638 duplex = (reg & BMCR_FULLDPLX) ? 1 : 0;
639 }
640
641 printk(KERN_INFO "%s: Configuring MAC for %s duplex\n",
642 dev->name, (duplex) ? "full" : "half");
643
644 if (duplex) {
645 /* full duplex */
646 sp->eth_regs->mac_control =
647 ((sp->eth_regs->
648 mac_control | MAC_CONTROL_F) & ~MAC_CONTROL_DRO);
649 } else {
650 /* half duplex */
651 sp->eth_regs->mac_control =
652 ((sp->eth_regs->
653 mac_control | MAC_CONTROL_DRO) & ~MAC_CONTROL_F);
654 }
655 } else {
656 /* no link */
657 sp->link = 0;
658 }
659 sp->phyData = phyData;
660 }
661 }
662
663 static int ar2313_reset_reg(struct net_device *dev)
664 {
665 struct ar2313_private *sp = netdev_priv(dev);
666 unsigned int ethsal, ethsah;
667 unsigned int flags;
668
669 *sp->int_regs |= sp->cfg->reset_mac;
670 mdelay(10);
671 *sp->int_regs &= ~sp->cfg->reset_mac;
672 mdelay(10);
673 *sp->int_regs |= sp->cfg->reset_phy;
674 mdelay(10);
675 *sp->int_regs &= ~sp->cfg->reset_phy;
676 mdelay(10);
677
678 sp->dma_regs->bus_mode = (DMA_BUS_MODE_SWR);
679 mdelay(10);
680 sp->dma_regs->bus_mode =
681 ((32 << DMA_BUS_MODE_PBL_SHIFT) | DMA_BUS_MODE_BLE);
682
683 /* enable interrupts */
684 sp->dma_regs->intr_ena = (DMA_STATUS_AIS |
685 DMA_STATUS_NIS |
686 DMA_STATUS_RI |
687 DMA_STATUS_TI | DMA_STATUS_FBE);
688 sp->dma_regs->xmt_base = virt_to_phys(sp->tx_ring);
689 sp->dma_regs->rcv_base = virt_to_phys(sp->rx_ring);
690 sp->dma_regs->control =
691 (DMA_CONTROL_SR | DMA_CONTROL_ST | DMA_CONTROL_SF);
692
693 sp->eth_regs->flow_control = (FLOW_CONTROL_FCE);
694 sp->eth_regs->vlan_tag = (0x8100);
695
696 /* Enable Ethernet Interface */
697 flags = (MAC_CONTROL_TE | /* transmit enable */
698 MAC_CONTROL_PM | /* pass mcast */
699 MAC_CONTROL_F | /* full duplex */
700 MAC_CONTROL_HBD); /* heart beat disabled */
701
702 if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
703 flags |= MAC_CONTROL_PR;
704 }
705 sp->eth_regs->mac_control = flags;
706
707 /* Set all Ethernet station address registers to their initial values */
708 ethsah = ((((u_int) (dev->dev_addr[5]) << 8) & (u_int) 0x0000FF00) |
709 (((u_int) (dev->dev_addr[4]) << 0) & (u_int) 0x000000FF));
710
711 ethsal = ((((u_int) (dev->dev_addr[3]) << 24) & (u_int) 0xFF000000) |
712 (((u_int) (dev->dev_addr[2]) << 16) & (u_int) 0x00FF0000) |
713 (((u_int) (dev->dev_addr[1]) << 8) & (u_int) 0x0000FF00) |
714 (((u_int) (dev->dev_addr[0]) << 0) & (u_int) 0x000000FF));
715
716 sp->eth_regs->mac_addr[0] = ethsah;
717 sp->eth_regs->mac_addr[1] = ethsal;
718
719 mdelay(10);
720
721 return (0);
722 }
723
724
725 static int ar2313_init(struct net_device *dev)
726 {
727 struct ar2313_private *sp = netdev_priv(dev);
728 int ecode = 0;
729
730 /*
731 * Allocate descriptors
732 */
733 if (ar2313_allocate_descriptors(dev)) {
734 printk("%s: %s: ar2313_allocate_descriptors failed\n",
735 dev->name, __FUNCTION__);
736 ecode = -EAGAIN;
737 goto init_error;
738 }
739
740 /*
741 * Get the memory for the skb rings.
742 */
743 if (sp->rx_skb == NULL) {
744 sp->rx_skb =
745 kmalloc(sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES,
746 GFP_KERNEL);
747 if (!(sp->rx_skb)) {
748 printk("%s: %s: rx_skb kmalloc failed\n",
749 dev->name, __FUNCTION__);
750 ecode = -EAGAIN;
751 goto init_error;
752 }
753 }
754 memset(sp->rx_skb, 0, sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES);
755
756 if (sp->tx_skb == NULL) {
757 sp->tx_skb =
758 kmalloc(sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES,
759 GFP_KERNEL);
760 if (!(sp->tx_skb)) {
761 printk("%s: %s: tx_skb kmalloc failed\n",
762 dev->name, __FUNCTION__);
763 ecode = -EAGAIN;
764 goto init_error;
765 }
766 }
767 memset(sp->tx_skb, 0, sizeof(struct sk_buff *) * AR2313_DESCR_ENTRIES);
768
769 /*
770 * Set tx_csm before we start receiving interrupts, otherwise
771 * the interrupt handler might think it is supposed to process
772 * tx ints before we are up and running, which may cause a null
773 * pointer access in the int handler.
774 */
775 sp->rx_skbprd = 0;
776 sp->cur_rx = 0;
777 sp->tx_prd = 0;
778 sp->tx_csm = 0;
779
780 /*
781 * Zero the stats before starting the interface
782 */
783 memset(&dev->stats, 0, sizeof(dev->stats));
784
785 /*
786 * We load the ring here as there seem to be no way to tell the
787 * firmware to wipe the ring without re-initializing it.
788 */
789 ar2313_load_rx_ring(dev, RX_RING_SIZE);
790
791 /*
792 * Init hardware
793 */
794 ar2313_reset_reg(dev);
795
796 /*
797 * Get the IRQ
798 */
799 ecode =
800 request_irq(dev->irq, &ar2313_interrupt,
801 IRQF_SHARED | IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
802 dev->name, dev);
803 if (ecode) {
804 printk(KERN_WARNING "%s: %s: Requested IRQ %d is busy\n",
805 dev->name, __FUNCTION__, dev->irq);
806 goto init_error;
807 }
808
809
810 tasklet_enable(&sp->rx_tasklet);
811
812 return 0;
813
814 init_error:
815 ar2313_init_cleanup(dev);
816 return ecode;
817 }
818
819 /*
820 * Load the rx ring.
821 *
822 * Loading rings is safe without holding the spin lock since this is
823 * done only before the device is enabled, thus no interrupts are
824 * generated and by the interrupt handler/tasklet handler.
825 */
826 static void ar2313_load_rx_ring(struct net_device *dev, int nr_bufs)
827 {
828
829 struct ar2313_private *sp = netdev_priv(dev);
830 short i, idx;
831
832 idx = sp->rx_skbprd;
833
834 for (i = 0; i < nr_bufs; i++) {
835 struct sk_buff *skb;
836 ar2313_descr_t *rd;
837
838 if (sp->rx_skb[idx]) {
839 #if DEBUG_RX
840 printk(KERN_INFO "ar2313 rx refill full\n");
841 #endif /* DEBUG */
842 break;
843 }
844 // partha: create additional room for the second GRE fragment
845 skb = alloc_skb(AR2313_BUFSIZE + 128, GFP_ATOMIC);
846 if (!skb) {
847 printk("\n\n\n\n %s: No memory in system\n\n\n\n",
848 __FUNCTION__);
849 break;
850 }
851 // partha: create additional room in the front for tx pkt capture
852 skb_reserve(skb, 32);
853
854 /*
855 * Make sure IP header starts on a fresh cache line.
856 */
857 skb->dev = dev;
858 skb_reserve(skb, RX_OFFSET);
859 sp->rx_skb[idx] = skb;
860
861 rd = (ar2313_descr_t *) & sp->rx_ring[idx];
862
863 /* initialize dma descriptor */
864 rd->devcs = ((AR2313_BUFSIZE << DMA_RX1_BSIZE_SHIFT) |
865 DMA_RX1_CHAINED);
866 rd->addr = virt_to_phys(skb->data);
867 rd->descr =
868 virt_to_phys(&sp->
869 rx_ring[(idx + 1) & (AR2313_DESCR_ENTRIES - 1)]);
870 rd->status = DMA_RX_OWN;
871
872 idx = DSC_NEXT(idx);
873 }
874
875 if (!i) {
876 #if DEBUG_ERR
877 printk(KERN_INFO
878 "Out of memory when allocating standard receive buffers\n");
879 #endif /* DEBUG */
880 } else {
881 sp->rx_skbprd = idx;
882 }
883
884 return;
885 }
886
887 #define AR2313_MAX_PKTS_PER_CALL 64
888
889 static int ar2313_rx_int(struct net_device *dev)
890 {
891 struct ar2313_private *sp = netdev_priv(dev);
892 struct sk_buff *skb, *skb_new;
893 ar2313_descr_t *rxdesc;
894 unsigned int status;
895 u32 idx;
896 int pkts = 0;
897 int rval;
898
899 idx = sp->cur_rx;
900
901 /* process at most the entire ring and then wait for another interrupt
902 */
903 while (1) {
904
905 rxdesc = &sp->rx_ring[idx];
906 status = rxdesc->status;
907 if (status & DMA_RX_OWN) {
908 /* SiByte owns descriptor or descr not yet filled in */
909 rval = 0;
910 break;
911 }
912
913 if (++pkts > AR2313_MAX_PKTS_PER_CALL) {
914 rval = 1;
915 break;
916 }
917 #if DEBUG_RX
918 printk("index %d\n", idx);
919 printk("RX status %08x\n", rxdesc->status);
920 printk("RX devcs %08x\n", rxdesc->devcs);
921 printk("RX addr %08x\n", rxdesc->addr);
922 printk("RX descr %08x\n", rxdesc->descr);
923 #endif
924
925 if ((status & (DMA_RX_ERROR | DMA_RX_ERR_LENGTH)) &&
926 (!(status & DMA_RX_LONG))) {
927 #if DEBUG_RX
928 printk("%s: rx ERROR %08x\n", __FUNCTION__, status);
929 #endif
930 dev->stats.rx_errors++;
931 dev->stats.rx_dropped++;
932
933 /* add statistics counters */
934 if (status & DMA_RX_ERR_CRC)
935 dev->stats.rx_crc_errors++;
936 if (status & DMA_RX_ERR_COL)
937 dev->stats.rx_over_errors++;
938 if (status & DMA_RX_ERR_LENGTH)
939 dev->stats.rx_length_errors++;
940 if (status & DMA_RX_ERR_RUNT)
941 dev->stats.rx_over_errors++;
942 if (status & DMA_RX_ERR_DESC)
943 dev->stats.rx_over_errors++;
944
945 } else {
946 /* alloc new buffer. */
947 skb_new = dev_alloc_skb(AR2313_BUFSIZE + RX_OFFSET + 128);
948 if (skb_new != NULL) {
949
950 skb = sp->rx_skb[idx];
951 /* set skb */
952 skb_put(skb,
953 ((status >> DMA_RX_LEN_SHIFT) & 0x3fff) - CRC_LEN);
954
955 dev->stats.rx_bytes += skb->len;
956 skb->protocol = eth_type_trans(skb, dev);
957 /* pass the packet to upper layers */
958 netif_rx(skb);
959
960 skb_new->dev = dev;
961 /* 16 bit align */
962 skb_reserve(skb_new, RX_OFFSET + 32);
963 /* reset descriptor's curr_addr */
964 rxdesc->addr = virt_to_phys(skb_new->data);
965
966 dev->stats.rx_packets++;
967 sp->rx_skb[idx] = skb_new;
968 } else {
969 dev->stats.rx_dropped++;
970 }
971 }
972
973 rxdesc->devcs = ((AR2313_BUFSIZE << DMA_RX1_BSIZE_SHIFT) |
974 DMA_RX1_CHAINED);
975 rxdesc->status = DMA_RX_OWN;
976
977 idx = DSC_NEXT(idx);
978 }
979
980 sp->cur_rx = idx;
981
982 return rval;
983 }
984
985
986 static void ar2313_tx_int(struct net_device *dev)
987 {
988 struct ar2313_private *sp = netdev_priv(dev);
989 u32 idx;
990 struct sk_buff *skb;
991 ar2313_descr_t *txdesc;
992 unsigned int status = 0;
993
994 idx = sp->tx_csm;
995
996 while (idx != sp->tx_prd) {
997
998 txdesc = &sp->tx_ring[idx];
999
1000 #if DEBUG_TX
1001 printk
1002 ("%s: TXINT: csm=%d idx=%d prd=%d status=%x devcs=%x addr=%08x descr=%x\n",
1003 dev->name, sp->tx_csm, idx, sp->tx_prd, txdesc->status,
1004 txdesc->devcs, txdesc->addr, txdesc->descr);
1005 #endif /* DEBUG */
1006
1007 if ((status = txdesc->status) & DMA_TX_OWN) {
1008 /* ar2313 dma still owns descr */
1009 break;
1010 }
1011 /* done with this descriptor */
1012 dma_unmap_single(NULL, txdesc->addr,
1013 txdesc->devcs & DMA_TX1_BSIZE_MASK,
1014 DMA_TO_DEVICE);
1015 txdesc->status = 0;
1016
1017 if (status & DMA_TX_ERROR) {
1018 dev->stats.tx_errors++;
1019 dev->stats.tx_dropped++;
1020 if (status & DMA_TX_ERR_UNDER)
1021 dev->stats.tx_fifo_errors++;
1022 if (status & DMA_TX_ERR_HB)
1023 dev->stats.tx_heartbeat_errors++;
1024 if (status & (DMA_TX_ERR_LOSS | DMA_TX_ERR_LINK))
1025 dev->stats.tx_carrier_errors++;
1026 if (status & (DMA_TX_ERR_LATE |
1027 DMA_TX_ERR_COL |
1028 DMA_TX_ERR_JABBER | DMA_TX_ERR_DEFER))
1029 dev->stats.tx_aborted_errors++;
1030 } else {
1031 /* transmit OK */
1032 dev->stats.tx_packets++;
1033 }
1034
1035 skb = sp->tx_skb[idx];
1036 sp->tx_skb[idx] = NULL;
1037 idx = DSC_NEXT(idx);
1038 dev->stats.tx_bytes += skb->len;
1039 dev_kfree_skb_irq(skb);
1040 }
1041
1042 sp->tx_csm = idx;
1043
1044 return;
1045 }
1046
1047
1048 static void rx_tasklet_func(unsigned long data)
1049 {
1050 struct net_device *dev = (struct net_device *) data;
1051 struct ar2313_private *sp = netdev_priv(dev);
1052
1053 if (sp->unloading) {
1054 return;
1055 }
1056
1057 if (ar2313_rx_int(dev)) {
1058 tasklet_hi_schedule(&sp->rx_tasklet);
1059 } else {
1060 unsigned long flags;
1061 spin_lock_irqsave(&sp->lock, flags);
1062 sp->dma_regs->intr_ena |= DMA_STATUS_RI;
1063 spin_unlock_irqrestore(&sp->lock, flags);
1064 }
1065 }
1066
1067 static void rx_schedule(struct net_device *dev)
1068 {
1069 struct ar2313_private *sp = netdev_priv(dev);
1070
1071 sp->dma_regs->intr_ena &= ~DMA_STATUS_RI;
1072
1073 tasklet_hi_schedule(&sp->rx_tasklet);
1074 }
1075
1076 static irqreturn_t ar2313_interrupt(int irq, void *dev_id)
1077 {
1078 struct net_device *dev = (struct net_device *) dev_id;
1079 struct ar2313_private *sp = netdev_priv(dev);
1080 unsigned int status, enabled;
1081
1082 /* clear interrupt */
1083 /*
1084 * Don't clear RI bit if currently disabled.
1085 */
1086 status = sp->dma_regs->status;
1087 enabled = sp->dma_regs->intr_ena;
1088 sp->dma_regs->status = status & enabled;
1089
1090 if (status & DMA_STATUS_NIS) {
1091 /* normal status */
1092 /*
1093 * Don't schedule rx processing if interrupt
1094 * is already disabled.
1095 */
1096 if (status & enabled & DMA_STATUS_RI) {
1097 /* receive interrupt */
1098 rx_schedule(dev);
1099 }
1100 if (status & DMA_STATUS_TI) {
1101 /* transmit interrupt */
1102 ar2313_tx_int(dev);
1103 }
1104 }
1105
1106 if (status & DMA_STATUS_AIS) {
1107 #if DEBUG_INT
1108 printk("%s: AIS set %08x & %x\n", __FUNCTION__,
1109 status, (DMA_STATUS_FBE | DMA_STATUS_TPS));
1110 #endif
1111 /* abnormal status */
1112 if (status & (DMA_STATUS_FBE | DMA_STATUS_TPS)) {
1113 ar2313_restart(dev);
1114 }
1115 }
1116 return IRQ_HANDLED;
1117 }
1118
1119
1120 static int ar2313_open(struct net_device *dev)
1121 {
1122 struct ar2313_private *sp = netdev_priv(dev);
1123
1124 dev->mtu = 1500;
1125 netif_start_queue(dev);
1126
1127 sp->eth_regs->mac_control |= MAC_CONTROL_RE;
1128
1129 return 0;
1130 }
1131
1132 static void ar2313_halt(struct net_device *dev)
1133 {
1134 struct ar2313_private *sp = netdev_priv(dev);
1135 int j;
1136
1137 tasklet_disable(&sp->rx_tasklet);
1138
1139 /* kill the MAC */
1140 sp->eth_regs->mac_control &= ~(MAC_CONTROL_RE | /* disable Receives */
1141 MAC_CONTROL_TE); /* disable Transmits */
1142 /* stop dma */
1143 sp->dma_regs->control = 0;
1144 sp->dma_regs->bus_mode = DMA_BUS_MODE_SWR;
1145
1146 /* place phy and MAC in reset */
1147 *sp->int_regs |= (sp->cfg->reset_mac | sp->cfg->reset_phy);
1148
1149 /* free buffers on tx ring */
1150 for (j = 0; j < AR2313_DESCR_ENTRIES; j++) {
1151 struct sk_buff *skb;
1152 ar2313_descr_t *txdesc;
1153
1154 txdesc = &sp->tx_ring[j];
1155 txdesc->descr = 0;
1156
1157 skb = sp->tx_skb[j];
1158 if (skb) {
1159 dev_kfree_skb(skb);
1160 sp->tx_skb[j] = NULL;
1161 }
1162 }
1163 }
1164
1165 /*
1166 * close should do nothing. Here's why. It's called when
1167 * 'ifconfig bond0 down' is run. If it calls free_irq then
1168 * the irq is gone forever ! When bond0 is made 'up' again,
1169 * the ar2313_open () does not call request_irq (). Worse,
1170 * the call to ar2313_halt() generates a WDOG reset due to
1171 * the write to 'sp->int_regs' and the box reboots.
1172 * Commenting this out is good since it allows the
1173 * system to resume when bond0 is made up again.
1174 */
1175 static int ar2313_close(struct net_device *dev)
1176 {
1177 #if 0
1178 /*
1179 * Disable interrupts
1180 */
1181 disable_irq(dev->irq);
1182
1183 /*
1184 * Without (or before) releasing irq and stopping hardware, this
1185 * is an absolute non-sense, by the way. It will be reset instantly
1186 * by the first irq.
1187 */
1188 netif_stop_queue(dev);
1189
1190 /* stop the MAC and DMA engines */
1191 ar2313_halt(dev);
1192
1193 /* release the interrupt */
1194 free_irq(dev->irq, dev);
1195
1196 #endif
1197 return 0;
1198 }
1199
1200 static int ar2313_start_xmit(struct sk_buff *skb, struct net_device *dev)
1201 {
1202 struct ar2313_private *sp = netdev_priv(dev);
1203 ar2313_descr_t *td;
1204 u32 idx;
1205
1206 idx = sp->tx_prd;
1207 td = &sp->tx_ring[idx];
1208
1209 if (td->status & DMA_TX_OWN) {
1210 #if DEBUG_TX
1211 printk("%s: No space left to Tx\n", __FUNCTION__);
1212 #endif
1213 /* free skbuf and lie to the caller that we sent it out */
1214 dev->stats.tx_dropped++;
1215 dev_kfree_skb(skb);
1216
1217 /* restart transmitter in case locked */
1218 sp->dma_regs->xmt_poll = 0;
1219 return 0;
1220 }
1221
1222 /* Setup the transmit descriptor. */
1223 td->devcs = ((skb->len << DMA_TX1_BSIZE_SHIFT) |
1224 (DMA_TX1_LS | DMA_TX1_IC | DMA_TX1_CHAINED));
1225 td->addr = dma_map_single(NULL, skb->data, skb->len, DMA_TO_DEVICE);
1226 td->status = DMA_TX_OWN;
1227
1228 /* kick transmitter last */
1229 sp->dma_regs->xmt_poll = 0;
1230
1231 #if DEBUG_TX
1232 printk("index %d\n", idx);
1233 printk("TX status %08x\n", td->status);
1234 printk("TX devcs %08x\n", td->devcs);
1235 printk("TX addr %08x\n", td->addr);
1236 printk("TX descr %08x\n", td->descr);
1237 #endif
1238
1239 sp->tx_skb[idx] = skb;
1240 idx = DSC_NEXT(idx);
1241 sp->tx_prd = idx;
1242
1243 return 0;
1244 }
1245
1246 static int ar2313_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1247 {
1248 struct mii_ioctl_data *data = (struct mii_ioctl_data *) &ifr->ifr_data;
1249 struct ar2313_private *sp = netdev_priv(dev);
1250 int ret;
1251
1252 switch (cmd) {
1253
1254 case SIOCETHTOOL:
1255 spin_lock_irq(&sp->lock);
1256 ret = phy_ethtool_ioctl(sp->phy_dev, (void *) ifr->ifr_data);
1257 spin_unlock_irq(&sp->lock);
1258 return ret;
1259
1260 case SIOCSIFHWADDR:
1261 if (copy_from_user
1262 (dev->dev_addr, ifr->ifr_data, sizeof(dev->dev_addr)))
1263 return -EFAULT;
1264 return 0;
1265
1266 case SIOCGIFHWADDR:
1267 if (copy_to_user
1268 (ifr->ifr_data, dev->dev_addr, sizeof(dev->dev_addr)))
1269 return -EFAULT;
1270 return 0;
1271
1272 case SIOCGMIIPHY:
1273 case SIOCGMIIREG:
1274 case SIOCSMIIREG:
1275 return phy_mii_ioctl(sp->phy_dev, data, cmd);
1276
1277 default:
1278 break;
1279 }
1280
1281 return -EOPNOTSUPP;
1282 }
1283
1284 static void ar2313_adjust_link(struct net_device *dev)
1285 {
1286 struct ar2313_private *sp = netdev_priv(dev);
1287 unsigned int mc;
1288
1289 if (!sp->phy_dev->link)
1290 return;
1291
1292 if (sp->phy_dev->duplex != sp->oldduplex) {
1293 mc = readl(&sp->eth_regs->mac_control);
1294 mc &= ~(MAC_CONTROL_F | MAC_CONTROL_DRO);
1295 if (sp->phy_dev->duplex)
1296 mc |= MAC_CONTROL_F;
1297 else
1298 mc |= MAC_CONTROL_DRO;
1299 writel(mc, &sp->eth_regs->mac_control);
1300 sp->oldduplex = sp->phy_dev->duplex;
1301 }
1302 }
1303
1304 #define MII_ADDR(phy, reg) \
1305 ((reg << MII_ADDR_REG_SHIFT) | (phy << MII_ADDR_PHY_SHIFT))
1306
1307 static int
1308 mdiobus_read(struct mii_bus *bus, int phy_addr, int regnum)
1309 {
1310 struct net_device *const dev = bus->priv;
1311 struct ar2313_private *sp = netdev_priv(dev);
1312 volatile ETHERNET_STRUCT *ethernet = sp->phy_regs;
1313
1314 ethernet->mii_addr = MII_ADDR(phy_addr, regnum);
1315 while (ethernet->mii_addr & MII_ADDR_BUSY);
1316 return (ethernet->mii_data >> MII_DATA_SHIFT);
1317 }
1318
1319 static int
1320 mdiobus_write(struct mii_bus *bus, int phy_addr, int regnum,
1321 u16 value)
1322 {
1323 struct net_device *const dev = bus->priv;
1324 struct ar2313_private *sp = netdev_priv(dev);
1325 volatile ETHERNET_STRUCT *ethernet = sp->phy_regs;
1326
1327 while (ethernet->mii_addr & MII_ADDR_BUSY);
1328 ethernet->mii_data = value << MII_DATA_SHIFT;
1329 ethernet->mii_addr = MII_ADDR(phy_addr, regnum) | MII_ADDR_WRITE;
1330
1331 return 0;
1332 }
1333
1334 static int mdiobus_reset(struct mii_bus *bus)
1335 {
1336 struct net_device *const dev = bus->priv;
1337
1338 ar2313_reset_reg(dev);
1339
1340 return 0;
1341 }
1342
1343 static int mdiobus_probe (struct net_device *dev)
1344 {
1345 struct ar2313_private *const sp = netdev_priv(dev);
1346 struct phy_device *phydev = NULL;
1347 int phy_addr;
1348
1349 /* find the first (lowest address) PHY on the current MAC's MII bus */
1350 for (phy_addr = 0; phy_addr < PHY_MAX_ADDR; phy_addr++)
1351 if (sp->mii_bus.phy_map[phy_addr]) {
1352 phydev = sp->mii_bus.phy_map[phy_addr];
1353 break; /* break out with first one found */
1354 }
1355
1356 if (!phydev) {
1357 printk (KERN_ERR "ar2313:%s: no PHY found\n", dev->name);
1358 return -1;
1359 }
1360
1361 /* now we are supposed to have a proper phydev, to attach to... */
1362 BUG_ON(!phydev);
1363 BUG_ON(phydev->attached_dev);
1364
1365 phydev = phy_connect(dev, phydev->dev.bus_id, &ar2313_adjust_link, 0,
1366 PHY_INTERFACE_MODE_MII);
1367
1368 if (IS_ERR(phydev)) {
1369 printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name);
1370 return PTR_ERR(phydev);
1371 }
1372
1373 /* mask with MAC supported features */
1374 phydev->supported &= (SUPPORTED_10baseT_Half
1375 | SUPPORTED_10baseT_Full
1376 | SUPPORTED_100baseT_Half
1377 | SUPPORTED_100baseT_Full
1378 | SUPPORTED_Autoneg
1379 /* | SUPPORTED_Pause | SUPPORTED_Asym_Pause */
1380 | SUPPORTED_MII
1381 | SUPPORTED_TP);
1382
1383 phydev->advertising = phydev->supported;
1384
1385 sp->oldduplex = -1;
1386 sp->phy_dev = phydev;
1387
1388 printk(KERN_INFO "%s: attached PHY driver [%s] "
1389 "(mii_bus:phy_addr=%s)\n",
1390 dev->name, phydev->drv->name, phydev->dev.bus_id);
1391
1392 return 0;
1393 }
1394
Personal OpenWRT clone
This page took 0.110238 seconds and 5 git commands to generate.