source: trunk/target/linux/atheros/patches-2.6.31/110-ar2313_ethernet.patch @ 17700

Last change on this file since 17700 was 17700, checked in by nbd, 7 years ago

atheros: add config and patches for 2.6.31 (untested), includes patch from #5847

File size: 43.3 KB
  • drivers/net/Kconfig

    a b config AX88796_93CX6 
    359359        help 
    360360          Select this if your platform comes with an external 93CX6 eeprom. 
    361361 
     362config AR231X_ETHERNET 
     363        tristate "AR231x Ethernet support" 
     364        depends on ATHEROS_AR231X 
     365        help 
     366          Support for the AR231x/531x ethernet controller 
     367 
    362368config MACE 
    363369        tristate "MACE (Power Mac ethernet) support" 
    364370        depends on PPC_PMAC && PPC32 
  • drivers/net/Makefile

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