qlge: Size RX buffers based on MTU.

Change RX large buffer size based on MTU. If pages are larger
than the MTU the page is divided up into multiple chunks and passed to
the hardware.  When pages are smaller than MTU each RX buffer can
contain be comprised of up to 2 pages.

Signed-off-by: Ron Mercer <ron.mercer@qlogic.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

2 files changed, 214 insertions, 74 deletions

diff --git a/drivers/net/qlge/qlge.h b/drivers/net/qlge/qlge.h
index 421471790601..bc7a2e43c62e 100644
--- a/drivers/net/qlge/qlge.h
+++ b/drivers/net/qlge/qlge.h
@@ -56,7 +56,8 @@
                 MAX_DB_PAGES_PER_BQ(NUM_LARGE_BUFFERS) * sizeof(u64))
 #define SMALL_BUFFER_SIZE 512
 #define SMALL_BUF_MAP_SIZE (SMALL_BUFFER_SIZE / 2)
-#define LARGE_BUFFER_SIZE       PAGE_SIZE
+#define LARGE_BUFFER_MAX_SIZE 8192
+#define LARGE_BUFFER_MIN_SIZE 2048
 #define MAX_SPLIT_SIZE 1023
 #define QLGE_SB_PAD 32
 
@@ -1201,9 +1202,17 @@ struct tx_ring_desc {
         struct tx_ring_desc *next;
 };
 
