brcm80211: fmac: separate receiving skb chain from other receive path

In the receive path the buffer used to store the receive data from the
device can be a chain of sk_buff. It has been separated to allow the
use of skb queues.

Reported-by: Johannes Berg <johannes@sipsolutions.net>
Reviewed-by: Pieter-Paul Giesberts <pieterpg@broadcom.com>
Reviewed-by: Franky (Zhenhui) Lin <frankyl@broadcom.com>
Reviewed-by: Alwin Beukers <alwin@broadcom.com>
Signed-off-by: Arend van Spriel <arend@broadcom.com>
Signed-off-by: Franky Lin <frankyl@broadcom.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

4 files changed, 201 insertions, 77 deletions

diff --git a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c b/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
index 89ff94da556a..9c27870a62c6 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
@@ -222,19 +222,12 @@ bool brcmf_sdcard_regfail(struct brcmf_sdio_dev *sdiodev)
         return sdiodev->regfail;
 }
 
-int
-brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
-                      uint flags,
-                      u8 *buf, uint nbytes, struct sk_buff *pkt)
+static int brcmf_sdcard_recv_prepare(struct brcmf_sdio_dev *sdiodev, uint fn,
+                                     uint flags, uint width, u32 *addr)
 {
-        int status;
-        uint incr_fix;
-        uint width;
-        uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
+        uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK;
         int err = 0;
 
-        brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n", fn, addr, nbytes);
-
         /* Async not implemented yet */
         if (flags & SDIO_REQ_ASYNC)
                 return -ENOTSUPP;
@@ -247,29 +240,114 @@ brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
                 sdiodev->sbwad = bar0;
         }
 
-        addr &= SBSDIO_SB_OFT_ADDR_MASK;
+        *addr &= SBSDIO_SB_OFT_ADDR_MASK;
+
+        if (width == 4)
+                *addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
+
+        return 0;
+}
+
+int
+brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
+                      uint flags, u8 *buf, uint nbytes)
+{
+        struct sk_buff *mypkt;
+        int err;
+
+        mypkt = brcmu_pkt_buf_get_skb(nbytes);
+        if (!mypkt) {
+                brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
+                          nbytes);
+                return -EIO;
+        }
+
+        err = brcmf_sdcard_recv_pkt(sdiodev, addr, fn, flags, mypkt);
+        if (!err)
+                memcpy(buf, mypkt->data, nbytes);
+
+        brcmu_pkt_buf_free_skb(mypkt);
+        return err;
+}
+
+int
+brcmf_sdcard_recv_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
+                      uint flags, struct sk_buff *pkt)
+{
+        uint incr_fix;
+        uint width;
+        int err = 0;
+
+        brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
+                  fn, addr, pkt->len);
+
+        width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
+        err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
+        if (err)
+                return err;
 
         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
+        err = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_READ,
+                                         fn, addr, width, 0, NULL, pkt);
+
+        return err;
+}
+
+int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
+                            uint flags, struct sk_buff_head *pktq)
+{
+        uint incr_fix;
+        uint width;
+        int err = 0;
+
+        brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
+                  fn, addr, pktq->qlen);
+
         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
-        if (width == 4)
-                addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
+        err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
+        if (err)
+                return err;
 
-        status = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_READ,
-                                            fn, addr, width, nbytes, buf, pkt);
+        incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
+        err = brcmf_sdioh_request_chain(sdiodev, incr_fix, SDIOH_READ, fn, addr,
+                                        pktq);
 
-        return status;
+        return err;
 }
 
 int
 brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
-                      uint flags, u8 *buf, uint nbytes, struct sk_buff *pkt)
+                      uint flags, u8 *buf, uint nbytes)
+{
+        struct sk_buff *mypkt;
+        int err;
+
+        mypkt = brcmu_pkt_buf_get_skb(nbytes);
+        if (!mypkt) {
+                brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
+                          nbytes);
+                return -EIO;
+        }
+
+        memcpy(mypkt->data, buf, nbytes);
+        err = brcmf_sdcard_send_pkt(sdiodev, addr, fn, flags, mypkt);
+
+        brcmu_pkt_buf_free_skb(mypkt);
+        return err;
+
+}
+
+int
+brcmf_sdcard_send_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
+                      uint flags, struct sk_buff *pkt)
 {
         uint incr_fix;
         uint width;
         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
         int err = 0;
 
-        brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n", fn, addr, nbytes);
+        brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
+                  fn, addr, pkt->len);
 
         /* Async not implemented yet */
         if (flags & SDIO_REQ_ASYNC)
@@ -291,7 +369,7 @@ brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 
         return brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_WRITE, fn,
