source: trunk/target/linux/atheros/patches-3.3/110-ar2313_ethernet.patch @ 31626

Last change on this file since 31626 was 31626, checked in by nbd, 5 years ago

atheros: clean up the patches some more

File size: 44.3 KB
  • drivers/net/ethernet/Kconfig

    a b source "drivers/net/ethernet/adaptec/Kco 
    2222source "drivers/net/ethernet/aeroflex/Kconfig" 
    2323source "drivers/net/ethernet/alteon/Kconfig" 
    2424source "drivers/net/ethernet/amd/Kconfig" 
     25source "drivers/net/ethernet/ar231x/Kconfig" 
    2526source "drivers/net/ethernet/apple/Kconfig" 
    2627source "drivers/net/ethernet/atheros/Kconfig" 
    2728source "drivers/net/ethernet/cadence/Kconfig" 
  • drivers/net/ethernet/Makefile

    a b obj-$(CONFIG_GRETH) += aeroflex/ 
    99obj-$(CONFIG_NET_VENDOR_ALTEON) += alteon/ 
    1010obj-$(CONFIG_NET_VENDOR_AMD) += amd/ 
    1111obj-$(CONFIG_NET_VENDOR_APPLE) += apple/ 
     12obj-$(CONFIG_NET_VENDOR_AR231X) += ar231x/ 
    1213obj-$(CONFIG_NET_VENDOR_ATHEROS) += atheros/ 
    1314obj-$(CONFIG_NET_CADENCE) += cadence/ 
    1415obj-$(CONFIG_NET_BFIN) += adi/ 
  • new file drivers/net/ethernet/ar231x/Kconfig

    - +  
     1config NET_VENDOR_AR231X 
     2        tristate "AR231X Ethernet support" 
     3        depends on ATHEROS_AR231X 
     4        help 
     5          Support for the AR231x/531x ethernet controller 
  • new file drivers/net/ethernet/ar231x/Makefile

    - +  
     1obj-$(CONFIG_NET_VENDOR_AR231X) += ar231x.o 
  • new file drivers/net/ethernet/ar231x/ar231x.c

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

    - +  
     1/* 
     2 * ar231x.h: 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-2009 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 
     17#ifndef _AR2313_H_ 
     18#define _AR2313_H_ 
     19 
     20#include <linux/interrupt.h> 
     21#include <generated/autoconf.h> 
     22#include <linux/bitops.h> 
     23#include <asm/bootinfo.h> 
     24#include <ar231x_platform.h> 
     25 
     26/* 
     27 * probe link timer - 5 secs 
     28 */ 
     29#define LINK_TIMER    (5*HZ) 
     30 
     31#define IS_DMA_TX_INT(X)   (((X) & (DMA_STATUS_TI)) != 0) 
     32#define IS_DMA_RX_INT(X)   (((X) & (DMA_STATUS_RI)) != 0) 
     33#define IS_DRIVER_OWNED(X) (((X) & (DMA_TX_OWN))    == 0) 
     34 
     35#define AR2313_TX_TIMEOUT (HZ/4) 
     36 
     37/* 
     38 * Rings 
     39 */ 
     40#define DSC_RING_ENTRIES_SIZE   (AR2313_DESCR_ENTRIES * sizeof(struct desc)) 
     41#define DSC_NEXT(idx)           ((idx + 1) & (AR2313_DESCR_ENTRIES - 1)) 
     42 
     43#define AR2313_MBGET            2 
     44#define AR2313_MBSET            3 
     45#define AR2313_PCI_RECONFIG     4 
     46#define AR2313_PCI_DUMP         5 
     47#define AR2313_TEST_PANIC       6 
     48#define AR2313_TEST_NULLPTR     7 
     49#define AR2313_READ_DATA        8 
     50#define AR2313_WRITE_DATA       9 
     51#define AR2313_GET_VERSION      10 
     52#define AR2313_TEST_HANG        11 
     53#define AR2313_SYNC             12 
     54 
     55#define DMA_RX_ERR_CRC          BIT(1) 
     56#define DMA_RX_ERR_DRIB         BIT(2) 
     57#define DMA_RX_ERR_MII          BIT(3) 
     58#define DMA_RX_EV2              BIT(5) 
     59#define DMA_RX_ERR_COL          BIT(6) 
     60#define DMA_RX_LONG             BIT(7) 
     61#define DMA_RX_LS               BIT(8)  /* last descriptor */ 
     62#define DMA_RX_FS               BIT(9)  /* first descriptor */ 
     63#define DMA_RX_MF               BIT(10) /* multicast frame */ 
     64#define DMA_RX_ERR_RUNT         BIT(11) /* runt frame */ 
     65#define DMA_RX_ERR_LENGTH       BIT(12) /* length error */ 
     66#define DMA_RX_ERR_DESC         BIT(14) /* descriptor error */ 
     67#define DMA_RX_ERROR            BIT(15) /* error summary */ 
     68#define DMA_RX_LEN_MASK         0x3fff0000 
     69#define DMA_RX_LEN_SHIFT        16 
     70#define DMA_RX_FILT             BIT(30) 
     71#define DMA_RX_OWN              BIT(31) /* desc owned by DMA controller */ 
     72 
     73#define DMA_RX1_BSIZE_MASK      0x000007ff 
     74#define DMA_RX1_BSIZE_SHIFT     0 
     75#define DMA_RX1_CHAINED         BIT(24) 
     76#define DMA_RX1_RER             BIT(25) 
     77 
     78#define DMA_TX_ERR_UNDER        BIT(1)  /* underflow error */ 
     79#define DMA_TX_ERR_DEFER        BIT(2)  /* excessive deferral */ 
     80#define DMA_TX_COL_MASK         0x78 
     81#define DMA_TX_COL_SHIFT        3 
     82#define DMA_TX_ERR_HB           BIT(7)  /* hearbeat failure */ 
     83#define DMA_TX_ERR_COL          BIT(8)  /* excessive collisions */ 
     84#define DMA_TX_ERR_LATE         BIT(9)  /* late collision */ 
     85#define DMA_TX_ERR_LINK         BIT(10) /* no carrier */ 
     86#define DMA_TX_ERR_LOSS         BIT(11) /* loss of carrier */ 
     87#define DMA_TX_ERR_JABBER       BIT(14) /* transmit jabber timeout */ 
     88#define DMA_TX_ERROR            BIT(15) /* frame aborted */ 
     89#define DMA_TX_OWN              BIT(31) /* descr owned by DMA controller */ 
     90 
     91#define DMA_TX1_BSIZE_MASK      0x000007ff 
     92#define DMA_TX1_BSIZE_SHIFT     0 
     93#define DMA_TX1_CHAINED         BIT(24) /* chained descriptors */ 
     94#define DMA_TX1_TER             BIT(25) /* transmit end of ring */ 
     95#define DMA_TX1_FS              BIT(29) /* first segment */ 
     96#define DMA_TX1_LS              BIT(30) /* last segment */ 
     97#define DMA_TX1_IC              BIT(31) /* interrupt on completion */ 
     98 
     99#define RCVPKT_LENGTH(X)        (X  >> 16)      /* Received pkt Length */ 
     100 
     101#define MAC_CONTROL_RE          BIT(2)  /* receive enable */ 
     102#define MAC_CONTROL_TE          BIT(3)  /* transmit enable */ 
     103#define MAC_CONTROL_DC          BIT(5)  /* Deferral check */ 
     104#define MAC_CONTROL_ASTP        BIT(8)  /* Auto pad strip */ 
     105#define MAC_CONTROL_DRTY        BIT(10) /* Disable retry */ 
     106#define MAC_CONTROL_DBF         BIT(11) /* Disable bcast frames */ 
     107#define MAC_CONTROL_LCC         BIT(12) /* late collision ctrl */ 
     108#define MAC_CONTROL_HP          BIT(13) /* Hash Perfect filtering */ 
     109#define MAC_CONTROL_HASH        BIT(14) /* Unicast hash filtering */ 
     110#define MAC_CONTROL_HO          BIT(15) /* Hash only filtering */ 
     111#define MAC_CONTROL_PB          BIT(16) /* Pass Bad frames */ 
     112#define MAC_CONTROL_IF          BIT(17) /* Inverse filtering */ 
     113#define MAC_CONTROL_PR          BIT(18) /* promiscuous mode (valid frames only) */ 
     114#define MAC_CONTROL_PM          BIT(19) /* pass multicast */ 
     115#define MAC_CONTROL_F           BIT(20) /* full-duplex */ 
     116#define MAC_CONTROL_DRO         BIT(23) /* Disable Receive Own */ 
     117#define MAC_CONTROL_HBD         BIT(28) /* heart-beat disabled (MUST BE SET) */ 
     118#define MAC_CONTROL_BLE         BIT(30) /* big endian mode */ 
     119#define MAC_CONTROL_RA          BIT(31) /* receive all (valid and invalid frames) */ 
     120 
     121#define MII_ADDR_BUSY           BIT(0) 
     122#define MII_ADDR_WRITE          BIT(1) 
     123#define MII_ADDR_REG_SHIFT      6 
     124#define MII_ADDR_PHY_SHIFT      11 
     125#define MII_DATA_SHIFT          0 
     126 
     127#define FLOW_CONTROL_FCE        BIT(1) 
     128 
     129#define DMA_BUS_MODE_SWR        BIT(0)  /* software reset */ 
     130#define DMA_BUS_MODE_BLE        BIT(7)  /* big endian mode */ 
     131#define DMA_BUS_MODE_PBL_SHIFT  8       /* programmable burst length 32 */ 
     132#define DMA_BUS_MODE_DBO        BIT(20) /* big-endian descriptors */ 
     133 
     134#define DMA_STATUS_TI           BIT(0)  /* transmit interrupt */ 
     135#define DMA_STATUS_TPS          BIT(1)  /* transmit process stopped */ 
     136#define DMA_STATUS_TU           BIT(2)  /* transmit buffer unavailable */ 
     137#define DMA_STATUS_TJT          BIT(3)  /* transmit buffer timeout */ 
     138#define DMA_STATUS_UNF          BIT(5)  /* transmit underflow */ 
     139#define DMA_STATUS_RI           BIT(6)  /* receive interrupt */ 
     140#define DMA_STATUS_RU           BIT(7)  /* receive buffer unavailable */ 
     141#define DMA_STATUS_RPS          BIT(8)  /* receive process stopped */ 
     142#define DMA_STATUS_ETI          BIT(10) /* early transmit interrupt */ 
     143#define DMA_STATUS_FBE          BIT(13) /* fatal bus interrupt */ 
     144#define DMA_STATUS_ERI          BIT(14) /* early receive interrupt */ 
     145#define DMA_STATUS_AIS          BIT(15) /* abnormal interrupt summary */ 
     146#define DMA_STATUS_NIS          BIT(16) /* normal interrupt summary */ 
     147#define DMA_STATUS_RS_SHIFT     17      /* receive process state */ 
     148#define DMA_STATUS_TS_SHIFT     20      /* transmit process state */ 
     149#define DMA_STATUS_EB_SHIFT     23      /* error bits */ 
     150 
     151#define DMA_CONTROL_SR          BIT(1)  /* start receive */ 
     152#define DMA_CONTROL_ST          BIT(13) /* start transmit */ 
     153#define DMA_CONTROL_SF          BIT(21) /* store and forward */ 
     154 
     155 
     156typedef struct { 
     157        volatile unsigned int status;   // OWN, Device control and status. 
     158        volatile unsigned int devcs;    // pkt Control bits + Length 
     159        volatile unsigned int addr;     // Current Address. 
     160        volatile unsigned int descr;    // Next descriptor in chain. 
     161} ar231x_descr_t; 
     162 
     163 
     164 
     165// 
     166// New Combo structure for Both Eth0 AND eth1 
     167// 
     168typedef struct { 
     169        volatile unsigned int mac_control;      /* 0x00 */ 
     170        volatile unsigned int mac_addr[2];      /* 0x04 - 0x08 */ 
     171        volatile unsigned int mcast_table[2];   /* 0x0c - 0x10 */ 
     172        volatile unsigned int mii_addr; /* 0x14 */ 
     173        volatile unsigned int mii_data; /* 0x18 */ 
     174        volatile unsigned int flow_control;     /* 0x1c */ 
     175        volatile unsigned int vlan_tag; /* 0x20 */ 
     176        volatile unsigned int pad[7];   /* 0x24 - 0x3c */ 
     177        volatile unsigned int ucast_table[8];   /* 0x40-0x5c */ 
     178 
     179} ETHERNET_STRUCT; 
     180 
     181/******************************************************************** 
     182 * Interrupt controller 
     183 ********************************************************************/ 
     184 
     185typedef struct { 
     186        volatile unsigned int wdog_control;     /* 0x08 */ 
     187        volatile unsigned int wdog_timer;       /* 0x0c */ 
     188        volatile unsigned int misc_status;      /* 0x10 */ 
     189        volatile unsigned int misc_mask;        /* 0x14 */ 
     190        volatile unsigned int global_status;    /* 0x18 */ 
     191        volatile unsigned int reserved; /* 0x1c */ 
     192        volatile unsigned int reset_control;    /* 0x20 */ 
     193} INTERRUPT; 
     194 
     195/******************************************************************** 
     196 * DMA controller 
     197 ********************************************************************/ 
     198typedef struct { 
     199        volatile unsigned int bus_mode; /* 0x00 (CSR0) */ 
     200        volatile unsigned int xmt_poll; /* 0x04 (CSR1) */ 
     201        volatile unsigned int rcv_poll; /* 0x08 (CSR2) */ 
     202        volatile unsigned int rcv_base; /* 0x0c (CSR3) */ 
     203        volatile unsigned int xmt_base; /* 0x10 (CSR4) */ 
     204        volatile unsigned int status;   /* 0x14 (CSR5) */ 
     205        volatile unsigned int control;  /* 0x18 (CSR6) */ 
     206        volatile unsigned int intr_ena; /* 0x1c (CSR7) */ 
     207        volatile unsigned int rcv_missed;       /* 0x20 (CSR8) */ 
     208        volatile unsigned int reserved[11];     /* 0x24-0x4c (CSR9-19) */ 
     209        volatile unsigned int cur_tx_buf_addr;  /* 0x50 (CSR20) */ 
     210        volatile unsigned int cur_rx_buf_addr;  /* 0x50 (CSR21) */ 
     211} DMA; 
     212 
     213/* 
     214 * Struct private for the Sibyte. 
     215 * 
     216 * Elements are grouped so variables used by the tx handling goes 
     217 * together, and will go into the same cache lines etc. in order to 
     218 * avoid cache line contention between the rx and tx handling on SMP. 
     219 * 
     220 * Frequently accessed variables are put at the beginning of the 
     221 * struct to help the compiler generate better/shorter code. 
     222 */ 
     223struct ar231x_private { 
     224        struct net_device *dev; 
     225        int version; 
     226        u32 mb[2]; 
     227 
     228        volatile ETHERNET_STRUCT *phy_regs; 
     229        volatile ETHERNET_STRUCT *eth_regs; 
     230        volatile DMA *dma_regs; 
     231        volatile u32 *int_regs; 
     232        struct ar231x_eth *cfg; 
     233 
     234        spinlock_t lock;                        /* Serialise access to device */ 
     235 
     236        /* 
     237         * RX and TX descriptors, must be adjacent 
     238         */ 
     239        ar231x_descr_t *rx_ring; 
     240        ar231x_descr_t *tx_ring; 
     241 
     242 
     243        struct sk_buff **rx_skb; 
     244        struct sk_buff **tx_skb; 
     245 
     246        /* 
     247         * RX elements 
     248         */ 
     249        u32 rx_skbprd; 
     250        u32 cur_rx; 
     251 
     252        /* 
     253         * TX elements 
     254         */ 
     255        u32 tx_prd; 
     256        u32 tx_csm; 
     257 
     258        /* 
     259         * Misc elements 
     260         */ 
     261        char name[48]; 
     262        struct { 
     263                u32 address; 
     264                u32 length; 
     265                char *mapping; 
     266        } desc; 
     267 
     268 
     269        struct timer_list link_timer; 
     270        unsigned short phy;                     /* merlot phy = 1, samsung phy = 0x1f */ 
     271        unsigned short mac; 
     272        unsigned short link;            /* 0 - link down, 1 - link up */ 
     273        u16 phyData; 
     274 
     275        struct tasklet_struct rx_tasklet; 
     276        int unloading; 
     277 
     278        struct phy_device *phy_dev; 
     279        struct mii_bus *mii_bus; 
     280        int oldduplex; 
     281}; 
     282 
     283 
     284/* 
     285 * Prototypes 
     286 */ 
     287static int ar231x_init(struct net_device *dev); 
     288#ifdef TX_TIMEOUT 
     289static void ar231x_tx_timeout(struct net_device *dev); 
     290#endif 
     291static int ar231x_restart(struct net_device *dev); 
     292static void ar231x_load_rx_ring(struct net_device *dev, int bufs); 
     293static irqreturn_t ar231x_interrupt(int irq, void *dev_id); 
     294static int ar231x_open(struct net_device *dev); 
     295static int ar231x_start_xmit(struct sk_buff *skb, struct net_device *dev); 
     296static int ar231x_close(struct net_device *dev); 
     297static int ar231x_ioctl(struct net_device *dev, struct ifreq *ifr, 
     298                                                int cmd); 
     299static void ar231x_init_cleanup(struct net_device *dev); 
     300static int ar231x_setup_timer(struct net_device *dev); 
     301static void ar231x_link_timer_fn(unsigned long data); 
     302static void ar231x_check_link(struct net_device *dev); 
     303#endif                                                  /* _AR2313_H_ */ 
Note: See TracBrowser for help on using the repository browser.