source: trunk/target/linux/atheros/patches-2.6.34/110-ar2313_ethernet.patch @ 22412

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

[atheros] enable mtu & mac config options

File size: 43.4 KB
  • drivers/net/Kconfig

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

    a b obj-$(CONFIG_EQUALIZER) += eql.o 
    221221obj-$(CONFIG_KORINA) += korina.o 
    222222obj-$(CONFIG_MIPS_JAZZ_SONIC) += jazzsonic.o 
    223223obj-$(CONFIG_MIPS_AU1X00_ENET) += au1000_eth.o 
     224obj-$(CONFIG_AR231X_ETHERNET) += ar231x.o 
    224225obj-$(CONFIG_MIPS_SIM_NET) += mipsnet.o 
    225226obj-$(CONFIG_SGI_IOC3_ETH) += ioc3-eth.o 
    226227obj-$(CONFIG_DECLANCE) += declance.o 
  • new file drivers/net/ar231x.c

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