2 * ar2313.c: Linux driver for the Atheros AR231x Ethernet device.
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>
8 * Thanks to Atheros for providing hardware and documentation
9 * enabling me to write this driver.
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.
17 * This code is taken from John Taylor's Sibyte driver and then
18 * modified for the AR2313.
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>
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>
47 #include <asm/system.h>
50 #include <asm/byteorder.h>
51 #include <asm/uaccess.h>
52 #include <asm/bootinfo.h>
54 #define AR2313_MTU 1692
55 #define AR2313_PRIOS 1
56 #define AR2313_QUEUES (2*AR2313_PRIOS)
57 #define AR2313_DESCR_ENTRIES 64
68 #define min(a,b) (((a)<(b))?(a):(b))
71 #ifndef SMP_CACHE_BYTES
72 #define SMP_CACHE_BYTES L1_CACHE_BYTES
75 #define AR2313_MBOX_SET_BIT 0x8
77 #define BOARD_IDX_STATIC 0
78 #define BOARD_IDX_OVERFLOW -1
84 * New interrupt handler strategy:
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
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
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.
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
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
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
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)
137 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
143 #define AR2313_BUFSIZE (AR2313_MTU + VLAN_HDR + ETH_HLEN + CRC_LEN + RX_OFFSET)
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");
151 #define virt_to_phys(x) ((u32)(x) & 0x1fffffff)
155 static void ar2313_tx_timeout(struct net_device
*dev
);
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
);
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
);
169 #define ERR(fmt, args...) printk("%s: " fmt, __func__, ##args)
173 int __init
ar2313_probe(struct platform_device
*pdev
)
175 struct net_device
*dev
;
176 struct ar2313_private
*sp
;
177 struct resource
*res
;
178 unsigned long ar_eth_base
;
181 dev
= alloc_etherdev(sizeof(struct ar2313_private
));
185 "ar2313: Unable to allocate net_device structure!\n");
189 platform_set_drvdata(pdev
, dev
);
191 sp
= netdev_priv(dev
);
193 sp
->cfg
= pdev
->dev
.platform_data
;
195 sprintf(buf
, "eth%d_membase", pdev
->id
);
196 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, buf
);
201 ar_eth_base
= res
->start
;
202 sp
->phy
= sp
->cfg
->phy
;
204 sprintf(buf
, "eth%d_irq", pdev
->id
);
205 dev
->irq
= platform_get_irq_byname(pdev
, buf
);
207 spin_lock_init(&sp
->lock
);
209 /* initialize func pointers */
210 dev
->open
= &ar2313_open
;
211 dev
->stop
= &ar2313_close
;
212 dev
->hard_start_xmit
= &ar2313_start_xmit
;
214 dev
->set_multicast_list
= &ar2313_multicast_list
;
216 dev
->tx_timeout
= ar2313_tx_timeout
;
217 dev
->watchdog_timeo
= AR2313_TX_TIMEOUT
;
219 dev
->do_ioctl
= &ar2313_ioctl
;
221 // SAMEER: do we need this?
222 dev
->features
|= NETIF_F_HIGHDMA
;
224 tasklet_init(&sp
->rx_tasklet
, rx_tasklet_func
, (unsigned long) dev
);
225 tasklet_disable(&sp
->rx_tasklet
);
228 ioremap_nocache(virt_to_phys(ar_eth_base
), sizeof(*sp
->eth_regs
));
230 printk("Can't remap eth registers\n");
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
239 if (virt_to_phys(ar_eth_base
) == virt_to_phys(sp
->phy_regs
))
240 sp
->phy_regs
= sp
->eth_regs
;
243 ioremap_nocache(virt_to_phys(sp
->cfg
->phy_base
),
244 sizeof(*sp
->phy_regs
));
246 printk("Can't remap phy registers\n");
252 ioremap_nocache(virt_to_phys(ar_eth_base
+ 0x1000),
253 sizeof(*sp
->dma_regs
));
254 dev
->base_addr
= (unsigned int) sp
->dma_regs
;
256 printk("Can't remap DMA registers\n");
260 sp
->int_regs
= ioremap_nocache(virt_to_phys(sp
->cfg
->reset_base
), 4);
262 printk("Can't remap INTERRUPT registers\n");
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
;
271 if (ar2313_init(dev
)) {
273 * ar2313_init() calls ar2313_init_cleanup() on error.
279 if (register_netdev(dev
)) {
280 printk("%s: register_netdev failed\n", __func__
);
284 printk("%s: %s: %02x:%02x:%02x:%02x:%02x:%02x, irq %d\n",
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
);
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";
295 sp
->mii_bus
.irq
= kmalloc(sizeof(int), GFP_KERNEL
);
296 *sp
->mii_bus
.irq
= PHY_POLL
;
298 mdiobus_register(&sp
->mii_bus
);
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
);
307 /* start link poll timer */
308 ar2313_setup_timer(dev
);
315 static void ar2313_dump_regs(struct net_device
*dev
)
317 unsigned int *ptr
, i
;
318 struct ar2313_private
*sp
= netdev_priv(dev
);
320 ptr
= (unsigned int *) sp
->eth_regs
;
321 for (i
= 0; i
< (sizeof(ETHERNET_STRUCT
) / sizeof(unsigned int));
323 printk("ENET: %08x = %08x\n", (int) ptr
, *ptr
);
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
);
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
);
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
);
345 static void ar2313_tx_timeout(struct net_device
*dev
)
347 struct ar2313_private
*sp
= netdev_priv(dev
);
351 printk("Tx timeout\n");
353 spin_lock_irqsave(&sp
->lock
, flags
);
355 spin_unlock_irqrestore(&sp
->lock
, flags
);
360 static void printMcList(struct net_device
*dev
)
362 struct dev_mc_list
*list
= dev
->mc_list
;
365 printk("%d MC ADDR ", num
);
366 for (i
= 0; i
< list
->dmi_addrlen
; i
++) {
367 printk(":%02x", list
->dmi_addr
[i
]);
376 * Set or clear the multicast filter for this adaptor.
377 * THIS IS ABSOLUTE CRAP, disabled
379 static void ar2313_multicast_list(struct net_device
*dev
)
382 * Always listen to broadcasts and
383 * treat IFF bits independently
385 struct ar2313_private
*sp
= netdev_priv(dev
);
386 unsigned int recognise
;
388 recognise
= sp
->eth_regs
->mac_control
;
390 if (dev
->flags
& IFF_PROMISC
) { /* set promiscuous mode */
391 recognise
|= MAC_CONTROL_PR
;
393 recognise
&= ~MAC_CONTROL_PR
;
396 if ((dev
->flags
& IFF_ALLMULTI
) || (dev
->mc_count
> 15)) {
399 printk("%s: all MULTICAST mc_count %d\n", __FUNCTION__
,
402 recognise
|= MAC_CONTROL_PM
; /* all multicast */
403 } else if (dev
->mc_count
> 0) {
406 printk("%s: mc_count %d\n", __FUNCTION__
, dev
->mc_count
);
408 recognise
|= MAC_CONTROL_PM
; /* for the time being */
411 printk("%s: setting %08x to %08x\n", __FUNCTION__
, (int) sp
->eth_regs
,
415 sp
->eth_regs
->mac_control
= recognise
;
418 static void rx_tasklet_cleanup(struct net_device
*dev
)
420 struct ar2313_private
*sp
= netdev_priv(dev
);
423 * Tasklet may be scheduled. Need to get it removed from the list
424 * since we're about to free the struct.
428 tasklet_enable(&sp
->rx_tasklet
);
429 tasklet_kill(&sp
->rx_tasklet
);
432 static int __exit
ar2313_remove(struct platform_device
*pdev
)
434 struct net_device
*dev
= platform_get_drvdata(pdev
);
435 rx_tasklet_cleanup(dev
);
436 ar2313_init_cleanup(dev
);
437 unregister_netdev(dev
);
444 * Restart the AR2313 ethernet controller.
446 static int ar2313_restart(struct net_device
*dev
)
448 /* disable interrupts */
449 disable_irq(dev
->irq
);
457 /* enable interrupts */
458 enable_irq(dev
->irq
);
463 static struct platform_driver ar2313_driver
= {
464 .driver
.name
= "ar531x-eth",
465 .probe
= ar2313_probe
,
466 .remove
= ar2313_remove
,
469 int __init
ar2313_module_init(void)
471 return platform_driver_register(&ar2313_driver
);
474 void __exit
ar2313_module_cleanup(void)
476 platform_driver_unregister(&ar2313_driver
);
479 module_init(ar2313_module_init
);
480 module_exit(ar2313_module_cleanup
);
483 static void ar2313_free_descriptors(struct net_device
*dev
)
485 struct ar2313_private
*sp
= netdev_priv(dev
);
486 if (sp
->rx_ring
!= NULL
) {
487 kfree((void *) KSEG0ADDR(sp
->rx_ring
));
494 static int ar2313_allocate_descriptors(struct net_device
*dev
)
496 struct ar2313_private
*sp
= netdev_priv(dev
);
499 ar2313_descr_t
*space
;
501 if (sp
->rx_ring
!= NULL
) {
502 printk("%s: already done.\n", __FUNCTION__
);
507 (sizeof(ar2313_descr_t
) * (AR2313_DESCR_ENTRIES
* AR2313_QUEUES
));
508 space
= kmalloc(size
, GFP_KERNEL
);
512 /* invalidate caches */
513 dma_cache_inv((unsigned int) space
, size
);
515 /* now convert pointer to KSEG1 */
516 space
= (ar2313_descr_t
*) KSEG1ADDR(space
);
518 memset((void *) space
, 0, size
);
521 space
+= AR2313_DESCR_ENTRIES
;
524 space
+= AR2313_DESCR_ENTRIES
;
526 /* Initialize the transmit Descriptors */
527 for (j
= 0; j
< AR2313_DESCR_ENTRIES
; j
++) {
528 ar2313_descr_t
*td
= &sp
->tx_ring
[j
];
530 td
->devcs
= DMA_TX1_CHAINED
;
534 tx_ring
[(j
+ 1) & (AR2313_DESCR_ENTRIES
- 1)]);
542 * Generic cleanup handling data allocated during init. Used when the
543 * module is unloaded or if an error occurs during initialization
545 static void ar2313_init_cleanup(struct net_device
*dev
)
547 struct ar2313_private
*sp
= netdev_priv(dev
);
551 ar2313_free_descriptors(dev
);
554 iounmap((void *) sp
->eth_regs
);
556 iounmap((void *) sp
->dma_regs
);
559 for (j
= 0; j
< AR2313_DESCR_ENTRIES
; j
++) {
562 sp
->rx_skb
[j
] = NULL
;
571 for (j
= 0; j
< AR2313_DESCR_ENTRIES
; j
++) {
574 sp
->tx_skb
[j
] = NULL
;
583 static int ar2313_setup_timer(struct net_device
*dev
)
585 struct ar2313_private
*sp
= netdev_priv(dev
);
587 init_timer(&sp
->link_timer
);
589 sp
->link_timer
.function
= ar2313_link_timer_fn
;
590 sp
->link_timer
.data
= (int) dev
;
591 sp
->link_timer
.expires
= jiffies
+ HZ
;
593 add_timer(&sp
->link_timer
);
598 static void ar2313_link_timer_fn(unsigned long data
)
600 struct net_device
*dev
= (struct net_device
*) data
;
601 struct ar2313_private
*sp
= netdev_priv(dev
);
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
);
608 // Loop faster when we don't have link.
609 // This was needed to speed up the AP bootstrap time.
611 mod_timer(&sp
->link_timer
, jiffies
+ HZ
/ 2);
613 mod_timer(&sp
->link_timer
, jiffies
+ LINK_TIMER
);
617 static void ar2313_check_link(struct net_device
*dev
)
619 struct ar2313_private
*sp
= netdev_priv(dev
);
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
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;
637 /* no auto neg, just read duplex config */
638 duplex
= (reg
& BMCR_FULLDPLX
) ? 1 : 0;
641 printk(KERN_INFO
"%s: Configuring MAC for %s duplex\n",
642 dev
->name
, (duplex
) ? "full" : "half");
646 sp
->eth_regs
->mac_control
=
648 mac_control
| MAC_CONTROL_F
) & ~MAC_CONTROL_DRO
);
651 sp
->eth_regs
->mac_control
=
653 mac_control
| MAC_CONTROL_DRO
) & ~MAC_CONTROL_F
);
659 sp
->phyData
= phyData
;
663 static int ar2313_reset_reg(struct net_device
*dev
)
665 struct ar2313_private
*sp
= netdev_priv(dev
);
666 unsigned int ethsal
, ethsah
;
669 *sp
->int_regs
|= sp
->cfg
->reset_mac
;
671 *sp
->int_regs
&= ~sp
->cfg
->reset_mac
;
673 *sp
->int_regs
|= sp
->cfg
->reset_phy
;
675 *sp
->int_regs
&= ~sp
->cfg
->reset_phy
;
678 sp
->dma_regs
->bus_mode
= (DMA_BUS_MODE_SWR
);
680 sp
->dma_regs
->bus_mode
=
681 ((32 << DMA_BUS_MODE_PBL_SHIFT
) | DMA_BUS_MODE_BLE
);
683 /* enable interrupts */
684 sp
->dma_regs
->intr_ena
= (DMA_STATUS_AIS
|
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
);
693 sp
->eth_regs
->flow_control
= (FLOW_CONTROL_FCE
);
694 sp
->eth_regs
->vlan_tag
= (0x8100);
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 */
702 if (dev
->flags
& IFF_PROMISC
) { /* set promiscuous mode */
703 flags
|= MAC_CONTROL_PR
;
705 sp
->eth_regs
->mac_control
= flags
;
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));
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));
716 sp
->eth_regs
->mac_addr
[0] = ethsah
;
717 sp
->eth_regs
->mac_addr
[1] = ethsal
;
725 static int ar2313_init(struct net_device
*dev
)
727 struct ar2313_private
*sp
= netdev_priv(dev
);
731 * Allocate descriptors
733 if (ar2313_allocate_descriptors(dev
)) {
734 printk("%s: %s: ar2313_allocate_descriptors failed\n",
735 dev
->name
, __FUNCTION__
);
741 * Get the memory for the skb rings.
743 if (sp
->rx_skb
== NULL
) {
745 kmalloc(sizeof(struct sk_buff
*) * AR2313_DESCR_ENTRIES
,
748 printk("%s: %s: rx_skb kmalloc failed\n",
749 dev
->name
, __FUNCTION__
);
754 memset(sp
->rx_skb
, 0, sizeof(struct sk_buff
*) * AR2313_DESCR_ENTRIES
);
756 if (sp
->tx_skb
== NULL
) {
758 kmalloc(sizeof(struct sk_buff
*) * AR2313_DESCR_ENTRIES
,
761 printk("%s: %s: tx_skb kmalloc failed\n",
762 dev
->name
, __FUNCTION__
);
767 memset(sp
->tx_skb
, 0, sizeof(struct sk_buff
*) * AR2313_DESCR_ENTRIES
);
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.
781 * Zero the stats before starting the interface
783 memset(&dev
->stats
, 0, sizeof(dev
->stats
));
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.
789 ar2313_load_rx_ring(dev
, RX_RING_SIZE
);
794 ar2313_reset_reg(dev
);
800 request_irq(dev
->irq
, &ar2313_interrupt
,
801 IRQF_SHARED
| IRQF_DISABLED
| IRQF_SAMPLE_RANDOM
,
804 printk(KERN_WARNING
"%s: %s: Requested IRQ %d is busy\n",
805 dev
->name
, __FUNCTION__
, dev
->irq
);
810 tasklet_enable(&sp
->rx_tasklet
);
815 ar2313_init_cleanup(dev
);
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.
826 static void ar2313_load_rx_ring(struct net_device
*dev
, int nr_bufs
)
829 struct ar2313_private
*sp
= netdev_priv(dev
);
834 for (i
= 0; i
< nr_bufs
; i
++) {
838 if (sp
->rx_skb
[idx
]) {
840 printk(KERN_INFO
"ar2313 rx refill full\n");
844 // partha: create additional room for the second GRE fragment
845 skb
= alloc_skb(AR2313_BUFSIZE
+ 128, GFP_ATOMIC
);
847 printk("\n\n\n\n %s: No memory in system\n\n\n\n",
851 // partha: create additional room in the front for tx pkt capture
852 skb_reserve(skb
, 32);
855 * Make sure IP header starts on a fresh cache line.
858 skb_reserve(skb
, RX_OFFSET
);
859 sp
->rx_skb
[idx
] = skb
;
861 rd
= (ar2313_descr_t
*) & sp
->rx_ring
[idx
];
863 /* initialize dma descriptor */
864 rd
->devcs
= ((AR2313_BUFSIZE
<< DMA_RX1_BSIZE_SHIFT
) |
866 rd
->addr
= virt_to_phys(skb
->data
);
869 rx_ring
[(idx
+ 1) & (AR2313_DESCR_ENTRIES
- 1)]);
870 rd
->status
= DMA_RX_OWN
;
878 "Out of memory when allocating standard receive buffers\n");
887 #define AR2313_MAX_PKTS_PER_CALL 64
889 static int ar2313_rx_int(struct net_device
*dev
)
891 struct ar2313_private
*sp
= netdev_priv(dev
);
892 struct sk_buff
*skb
, *skb_new
;
893 ar2313_descr_t
*rxdesc
;
901 /* process at most the entire ring and then wait for another interrupt
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 */
913 if (++pkts
> AR2313_MAX_PKTS_PER_CALL
) {
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
);
925 if ((status
& (DMA_RX_ERROR
| DMA_RX_ERR_LENGTH
)) &&
926 (!(status
& DMA_RX_LONG
))) {
928 printk("%s: rx ERROR %08x\n", __FUNCTION__
, status
);
930 dev
->stats
.rx_errors
++;
931 dev
->stats
.rx_dropped
++;
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
++;
946 /* alloc new buffer. */
947 skb_new
= dev_alloc_skb(AR2313_BUFSIZE
+ RX_OFFSET
+ 128);
948 if (skb_new
!= NULL
) {
950 skb
= sp
->rx_skb
[idx
];
953 ((status
>> DMA_RX_LEN_SHIFT
) & 0x3fff) - CRC_LEN
);
955 dev
->stats
.rx_bytes
+= skb
->len
;
956 skb
->protocol
= eth_type_trans(skb
, dev
);
957 /* pass the packet to upper layers */
962 skb_reserve(skb_new
, RX_OFFSET
+ 32);
963 /* reset descriptor's curr_addr */
964 rxdesc
->addr
= virt_to_phys(skb_new
->data
);
966 dev
->stats
.rx_packets
++;
967 sp
->rx_skb
[idx
] = skb_new
;
969 dev
->stats
.rx_dropped
++;
973 rxdesc
->devcs
= ((AR2313_BUFSIZE
<< DMA_RX1_BSIZE_SHIFT
) |
975 rxdesc
->status
= DMA_RX_OWN
;
986 static void ar2313_tx_int(struct net_device
*dev
)
988 struct ar2313_private
*sp
= netdev_priv(dev
);
991 ar2313_descr_t
*txdesc
;
992 unsigned int status
= 0;
996 while (idx
!= sp
->tx_prd
) {
998 txdesc
= &sp
->tx_ring
[idx
];
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
);
1007 if ((status
= txdesc
->status
) & DMA_TX_OWN
) {
1008 /* ar2313 dma still owns descr */
1011 /* done with this descriptor */
1012 dma_unmap_single(NULL
, txdesc
->addr
,
1013 txdesc
->devcs
& DMA_TX1_BSIZE_MASK
,
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
|
1028 DMA_TX_ERR_JABBER
| DMA_TX_ERR_DEFER
))
1029 dev
->stats
.tx_aborted_errors
++;
1032 dev
->stats
.tx_packets
++;
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
);
1048 static void rx_tasklet_func(unsigned long data
)
1050 struct net_device
*dev
= (struct net_device
*) data
;
1051 struct ar2313_private
*sp
= netdev_priv(dev
);
1053 if (sp
->unloading
) {
1057 if (ar2313_rx_int(dev
)) {
1058 tasklet_hi_schedule(&sp
->rx_tasklet
);
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
);
1067 static void rx_schedule(struct net_device
*dev
)
1069 struct ar2313_private
*sp
= netdev_priv(dev
);
1071 sp
->dma_regs
->intr_ena
&= ~DMA_STATUS_RI
;
1073 tasklet_hi_schedule(&sp
->rx_tasklet
);
1076 static irqreturn_t
ar2313_interrupt(int irq
, void *dev_id
)
1078 struct net_device
*dev
= (struct net_device
*) dev_id
;
1079 struct ar2313_private
*sp
= netdev_priv(dev
);
1080 unsigned int status
, enabled
;
1082 /* clear interrupt */
1084 * Don't clear RI bit if currently disabled.
1086 status
= sp
->dma_regs
->status
;
1087 enabled
= sp
->dma_regs
->intr_ena
;
1088 sp
->dma_regs
->status
= status
& enabled
;
1090 if (status
& DMA_STATUS_NIS
) {
1093 * Don't schedule rx processing if interrupt
1094 * is already disabled.
1096 if (status
& enabled
& DMA_STATUS_RI
) {
1097 /* receive interrupt */
1100 if (status
& DMA_STATUS_TI
) {
1101 /* transmit interrupt */
1106 if (status
& DMA_STATUS_AIS
) {
1108 printk("%s: AIS set %08x & %x\n", __FUNCTION__
,
1109 status
, (DMA_STATUS_FBE
| DMA_STATUS_TPS
));
1111 /* abnormal status */
1112 if (status
& (DMA_STATUS_FBE
| DMA_STATUS_TPS
)) {
1113 ar2313_restart(dev
);
1120 static int ar2313_open(struct net_device
*dev
)
1122 struct ar2313_private
*sp
= netdev_priv(dev
);
1125 netif_start_queue(dev
);
1127 sp
->eth_regs
->mac_control
|= MAC_CONTROL_RE
;
1132 static void ar2313_halt(struct net_device
*dev
)
1134 struct ar2313_private
*sp
= netdev_priv(dev
);
1137 tasklet_disable(&sp
->rx_tasklet
);
1140 sp
->eth_regs
->mac_control
&= ~(MAC_CONTROL_RE
| /* disable Receives */
1141 MAC_CONTROL_TE
); /* disable Transmits */
1143 sp
->dma_regs
->control
= 0;
1144 sp
->dma_regs
->bus_mode
= DMA_BUS_MODE_SWR
;
1146 /* place phy and MAC in reset */
1147 *sp
->int_regs
|= (sp
->cfg
->reset_mac
| sp
->cfg
->reset_phy
);
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
;
1154 txdesc
= &sp
->tx_ring
[j
];
1157 skb
= sp
->tx_skb
[j
];
1160 sp
->tx_skb
[j
] = NULL
;
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.
1175 static int ar2313_close(struct net_device
*dev
)
1179 * Disable interrupts
1181 disable_irq(dev
->irq
);
1184 * Without (or before) releasing irq and stopping hardware, this
1185 * is an absolute non-sense, by the way. It will be reset instantly
1188 netif_stop_queue(dev
);
1190 /* stop the MAC and DMA engines */
1193 /* release the interrupt */
1194 free_irq(dev
->irq
, dev
);
1200 static int ar2313_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1202 struct ar2313_private
*sp
= netdev_priv(dev
);
1207 td
= &sp
->tx_ring
[idx
];
1209 if (td
->status
& DMA_TX_OWN
) {
1211 printk("%s: No space left to Tx\n", __FUNCTION__
);
1213 /* free skbuf and lie to the caller that we sent it out */
1214 dev
->stats
.tx_dropped
++;
1217 /* restart transmitter in case locked */
1218 sp
->dma_regs
->xmt_poll
= 0;
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
;
1228 /* kick transmitter last */
1229 sp
->dma_regs
->xmt_poll
= 0;
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
);
1239 sp
->tx_skb
[idx
] = skb
;
1240 idx
= DSC_NEXT(idx
);
1246 static int ar2313_ioctl(struct net_device
*dev
, struct ifreq
*ifr
, int cmd
)
1248 struct mii_ioctl_data
*data
= (struct mii_ioctl_data
*) &ifr
->ifr_data
;
1249 struct ar2313_private
*sp
= netdev_priv(dev
);
1255 spin_lock_irq(&sp
->lock
);
1256 ret
= phy_ethtool_ioctl(sp
->phy_dev
, (void *) ifr
->ifr_data
);
1257 spin_unlock_irq(&sp
->lock
);
1262 (dev
->dev_addr
, ifr
->ifr_data
, sizeof(dev
->dev_addr
)))
1268 (ifr
->ifr_data
, dev
->dev_addr
, sizeof(dev
->dev_addr
)))
1275 return phy_mii_ioctl(sp
->phy_dev
, data
, cmd
);
1284 static void ar2313_adjust_link(struct net_device
*dev
)
1286 struct ar2313_private
*sp
= netdev_priv(dev
);
1289 if (!sp
->phy_dev
->link
)
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
;
1298 mc
|= MAC_CONTROL_DRO
;
1299 writel(mc
, &sp
->eth_regs
->mac_control
);
1300 sp
->oldduplex
= sp
->phy_dev
->duplex
;
1304 #define MII_ADDR(phy, reg) \
1305 ((reg << MII_ADDR_REG_SHIFT) | (phy << MII_ADDR_PHY_SHIFT))
1308 mdiobus_read(struct mii_bus
*bus
, int phy_addr
, int regnum
)
1310 struct net_device
*const dev
= bus
->priv
;
1311 struct ar2313_private
*sp
= netdev_priv(dev
);
1312 volatile ETHERNET_STRUCT
*ethernet
= sp
->phy_regs
;
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
);
1320 mdiobus_write(struct mii_bus
*bus
, int phy_addr
, int regnum
,
1323 struct net_device
*const dev
= bus
->priv
;
1324 struct ar2313_private
*sp
= netdev_priv(dev
);
1325 volatile ETHERNET_STRUCT
*ethernet
= sp
->phy_regs
;
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
;
1334 static int mdiobus_reset(struct mii_bus
*bus
)
1336 struct net_device
*const dev
= bus
->priv
;
1338 ar2313_reset_reg(dev
);
1343 static int mdiobus_probe (struct net_device
*dev
)
1345 struct ar2313_private
*const sp
= netdev_priv(dev
);
1346 struct phy_device
*phydev
= NULL
;
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 */
1357 printk (KERN_ERR
"ar2313:%s: no PHY found\n", dev
->name
);
1361 /* now we are supposed to have a proper phydev, to attach to... */
1363 BUG_ON(phydev
->attached_dev
);
1365 phydev
= phy_connect(dev
, phydev
->dev
.bus_id
, &ar2313_adjust_link
, 0,
1366 PHY_INTERFACE_MODE_MII
);
1368 if (IS_ERR(phydev
)) {
1369 printk(KERN_ERR
"%s: Could not attach to PHY\n", dev
->name
);
1370 return PTR_ERR(phydev
);
1373 /* mask with MAC supported features */
1374 phydev
->supported
&= (SUPPORTED_10baseT_Half
1375 | SUPPORTED_10baseT_Full
1376 | SUPPORTED_100baseT_Half
1377 | SUPPORTED_100baseT_Full
1379 /* | SUPPORTED_Pause | SUPPORTED_Asym_Pause */
1383 phydev
->advertising
= phydev
->supported
;
1386 sp
->phy_dev
= phydev
;
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
);