]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/commitdiff
net: ep93xx_eth: allocate buffers using kmalloc()
authorMika Westerberg <mika.westerberg@iki.fi>
Sat, 11 Jun 2011 08:39:56 +0000 (08:39 +0000)
committerDavid S. Miller <davem@davemloft.net>
Sat, 11 Jun 2011 23:25:15 +0000 (16:25 -0700)
We can use simply kmalloc() to allocate the buffers. This also simplifies the
code and allows us to perform DMA sync operations more easily.

Memory is allocated with only GFP_KERNEL since there are no DMA allocation
restrictions on this platform.

Signed-off-by: Mika Westerberg <mika.westerberg@iki.fi>
Acked-by: Russell King <rmk+kernel@arm.linux.org.uk>
Acked-by: H Hartley Sweeten <hsweeten@visionengravers.com>
Tested-by: Petr Stetiar <ynezz@true.cz>
Signed-off-by: David S. Miller <davem@davemloft.net>
drivers/net/arm/ep93xx_eth.c

index f65dfb6e57056f1b951075ec99a2de310218a4b7..97bf6b10ce6105494fcbd2ef30d7d0f0869494ed 100644 (file)
@@ -460,36 +460,32 @@ static void ep93xx_free_buffers(struct ep93xx_priv *ep)
        struct device *dev = ep->dev->dev.parent;
        int i;
 
-       for (i = 0; i < RX_QUEUE_ENTRIES; i += 2) {
+       for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
                dma_addr_t d;
 
                d = ep->descs->rdesc[i].buf_addr;
                if (d)
-                       dma_unmap_single(dev, d, PAGE_SIZE, DMA_FROM_DEVICE);
+                       dma_unmap_single(dev, d, PKT_BUF_SIZE, DMA_FROM_DEVICE);
 
                if (ep->rx_buf[i] != NULL)
-                       free_page((unsigned long)ep->rx_buf[i]);
+                       kfree(ep->rx_buf[i]);
        }
 
-       for (i = 0; i < TX_QUEUE_ENTRIES; i += 2) {
+       for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
                dma_addr_t d;
 
                d = ep->descs->tdesc[i].buf_addr;
                if (d)
-                       dma_unmap_single(dev, d, PAGE_SIZE, DMA_TO_DEVICE);
+                       dma_unmap_single(dev, d, PKT_BUF_SIZE, DMA_TO_DEVICE);
 
                if (ep->tx_buf[i] != NULL)
-                       free_page((unsigned long)ep->tx_buf[i]);
+                       kfree(ep->tx_buf[i]);
        }
 
        dma_free_coherent(dev, sizeof(struct ep93xx_descs), ep->descs,
                                                        ep->descs_dma_addr);
 }
 
-/*
- * The hardware enforces a sub-2K maximum packet size, so we put
- * two buffers on every hardware page.
- */
 static int ep93xx_alloc_buffers(struct ep93xx_priv *ep)
 {
        struct device *dev = ep->dev->dev.parent;
@@ -500,48 +496,41 @@ static int ep93xx_alloc_buffers(struct ep93xx_priv *ep)
        if (ep->descs == NULL)
                return 1;
 
-       for (i = 0; i < RX_QUEUE_ENTRIES; i += 2) {
-               void *page;
+       for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
+               void *buf;
                dma_addr_t d;
 
-               page = (void *)__get_free_page(GFP_KERNEL | GFP_DMA);
-               if (page == NULL)
+               buf = kmalloc(PKT_BUF_SIZE, GFP_KERNEL);
+               if (buf == NULL)
                        goto err;
 
-               d = dma_map_single(dev, page, PAGE_SIZE, DMA_FROM_DEVICE);
+               d = dma_map_single(dev, buf, PKT_BUF_SIZE, DMA_FROM_DEVICE);
                if (dma_mapping_error(dev, d)) {
-                       free_page((unsigned long)page);
+                       kfree(buf);
                        goto err;
                }
 
-               ep->rx_buf[i] = page;
+               ep->rx_buf[i] = buf;
                ep->descs->rdesc[i].buf_addr = d;
                ep->descs->rdesc[i].rdesc1 = (i << 16) | PKT_BUF_SIZE;
-
-               ep->rx_buf[i + 1] = page + PKT_BUF_SIZE;
-               ep->descs->rdesc[i + 1].buf_addr = d + PKT_BUF_SIZE;
-               ep->descs->rdesc[i + 1].rdesc1 = ((i + 1) << 16) | PKT_BUF_SIZE;
        }
 
-       for (i = 0; i < TX_QUEUE_ENTRIES; i += 2) {
-               void *page;
+       for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
+               void *buf;
                dma_addr_t d;
 
-               page = (void *)__get_free_page(GFP_KERNEL | GFP_DMA);
-               if (page == NULL)
+               buf = kmalloc(PKT_BUF_SIZE, GFP_KERNEL);
+               if (buf == NULL)
                        goto err;
 
-               d = dma_map_single(dev, page, PAGE_SIZE, DMA_TO_DEVICE);
+               d = dma_map_single(dev, buf, PKT_BUF_SIZE, DMA_TO_DEVICE);
                if (dma_mapping_error(dev, d)) {
-                       free_page((unsigned long)page);
+                       kfree(buf);
                        goto err;
                }
 
-               ep->tx_buf[i] = page;
+               ep->tx_buf[i] = buf;
                ep->descs->tdesc[i].buf_addr = d;
-
-               ep->tx_buf[i + 1] = page + PKT_BUF_SIZE;
-               ep->descs->tdesc[i + 1].buf_addr = d + PKT_BUF_SIZE;
        }
 
        return 0;