-                                          addr, width, nbytes, buf, pkt);
+                                          addr, width, 0, NULL, pkt);
 }
 
 int brcmf_sdcard_rwdata(struct brcmf_sdio_dev *sdiodev, uint rw, u32 addr,
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh_sdmmc.c b/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh_sdmmc.c
index bbaeb2d5c93a..4e75c191c290 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh_sdmmc.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/bcmsdh_sdmmc.c
@@ -204,16 +204,79 @@ int brcmf_sdioh_request_word(struct brcmf_sdio_dev *sdiodev,
         return err_ret;
 }
 
+/* precondition: host controller is claimed */
+static int
+brcmf_sdioh_request_data(struct brcmf_sdio_dev *sdiodev, uint write, bool fifo,
+                         uint func, uint addr, struct sk_buff *pkt, uint pktlen)
+{
+        int err_ret = 0;
+
+        if ((write) && (!fifo)) {
+                err_ret = sdio_memcpy_toio(sdiodev->func[func], addr,
+                                           ((u8 *) (pkt->data)), pktlen);
+        } else if (write) {
+                err_ret = sdio_memcpy_toio(sdiodev->func[func], addr,
+                                           ((u8 *) (pkt->data)), pktlen);
+        } else if (fifo) {
+                err_ret = sdio_readsb(sdiodev->func[func],
+                                      ((u8 *) (pkt->data)), addr, pktlen);
+        } else {
+                err_ret = sdio_memcpy_fromio(sdiodev->func[func],
+                                             ((u8 *) (pkt->data)),
+                                             addr, pktlen);
+        }
+
+        return err_ret;
+}
+
 static int
 brcmf_sdioh_request_packet(struct brcmf_sdio_dev *sdiodev, uint fix_inc,
                            uint write, uint func, uint addr,
                            struct sk_buff *pkt)
 {
         bool fifo = (fix_inc == SDIOH_DATA_FIX);
+        int err_ret = 0;
+        uint pkt_len = pkt->len;
+
+        brcmf_dbg(TRACE, "Enter\n");
+
+        brcmf_pm_resume_wait(sdiodev, &sdiodev->request_packet_wait);
+        if (brcmf_pm_resume_error(sdiodev))
+                return -EIO;
+
+        /* Claim host controller */
+        sdio_claim_host(sdiodev->func[func]);
+
+        pkt_len += 3;
+        pkt_len &= 0xFFFFFFFC;
+
+        err_ret = brcmf_sdioh_request_data(sdiodev, write, fifo, func,
+                                           addr, pkt, pkt_len);
+        if (err_ret) {
+                brcmf_dbg(ERROR, "%s FAILED %p, addr=0x%05x, pkt_len=%d, ERR=0x%08x\n",
+                          write ? "TX" : "RX", pkt, addr, pkt_len, err_ret);
+        } else {
+                brcmf_dbg(TRACE, "%s xfr'd %p, addr=0x%05x, len=%d\n",
+                          write ? "TX" : "RX", pkt, addr, pkt_len);
+        }
+
+        /* Release host controller */
+        sdio_release_host(sdiodev->func[func]);
+
+        brcmf_dbg(TRACE, "Exit\n");
+        return err_ret;
+}
+
+int
+brcmf_sdioh_request_chain(struct brcmf_sdio_dev *sdiodev, uint fix_inc,
+                          uint write, uint func, uint addr,
+                          struct sk_buff_head *pktq)
+{
+        bool fifo = (fix_inc == SDIOH_DATA_FIX);
         u32 SGCount = 0;
         int err_ret = 0;
 
-        struct sk_buff *pnext;
+        struct sk_buff *pkt;
 
         brcmf_dbg(TRACE, "Enter\n");
 
@@ -223,43 +286,27 @@ brcmf_sdioh_request_packet(struct brcmf_sdio_dev *sdiodev, uint fix_inc,
 
         /* Claim host controller */
         sdio_claim_host(sdiodev->func[func]);
-        for (pnext = pkt; pnext; pnext = pnext->next) {
-                uint pkt_len = pnext->len;
+
+        skb_queue_walk(pktq, pkt) {
+                uint pkt_len = pkt->len;
                 pkt_len += 3;
                 pkt_len &= 0xFFFFFFFC;
 
-                if ((write) && (!fifo)) {
-                        err_ret = sdio_memcpy_toio(sdiodev->func[func], addr,
-                                                   ((u8 *) (pnext->data)),
-                                                   pkt_len);
-                } else if (write) {
-                        err_ret = sdio_memcpy_toio(sdiodev->func[func], addr,
-                                                   ((u8 *) (pnext->data)),
-                                                   pkt_len);
-                } else if (fifo) {
-                        err_ret = sdio_readsb(sdiodev->func[func],
-                                              ((u8 *) (pnext->data)),
-                                              addr, pkt_len);
-                } else {
-                        err_ret = sdio_memcpy_fromio(sdiodev->func[func],
-                                                     ((u8 *) (pnext->data)),
-                                                     addr, pkt_len);
-                }
-
+                err_ret = brcmf_sdioh_request_data(sdiodev, write, fifo, func,
+                                                   addr, pkt, pkt_len);
                 if (err_ret) {
                         brcmf_dbg(ERROR, "%s FAILED %p[%d], addr=0x%05x, pkt_len=%d, ERR=0x%08x\n",
-                                  write ? "TX" : "RX", pnext, SGCount, addr,
+                                  write ? "TX" : "RX", pkt, SGCount, addr,
                                   pkt_len, err_ret);
                 } else {
                         brcmf_dbg(TRACE, "%s xfr'd %p[%d], addr=0x%05x, len=%d\n",
-                                  write ? "TX" : "RX", pnext, SGCount, addr,
+                                  write ? "TX" : "RX", pkt, SGCount, addr,
                                   pkt_len);
                 }
-
                 if (!fifo)
                         addr += pkt_len;
-                SGCount++;
 
+                SGCount++;
         }
 
         /* Release host controller */
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c b/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c
index 10b9247ec539..a9b8272d1b17 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c
+++ b/drivers/net/wireless/brcm80211/brcmfmac/dhd_sdio.c
@@ -1228,17 +1228,14 @@ static u8 brcmf_sdbrcm_rxglom(struct brcmf_bus *bus, u8 rxseq)
                  * packet and and copy into the chain.
                  */
                 if (usechain) {
-                        errcode = brcmf_sdcard_recv_buf(bus->sdiodev,
+                        errcode = brcmf_sdcard_recv_chain(bus->sdiodev,
                                         bus->sdiodev->sbwad,
-                                        SDIO_FUNC_2,
-                                        F2SYNC, (u8 *) pfirst->data, dlen,
-                                        pfirst);
+                                        SDIO_FUNC_2, F2SYNC, &bus->glom);
                 } else if (bus->dataptr) {
                         errcode = brcmf_sdcard_recv_buf(bus->sdiodev,
                                         bus->sdiodev->sbwad,
-                                        SDIO_FUNC_2,
-                                        F2SYNC, bus->dataptr, dlen,
-                                        NULL);
+                                        SDIO_FUNC_2, F2SYNC,
+                                        bus->dataptr, dlen);
                         sublen = (u16) brcmf_sdbrcm_glom_from_buf(bus, dlen);
                         if (sublen != dlen) {
                                 brcmf_dbg(ERROR, "FAILED TO COPY, dlen %d sublen %d\n",
@@ -1560,8 +1557,7 @@ brcmf_sdbrcm_read_control(struct brcmf_bus *bus, u8 *hdr, uint len, uint doff)
         sdret = brcmf_sdcard_recv_buf(bus->sdiodev,
                                 bus->sdiodev->sbwad,
                                 SDIO_FUNC_2,
-                                F2SYNC, (bus->rxctl + BRCMF_FIRSTREAD), rdlen,
-                                NULL);
+                                F2SYNC, (bus->rxctl + BRCMF_FIRSTREAD), rdlen);
         bus->f2rxdata++;
 
         /* Control frame failures need retransmission */
@@ -1617,9 +1613,8 @@ brcmf_alloc_pkt_and_read(struct brcmf_bus *bus, u16 rdlen,
         pkt_align(*pkt, rdlen, BRCMF_SDALIGN);
         *rxbuf = (u8 *) ((*pkt)->data);
         /* Read the entire frame */
-        sdret = brcmf_sdcard_recv_buf(bus->sdiodev, bus->sdiodev->sbwad,
-                                      SDIO_FUNC_2, F2SYNC,
-                                      *rxbuf, rdlen, *pkt);
+        sdret = brcmf_sdcard_recv_pkt(bus->sdiodev, bus->sdiodev->sbwad,
+                                      SDIO_FUNC_2, F2SYNC, *pkt);
         bus->f2rxdata++;
 
         if (sdret < 0) {
@@ -1847,7 +1842,7 @@ brcmf_sdbrcm_readframes(struct brcmf_bus *bus, uint maxframes, bool *finished)
                 /* Read frame header (hardware and software) */
                 sdret = brcmf_sdcard_recv_buf(bus->sdiodev, bus->sdiodev->sbwad,
                                               SDIO_FUNC_2, F2SYNC, bus->rxhdr,
-                                              BRCMF_FIRSTREAD, NULL);
+                                              BRCMF_FIRSTREAD);
                 bus->f2rxhdrs++;
 
                 if (sdret < 0) {
@@ -1996,9 +1991,8 @@ brcmf_sdbrcm_readframes(struct brcmf_bus *bus, uint maxframes, bool *finished)
                 pkt_align(pkt, rdlen, BRCMF_SDALIGN);
 
                 /* Read the remaining frame data */
-                sdret = brcmf_sdcard_recv_buf(bus->sdiodev, bus->sdiodev->sbwad,
-                                SDIO_FUNC_2, F2SYNC, ((u8 *) (pkt->data)),
-                                rdlen, pkt);
+                sdret = brcmf_sdcard_recv_pkt(bus->sdiodev, bus->sdiodev->sbwad,
+                                              SDIO_FUNC_2, F2SYNC, pkt);
                 bus->f2rxdata++;
 
                 if (sdret < 0) {
@@ -2085,14 +2079,6 @@ deliver:
         return rxcount;
 }
 
-static int
-brcmf_sdbrcm_send_buf(struct brcmf_bus *bus, u32 addr, uint fn, uint flags,
-                    u8 *buf, uint nbytes, struct sk_buff *pkt)
-{
-        return brcmf_sdcard_send_buf
-                (bus->sdiodev, addr, fn, flags, buf, nbytes, pkt);
-}
-
 static void
 brcmf_sdbrcm_wait_for_event(struct brcmf_bus *bus, bool *lockvar)
 {
@@ -2202,9 +2188,8 @@ static int brcmf_sdbrcm_txpkt(struct brcmf_bus *bus, struct sk_buff *pkt,
         if (len & (ALIGNMENT - 1))
                         len = roundup(len, ALIGNMENT);
 
-        ret = brcmf_sdbrcm_send_buf(bus, bus->sdiodev->sbwad,
-                                    SDIO_FUNC_2, F2SYNC, frame,
-                                    len, pkt);
+        ret = brcmf_sdcard_send_pkt(bus->sdiodev, bus->sdiodev->sbwad,
+                                    SDIO_FUNC_2, F2SYNC, pkt);
         bus->f2txdata++;
 
         if (ret < 0) {
@@ -2467,9 +2452,9 @@ clkwait:
                 (bus->clkstate == CLK_AVAIL)) {
                 int ret, i;
 
-                ret = brcmf_sdbrcm_send_buf(bus, bus->sdiodev->sbwad,
+                ret = brcmf_sdcard_send_buf(bus->sdiodev, bus->sdiodev->sbwad,
                         SDIO_FUNC_2, F2SYNC, (u8 *) bus->ctrl_frame_buf,
-                        (u32) bus->ctrl_frame_len, NULL);
+                        (u32) bus->ctrl_frame_len);
 
                 if (ret < 0) {
                         /* On failure, abort the command and
@@ -2772,8 +2757,8 @@ static int brcmf_tx_frame(struct brcmf_bus *bus, u8 *frame, u16 len)
         int ret;
 
         bus->ctrl_frame_stat = false;
-        ret = brcmf_sdbrcm_send_buf(bus, bus->sdiodev->sbwad,
-                                    SDIO_FUNC_2, F2SYNC, frame, len, NULL);
+        ret = brcmf_sdcard_send_buf(bus->sdiodev, bus->sdiodev->sbwad,
+                                    SDIO_FUNC_2, F2SYNC, frame, len);
 
         if (ret < 0) {
                 /* On failure, abort the command and terminate the frame */
diff --git a/drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h b/drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h
index 726fa8981113..85694ac2f420 100644
--- a/drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h
+++ b/drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h
@@ -182,11 +182,21 @@ extern bool brcmf_sdcard_regfail(struct brcmf_sdio_dev *sdiodev);
  * NOTE: Async operation is not currently supported.
  */
 extern int
+brcmf_sdcard_send_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
+                      uint flags, struct sk_buff *pkt);
+extern int
 brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
-                      uint flags, u8 *buf, uint nbytes, struct sk_buff *pkt);
+                      uint flags, u8 *buf, uint nbytes);
+
+extern int
+brcmf_sdcard_recv_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
+                      uint flags, struct sk_buff *pkt);
 extern int
 brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
-                      uint flags, u8 *buf, uint nbytes, struct sk_buff *pkt);
+                      uint flags, u8 *buf, uint nbytes);
+extern int
+brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
+                        uint flags, struct sk_buff_head *pktq);
 
 /* Flags bits */
 
@@ -240,6 +250,10 @@ brcmf_sdioh_request_buffer(struct brcmf_sdio_dev *sdiodev,
                            uint fix_inc, uint rw, uint fnc_num,
                            u32 addr, uint regwidth,
                            u32 buflen, u8 *buffer, struct sk_buff *pkt);
+extern int
+brcmf_sdioh_request_chain(struct brcmf_sdio_dev *sdiodev, uint fix_inc,
+                          uint write, uint func, uint addr,
+                          struct sk_buff_head *pktq);
 
 /* Watchdog timer interface for pm ops */
 extern void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev,