source: trunk/target/linux/atheros/patches-2.6.37/110-ar2313_ethernet.patch @ 27747

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

atheros: fix mii phy read/write ioctl

Signed-off-by: Marek Lindner <lindner_marek@…>

File size: 44.1 KB
  • drivers/net/Kconfig

    a b config AX88796_93CX6 
    251251        help 
    252252          Select this if your platform comes with an external 93CX6 eeprom. 
    253253 
     254config AR231X_ETHERNET 
     255        tristate "AR231x Ethernet support" 
     256        depends on ATHEROS_AR231X 
     257        help 
     258          Support for the AR231x/531x ethernet controller 
     259 
    254260config MACE 
    255261        tristate "MACE (Power Mac ethernet) support" 
    256262        depends on PPC_PMAC && PPC32 
  • drivers/net/Makefile

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