Changeset 9330


Ignore:
Timestamp:
2007-10-16T10:15:18+02:00 (10 years ago)
Author:
juhosg
Message:

[adm5120] switch driver cleanup, 2nd phase

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/adm5120/files/drivers/net/adm5120sw.c

    r9324 r9330  
    4646/* ------------------------------------------------------------------------ */ 
    4747 
    48 #if 1 /*def ADM5120_SWITCH_DEBUG*/ 
     48#if 0 /*def ADM5120_SWITCH_DEBUG*/ 
    4949#define SW_DBG(f, a...)         printk(KERN_DEBUG "%s: " f, DRV_NAME , ## a) 
    5050#else 
     
    6363#define TX_QUEUE_LEN    28      /* Limit ring entries actually used. */ 
    6464#define TX_TIMEOUT      HZ*400 
     65 
     66#define RX_DESCS_SIZE   (RX_RING_SIZE * sizeof(struct dma_desc *)) 
     67#define RX_SKBS_SIZE    (RX_RING_SIZE * sizeof(struct sk_buff *)) 
     68#define TX_DESCS_SIZE   (TX_RING_SIZE * sizeof(struct dma_desc *)) 
     69#define TX_SKBS_SIZE    (TX_RING_SIZE * sizeof(struct sk_buff *)) 
    6570 
    6671#define SKB_ALLOC_LEN           (RX_MAX_PKTLEN + 32) 
     
    141146static struct net_device *adm5120_port[SWITCH_NUM_PORTS]; 
    142147 
    143 static struct dma_desc txh_descs_v[TX_RING_SIZE] __attribute__((aligned(16))); 
    144 static struct dma_desc txl_descs_v[TX_RING_SIZE] __attribute__((aligned(16))); 
    145 static struct dma_desc rxh_descs_v[RX_RING_SIZE] __attribute__((aligned(16))); 
    146 static struct dma_desc rxl_descs_v[RX_RING_SIZE] __attribute__((aligned(16))); 
    147 static struct dma_desc *txh_descs; 
    148148static struct dma_desc *txl_descs; 
    149 static struct dma_desc *rxh_descs; 
    150149static struct dma_desc *rxl_descs; 
    151150 
    152 static struct sk_buff *rxl_skbuff[RX_RING_SIZE]; 
    153 static struct sk_buff *rxh_skbuff[RX_RING_SIZE]; 
    154 static struct sk_buff *txl_skbuff[TX_RING_SIZE]; 
    155 static struct sk_buff *txh_skbuff[TX_RING_SIZE]; 
     151static dma_addr_t txl_descs_dma; 
     152static dma_addr_t rxl_descs_dma; 
     153 
     154static struct sk_buff **txl_skbuff; 
     155static struct sk_buff **rxl_skbuff; 
    156156 
    157157static unsigned int cur_rxl, dirty_rxl; /* producer/consumer ring indices */ 
     
    161161 
    162162static spinlock_t sw_lock = SPIN_LOCK_UNLOCKED; 
     163static spinlock_t poll_lock = SPIN_LOCK_UNLOCKED; 
    163164 
    164165static struct net_device sw_dev; 
     166static struct net_device *poll_dev; 
    165167 
    166168/* ------------------------------------------------------------------------ */ 
     
    176178} 
    177179 
    178 static inline void sw_int_disable(u32 mask) 
     180static inline void sw_int_mask(u32 mask) 
    179181{ 
    180182        u32     t; 
     
    185187} 
    186188 
    187 static inline void sw_int_enable(u32 mask) 
     189static inline void sw_int_unmask(u32 mask) 
    188190{ 
    189191        u32     t; 
     
    197199{ 
    198200        sw_write_reg(SWITCH_REG_INT_STATUS, mask); 
     201} 
     202 
     203static inline u32 sw_int_status(void) 
     204{ 
     205        u32     t; 
     206 
     207        t = sw_read_reg(SWITCH_REG_INT_STATUS); 
     208        t &= ~sw_read_reg(SWITCH_REG_INT_MASK); 
     209        return t; 
    199210} 
    200211 
     
    265276} 
    266277 
     278static void sw_dump_regs(void) 
     279{ 
     280        u32 t; 
     281 
     282        t = SW_READ_REG(PHY_STATUS); 
     283        SW_DBG("phy_status: %08X\n", t); 
     284 
     285        t = SW_READ_REG(CPUP_CONF); 
     286        SW_DBG("cpup_conf: %08X%s%s%s\n", t, 
     287                (t & CPUP_CONF_DCPUP) ? " DCPUP" : "", 
     288                (t & CPUP_CONF_CRCP) ? " CRCP" : "", 
     289                (t & CPUP_CONF_BTM) ? " BTM" : ""); 
     290 
     291        t = SW_READ_REG(PORT_CONF0); 
     292        SW_DBG("port_conf0: %08X\n", t); 
     293        t = SW_READ_REG(PORT_CONF1); 
     294        SW_DBG("port_conf1: %08X\n", t); 
     295        t = SW_READ_REG(PORT_CONF2); 
     296        SW_DBG("port_conf2: %08X\n", t); 
     297 
     298        t = SW_READ_REG(VLAN_G1); 
     299        SW_DBG("vlan g1: %08X\n", t); 
     300        t = SW_READ_REG(VLAN_G2); 
     301        SW_DBG("vlan g2: %08X\n", t); 
     302 
     303        t = SW_READ_REG(BW_CNTL0); 
     304        SW_DBG("bw_cntl0: %08X\n", t); 
     305        t = SW_READ_REG(BW_CNTL1); 
     306        SW_DBG("bw_cntl1: %08X\n", t); 
     307 
     308        t = SW_READ_REG(PHY_CNTL0); 
     309        SW_DBG("phy_cntl0: %08X\n", t); 
     310        t = SW_READ_REG(PHY_CNTL1); 
     311        SW_DBG("phy_cntl1: %08X\n", t); 
     312        t = SW_READ_REG(PHY_CNTL2); 
     313        SW_DBG("phy_cntl2: %08X\n", t); 
     314        t = SW_READ_REG(PHY_CNTL3); 
     315        SW_DBG("phy_cntl3: %08X\n", t); 
     316        t = SW_READ_REG(PHY_CNTL4); 
     317        SW_DBG("phy_cntl4: %08X\n", t); 
     318 
     319        t = SW_READ_REG(INT_STATUS); 
     320        sw_dump_intr_mask("int_status: ", t); 
     321 
     322        t = SW_READ_REG(INT_MASK); 
     323        sw_dump_intr_mask("int_mask: ", t); 
     324 
     325        t = SW_READ_REG(SHDA); 
     326        SW_DBG("shda: %08X\n", t); 
     327        t = SW_READ_REG(SLDA); 
     328        SW_DBG("slda: %08X\n", t); 
     329        t = SW_READ_REG(RHDA); 
     330        SW_DBG("rhda: %08X\n", t); 
     331        t = SW_READ_REG(RLDA); 
     332        SW_DBG("rlda: %08X\n", t); 
     333} 
     334 
     335 
    267336/* ------------------------------------------------------------------------ */ 
    268337 
     
    277346} 
    278347 
    279 static int adm5120_switch_rx(struct net_device *dev, int *budget) 
    280 { 
    281         struct sk_buff *skb, *skbn; 
    282         struct adm5120_sw *priv; 
    283         struct net_device *cdev; 
    284         struct dma_desc *desc; 
    285         int len, quota; 
    286  
    287         quota = min(dev->quota, *budget); 
    288         SW_DBG("%s polling, quota=%d\n", dev->name, quota); 
    289  
    290         sw_int_ack(SWITCH_INTS_POLL); 
    291  
    292         desc = &rxl_descs[cur_rxl]; 
    293         while (!(desc->buf1 & DESC_OWN) && quota) { 
    294                 u32 port = desc_get_srcport(desc); 
    295                 cdev = adm5120_port[port]; 
    296                 if (cdev != dev) {      /* The current packet belongs to a different device */ 
    297                         if ((cdev==NULL) || !netif_running(cdev)) { 
    298                                 /* discard (update with old skb) */ 
    299                                 skb = skbn = NULL; 
    300                                 goto rx_skip; 
    301                         } 
    302                         else { 
    303                                 netif_rx_schedule(cdev);/* Start polling next device */ 
    304                                 return 1;       /* return 1 -> More packets to process */ 
    305                         } 
    306  
    307                 } 
    308                 skb = rxl_skbuff[cur_rxl]; 
    309                 len = desc_get_pktlen(desc); 
    310                 len -= ETH_CSUM_LEN; 
    311  
    312                 priv = netdev_priv(dev); 
    313                 if (len <= 0 || len > RX_MAX_PKTLEN || 
    314                         desc_ipcsum_fail(desc)) { 
    315                         dev->stats.rx_errors++; 
    316                         skbn = NULL; 
    317                 } else { 
    318                         skbn = dev_alloc_skb(SKB_ALLOC_LEN); 
    319                         if (skbn) { 
    320                                 skb_put(skb, len); 
    321                                 skb->dev = dev; 
    322                                 skb->protocol = eth_type_trans(skb, dev); 
    323                                 skb->ip_summed = CHECKSUM_UNNECESSARY; 
    324                                 dev->last_rx = jiffies; 
    325                                 dev->stats.rx_packets++; 
    326                                 dev->stats.rx_bytes += len; 
    327                                 skb_reserve(skbn, SKB_RESERVE_LEN); 
    328                                 rxl_skbuff[cur_rxl] = skbn; 
     348static void adm5120_switch_rx_refill(void) 
     349{ 
     350        unsigned int entry; 
     351 
     352        for (; cur_rxl - dirty_rxl > 0; dirty_rxl++) { 
     353                struct dma_desc *desc; 
     354                struct sk_buff *skb; 
     355 
     356                entry = dirty_rxl % RX_RING_SIZE; 
     357                desc = &rxl_descs[entry]; 
     358 
     359                skb = rxl_skbuff[entry]; 
     360                if (skb == NULL) { 
     361                        skb = alloc_skb(SKB_ALLOC_LEN, GFP_ATOMIC); 
     362                        if (skb) { 
     363                                skb_reserve(skb, SKB_RESERVE_LEN); 
     364                                rxl_skbuff[entry] = skb; 
    329365                        } else { 
    330                                 SW_INFO("%s recycling!\n", dev->name); 
     366                                SW_ERR("no memory for skb\n"); 
     367                                desc->buflen = 0; 
     368                                desc->buf2 = 0; 
     369                                desc->misc = 0; 
     370                                desc->buf1 = (desc->buf1 & DESC_EOR) | DESC_OWN; 
     371                                break; 
    331372                        } 
    332373                } 
    333 rx_skip: 
    334                 adm5120_rx_dma_update(&rxl_descs[cur_rxl], 
    335                         rxl_skbuff[cur_rxl], 
    336                         (RX_RING_SIZE-1==cur_rxl)); 
    337                 if (RX_RING_SIZE == ++cur_rxl) 
    338                         cur_rxl = 0; 
    339                 desc = &rxl_descs[cur_rxl]; 
    340                 if (skbn){ 
    341                         netif_receive_skb(skb); 
    342                         dev->quota--; 
    343                         (*budget)--; 
    344                         quota--; 
     374 
     375                desc->buf2 = 0; 
     376                desc->buflen = RX_MAX_PKTLEN; 
     377                desc->misc = 0; 
     378                desc->buf1 = (desc->buf1 & DESC_EOR) | DESC_OWN | 
     379                                DESC_ADDR(skb->data); 
     380        } 
     381} 
     382 
     383static int adm5120_switch_rx(int limit) 
     384{ 
     385        unsigned int done = 0; 
     386 
     387        SW_DBG("rx start, limit=%d, cur_rxl=%u, dirty_rxl=%u\n", 
     388                                limit, cur_rxl, dirty_rxl); 
     389 
     390        sw_int_ack(SWITCH_INTS_POLL); 
     391 
     392        while (done < limit) { 
     393                int entry = cur_rxl % RX_RING_SIZE; 
     394                struct dma_desc *desc = &rxl_descs[entry]; 
     395                struct net_device *rdev; 
     396                unsigned int port; 
     397 
     398                if (desc->buf1 & DESC_OWN) 
     399                        break; 
     400 
     401                if (dirty_rxl + RX_RING_SIZE == cur_rxl) 
     402                        break; 
     403 
     404                port = desc_get_srcport(desc); 
     405                rdev = adm5120_port[port]; 
     406 
     407                SW_DBG("rx descriptor %u, desc=%p, skb=%p\n", entry, desc, 
     408                                rxl_skbuff[entry]); 
     409 
     410                if ((rdev) && netif_running(rdev)) { 
     411                        struct sk_buff *skb = rxl_skbuff[entry]; 
     412                        int pktlen; 
     413 
     414                        pktlen = desc_get_pktlen(desc); 
     415                        pktlen -= ETH_CSUM_LEN; 
     416 
     417                        if ((pktlen == 0) || desc_ipcsum_fail(desc)) { 
     418                                rdev->stats.rx_errors++; 
     419                                if (pktlen == 0) 
     420                                        rdev->stats.rx_length_errors++; 
     421                                if (desc_ipcsum_fail(desc)) 
     422                                        rdev->stats.rx_crc_errors++; 
     423                                SW_DBG("rx error, recycling skb %u\n", entry); 
     424                        } else { 
     425                                skb_put(skb, pktlen); 
     426 
     427                                skb->dev = rdev; 
     428                                skb->protocol = eth_type_trans(skb, rdev); 
     429                                skb->ip_summed = CHECKSUM_UNNECESSARY; 
     430 
     431                                dma_cache_wback_inv((unsigned long)skb->data, 
     432                                        skb->len); 
     433 
     434                                netif_receive_skb(skb); 
     435 
     436                                rdev->last_rx = jiffies; 
     437                                rdev->stats.rx_packets++; 
     438                                rdev->stats.rx_bytes += pktlen; 
     439 
     440                                rxl_skbuff[entry] = NULL; 
     441                                done++; 
     442                        } 
     443                } else { 
     444                        SW_DBG("no rx device, recycling skb %u\n", entry); 
    345445                } 
    346         } /* while */ 
    347  
    348         if (quota) { 
    349                 netif_rx_complete(dev); 
    350                 sw_int_enable(SWITCH_INTS_POLL); 
     446 
     447                cur_rxl++; 
     448                if (cur_rxl - dirty_rxl > RX_RING_SIZE / 4) 
     449                        adm5120_switch_rx_refill(); 
     450        } 
     451 
     452        adm5120_switch_rx_refill(); 
     453 
     454        SW_DBG("rx finished, cur_rxl=%u, dirty_rxl=%u, processed %d\n", 
     455                                cur_rxl, dirty_rxl, done); 
     456 
     457        return done; 
     458} 
     459 
     460 
     461static int adm5120_switch_poll(struct net_device *dev, int *budget) 
     462{ 
     463        int limit = min(dev->quota, *budget); 
     464        int done; 
     465        u32 status; 
     466 
     467        done = adm5120_switch_rx(limit); 
     468 
     469        *budget -= done; 
     470        dev->quota -= done; 
     471 
     472        status = sw_int_status() & SWITCH_INTS_POLL; 
     473        if ((done < limit) && (!status)) { 
     474                spin_lock_irq(&poll_lock); 
     475                SW_DBG("disable polling mode for %s\n", poll_dev->name); 
     476                netif_rx_complete(poll_dev); 
     477                sw_int_unmask(SWITCH_INTS_POLL); 
     478                poll_dev = NULL; 
     479                spin_unlock_irq(&poll_lock); 
    351480                return 0; 
    352481        } 
    353482 
    354         /* If there are still packets to process, return 1 */ 
    355483        return 1; 
    356484} 
     
    369497                        break; 
    370498 
    371                 sw_dump_desc("tx done", desc, 1); 
    372499                if (netif_running(skb->dev)) { 
    373500                        skb->dev->stats.tx_bytes += skb->len; 
     
    396523        u32 status; 
    397524 
    398         status = sw_read_reg(SWITCH_REG_INT_STATUS); 
    399         status &= ~(sw_read_reg(SWITCH_REG_INT_MASK)); 
    400  
     525        status = sw_int_status(); 
    401526        status &= SWITCH_INTS_POLL; 
    402527        if (!status) 
    403528                return IRQ_NONE; 
    404529 
    405         sw_int_disable(SWITCH_INTS_POLL); 
    406         netif_rx_schedule(dev); 
    407  
    408         SW_DBG("%s handling IRQ%d\n", dev->name, irq); 
     530        sw_dump_intr_mask("poll ints", status); 
     531 
     532        if (!netif_running(dev)) { 
     533                SW_DBG("device %s is not running\n", dev->name); 
     534                return IRQ_NONE; 
     535        } 
     536 
     537        spin_lock(&poll_lock); 
     538        if (!poll_dev) { 
     539                SW_DBG("enable polling mode for %s\n", dev->name); 
     540                poll_dev = dev; 
     541                sw_int_mask(SWITCH_INTS_POLL); 
     542                netif_rx_schedule(poll_dev); 
     543        } 
     544        spin_unlock(&poll_lock); 
     545 
    409546        return IRQ_HANDLED; 
    410547} 
     
    412549static irqreturn_t adm5120_switch_irq(int irq, void *dev_id) 
    413550{ 
    414         irqreturn_t ret; 
    415551        u32 status; 
    416552 
    417         status = sw_read_reg(SWITCH_REG_INT_STATUS); 
    418         status &= ~(sw_read_reg(SWITCH_REG_INT_MASK)); 
    419  
    420         sw_dump_intr_mask("sw irq", status); 
    421  
     553        status = sw_int_status(); 
    422554        status &= SWITCH_INTS_ALL & ~SWITCH_INTS_POLL; 
    423555        if (!status) 
     
    482614        if (!sw_used++) 
    483615                /* enable interrupts on first open */ 
    484                 sw_int_enable(SWITCH_INTS_USED); 
     616                sw_int_unmask(SWITCH_INTS_USED); 
    485617 
    486618        /* enable (additional) port */ 
     
    501633 
    502634        if (!--sw_used) 
    503                 sw_int_disable(SWITCH_INTS_USED); 
     635                sw_int_mask(SWITCH_INTS_USED); 
    504636 
    505637        /* disable port if not assigned to other devices */ 
     
    522654        unsigned int entry; 
    523655        unsigned long data; 
     656 
     657        /* lock switch irq */ 
     658        spin_lock_irq(&sw_lock); 
    524659 
    525660        /* calculate the next TX descriptor entry. */ 
     
    544679 
    545680        desc->buflen = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len; 
    546  
    547         /* lock switch irq */ 
    548         spin_lock_irq(&sw_lock); 
    549681 
    550682        desc->buf1 = data | DESC_OWN; 
     
    721853} 
    722854 
    723 static int __init adm5120_sw_init(void) 
     855static void adm5120_switch_cleanup(void) 
     856{ 
     857        int i; 
     858 
     859        /* disable interrupts */ 
     860        sw_int_mask(SWITCH_INTS_ALL); 
     861 
     862        for (i = 0; i < SWITCH_NUM_PORTS; i++) { 
     863                struct net_device *dev = adm5120_devs[i]; 
     864                if (dev) { 
     865                        unregister_netdev(dev); 
     866                        free_irq(ADM5120_IRQ_SWITCH, dev); 
     867                        free_netdev(dev); 
     868                } 
     869        } 
     870 
     871        /* cleanup TX ring */ 
     872        if (txl_skbuff) { 
     873                for (i = 0; i < TX_RING_SIZE; i++) 
     874                        if (txl_skbuff[i]) 
     875                                kfree_skb(txl_skbuff[i]); 
     876                kfree(txl_skbuff); 
     877        } 
     878 
     879        if (txl_descs) 
     880                dma_free_coherent(NULL, TX_DESCS_SIZE, txl_descs, 
     881                        txl_descs_dma); 
     882 
     883        /* cleanup RX ring */ 
     884        if (rxl_skbuff) { 
     885                for (i = 0; i < RX_RING_SIZE; i++) 
     886                        if (rxl_skbuff[i]) 
     887                                kfree_skb(rxl_skbuff[i]); 
     888                kfree(rxl_skbuff); 
     889        } 
     890 
     891        if (rxl_descs) 
     892                dma_free_coherent(NULL, RX_DESCS_SIZE, rxl_descs, 
     893                        rxl_descs_dma); 
     894 
     895        free_irq(ADM5120_IRQ_SWITCH, &sw_dev); 
     896} 
     897 
     898static int __init adm5120_switch_init(void) 
    724899{ 
    725900        struct net_device *dev; 
     
    729904        err = request_irq(ADM5120_IRQ_SWITCH, adm5120_switch_irq, 
    730905                (IRQF_SHARED | IRQF_DISABLED), "switch", &sw_dev); 
    731         if (err) 
    732                 goto out; 
     906        if (err) { 
     907                SW_ERR("request_irq failed with error %d\n", err); 
     908                goto err; 
     909        } 
    733910 
    734911        adm5120_nrdevs = adm5120_eth_num_ports; 
     
    760937        sw_write_reg(SWITCH_REG_PRI_CNTL, 0); 
    761938 
    762         sw_int_disable(SWITCH_INTS_ALL); 
     939        sw_int_mask(SWITCH_INTS_ALL); 
    763940        sw_int_ack(SWITCH_INTS_ALL); 
    764941 
     942        /* init RX ring */ 
     943        cur_rxl = dirty_rxl = 0; 
     944        rxl_descs = dma_alloc_coherent(NULL, RX_DESCS_SIZE, &rxl_descs_dma, 
     945                                        GFP_ATOMIC); 
     946        if (!rxl_descs) { 
     947                err = -ENOMEM; 
     948                goto err; 
     949        } 
     950 
     951        rxl_skbuff = kzalloc(RX_SKBS_SIZE, GFP_KERNEL); 
     952        if (!rxl_skbuff) { 
     953                err = -ENOMEM; 
     954                goto err; 
     955        } 
     956 
     957        for (i = 0; i < RX_RING_SIZE; i++) { 
     958                struct sk_buff *skb; 
     959                skb = alloc_skb(SKB_ALLOC_LEN, GFP_ATOMIC); 
     960                if (!skb) { 
     961                        err = -ENOMEM; 
     962                        goto err; 
     963                } 
     964                rxl_skbuff[i] = skb; 
     965                skb_reserve(skb, SKB_RESERVE_LEN); 
     966        } 
     967 
     968        /* init TX ring */ 
    765969        cur_txl = dirty_txl = 0; 
    766         cur_rxl = dirty_rxl = 0; 
    767  
    768         txh_descs = (void *)KSEG1ADDR((u32)txh_descs_v); 
    769         txl_descs = (void *)KSEG1ADDR((u32)txl_descs_v); 
    770         rxh_descs = (void *)KSEG1ADDR((u32)rxh_descs_v); 
    771         rxl_descs = (void *)KSEG1ADDR((u32)rxl_descs_v); 
    772  
    773         adm5120_dma_tx_init(txh_descs, txh_skbuff, TX_RING_SIZE); 
     970        txl_descs = dma_alloc_coherent(NULL, TX_DESCS_SIZE, &txl_descs_dma, 
     971                                        GFP_ATOMIC); 
     972        if (!txl_descs) { 
     973                err = -ENOMEM; 
     974                goto err; 
     975        } 
     976 
     977        txl_skbuff = kzalloc(TX_SKBS_SIZE, GFP_KERNEL); 
     978        if (!txl_skbuff) { 
     979                err = -ENOMEM; 
     980                goto err; 
     981        } 
     982 
    774983        adm5120_dma_tx_init(txl_descs, txl_skbuff, TX_RING_SIZE); 
    775         adm5120_dma_rx_init(rxh_descs, rxh_skbuff, RX_RING_SIZE); 
    776984        adm5120_dma_rx_init(rxl_descs, rxl_skbuff, RX_RING_SIZE); 
    777         sw_write_reg(SWITCH_REG_SHDA, KSEG1ADDR(txh_descs)); 
     985 
     986        sw_write_reg(SWITCH_REG_SHDA, 0); 
    778987        sw_write_reg(SWITCH_REG_SLDA, KSEG1ADDR(txl_descs)); 
    779         sw_write_reg(SWITCH_REG_RHDA, KSEG1ADDR(rxh_descs)); 
     988        sw_write_reg(SWITCH_REG_RHDA, 0); 
    780989        sw_write_reg(SWITCH_REG_RLDA, KSEG1ADDR(rxl_descs)); 
    781990 
     
    784993                if (!adm5120_devs[i]) { 
    785994                        err = -ENOMEM; 
    786                         goto out_int; 
     995                        goto err; 
    787996                } 
    788997 
     
    7921001                if (err) { 
    7931002                        SW_ERR("unable to get irq for %s\n", dev->name); 
    794                         goto out_int; 
     1003                        goto err; 
    7951004                } 
    7961005 
     
    8081017                dev->watchdog_timeo = TX_TIMEOUT; 
    8091018                dev->set_mac_address = adm5120_sw_set_mac_address; 
    810                 dev->poll = adm5120_switch_rx; 
     1019                dev->poll = adm5120_switch_poll; 
    8111020                dev->weight = 64; 
    8121021 
     
    8141023                adm5120_write_mac(dev); 
    8151024 
    816                 if ((err = register_netdev(dev))) { 
    817                         free_irq(ADM5120_IRQ_SWITCH, dev); 
    818                         free_netdev(dev); 
    819                         goto out_int; 
     1025                err = register_netdev(dev); 
     1026                if (err) { 
     1027                        SW_INFO("%s register failed, error=%d\n", 
     1028                                        dev->name, err); 
     1029                        goto err; 
    8201030                } 
    8211031                SW_INFO("%s created for switch port%d\n", dev->name, i); 
    8221032        } 
     1033 
    8231034        /* setup vlan/port mapping after devs are filled up */ 
    8241035        adm5120_set_vlan(adm5120_eth_vlans); 
     
    8311042        return 0; 
    8321043 
    833 out_int: 
    834         /* Undo everything that did succeed */ 
    835         for (; i; i--) { 
    836                 unregister_netdev(adm5120_devs[i-1]); 
    837                 free_netdev(adm5120_devs[i-1]); 
    838         } 
    839         free_irq(ADM5120_IRQ_SWITCH, NULL); 
    840 out: 
     1044err: 
     1045        adm5120_switch_cleanup(); 
     1046 
    8411047        SW_ERR("init failed\n"); 
    8421048        return err; 
    8431049} 
    8441050 
    845 static void __exit adm5120_sw_exit(void) 
    846 { 
    847         int i; 
    848  
    849         for (i = 0; i < SWITCH_NUM_PORTS; i++) { 
    850                 struct net_device *dev = adm5120_devs[i]; 
    851                 unregister_netdev(dev); 
    852                 free_irq(ADM5120_IRQ_SWITCH, dev); 
    853                 free_netdev(dev); 
    854         } 
    855  
    856         free_irq(ADM5120_IRQ_SWITCH, &sw_dev); 
    857  
    858         for (i = 0; i < RX_RING_SIZE; i++) { 
    859                 if (!rxh_skbuff[i]) 
    860                         break; 
    861                 kfree_skb(rxh_skbuff[i]); 
    862         } 
    863  
    864         for (i = 0; i < RX_RING_SIZE; i++) { 
    865                 if (!rxl_skbuff[i]) 
    866                         break; 
    867                 kfree_skb(rxl_skbuff[i]); 
    868         } 
    869 } 
    870  
    871 module_init(adm5120_sw_init); 
    872 module_exit(adm5120_sw_exit); 
     1051static void __exit adm5120_switch_exit(void) 
     1052{ 
     1053        adm5120_switch_cleanup(); 
     1054} 
     1055 
     1056module_init(adm5120_switch_init); 
     1057module_exit(adm5120_switch_exit); 
Note: See TracChangeset for help on using the changeset viewer.