Changeset 30573


Ignore:
Timestamp:
2012-02-16T09:17:50+01:00 (6 years ago)
Author:
juhosg
Message:

ramips: raeth: separate ring allocation and setup

File:
1 edited

Legend:

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

    r30555 r30573  
    103103} 
    104104 
     105static void 
     106ramips_ring_setup(struct raeth_priv *re) 
     107{ 
     108        int len; 
     109        int i; 
     110 
     111        len = NUM_TX_DESC * sizeof(struct ramips_tx_dma); 
     112        memset(re->tx, 0, len); 
     113 
     114        for (i = 0; i < NUM_TX_DESC; i++) { 
     115                struct ramips_tx_dma *txd; 
     116 
     117                txd = &re->tx[i]; 
     118                txd->txd4 = TX_DMA_QN(3) | TX_DMA_PN(1); 
     119                txd->txd2 = TX_DMA_LSO | TX_DMA_DONE; 
     120 
     121                if (re->tx_skb[i] != NULL) { 
     122                        netdev_warn(re->netdev, 
     123                                    "dirty skb for TX desc %d\n", i); 
     124                        re->tx_skb[i] = NULL; 
     125                } 
     126        } 
     127 
     128        len = NUM_RX_DESC * sizeof(struct ramips_rx_dma); 
     129        memset(re->rx, 0, len); 
     130 
     131        for (i = 0; i < NUM_RX_DESC; i++) { 
     132                dma_addr_t dma_addr; 
     133 
     134                BUG_ON(re->rx_skb[i] == NULL); 
     135                dma_addr = dma_map_single(&re->netdev->dev, re->rx_skb[i]->data, 
     136                                          MAX_RX_LENGTH, DMA_FROM_DEVICE); 
     137                re->rx_dma[i] = dma_addr; 
     138                re->rx[i].rxd1 = (unsigned int) dma_addr; 
     139                re->rx[i].rxd2 = RX_DMA_LSO; 
     140        } 
     141 
     142        /* flush descriptors */ 
     143        wmb(); 
     144} 
     145 
     146static void 
     147ramips_ring_cleanup(struct raeth_priv *re) 
     148{ 
     149        int i; 
     150 
     151        for (i = 0; i < NUM_RX_DESC; i++) 
     152                if (re->rx_skb[i]) 
     153                        dma_unmap_single(&re->netdev->dev, re->rx_dma[i], 
     154                                         MAX_RX_LENGTH, DMA_FROM_DEVICE); 
     155 
     156        for (i = 0; i < NUM_TX_DESC; i++) 
     157                if (re->tx_skb[i]) { 
     158                        dev_kfree_skb_any(re->tx_skb[i]); 
     159                        re->tx_skb[i] = NULL; 
     160                } 
     161} 
     162 
    105163#if defined(CONFIG_RALINK_RT288X) || defined(CONFIG_RALINK_RT3883) 
    106164 
     
    482540 
    483541static void 
    484 ramips_cleanup_dma(struct raeth_priv *re) 
    485 { 
     542ramips_ring_free(struct raeth_priv *re) 
     543{ 
     544        int len; 
    486545        int i; 
    487546 
    488547        for (i = 0; i < NUM_RX_DESC; i++) 
    489                 if (re->rx_skb[i]) { 
    490                         dma_unmap_single(&re->netdev->dev, re->rx_dma[i], 
    491                                          MAX_RX_LENGTH, DMA_FROM_DEVICE); 
     548                if (re->rx_skb[i]) 
    492549                        dev_kfree_skb_any(re->rx_skb[i]); 
    493                 } 
    494  
    495         if (re->rx) 
    496                 dma_free_coherent(&re->netdev->dev, 
    497                                   NUM_RX_DESC * sizeof(struct ramips_rx_dma), 
    498                                   re->rx, re->rx_desc_dma); 
    499  
    500         if (re->tx) 
    501                 dma_free_coherent(&re->netdev->dev, 
    502                                   NUM_TX_DESC * sizeof(struct ramips_tx_dma), 
    503                                   re->tx, re->tx_desc_dma); 
    504 } 
    505  
    506 static int 
    507 ramips_alloc_dma(struct raeth_priv *re) 
    508 { 
     550 
     551        if (re->rx) { 
     552                len = NUM_RX_DESC * sizeof(struct ramips_rx_dma); 
     553                dma_free_coherent(&re->netdev->dev, len, re->rx, 
     554                                  re->rx_desc_dma); 
     555        } 
     556 
     557        if (re->tx) { 
     558                len = NUM_TX_DESC * sizeof(struct ramips_tx_dma); 
     559                dma_free_coherent(&re->netdev->dev, len, re->tx, 
     560                                  re->tx_desc_dma); 
     561        } 
     562} 
     563 
     564static int 
     565ramips_ring_alloc(struct raeth_priv *re) 
     566{ 
     567        int len; 
    509568        int err = -ENOMEM; 
    510569        int i; 
    511570 
    512         re->skb_free_idx = 0; 
    513  
    514         /* setup tx ring */ 
    515         re->tx = dma_alloc_coherent(&re->netdev->dev, 
    516                                     NUM_TX_DESC * sizeof(struct ramips_tx_dma), 
    517                                     &re->tx_desc_dma, GFP_ATOMIC); 
     571        /* allocate tx ring */ 
     572        len = NUM_TX_DESC * sizeof(struct ramips_tx_dma); 
     573        re->tx = dma_alloc_coherent(&re->netdev->dev, len, 
     574                                          &re->tx_desc_dma, GFP_ATOMIC); 
    518575        if (!re->tx) 
    519576                goto err_cleanup; 
    520577 
    521         memset(re->tx, 0, NUM_TX_DESC * sizeof(struct ramips_tx_dma)); 
    522         for (i = 0; i < NUM_TX_DESC; i++) { 
    523                 re->tx[i].txd2 = TX_DMA_LSO | TX_DMA_DONE; 
    524                 re->tx[i].txd4 = TX_DMA_QN(3) | TX_DMA_PN(1); 
    525         } 
    526  
    527         /* setup rx ring */ 
    528         re->rx = dma_alloc_coherent(&re->netdev->dev, 
    529                                     NUM_RX_DESC * sizeof(struct ramips_rx_dma), 
     578        /* allocate rx ring */ 
     579        len = NUM_RX_DESC * sizeof(struct ramips_rx_dma); 
     580        re->rx = dma_alloc_coherent(&re->netdev->dev, len, 
    530581                                    &re->rx_desc_dma, GFP_ATOMIC); 
    531582        if (!re->rx) 
    532583                goto err_cleanup; 
    533584 
    534         memset(re->rx, 0, sizeof(struct ramips_rx_dma) * NUM_RX_DESC); 
    535585        for (i = 0; i < NUM_RX_DESC; i++) { 
    536                 dma_addr_t dma_addr; 
    537                 struct sk_buff *new_skb; 
    538  
    539                 new_skb = ramips_alloc_skb(re); 
    540                 if (!new_skb) 
     586                struct sk_buff *skb; 
     587 
     588                skb = ramips_alloc_skb(re); 
     589                if (!skb) 
    541590                        goto err_cleanup; 
    542591 
    543                 dma_addr = dma_map_single(&re->netdev->dev, new_skb->data, 
    544                                           MAX_RX_LENGTH, DMA_FROM_DEVICE); 
    545                 re->rx_dma[i] = dma_addr; 
    546                 re->rx[i].rxd1 = (unsigned int) re->rx_dma[i]; 
    547                 re->rx[i].rxd2 |= RX_DMA_LSO; 
    548                 re->rx_skb[i] = new_skb; 
    549         } 
    550  
    551         return 0; 
    552  
    553  err_cleanup: 
    554         ramips_cleanup_dma(re); 
     592                re->rx_skb[i] = skb; 
     593        } 
     594 
     595        return 0; 
     596 
     597err_cleanup: 
     598        ramips_ring_free(re); 
    555599        return err; 
    556600} 
     
    740784                return err; 
    741785 
    742         err = ramips_alloc_dma(re); 
     786        err = ramips_ring_alloc(re); 
    743787        if (err) 
    744788                goto err_free_irq; 
    745789 
     790        ramips_ring_setup(re); 
    746791        ramips_hw_set_macaddr(dev->dev_addr); 
    747792 
     
    799844        tasklet_kill(&re->tx_housekeeping_tasklet); 
    800845        tasklet_kill(&re->rx_tasklet); 
    801         ramips_cleanup_dma(re); 
     846        ramips_ring_cleanup(re); 
     847        ramips_ring_free(re); 
    802848        RADEBUG("ramips_eth: stopped\n"); 
    803849        return 0; 
Note: See TracChangeset for help on using the changeset viewer.