+struct page_chunk {
+        struct page *page;      /* master page */
+        char *va;               /* virt addr for this chunk */
+        u64 map;                /* mapping for master */
+        unsigned int offset;    /* offset for this chunk */
+        unsigned int last_flag; /* flag set for last chunk in page */
+};
+
 struct bq_desc {
         union {
-                struct page *lbq_page;
+                struct page_chunk pg_chunk;
                 struct sk_buff *skb;
         } p;
         __le64 *addr;
@@ -1272,6 +1281,7 @@ struct rx_ring {
         dma_addr_t lbq_base_dma;
         void *lbq_base_indirect;
         dma_addr_t lbq_base_indirect_dma;
+        struct page_chunk pg_chunk; /* current page for chunks */
         struct bq_desc *lbq;    /* array of control blocks */
         void __iomem *lbq_prod_idx_db_reg;      /* PCI doorbell mem area + 0x18 */
         u32 lbq_prod_idx;       /* current sw prod idx */
@@ -1526,6 +1536,7 @@ struct ql_adapter {
 
         struct rx_ring rx_ring[MAX_RX_RINGS];
         struct tx_ring tx_ring[MAX_TX_RINGS];
+        unsigned int lbq_buf_order;
 
         int rx_csum;
         u32 default_rx_queue;
diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c
index 817613919b51..34242fbcadff 100644
--- a/drivers/net/qlge/qlge_main.c
+++ b/drivers/net/qlge/qlge_main.c
@@ -1025,6 +1025,11 @@ end:
         return status;
 }
 
+static inline unsigned int ql_lbq_block_size(struct ql_adapter *qdev)
+{
+        return PAGE_SIZE << qdev->lbq_buf_order;
+}
+
 /* Get the next large buffer. */
 static struct bq_desc *ql_get_curr_lbuf(struct rx_ring *rx_ring)
 {
@@ -1036,6 +1041,28 @@ static struct bq_desc *ql_get_curr_lbuf(struct rx_ring *rx_ring)
         return lbq_desc;
 }
 
+static struct bq_desc *ql_get_curr_lchunk(struct ql_adapter *qdev,
+                struct rx_ring *rx_ring)
+{
+        struct bq_desc *lbq_desc = ql_get_curr_lbuf(rx_ring);
+
+        pci_dma_sync_single_for_cpu(qdev->pdev,
+                                        pci_unmap_addr(lbq_desc, mapaddr),
+                                    rx_ring->lbq_buf_size,
+                                        PCI_DMA_FROMDEVICE);
+
+        /* If it's the last chunk of our master page then
+         * we unmap it.
+         */
+        if ((lbq_desc->p.pg_chunk.offset + rx_ring->lbq_buf_size)
+                                        == ql_lbq_block_size(qdev))
+                pci_unmap_page(qdev->pdev,
+                                lbq_desc->p.pg_chunk.map,
+                                ql_lbq_block_size(qdev),
+                                PCI_DMA_FROMDEVICE);
+        return lbq_desc;
+}
+
 /* Get the next small buffer. */
 static struct bq_desc *ql_get_curr_sbuf(struct rx_ring *rx_ring)
 {
@@ -1063,6 +1090,53 @@ static void ql_write_cq_idx(struct rx_ring *rx_ring)
         ql_write_db_reg(rx_ring->cnsmr_idx, rx_ring->cnsmr_idx_db_reg);
 }
 
+static int ql_get_next_chunk(struct ql_adapter *qdev, struct rx_ring *rx_ring,
+                                                struct bq_desc *lbq_desc)
+{
+        if (!rx_ring->pg_chunk.page) {
+                u64 map;
+                rx_ring->pg_chunk.page = alloc_pages(__GFP_COLD | __GFP_COMP |
+                                                GFP_ATOMIC,
+                                                qdev->lbq_buf_order);
+                if (unlikely(!rx_ring->pg_chunk.page)) {
+                        QPRINTK(qdev, DRV, ERR,
+                                "page allocation failed.\n");
+                        return -ENOMEM;
+                }
+                rx_ring->pg_chunk.offset = 0;
+                map = pci_map_page(qdev->pdev, rx_ring->pg_chunk.page,
+                                        0, ql_lbq_block_size(qdev),
+                                        PCI_DMA_FROMDEVICE);
+                if (pci_dma_mapping_error(qdev->pdev, map)) {
+                        __free_pages(rx_ring->pg_chunk.page,
+                                        qdev->lbq_buf_order);
+                        QPRINTK(qdev, DRV, ERR,
+                                "PCI mapping failed.\n");
+                        return -ENOMEM;
+                }
+                rx_ring->pg_chunk.map = map;
+                rx_ring->pg_chunk.va = page_address(rx_ring->pg_chunk.page);
+        }
+
+        /* Copy the current master pg_chunk info
+         * to the current descriptor.
+         */
+        lbq_desc->p.pg_chunk = rx_ring->pg_chunk;
+
+        /* Adjust the master page chunk for next
+         * buffer get.
+         */
+        rx_ring->pg_chunk.offset += rx_ring->lbq_buf_size;
+        if (rx_ring->pg_chunk.offset == ql_lbq_block_size(qdev)) {
+                rx_ring->pg_chunk.page = NULL;
+                lbq_desc->p.pg_chunk.last_flag = 1;
+        } else {
+                rx_ring->pg_chunk.va += rx_ring->lbq_buf_size;
+                get_page(rx_ring->pg_chunk.page);
+                lbq_desc->p.pg_chunk.last_flag = 0;
+        }
+        return 0;
+}
 /* Process (refill) a large buffer queue. */
 static void ql_update_lbq(struct ql_adapter *qdev, struct rx_ring *rx_ring)
 {
@@ -1072,39 +1146,28 @@ static void ql_update_lbq(struct ql_adapter *qdev, struct rx_ring *rx_ring)
         u64 map;
         int i;
 
-        while (rx_ring->lbq_free_cnt > 16) {
+        while (rx_ring->lbq_free_cnt > 32) {
                 for (i = 0; i < 16; i++) {
                         QPRINTK(qdev, RX_STATUS, DEBUG,
                                 "lbq: try cleaning clean_idx = %d.\n",
                                 clean_idx);
                         lbq_desc = &rx_ring->lbq[clean_idx];
-                        if (lbq_desc->p.lbq_page == NULL) {
-                                QPRINTK(qdev, RX_STATUS, DEBUG,
-                                        "lbq: getting new page for index %d.\n",
-                                        lbq_desc->index);
-                                lbq_desc->p.lbq_page = alloc_page(GFP_ATOMIC);
-                                if (lbq_desc->p.lbq_page == NULL) {
-                                        rx_ring->lbq_clean_idx = clean_idx;
-                                        QPRINTK(qdev, RX_STATUS, ERR,
-                                                "Couldn't get a page.\n");
-                                        return;
-                                }
-                                map = pci_map_page(qdev->pdev,
-                                                   lbq_desc->p.lbq_page,
-                                                   0, PAGE_SIZE,
-                                                   PCI_DMA_FROMDEVICE);
-                                if (pci_dma_mapping_error(qdev->pdev, map)) {
-                                        rx_ring->lbq_clean_idx = clean_idx;
-                                        put_page(lbq_desc->p.lbq_page);
-                                        lbq_desc->p.lbq_page = NULL;
-                                        QPRINTK(qdev, RX_STATUS, ERR,
-                                                "PCI mapping failed.\n");
+                        if (ql_get_next_chunk(qdev, rx_ring, lbq_desc)) {
+                                QPRINTK(qdev, IFUP, ERR,
+                                        "Could not get a page chunk.\n");
                                         return;
                                 }
+
+                        map = lbq_desc->p.pg_chunk.map +
+                                lbq_desc->p.pg_chunk.offset;
                                 pci_unmap_addr_set(lbq_desc, mapaddr, map);
-                                pci_unmap_len_set(lbq_desc, maplen, PAGE_SIZE);
+                        pci_unmap_len_set(lbq_desc, maplen,
+                                        rx_ring->lbq_buf_size);
                                 *lbq_desc->addr = cpu_to_le64(map);
-                        }
+
+                        pci_dma_sync_single_for_device(qdev->pdev, map,
+                                                rx_ring->lbq_buf_size,
+                                                PCI_DMA_FROMDEVICE);
                         clean_idx++;
                         if (clean_idx == rx_ring->lbq_len)
                                 clean_idx = 0;
@@ -1480,27 +1543,24 @@ static struct sk_buff *ql_build_rx_skb(struct ql_adapter *qdev,
                          * chain it to the header buffer's skb and let
                          * it rip.
                          */
-                        lbq_desc = ql_get_curr_lbuf(rx_ring);
-                        pci_unmap_page(qdev->pdev,
-                                       pci_unmap_addr(lbq_desc,
-                                                      mapaddr),
-                                       pci_unmap_len(lbq_desc, maplen),
-                                       PCI_DMA_FROMDEVICE);
+                        lbq_desc = ql_get_curr_lchunk(qdev, rx_ring);
                         QPRINTK(qdev, RX_STATUS, DEBUG,
-                                "Chaining page to skb.\n");
-                        skb_fill_page_desc(skb, 0, lbq_desc->p.lbq_page,
-                                           0, length);
+                                "Chaining page at offset = %d,"
+                                "for %d bytes  to skb.\n",
+                                lbq_desc->p.pg_chunk.offset, length);
+                        skb_fill_page_desc(skb, 0, lbq_desc->p.pg_chunk.page,
+                                                lbq_desc->p.pg_chunk.offset,
+                                                length);
                         skb->len += length;
                         skb->data_len += length;
                         skb->truesize += length;
-                        lbq_desc->p.lbq_page = NULL;
                 } else {
                         /*
                          * The headers and data are in a single large buffer. We
                          * copy it to a new skb and let it go. This can happen with
                          * jumbo mtu on a non-TCP/UDP frame.
                          */
-                        lbq_desc = ql_get_curr_lbuf(rx_ring);
+                        lbq_desc = ql_get_curr_lchunk(qdev, rx_ring);
                         skb = netdev_alloc_skb(qdev->ndev, length);
                         if (skb == NULL) {
                                 QPRINTK(qdev, PROBE, DEBUG,
@@ -1515,13 +1575,14 @@ static struct sk_buff *ql_build_rx_skb(struct ql_adapter *qdev,
                         skb_reserve(skb, NET_IP_ALIGN);
                         QPRINTK(qdev, RX_STATUS, DEBUG,
                                 "%d bytes of headers and data in large. Chain page to new skb and pull tail.\n", length);
-                        skb_fill_page_desc(skb, 0, lbq_desc->p.lbq_page,
-                                           0, length);
+                        skb_fill_page_desc(skb, 0,
+                                                lbq_desc->p.pg_chunk.page,
+                                                lbq_desc->p.pg_chunk.offset,
+                                                length);
                         skb->len += length;
                         skb->data_len += length;
                         skb->truesize += length;
                         length -= length;
-                        lbq_desc->p.lbq_page = NULL;
                         __pskb_pull_tail(skb,
                                 (ib_mac_rsp->flags2 & IB_MAC_IOCB_RSP_V) ?
                                 VLAN_ETH_HLEN : ETH_HLEN);
@@ -1538,8 +1599,7 @@ static struct sk_buff *ql_build_rx_skb(struct ql_adapter *qdev,
                  *         frames.  If the MTU goes up we could
                  *          eventually be in trouble.
                  */
-                int size, offset, i = 0;
-                __le64 *bq, bq_array[8];
+                int size, i = 0;
                 sbq_desc = ql_get_curr_sbuf(rx_ring);
                 pci_unmap_single(qdev->pdev,
                                  pci_unmap_addr(sbq_desc, mapaddr),
@@ -1558,37 +1618,25 @@ static struct sk_buff *ql_build_rx_skb(struct ql_adapter *qdev,
                         QPRINTK(qdev, RX_STATUS, DEBUG,
                                 "%d bytes of headers & data in chain of large.\n", length);
                         skb = sbq_desc->p.skb;
-                        bq = &bq_array[0];
-                        memcpy(bq, skb->data, sizeof(bq_array));
                         sbq_desc->p.skb = NULL;
                         skb_reserve(skb, NET_IP_ALIGN);
-                } else {
-                        QPRINTK(qdev, RX_STATUS, DEBUG,
-                                "Headers in small, %d bytes of data in chain of large.\n", length);
-                        bq = (__le64 *)sbq_desc->p.skb->data;
                 }
                 while (length > 0) {
-                        lbq_desc = ql_get_curr_lbuf(rx_ring);
-                        pci_unmap_page(qdev->pdev,
-                                       pci_unmap_addr(lbq_desc,
-                                                      mapaddr),
-                                       pci_unmap_len(lbq_desc,
-                                                     maplen),
-                                       PCI_DMA_FROMDEVICE);
-                        size = (length < PAGE_SIZE) ? length : PAGE_SIZE;
-                        offset = 0;
+                        lbq_desc = ql_get_curr_lchunk(qdev, rx_ring);
+                        size = (length < rx_ring->lbq_buf_size) ? length :
+                                rx_ring->lbq_buf_size;
 
                         QPRINTK(qdev, RX_STATUS, DEBUG,
                                 "Adding page %d to skb for %d bytes.\n",
                                 i, size);
-                        skb_fill_page_desc(skb, i, lbq_desc->p.lbq_page,
-                                           offset, size);
+                        skb_fill_page_desc(skb, i,
+                                                lbq_desc->p.pg_chunk.page,
+                                                lbq_desc->p.pg_chunk.offset,
+                                                size);
                         skb->len += size;
                         skb->data_len += size;
                         skb->truesize += size;
                         length -= size;
-                        lbq_desc->p.lbq_page = NULL;
-                        bq++;
                         i++;
                 }
                 __pskb_pull_tail(skb, (ib_mac_rsp->flags2 & IB_MAC_IOCB_RSP_V) ?
@@ -2305,20 +2353,29 @@ err:
 
 static void ql_free_lbq_buffers(struct ql_adapter *qdev, struct rx_ring *rx_ring)
 {
-        int i;
         struct bq_desc *lbq_desc;
 
-        for (i = 0; i < rx_ring->lbq_len; i++) {
-                lbq_desc = &rx_ring->lbq[i];
-                if (lbq_desc->p.lbq_page) {
+        uint32_t  curr_idx, clean_idx;
+
+        curr_idx = rx_ring->lbq_curr_idx;
+        clean_idx = rx_ring->lbq_clean_idx;
+        while (curr_idx != clean_idx) {
+                lbq_desc = &rx_ring->lbq[curr_idx];
+
+                if (lbq_desc->p.pg_chunk.last_flag) {
                         pci_unmap_page(qdev->pdev,
-                                       pci_unmap_addr(lbq_desc, mapaddr),
-                                       pci_unmap_len(lbq_desc, maplen),
+                                lbq_desc->p.pg_chunk.map,
+                                ql_lbq_block_size(qdev),
                                        PCI_DMA_FROMDEVICE);
-
-                        put_page(lbq_desc->p.lbq_page);
-                        lbq_desc->p.lbq_page = NULL;
+                        lbq_desc->p.pg_chunk.last_flag = 0;
                 }
+
+                put_page(lbq_desc->p.pg_chunk.page);
+                lbq_desc->p.pg_chunk.page = NULL;
+
+                if (++curr_idx == rx_ring->lbq_len)
+                        curr_idx = 0;
+
         }
 }
 
@@ -2616,6 +2673,7 @@ static int ql_start_rx_ring(struct ql_adapter *qdev, struct rx_ring *rx_ring)
         /* Set up the shadow registers for this ring. */
         rx_ring->prod_idx_sh_reg = shadow_reg;
         rx_ring->prod_idx_sh_reg_dma = shadow_reg_dma;
+        *rx_ring->prod_idx_sh_reg = 0;
         shadow_reg += sizeof(u64);
         shadow_reg_dma += sizeof(u64);
         rx_ring->lbq_base_indirect = shadow_reg;
@@ -3496,6 +3554,10 @@ static int ql_configure_rings(struct ql_adapter *qdev)
         struct rx_ring *rx_ring;
         struct tx_ring *tx_ring;
         int cpu_cnt = min(MAX_CPUS, (int)num_online_cpus());
+        unsigned int lbq_buf_len = (qdev->ndev->mtu > 1500) ?
+                LARGE_BUFFER_MAX_SIZE : LARGE_BUFFER_MIN_SIZE;
+
+        qdev->lbq_buf_order = get_order(lbq_buf_len);
 
         /* In a perfect world we have one RSS ring for each CPU
          * and each has it's own vector.  To do that we ask for
@@ -3543,7 +3605,10 @@ static int ql_configure_rings(struct ql_adapter *qdev)
                         rx_ring->lbq_len = NUM_LARGE_BUFFERS;
                         rx_ring->lbq_size =
                             rx_ring->lbq_len * sizeof(__le64);
-                        rx_ring->lbq_buf_size = LARGE_BUFFER_SIZE;
+                        rx_ring->lbq_buf_size = (u16)lbq_buf_len;
+                        QPRINTK(qdev, IFUP, DEBUG,
+                                "lbq_buf_size %d, order = %d\n",
+                                rx_ring->lbq_buf_size, qdev->lbq_buf_order);
                         rx_ring->sbq_len = NUM_SMALL_BUFFERS;
                         rx_ring->sbq_size =
                             rx_ring->sbq_len * sizeof(__le64);
@@ -3593,14 +3658,63 @@ error_up:
         return err;
 }
 
+static int ql_change_rx_buffers(struct ql_adapter *qdev)
+{
+        struct rx_ring *rx_ring;
+        int i, status;
+        u32 lbq_buf_len;
+
+        /* Wait for an oustanding reset to complete. */
+        if (!test_bit(QL_ADAPTER_UP, &qdev->flags)) {
+                int i = 3;
+                while (i-- && !test_bit(QL_ADAPTER_UP, &qdev->flags)) {
+                        QPRINTK(qdev, IFUP, ERR,
+                                 "Waiting for adapter UP...\n");
+                        ssleep(1);
+                }
+
+                if (!i) {
+                        QPRINTK(qdev, IFUP, ERR,
+                         "Timed out waiting for adapter UP\n");
+                        return -ETIMEDOUT;
+                }
+        }
+
+        status = ql_adapter_down(qdev);
+        if (status)
+                goto error;
+
+        /* Get the new rx buffer size. */
+        lbq_buf_len = (qdev->ndev->mtu > 1500) ?
+                LARGE_BUFFER_MAX_SIZE : LARGE_BUFFER_MIN_SIZE;
+        qdev->lbq_buf_order = get_order(lbq_buf_len);
+
+        for (i = 0; i < qdev->rss_ring_count; i++) {
+                rx_ring = &qdev->rx_ring[i];
+                /* Set the new size. */
+                rx_ring->lbq_buf_size = lbq_buf_len;
+        }
+
+        status = ql_adapter_up(qdev);
+        if (status)
+                goto error;
+
+        return status;
+error:
+        QPRINTK(qdev, IFUP, ALERT,
+                "Driver up/down cycle failed, closing device.\n");
+        set_bit(QL_ADAPTER_UP, &qdev->flags);
+        dev_close(qdev->ndev);
+        return status;
+}
+
 static int qlge_change_mtu(struct net_device *ndev, int new_mtu)
 {
         struct ql_adapter *qdev = netdev_priv(ndev);
+        int status;
 
         if (ndev->mtu == 1500 && new_mtu == 9000) {
                 QPRINTK(qdev, IFUP, ERR, "Changing to jumbo MTU.\n");
-                queue_delayed_work(qdev->workqueue,
-                                &qdev->mpi_port_cfg_work, 0);
         } else if (ndev->mtu == 9000 && new_mtu == 1500) {
                 QPRINTK(qdev, IFUP, ERR, "Changing to normal MTU.\n");
         } else if ((ndev->mtu == 1500 && new_mtu == 1500) ||
@@ -3608,8 +3722,23 @@ static int qlge_change_mtu(struct net_device *ndev, int new_mtu)
                 return 0;
         } else
                 return -EINVAL;
+
+        queue_delayed_work(qdev->workqueue,
+                        &qdev->mpi_port_cfg_work, 3*HZ);
+
+        if (!netif_running(qdev->ndev)) {
+                ndev->mtu = new_mtu;
+                return 0;
+        }
+
         ndev->mtu = new_mtu;
-        return 0;
+        status = ql_change_rx_buffers(qdev);
+        if (status) {
+                QPRINTK(qdev, IFUP, ERR,
+                        "Changing MTU failed.\n");
+        }
+
+        return status;
 }
 
 static struct net_device_stats *qlge_get_stats(struct net_device