Changeset 30552


Ignore:
Timestamp:
2012-02-15T19:33:38+01:00 (6 years ago)
Author:
juhosg
Message:

ramips: raeth: use 're' instead of 'priv' everywhere

File:
1 edited

Legend:

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

    r30550 r30552  
    561561ramips_eth_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 
    562562{ 
    563         struct raeth_priv *priv = netdev_priv(dev); 
     563        struct raeth_priv *re = netdev_priv(dev); 
    564564        unsigned long tx; 
    565565        unsigned int tx_next; 
    566566        dma_addr_t mapped_addr; 
    567567 
    568         if (priv->plat->min_pkt_len) { 
    569                 if (skb->len < priv->plat->min_pkt_len) { 
    570                         if (skb_padto(skb, priv->plat->min_pkt_len)) { 
     568        if (re->plat->min_pkt_len) { 
     569                if (skb->len < re->plat->min_pkt_len) { 
     570                        if (skb_padto(skb, re->plat->min_pkt_len)) { 
    571571                                printk(KERN_ERR 
    572572                                       "ramips_eth: skb_padto failed\n"); 
     
    574574                                return 0; 
    575575                        } 
    576                         skb_put(skb, priv->plat->min_pkt_len - skb->len); 
     576                        skb_put(skb, re->plat->min_pkt_len - skb->len); 
    577577                } 
    578578        } 
    579579 
    580580        dev->trans_start = jiffies; 
    581         mapped_addr = dma_map_single(&priv->netdev->dev, skb->data, skb->len, 
     581        mapped_addr = dma_map_single(&re->netdev->dev, skb->data, skb->len, 
    582582                                     DMA_TO_DEVICE); 
    583583 
    584         spin_lock(&priv->page_lock); 
     584        spin_lock(&re->page_lock); 
    585585        tx = ramips_fe_rr(RAMIPS_TX_CTX_IDX0); 
    586586        tx_next = (tx + 1) % NUM_TX_DESC; 
    587587 
    588         if ((priv->tx_skb[tx]) || (priv->tx_skb[tx_next]) || 
    589             !(priv->tx[tx].txd2 & TX_DMA_DONE) || 
    590             !(priv->tx[tx_next].txd2 & TX_DMA_DONE)) 
     588        if ((re->tx_skb[tx]) || (re->tx_skb[tx_next]) || 
     589            !(re->tx[tx].txd2 & TX_DMA_DONE) || 
     590            !(re->tx[tx_next].txd2 & TX_DMA_DONE)) 
    591591                goto out; 
    592592 
    593         priv->tx[tx].txd1 = (unsigned int) mapped_addr; 
    594         priv->tx[tx].txd2 &= ~(TX_DMA_PLEN0_MASK | TX_DMA_DONE); 
    595         priv->tx[tx].txd2 |= TX_DMA_PLEN0(skb->len); 
     593        re->tx[tx].txd1 = (unsigned int) mapped_addr; 
     594        re->tx[tx].txd2 &= ~(TX_DMA_PLEN0_MASK | TX_DMA_DONE); 
     595        re->tx[tx].txd2 |= TX_DMA_PLEN0(skb->len); 
    596596        dev->stats.tx_packets++; 
    597597        dev->stats.tx_bytes += skb->len; 
    598         priv->tx_skb[tx] = skb; 
     598        re->tx_skb[tx] = skb; 
    599599        wmb(); 
    600600        ramips_fe_wr(tx_next, RAMIPS_TX_CTX_IDX0); 
    601         spin_unlock(&priv->page_lock); 
     601        spin_unlock(&re->page_lock); 
    602602        return NETDEV_TX_OK; 
    603603 
    604604 out: 
    605         spin_unlock(&priv->page_lock); 
     605        spin_unlock(&re->page_lock); 
    606606        dev->stats.tx_dropped++; 
    607607        kfree_skb(skb); 
     
    613613{ 
    614614        struct net_device *dev = (struct net_device *) ptr; 
    615         struct raeth_priv *priv = netdev_priv(dev); 
     615        struct raeth_priv *re = netdev_priv(dev); 
    616616        int rx; 
    617617        int max_rx = 16; 
     
    622622 
    623623                rx = (ramips_fe_rr(RAMIPS_RX_CALC_IDX0) + 1) % NUM_RX_DESC; 
    624                 if (!(priv->rx[rx].rxd2 & RX_DMA_DONE)) 
     624                if (!(re->rx[rx].rxd2 & RX_DMA_DONE)) 
    625625                        break; 
    626626                max_rx--; 
    627627 
    628                 rx_skb = priv->rx_skb[rx]; 
    629                 pktlen = RX_DMA_PLEN0(priv->rx[rx].rxd2); 
     628                rx_skb = re->rx_skb[rx]; 
     629                pktlen = RX_DMA_PLEN0(re->rx[rx].rxd2); 
    630630 
    631631                new_skb = netdev_alloc_skb(dev, MAX_RX_LENGTH + NET_IP_ALIGN); 
     
    634634                        dma_addr_t dma_addr; 
    635635 
    636                         dma_unmap_single(&priv->netdev->dev, priv->rx_dma[rx], 
     636                        dma_unmap_single(&re->netdev->dev, re->rx_dma[rx], 
    637637                                         MAX_RX_LENGTH, DMA_FROM_DEVICE); 
    638638 
     
    645645                        netif_rx(rx_skb); 
    646646 
    647                         priv->rx_skb[rx] = new_skb; 
     647                        re->rx_skb[rx] = new_skb; 
    648648                        skb_reserve(new_skb, NET_IP_ALIGN); 
    649649 
    650                         dma_addr = dma_map_single(&priv->netdev->dev, 
     650                        dma_addr = dma_map_single(&re->netdev->dev, 
    651651                                                  new_skb->data, 
    652652                                                  MAX_RX_LENGTH, 
    653653                                                  DMA_FROM_DEVICE); 
    654                         priv->rx_dma[rx] = dma_addr; 
    655                         priv->rx[rx].rxd1 = (unsigned int) dma_addr; 
     654                        re->rx_dma[rx] = dma_addr; 
     655                        re->rx[rx].rxd1 = (unsigned int) dma_addr; 
    656656                } else { 
    657657                        dev->stats.rx_dropped++; 
    658658                } 
    659659 
    660                 priv->rx[rx].rxd2 &= ~RX_DMA_DONE; 
     660                re->rx[rx].rxd2 &= ~RX_DMA_DONE; 
    661661                wmb(); 
    662662                ramips_fe_wr(rx, RAMIPS_RX_CALC_IDX0); 
     
    664664 
    665665        if (max_rx == 0) 
    666                 tasklet_schedule(&priv->rx_tasklet); 
     666                tasklet_schedule(&re->rx_tasklet); 
    667667        else 
    668668                ramips_fe_int_enable(RAMIPS_RX_DLY_INT); 
     
    673673{ 
    674674        struct net_device *dev = (struct net_device*)ptr; 
    675         struct raeth_priv *priv = netdev_priv(dev); 
    676  
    677         spin_lock(&priv->page_lock); 
    678         while ((priv->tx[priv->skb_free_idx].txd2 & TX_DMA_DONE) && 
    679                (priv->tx_skb[priv->skb_free_idx])) { 
    680                 dev_kfree_skb_irq(priv->tx_skb[priv->skb_free_idx]); 
    681                 priv->tx_skb[priv->skb_free_idx] = 0; 
    682                 priv->skb_free_idx++; 
    683                 if (priv->skb_free_idx >= NUM_TX_DESC) 
    684                         priv->skb_free_idx = 0; 
    685         } 
    686         spin_unlock(&priv->page_lock); 
     675        struct raeth_priv *re = netdev_priv(dev); 
     676 
     677        spin_lock(&re->page_lock); 
     678        while ((re->tx[re->skb_free_idx].txd2 & TX_DMA_DONE) && 
     679               (re->tx_skb[re->skb_free_idx])) { 
     680                dev_kfree_skb_irq(re->tx_skb[re->skb_free_idx]); 
     681                re->tx_skb[re->skb_free_idx] = 0; 
     682                re->skb_free_idx++; 
     683                if (re->skb_free_idx >= NUM_TX_DESC) 
     684                        re->skb_free_idx = 0; 
     685        } 
     686        spin_unlock(&re->page_lock); 
    687687 
    688688        ramips_fe_int_enable(RAMIPS_TX_DLY_INT); 
     
    692692ramips_eth_timeout(struct net_device *dev) 
    693693{ 
    694         struct raeth_priv *priv = netdev_priv(dev); 
    695  
    696         tasklet_schedule(&priv->tx_housekeeping_tasklet); 
     694        struct raeth_priv *re = netdev_priv(dev); 
     695 
     696        tasklet_schedule(&re->tx_housekeeping_tasklet); 
    697697} 
    698698 
     
    700700ramips_eth_irq(int irq, void *dev) 
    701701{ 
    702         struct raeth_priv *priv = netdev_priv(dev); 
     702        struct raeth_priv *re = netdev_priv(dev); 
    703703        unsigned long fe_int = ramips_fe_rr(RAMIPS_FE_INT_STATUS); 
    704704 
     
    707707        if (fe_int & RAMIPS_RX_DLY_INT) { 
    708708                ramips_fe_int_disable(RAMIPS_RX_DLY_INT); 
    709                 tasklet_schedule(&priv->rx_tasklet); 
     709                tasklet_schedule(&re->rx_tasklet); 
    710710        } 
    711711 
    712712        if (fe_int & RAMIPS_TX_DLY_INT) { 
    713713                ramips_fe_int_disable(RAMIPS_TX_DLY_INT); 
    714                 tasklet_schedule(&priv->tx_housekeeping_tasklet); 
     714                tasklet_schedule(&re->tx_housekeeping_tasklet); 
    715715        } 
    716716 
     
    721721ramips_eth_open(struct net_device *dev) 
    722722{ 
    723         struct raeth_priv *priv = netdev_priv(dev); 
     723        struct raeth_priv *re = netdev_priv(dev); 
    724724        int err; 
    725725 
     
    729729                return err; 
    730730 
    731         err = ramips_alloc_dma(priv); 
     731        err = ramips_alloc_dma(re); 
    732732        if (err) 
    733733                goto err_free_irq; 
     
    735735        ramips_hw_set_macaddr(dev->dev_addr); 
    736736 
    737         ramips_setup_dma(priv); 
     737        ramips_setup_dma(re); 
    738738        ramips_fe_wr((ramips_fe_rr(RAMIPS_PDMA_GLO_CFG) & 0xff) | 
    739739                (RAMIPS_TX_WB_DDONE | RAMIPS_RX_DMA_EN | 
     
    742742        ramips_fe_wr((ramips_fe_rr(RAMIPS_FE_GLO_CFG) & 
    743743                ~(RAMIPS_US_CYC_CNT_MASK << RAMIPS_US_CYC_CNT_SHIFT)) | 
    744                 ((priv->plat->sys_freq / RAMIPS_US_CYC_CNT_DIVISOR) << RAMIPS_US_CYC_CNT_SHIFT), 
     744                ((re->plat->sys_freq / RAMIPS_US_CYC_CNT_DIVISOR) << RAMIPS_US_CYC_CNT_SHIFT), 
    745745                RAMIPS_FE_GLO_CFG); 
    746746 
    747         tasklet_init(&priv->tx_housekeeping_tasklet, ramips_eth_tx_housekeeping, 
     747        tasklet_init(&re->tx_housekeeping_tasklet, ramips_eth_tx_housekeeping, 
    748748                     (unsigned long)dev); 
    749         tasklet_init(&priv->rx_tasklet, ramips_eth_rx_hw, (unsigned long)dev); 
    750  
    751         ramips_phy_start(priv); 
     749        tasklet_init(&re->rx_tasklet, ramips_eth_rx_hw, (unsigned long)dev); 
     750 
     751        ramips_phy_start(re); 
    752752 
    753753        ramips_fe_wr(RAMIPS_DELAY_INIT, RAMIPS_DLY_INT_CFG); 
     
    774774ramips_eth_stop(struct net_device *dev) 
    775775{ 
    776         struct raeth_priv *priv = netdev_priv(dev); 
     776        struct raeth_priv *re = netdev_priv(dev); 
    777777 
    778778        ramips_fe_wr(ramips_fe_rr(RAMIPS_PDMA_GLO_CFG) & 
     
    783783        ramips_fe_wr(0, RAMIPS_FE_INT_ENABLE); 
    784784 
    785         ramips_phy_stop(priv); 
     785        ramips_phy_stop(re); 
    786786        free_irq(dev->irq, dev); 
    787787        netif_stop_queue(dev); 
    788         tasklet_kill(&priv->tx_housekeeping_tasklet); 
    789         tasklet_kill(&priv->rx_tasklet); 
    790         ramips_cleanup_dma(priv); 
     788        tasklet_kill(&re->tx_housekeeping_tasklet); 
     789        tasklet_kill(&re->rx_tasklet); 
     790        ramips_cleanup_dma(re); 
    791791        RADEBUG("ramips_eth: stopped\n"); 
    792792        return 0; 
     
    796796ramips_eth_probe(struct net_device *dev) 
    797797{ 
    798         struct raeth_priv *priv = netdev_priv(dev); 
     798        struct raeth_priv *re = netdev_priv(dev); 
    799799        int err; 
    800800 
    801         BUG_ON(!priv->plat->reset_fe); 
    802         priv->plat->reset_fe(); 
     801        BUG_ON(!re->plat->reset_fe); 
     802        re->plat->reset_fe(); 
    803803        net_srandom(jiffies); 
    804         memcpy(dev->dev_addr, priv->plat->mac, ETH_ALEN); 
     804        memcpy(dev->dev_addr, re->plat->mac, ETH_ALEN); 
    805805 
    806806        ether_setup(dev); 
    807807        dev->mtu = 1500; 
    808808        dev->watchdog_timeo = TX_TIMEOUT; 
    809         spin_lock_init(&priv->page_lock); 
    810         spin_lock_init(&priv->phy_lock); 
    811  
    812         err = ramips_mdio_init(priv); 
     809        spin_lock_init(&re->page_lock); 
     810        spin_lock_init(&re->phy_lock); 
     811 
     812        err = ramips_mdio_init(re); 
    813813        if (err) 
    814814                return err; 
    815815 
    816         err = ramips_phy_connect(priv); 
     816        err = ramips_phy_connect(re); 
    817817        if (err) 
    818818                goto err_mdio_cleanup; 
     
    821821 
    822822err_mdio_cleanup: 
    823         ramips_mdio_cleanup(priv); 
     823        ramips_mdio_cleanup(re); 
    824824        return err; 
    825825} 
     
    849849ramips_eth_plat_probe(struct platform_device *plat) 
    850850{ 
    851         struct raeth_priv *priv; 
     851        struct raeth_priv *re; 
    852852        struct ramips_eth_platform_data *data = plat->dev.platform_data; 
    853853        struct resource *res; 
     
    887887        ramips_dev->netdev_ops = &ramips_eth_netdev_ops; 
    888888 
    889         priv = netdev_priv(ramips_dev); 
    890  
    891         priv->netdev = ramips_dev; 
    892         priv->parent = &plat->dev; 
    893         priv->speed = data->speed; 
    894         priv->duplex = data->duplex; 
    895         priv->rx_fc = data->rx_fc; 
    896         priv->tx_fc = data->tx_fc; 
    897         priv->plat = data; 
     889        re = netdev_priv(ramips_dev); 
     890 
     891        re->netdev = ramips_dev; 
     892        re->parent = &plat->dev; 
     893        re->speed = data->speed; 
     894        re->duplex = data->duplex; 
     895        re->rx_fc = data->rx_fc; 
     896        re->tx_fc = data->tx_fc; 
     897        re->plat = data; 
    898898 
    899899        err = register_netdev(ramips_dev); 
Note: See TracChangeset for help on using the changeset viewer.