source: trunk/target/linux/atheros/patches-2.6.35/110-ar2313_ethernet.patch @ 22416

Last change on this file since 22416 was 22416, checked in by acoul, 6 years ago

[atheros] add missing bits & bytes from r22412

File size: 43.8 KB
  • drivers/net/Kconfig

    a b config AX88796_93CX6 
    371371        help 
    372372          Select this if your platform comes with an external 93CX6 eeprom. 
    373373 
     374config AR231X_ETHERNET 
     375        tristate "AR231x Ethernet support" 
     376        depends on ATHEROS_AR231X 
     377        help 
     378          Support for the AR231x/531x ethernet controller 
     379 
    374380config MACE 
    375381        tristate "MACE (Power Mac ethernet) support" 
    376382        depends on PPC_PMAC && PPC32 
  • drivers/net/Makefile

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