Changeset 9340


Ignore:
Timestamp:
2007-10-17T10:10:47+02:00 (10 years ago)
Author:
juhosg
Message:

[adm5120] switch driver cleanup, 4th phase

Location:
trunk/target/linux/adm5120/files
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/board.c

    r9263 r9340  
    9999        amba_device_register(&adm5120_uart1_device, &iomem_resource); 
    100100 
     101        /* register built-in ethernet switch */ 
     102        platform_device_register(&adm5120_switch_device); 
     103 
    101104        /* setup PCI irq map */ 
    102105        adm5120_pci_set_irq_map(board->pci_nr_irqs, board->pci_irq_map); 
  • trunk/target/linux/adm5120/files/arch/mips/adm5120/platform.c

    r9118 r9340  
    6262}; 
    6363EXPORT_SYMBOL_GPL(adm5120_eth_vlans); 
    64  
    65 #else 
     64#endif 
     65 
    6666/* Built-in ethernet switch */ 
     67struct resource adm5120_switch_resources[] = { 
     68        [0] = { 
     69                .start  = ADM5120_SWITCH_BASE, 
     70                .end    = ADM5120_SWITCH_BASE+ADM5120_SWITCH_SIZE-1, 
     71                .flags  = IORESOURCE_MEM, 
     72        }, 
     73        [1] = { 
     74                .start  = ADM5120_IRQ_SWITCH, 
     75                .end    = ADM5120_IRQ_SWITCH, 
     76                .flags  = IORESOURCE_IRQ, 
     77        }, 
     78}; 
     79 
    6780struct adm5120_switch_platform_data adm5120_switch_data; 
    6881struct platform_device adm5120_switch_device = { 
    6982        .name   = "adm5120-switch", 
    7083        .id     = -1, 
     84        .num_resources  = ARRAY_SIZE(adm5120_switch_resources), 
     85        .resource       = adm5120_switch_resources, 
    7186        .dev.platform_data = &adm5120_switch_data, 
    7287}; 
    73 #endif 
    7488 
    7589/* USB Host Controller */ 
  • trunk/target/linux/adm5120/files/drivers/net/adm5120sw.c

    r9334 r9340  
    11/* 
    2  *      ADM5120 built in ethernet switch driver 
     2 *  ADM5120 built-in ethernet switch driver 
    33 * 
    4  *      Copyright Jeroen Vreeken (pe1rxq@amsat.org), 2005 
     4 *  Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org> 
    55 * 
    6  *      Inspiration for this driver came from the original ADMtek 2.4 
    7  *      driver, Copyright ADMtek Inc. 
     6 *  This code was based on a driver for Linux 2.6.xx by Jeroen Vreeken. 
     7 *    Copyright Jeroen Vreeken (pe1rxq@amsat.org), 2005 
     8 *  NAPI extension for the Jeroen's driver 
     9 *    Copyright Thomas Langer (Thomas.Langer@infineon.com), 2007 
     10 *    Copyright Friedrich Beckmann (Friedrich.Beckmann@infineon.com), 2007 
     11 *  Inspiration for the Jeroen's driver came from the ADMtek 2.4 driver. 
     12 *    Copyright ADMtek Inc. 
    813 * 
    9  *      NAPI extensions by Thomas Langer (Thomas.Langer@infineon.com) 
    10  *      and Friedrich Beckmann (Friedrich.Beckmann@infineon.com), 2007 
    11  * 
    12  *      TODO: Add support of high prio queues (currently disabled) 
     14 *  This program is free software; you can redistribute it and/or modify it 
     15 *  under the terms of the GNU General Public License version 2  as published 
     16 *  by the Free Software Foundation. 
    1317 * 
    1418 */ 
     19 
    1520#include <linux/kernel.h> 
    1621#include <linux/module.h> 
     
    1924#include <linux/ioport.h> 
    2025#include <linux/spinlock.h> 
     26#include <linux/platform_device.h> 
    2127 
    2228#include <linux/netdevice.h> 
     
    4046#define DRV_VERSION     "0.1.0" 
    4147 
    42 MODULE_AUTHOR("Jeroen Vreeken (pe1rxq@amsat.org)"); 
    43 MODULE_DESCRIPTION("ADM5120 ethernet switch driver"); 
    44 MODULE_LICENSE("GPL"); 
     48#define CONFIG_ADM5120_SWITCH_NAPI      1 
     49#undef CONFIG_ADM5120_SWITCH_DEBUG 
    4550 
    4651/* ------------------------------------------------------------------------ */ 
    4752 
    48 #if 0 /*def ADM5120_SWITCH_DEBUG*/ 
    49 #define SW_DBG(f, a...)         printk(KERN_DEBUG "%s: " f, DRV_NAME , ## a) 
     53#ifdef CONFIG_ADM5120_SWITCH_DEBUG 
     54#define SW_DBG(f, a...)         printk(KERN_DBG "%s: " f, DRV_NAME , ## a) 
    5055#else 
    5156#define SW_DBG(f, a...)         do {} while (0) 
     
    8489 
    8590#define SWITCH_INTS_USED (SWITCH_INTS_LOW | SWITCH_INT_PSC) 
    86 #define SWITCH_INTS_POLL (SWITCH_INT_RLD | SWITCH_INT_LDF) 
     91#define SWITCH_INTS_POLL (SWITCH_INT_RLD | SWITCH_INT_LDF | SWITCH_INT_SLD) 
    8792 
    8893/* ------------------------------------------------------------------------ */ 
     94 
     95struct adm5120_if_priv { 
     96        unsigned int    vlan_no; 
     97        unsigned int    port_mask; 
     98}; 
    8999 
    90100struct dma_desc { 
     
    118128} __attribute__ ((aligned(16))); 
    119129 
    120 static inline u32 desc_get_srcport(struct dma_desc *desc) 
    121 { 
    122         return (desc->misc >> DESC_SRCPORT_SHIFT) & DESC_SRCPORT_MASK; 
    123 } 
    124  
    125 static inline u32 desc_get_pktlen(struct dma_desc *desc) 
    126 { 
    127         return (desc->misc >> DESC_PKTLEN_SHIFT) & DESC_PKTLEN_MASK; 
    128 } 
    129  
    130 static inline int desc_ipcsum_fail(struct dma_desc *desc) 
    131 { 
    132         return ((desc->misc & DESC_IPCSUM_FAIL) != 0); 
    133 } 
    134  
    135130/* ------------------------------------------------------------------------ */ 
    136  
    137 /* default settings - unlimited TX and RX on all ports, default shaper mode */ 
    138 static unsigned char bw_matrix[SWITCH_NUM_PORTS] = { 
    139         0, 0, 0, 0, 0, 0 
    140 }; 
    141131 
    142132static int adm5120_nrdevs; 
     
    160150static unsigned int sw_used; 
    161151 
    162 static spinlock_t sw_lock = SPIN_LOCK_UNLOCKED; 
    163 static spinlock_t poll_lock = SPIN_LOCK_UNLOCKED; 
    164  
    165 static struct net_device sw_dev; 
     152static spinlock_t tx_lock = SPIN_LOCK_UNLOCKED; 
    166153 
    167154/* ------------------------------------------------------------------------ */ 
     
    207194        t &= ~sw_read_reg(SWITCH_REG_INT_MASK); 
    208195        return t; 
     196} 
     197 
     198static inline u32 desc_get_srcport(struct dma_desc *desc) 
     199{ 
     200        return (desc->misc >> DESC_SRCPORT_SHIFT) & DESC_SRCPORT_MASK; 
     201} 
     202 
     203static inline u32 desc_get_pktlen(struct dma_desc *desc) 
     204{ 
     205        return (desc->misc >> DESC_PKTLEN_SHIFT) & DESC_PKTLEN_MASK; 
     206} 
     207 
     208static inline int desc_ipcsum_fail(struct dma_desc *desc) 
     209{ 
     210        return ((desc->misc & DESC_IPCSUM_FAIL) != 0); 
    209211} 
    210212 
     
    387389                                limit, cur_rxl, dirty_rxl); 
    388390 
    389         sw_int_ack(SWITCH_INTS_POLL); 
    390  
    391391        while (done < limit) { 
    392392                int entry = cur_rxl % RX_RING_SIZE; 
     
    431431                                        skb->len); 
    432432 
     433#ifdef CONFIG_ADM5120_SWITCH_USE_NAPI 
    433434                                netif_receive_skb(skb); 
     435#else 
     436                                netif_rx(skb); 
     437#endif 
    434438 
    435439                                rdev->last_rx = jiffies; 
     
    457461} 
    458462 
    459  
    460463static void adm5120_switch_tx(void) 
    461464{ 
    462465        unsigned int entry; 
    463466 
    464         /* find and cleanup dirty tx descriptors */ 
     467        spin_lock(&tx_lock); 
    465468        entry = dirty_txl % TX_RING_SIZE; 
    466469        while (dirty_txl != cur_txl) { 
     
    482485 
    483486        if ((cur_txl - dirty_txl) < TX_QUEUE_LEN - 4) { 
    484                 /* wake up queue of all devices */ 
    485487                int i; 
    486488                for (i = 0; i < SWITCH_NUM_PORTS; i++) { 
     
    490492                } 
    491493        } 
    492 } 
    493  
     494        spin_unlock(&tx_lock); 
     495} 
     496 
     497#ifdef CONFIG_ADM5120_SWITCH_NAPI 
    494498static int adm5120_if_poll(struct net_device *dev, int *budget) 
    495499{ 
     
    498502        u32 status; 
    499503 
     504        sw_int_ack(SWITCH_INTS_POLL); 
     505 
     506        SW_DBG("%s: processing TX ring\n", dev->name); 
     507        adm5120_switch_tx(); 
     508 
     509        SW_DBG("%s: processing RX ring\n", dev->name); 
    500510        done = adm5120_switch_rx(limit); 
    501511 
     
    505515        status = sw_int_status() & SWITCH_INTS_POLL; 
    506516        if ((done < limit) && (!status)) { 
    507                 SW_DBG("disable polling mode for %s\n", poll_dev->name); 
     517                SW_DBG("disable polling mode for %s\n", dev->name); 
    508518                netif_rx_complete(dev); 
    509519                sw_int_unmask(SWITCH_INTS_POLL); 
     
    511521        } 
    512522 
     523        SW_DBG("%s still in polling mode, done=%d, status=%x\n", 
     524                        dev->name, done, status); 
    513525        return 1; 
    514526} 
    515  
    516 static irqreturn_t adm5120_poll_irq(int irq, void *dev_id) 
    517 { 
    518         struct net_device *dev = dev_id; 
     527#endif /* CONFIG_ADM5120_SWITCH_USE_NAPI */ 
     528 
     529 
     530static irqreturn_t adm5120_switch_irq(int irq, void *dev_id) 
     531{ 
    519532        u32 status; 
    520533 
    521534        status = sw_int_status(); 
    522         status &= SWITCH_INTS_POLL; 
     535        status &= SWITCH_INTS_ALL; 
    523536        if (!status) 
    524537                return IRQ_NONE; 
    525538 
    526         sw_dump_intr_mask("poll ints", status); 
    527  
    528         SW_DBG("enable polling mode for %s\n", dev->name); 
    529         sw_int_mask(SWITCH_INTS_POLL); 
    530         netif_rx_schedule(dev); 
     539#ifdef CONFIG_ADM5120_SWITCH_NAPI 
     540        sw_int_ack(status & ~SWITCH_INTS_POLL); 
     541 
     542        if (status & SWITCH_INTS_POLL) { 
     543                struct net_device *dev = dev_id; 
     544                sw_dump_intr_mask("poll ints", status); 
     545                SW_DBG("enable polling mode for %s\n", dev->name); 
     546                sw_int_mask(SWITCH_INTS_POLL); 
     547                netif_rx_schedule(dev); 
     548        } 
     549#else 
     550        sw_int_ack(status); 
     551 
     552        if (status & (SWITCH_INT_RLD | SWITCH_INT_LDF)) { 
     553                adm5120_switch_rx(RX_RING_SIZE); 
     554        } 
     555 
     556        if (status & SWITCH_INT_SLD) { 
     557                adm5120_switch_tx(); 
     558        } 
     559#endif 
    531560 
    532561        return IRQ_HANDLED; 
    533 } 
    534  
    535 static irqreturn_t adm5120_switch_irq(int irq, void *dev_id) 
    536 { 
    537         u32 status; 
    538  
    539         status = sw_int_status(); 
    540         status &= SWITCH_INTS_ALL & ~SWITCH_INTS_POLL; 
    541         if (!status) 
    542                 return IRQ_NONE; 
    543  
    544         sw_int_ack(status); 
    545  
    546         if (status & SWITCH_INT_SLD) { 
    547                 spin_lock(&sw_lock); 
    548                 adm5120_switch_tx(); 
    549                 spin_unlock(&sw_lock); 
    550         } 
    551  
    552         return IRQ_HANDLED; 
    553 } 
    554  
    555 static void adm5120_set_vlan(char *matrix) 
    556 { 
    557         unsigned long val; 
    558         int vlan_port, port; 
    559  
    560         val = matrix[0] + (matrix[1]<<8) + (matrix[2]<<16) + (matrix[3]<<24); 
    561         sw_write_reg(SWITCH_REG_VLAN_G1, val); 
    562         val = matrix[4] + (matrix[5]<<8); 
    563         sw_write_reg(SWITCH_REG_VLAN_G2, val); 
    564  
    565         /* Now set/update the port vs. device lookup table */ 
    566         for (port=0; port<SWITCH_NUM_PORTS; port++) { 
    567                 for (vlan_port=0; vlan_port<SWITCH_NUM_PORTS && !(matrix[vlan_port] & (0x00000001 << port)); vlan_port++); 
    568                 if (vlan_port <SWITCH_NUM_PORTS) 
    569                         adm5120_port[port] = adm5120_devs[vlan_port]; 
    570                 else 
    571                         adm5120_port[port] = NULL; 
    572         } 
    573562} 
    574563 
     
    714703} 
    715704 
     705static void adm5120_write_mac(struct net_device *dev) 
     706{ 
     707        struct adm5120_if_priv *priv = netdev_priv(dev); 
     708        unsigned char *mac = dev->dev_addr; 
     709        u32 t; 
     710 
     711        t = mac[2] | (mac[3] << MAC_WT1_MAC3_SHIFT) | 
     712                (mac[4] << MAC_WT1_MAC4_SHIFT) | (mac[5] << MAC_WT1_MAC4_SHIFT); 
     713        sw_write_reg(SWITCH_REG_MAC_WT1, t); 
     714 
     715        t = (mac[0] << MAC_WT0_MAC0_SHIFT) | (mac[1] << MAC_WT0_MAC1_SHIFT) | 
     716                MAC_WT0_MAWC | MAC_WT0_WVE | (priv->vlan_no<<3); 
     717 
     718        sw_write_reg(SWITCH_REG_MAC_WT0, t); 
     719 
     720        while (!(sw_read_reg(SWITCH_REG_MAC_WT0) & MAC_WT0_MWD)); 
     721} 
     722 
     723static void adm5120_set_vlan(char *matrix) 
     724{ 
     725        unsigned long val; 
     726        int vlan_port, port; 
     727 
     728        val = matrix[0] + (matrix[1]<<8) + (matrix[2]<<16) + (matrix[3]<<24); 
     729        sw_write_reg(SWITCH_REG_VLAN_G1, val); 
     730        val = matrix[4] + (matrix[5]<<8); 
     731        sw_write_reg(SWITCH_REG_VLAN_G2, val); 
     732 
     733        /* Now set/update the port vs. device lookup table */ 
     734        for (port=0; port<SWITCH_NUM_PORTS; port++) { 
     735                for (vlan_port=0; vlan_port<SWITCH_NUM_PORTS && !(matrix[vlan_port] & (0x00000001 << port)); vlan_port++); 
     736                if (vlan_port <SWITCH_NUM_PORTS) 
     737                        adm5120_port[port] = adm5120_devs[vlan_port]; 
     738                else 
     739                        adm5120_port[port] = NULL; 
     740        } 
     741} 
     742 
     743static void adm5120_switch_set_vlan_mac(unsigned int vlan, unsigned char *mac) 
     744{ 
     745        u32 t; 
     746 
     747        t = mac[2] | (mac[3] << MAC_WT1_MAC3_SHIFT) 
     748                | (mac[4] << MAC_WT1_MAC4_SHIFT) 
     749                | (mac[5] << MAC_WT1_MAC4_SHIFT); 
     750        sw_write_reg(SWITCH_REG_MAC_WT1, t); 
     751 
     752        t = (mac[0] << MAC_WT0_MAC0_SHIFT) | (mac[1] << MAC_WT0_MAC1_SHIFT) | 
     753                MAC_WT0_MAWC | MAC_WT0_WVE | (vlan << MAC_WT0_WVN_SHIFT) | 
     754                (MAC_WT0_WAF_STATIC << MAC_WT0_WAF_SHIFT); 
     755        sw_write_reg(SWITCH_REG_MAC_WT0, t); 
     756 
     757        do { 
     758                t = sw_read_reg(SWITCH_REG_MAC_WT0); 
     759        } while ((t & MAC_WT0_MWD) == 0); 
     760} 
     761 
     762static void adm5120_switch_set_vlan_ports(unsigned int vlan, u32 ports) 
     763{ 
     764        unsigned int reg; 
     765        u32 t; 
     766 
     767        if (vlan < 4) 
     768                reg = SWITCH_REG_VLAN_G1; 
     769        else { 
     770                vlan -= 4; 
     771                reg = SWITCH_REG_VLAN_G2; 
     772        } 
     773 
     774        t = sw_read_reg(reg); 
     775        t &= ~(0xFF << (vlan*8)); 
     776        t |= (ports << (vlan*8)); 
     777        sw_write_reg(reg, t); 
     778} 
     779 
    716780/* ------------------------------------------------------------------------ */ 
    717781 
     
    722786        int i; 
    723787 
    724         err = request_irq(dev->irq, adm5120_poll_irq, 
     788        err = request_irq(dev->irq, adm5120_switch_irq, 
    725789                (IRQF_SHARED | IRQF_DISABLED), dev->name, dev); 
    726790        if (err) { 
     
    777841{ 
    778842        struct dma_desc *desc; 
    779         struct adm5120_sw *priv = netdev_priv(dev); 
     843        struct adm5120_if_priv *priv = netdev_priv(dev); 
    780844        unsigned int entry; 
    781845        unsigned long data; 
    782846 
    783847        /* lock switch irq */ 
    784         spin_lock_irq(&sw_lock); 
     848        spin_lock_irq(&tx_lock); 
    785849 
    786850        /* calculate the next TX descriptor entry. */ 
     
    791855                /* We want to write a packet but the TX queue is still 
    792856                 * occupied by the DMA. We are faster than the DMA... */ 
     857                SW_DBG("%s unable to transmit, packet dopped\n", dev->name); 
    793858                dev_kfree_skb(skb); 
    794859                dev->stats.tx_dropped++; 
     
    802867        desc->misc = 
    803868            ((skb->len<ETH_ZLEN?ETH_ZLEN:skb->len) << DESC_PKTLEN_SHIFT) | 
    804             (0x1 << priv->port); 
     869            (0x1 << priv->vlan_no); 
    805870 
    806871        desc->buflen = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len; 
     
    817882        dev->trans_start = jiffies; 
    818883 
    819         spin_unlock_irq(&sw_lock); 
     884        spin_unlock_irq(&tx_lock); 
    820885 
    821886        return 0; 
     
    827892} 
    828893 
    829 static void adm5120_set_multicast_list(struct net_device *dev) 
    830 { 
    831         struct adm5120_sw *priv = netdev_priv(dev); 
     894static void adm5120_if_set_multicast_list(struct net_device *dev) 
     895{ 
     896        struct adm5120_if_priv *priv = netdev_priv(dev); 
    832897        u32 ports; 
    833898        u32 t; 
    834899 
    835         ports = adm5120_eth_vlans[priv->port] & SWITCH_PORTS_NOCPU; 
     900        ports = adm5120_eth_vlans[priv->vlan_no] & SWITCH_PORTS_NOCPU; 
    836901 
    837902        t = sw_read_reg(SWITCH_REG_CPUP_CONF); 
     
    878943} 
    879944 
    880 static void adm5120_write_mac(struct net_device *dev) 
    881 { 
    882         struct adm5120_sw *priv = netdev_priv(dev); 
    883         unsigned char *mac = dev->dev_addr; 
    884         u32 t; 
    885  
    886         t = mac[2] | (mac[3] << MAC_WT1_MAC3_SHIFT) | 
    887                 (mac[4] << MAC_WT1_MAC4_SHIFT) | (mac[5] << MAC_WT1_MAC4_SHIFT); 
    888         sw_write_reg(SWITCH_REG_MAC_WT1, t); 
    889  
    890         t = (mac[0] << MAC_WT0_MAC0_SHIFT) | (mac[1] << MAC_WT0_MAC1_SHIFT) | 
    891                 MAC_WT0_MAWC | MAC_WT0_WVE | (priv->port<<3); 
    892  
    893         sw_write_reg(SWITCH_REG_MAC_WT0, t); 
    894  
    895         while (!(sw_read_reg(SWITCH_REG_MAC_WT0) & MAC_WT0_MWD)); 
    896 } 
    897  
    898945static int adm5120_if_set_mac_address(struct net_device *dev, void *p) 
    899946{ 
     
    905952} 
    906953 
    907 static int adm5120_if_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 
     954static int adm5120_if_do_ioctl(struct net_device *dev, struct ifreq *rq, 
     955                int cmd) 
    908956{ 
    909957        int err; 
    910958        struct adm5120_sw_info info; 
    911         struct adm5120_sw *priv = netdev_priv(dev); 
     959        struct adm5120_if_priv *priv = netdev_priv(dev); 
    912960 
    913961        switch(cmd) { 
     
    915963                info.magic = 0x5120; 
    916964                info.ports = adm5120_nrdevs; 
    917                 info.vlan = priv->port; 
     965                info.vlan = priv->vlan_no; 
    918966                err = copy_to_user(rq->ifr_data, &info, sizeof(info)); 
    919967                if (err) 
     
    935983                        return -EFAULT; 
    936984                break; 
    937         case SIOCGETBW: 
    938                 err = copy_to_user(rq->ifr_data, bw_matrix, sizeof(bw_matrix)); 
    939                 if (err) 
    940                         return -EFAULT; 
    941                 break; 
    942         case SIOCSETBW: 
    943                 if (!capable(CAP_NET_ADMIN)) 
    944                         return -EPERM; 
    945                 err = copy_from_user(bw_matrix, rq->ifr_data, sizeof(bw_matrix)); 
    946                 if (err) 
    947                         return -EFAULT; 
    948                 adm5120_set_bw(bw_matrix); 
    949                 break; 
    950985        default: 
    951986                return -EOPNOTSUPP; 
     
    957992{ 
    958993        struct net_device *dev; 
    959         struct adm5120_sw *priv; 
     994        struct adm5120_if_priv *priv; 
    960995 
    961996        dev = alloc_etherdev(sizeof(*priv)); 
     
    9671002        dev->hard_start_xmit    = adm5120_if_hard_start_xmit; 
    9681003        dev->stop               = adm5120_if_stop; 
    969         dev->set_multicast_list = adm5120_set_multicast_list; 
     1004        dev->set_multicast_list = adm5120_if_set_multicast_list; 
    9701005        dev->do_ioctl           = adm5120_if_do_ioctl; 
    9711006        dev->tx_timeout         = adm5120_if_tx_timeout; 
    9721007        dev->watchdog_timeo     = TX_TIMEOUT; 
    9731008        dev->set_mac_address    = adm5120_if_set_mac_address; 
     1009#ifdef CONFIG_ADM5120_SWITCH_NAPI 
    9741010        dev->poll               = adm5120_if_poll; 
    9751011        dev->weight             = 64; 
     1012#endif 
    9761013 
    9771014        SET_MODULE_OWNER(dev); 
     
    9791016        return dev; 
    9801017} 
     1018 
     1019/* ------------------------------------------------------------------------ */ 
    9811020 
    9821021static void adm5120_switch_cleanup(void) 
     
    9971036        adm5120_switch_tx_ring_free(); 
    9981037        adm5120_switch_rx_ring_free(); 
    999  
    1000         free_irq(ADM5120_IRQ_SWITCH, &sw_dev); 
    1001 } 
    1002  
    1003 static int __init adm5120_switch_init(void) 
     1038} 
     1039 
     1040static int __init adm5120_switch_probe(struct platform_device *pdev) 
    10041041{ 
    10051042        u32 t; 
    10061043        int i, err; 
    1007  
    1008         err = request_irq(ADM5120_IRQ_SWITCH, adm5120_switch_irq, 
    1009                 (IRQF_SHARED | IRQF_DISABLED), "switch", &sw_dev); 
    1010         if (err) { 
    1011                 SW_ERR("request_irq failed with error %d\n", err); 
    1012                 goto err; 
    1013         } 
    10141044 
    10151045        adm5120_nrdevs = adm5120_eth_num_ports; 
     
    10621092        for (i = 0; i < SWITCH_NUM_PORTS; i++) { 
    10631093                struct net_device *dev; 
    1064                 struct adm5120_sw *priv; 
     1094                struct adm5120_if_priv *priv; 
    10651095 
    10661096                dev = adm5120_if_alloc(); 
     
    10731103                priv = netdev_priv(dev); 
    10741104 
    1075                 priv->port = i; 
     1105                priv->vlan_no = i; 
     1106                priv->port_mask = adm5120_eth_vlans[i]; 
    10761107 
    10771108                memcpy(dev->dev_addr, adm5120_eth_macs[i], 6); 
     
    11031134} 
    11041135 
    1105 static void __exit adm5120_switch_exit(void) 
     1136static int adm5120_switch_remove(struct platform_device *dev) 
    11061137{ 
    11071138        adm5120_switch_cleanup(); 
    1108 } 
    1109  
    1110 module_init(adm5120_switch_init); 
    1111 module_exit(adm5120_switch_exit); 
     1139        return 0; 
     1140} 
     1141 
     1142static struct platform_driver adm5120_switch_driver = { 
     1143        .probe          = adm5120_switch_probe, 
     1144        .remove         = adm5120_switch_remove, 
     1145        .driver         = { 
     1146                .name   = DRV_NAME, 
     1147        }, 
     1148}; 
     1149 
     1150/* -------------------------------------------------------------------------- */ 
     1151 
     1152static int __init adm5120_switch_mod_init(void) 
     1153{ 
     1154        int err; 
     1155 
     1156        pr_info(DRV_DESC " version " DRV_VERSION "\n"); 
     1157        err = platform_driver_register(&adm5120_switch_driver); 
     1158 
     1159        return err; 
     1160} 
     1161 
     1162static void __exit adm5120_switch_mod_exit(void) 
     1163{ 
     1164        platform_driver_unregister(&adm5120_switch_driver); 
     1165} 
     1166 
     1167module_init(adm5120_switch_mod_init); 
     1168module_exit(adm5120_switch_mod_exit); 
     1169 
     1170MODULE_LICENSE("GPL v2"); 
     1171MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>"); 
     1172MODULE_DESCRIPTION(DRV_DESC); 
     1173MODULE_VERSION(DRV_VERSION); 
  • trunk/target/linux/adm5120/files/drivers/net/adm5120sw.h

    r9324 r9340  
    1111#define _INCLUDE_ADM5120SW_H_ 
    1212 
    13 struct adm5120_sw { 
    14         int     port; 
    15 }; 
    16  
    1713#define SIOCSMATRIX     SIOCDEVPRIVATE 
    1814#define SIOCGMATRIX     SIOCDEVPRIVATE+1 
    1915#define SIOCGADMINFO    SIOCDEVPRIVATE+2 
    20 #define SIOCGETBW       SIOCDEVPRIVATE+3 
    21 #define SIOCSETBW       SIOCDEVPRIVATE+4 
    2216 
    2317struct adm5120_sw_info { 
  • trunk/target/linux/adm5120/files/include/asm-mips/mach-adm5120/adm5120_switch.h

    r9324 r9340  
    165165#define MAC_WT0_MWD             BIT(1)  /* MAC write done */ 
    166166#define MAC_WT0_WFB             BIT(2)  /* Write Filter Bit */ 
    167 #define MAC_WT0_WVN_SHIFT       3 
     167#define MAC_WT0_WVN_SHIFT       3       /* Write Vlan Number shift */ 
    168168#define MAC_WT0_WVE             BIT(6)  /* Write VLAN enable */ 
    169169#define MAC_WT0_WPMN_SHIFT      7 
    170170#define MAC_WT0_WAF_SHIFT       13      /* Write Age Field shift */ 
    171171#define MAC_WT0_WAF_EMPTY       0 
    172 #define MAC_WT0_WAF_STATIC      7 
     172#define MAC_WT0_WAF_STATIC      7       /* age: static */ 
    173173#define MAC_WT0_MAC0_SHIFT      16 
    174174#define MAC_WT0_MAC1_SHIFT      24 
Note: See TracChangeset for help on using the changeset viewer.