ath6kl: Merge scatter gather setup functions for two method

Signed-off-by: Vasanthakumar Thiagarajan <vthiagar@qca.qualcomm.com>
Signed-off-by: Kalle Valo <kvalo@qca.qualcomm.com>

diff --git a/drivers/net/wireless/ath/ath6kl/hif.h b/drivers/net/wireless/ath/ath6kl/hif.h
index 1458660a1c034b969ad0333c43b9ad27311e4ef6..d5a79911bdc9f50b1e65baadc938fcb91104fa09 100644 (file)
--- a/drivers/net/wireless/ath/ath6kl/hif.h
+++ b/drivers/net/wireless/ath/ath6kl/hif.h
@@ -187,6 +187,7 @@ struct hif_scatter_req {
 struct hif_dev_scat_sup_info {
        int max_scat_entries;
        int max_xfer_szper_scatreq;
+       bool virt_scat;
 };
 
 struct ath6kl_hif_ops {

diff --git a/drivers/net/wireless/ath/ath6kl/htc_hif.c b/drivers/net/wireless/ath/ath6kl/htc_hif.c
index 40853cbad365c4176ff2ccd5fab5bdc841b595f7..33887ccce0344a2a205bcf60c622f4e01397a50e 100644 (file)
--- a/drivers/net/wireless/ath/ath6kl/htc_hif.c
+++ b/drivers/net/wireless/ath/ath6kl/htc_hif.c
@@ -273,7 +273,7 @@ int ath6kldev_submit_scat_req(struct ath6kl_device *dev,
                   scat_req->addr, !read ? "async" : "sync",
                   (read) ? "rd" : "wr");
 
-       if (!read && dev->virt_scat)
+       if (!read && dev->hif_scat_info.virt_scat)
                status = ath6kldev_cp_scat_dma_buf(scat_req, false);
 
        if (status) {
@@ -285,7 +285,7 @@ int ath6kldev_submit_scat_req(struct ath6kl_device *dev,
                return status;
        }
 
-       if (dev->virt_scat)
+       if (dev->hif_scat_info.virt_scat)
                status =  ath6kldev_rw_scatter(dev->ar, scat_req);
        else
                status = ath6kl_hif_scat_req_rw(dev->ar, scat_req);
@@ -293,7 +293,7 @@ int ath6kldev_submit_scat_req(struct ath6kl_device *dev,
        if (read) {
                /* in sync mode, we can touch the scatter request */
                scat_req->status = status;
-               if (!status && dev->virt_scat)
+               if (!status && dev->hif_scat_info.virt_scat)
                        scat_req->status =
                                ath6kldev_cp_scat_dma_buf(scat_req, true);
        }
@@ -301,78 +301,9 @@ int ath6kldev_submit_scat_req(struct ath6kl_device *dev,
        return status;
 }
 
-/*
- * function to set up virtual scatter support if HIF
- * layer has not implemented the interface.
- */
-static int ath6kldev_setup_virt_scat_sup(struct ath6kl_device *dev)
-{
-       struct hif_scatter_req *scat_req;
-       int buf_sz, scat_req_sz, scat_list_sz;
-       int i, status = 0;
-       u8 *virt_dma_buf;
-
-       buf_sz = 2 * L1_CACHE_BYTES + ATH6KL_MAX_TRANSFER_SIZE_PER_SCATTER;
-
-       scat_list_sz = (ATH6KL_SCATTER_ENTRIES_PER_REQ - 1) *
-                      sizeof(struct hif_scatter_item);
-       scat_req_sz = sizeof(*scat_req) + scat_list_sz;
-
-       for (i = 0; i < ATH6KL_SCATTER_REQS; i++) {
-               scat_req = kzalloc(scat_req_sz, GFP_KERNEL);
-
-               if (!scat_req) {
-                       status = -ENOMEM;
-                       break;
-               }
-
-               virt_dma_buf = kzalloc(buf_sz, GFP_KERNEL);
-               if (!virt_dma_buf) {
-                       kfree(scat_req);
-                       status = -ENOMEM;
-                       break;
-               }
-
-               scat_req->virt_dma_buf =
-                       (u8 *)L1_CACHE_ALIGN((unsigned long)virt_dma_buf);
-
-               /* we emulate a DMA bounce interface */
-               hif_scatter_req_add(dev->ar, scat_req);
-       }
-
-       if (status)
-               ath6kl_hif_cleanup_scatter(dev->ar);
-       else {
-               dev->hif_scat_info.max_scat_entries =
-                       ATH6KL_SCATTER_ENTRIES_PER_REQ;
-               dev->hif_scat_info.max_xfer_szper_scatreq =
-                       ATH6KL_MAX_TRANSFER_SIZE_PER_SCATTER;
-               dev->virt_scat = true;
-       }
-
-       return status;
-}
-
 int ath6kldev_setup_msg_bndl(struct ath6kl_device *dev, int max_msg_per_trans)
 {
-       int status;
-
-       status = ath6kl_hif_enable_scatter(dev->ar, &dev->hif_scat_info);
-
-       if (status) {
-               ath6kl_warn("hif does not support scatter requests (%d)\n",
-                           status);
-
-               /* we can try to use a virtual DMA scatter mechanism */
-               status = ath6kldev_setup_virt_scat_sup(dev);
-       }
-
-       if (!status)
-               ath6kl_dbg(ATH6KL_DBG_ANY, "max scatter items:%d: maxlen:%d\n",
-                          dev->hif_scat_info.max_scat_entries,
-                          dev->hif_scat_info.max_xfer_szper_scatreq);
-
-       return status;
+       return ath6kl_hif_enable_scatter(dev->ar, &dev->hif_scat_info);
 }
 
 static int ath6kldev_proc_counter_intr(struct ath6kl_device *dev)

diff --git a/drivers/net/wireless/ath/ath6kl/htc_hif.h b/drivers/net/wireless/ath/ath6kl/htc_hif.h
index d770d4ec612e513fa96413347e1b27e7a9fd7ec8..3514c22f72186ccabfc020d9c90979e5d06c9922 100644 (file)
--- a/drivers/net/wireless/ath/ath6kl/htc_hif.h
+++ b/drivers/net/wireless/ath/ath6kl/htc_hif.h
@@ -87,7 +87,6 @@ struct ath6kl_device {
        int (*msg_pending) (struct htc_target *target, u32 lk_ahds[],
                            int *npkts_fetched);
        struct hif_dev_scat_sup_info hif_scat_info;
-       bool virt_scat;
        int max_rx_bndl_sz;
        int max_tx_bndl_sz;
        int chk_irq_status_cnt;

diff --git a/drivers/net/wireless/ath/ath6kl/sdio.c b/drivers/net/wireless/ath/ath6kl/sdio.c
index 9220a01915b1a29115142f40b38978e27ae54569..96a112ef34b44803b180da6a88d9123e788ad6a7 100644 (file)
--- a/drivers/net/wireless/ath/ath6kl/sdio.c
+++ b/drivers/net/wireless/ath/ath6kl/sdio.c
@@ -275,13 +275,17 @@ static int ath6kl_sdio_alloc_prep_scat_req(struct ath6kl_sdio *ar_sdio,
 {
        struct hif_scatter_req *s_req;
        struct bus_request *bus_req;
-       int i, scat_req_sz, scat_list_sz, sg_sz = 0;
+       int i, scat_req_sz, scat_list_sz, sg_sz, buf_sz;
+       u8 *virt_buf;
 
        scat_list_sz = (n_scat_entry - 1) * sizeof(struct hif_scatter_item);
        scat_req_sz = sizeof(*s_req) + scat_list_sz;
 
        if (!virt_scat)
                sg_sz = sizeof(struct scatterlist) * n_scat_entry;
+       else
+               buf_sz =  2 * L1_CACHE_BYTES +
+                         ATH6KL_MAX_TRANSFER_SIZE_PER_SCATTER;
 
        for (i = 0; i < n_scat_req; i++) {
                /* allocate the scatter request */
@@ -289,7 +293,16 @@ static int ath6kl_sdio_alloc_prep_scat_req(struct ath6kl_sdio *ar_sdio,
                if (!s_req)
                        return -ENOMEM;
 
-               if (sg_sz) {
+               if (virt_scat) {
+                       virt_buf = kzalloc(buf_sz, GFP_KERNEL);
+                       if (!virt_buf) {
+                               kfree(s_req);
+                               return -ENOMEM;
+                       }
+
+                       s_req->virt_dma_buf =
+                               (u8 *)L1_CACHE_ALIGN((unsigned long)virt_buf);
+               } else {
                        /* allocate sglist */
                        s_req->sgentries = kzalloc(sg_sz, GFP_KERNEL);
 
@@ -303,6 +316,7 @@ static int ath6kl_sdio_alloc_prep_scat_req(struct ath6kl_sdio *ar_sdio,
                bus_req = ath6kl_sdio_alloc_busreq(ar_sdio);
                if (!bus_req) {
                        kfree(s_req->sgentries);
+                       kfree(s_req->virt_dma_buf);
                        kfree(s_req);
                        return -ENOMEM;
                }
@@ -629,31 +643,58 @@ static int ath6kl_sdio_enable_scatter(struct ath6kl *ar,
                                      struct hif_dev_scat_sup_info *pinfo)
 {
        struct ath6kl_sdio *ar_sdio = ath6kl_sdio_priv(ar);
-       int ret = 0;
+       int ret;
+       bool virt_scat = false;
 
        /* check if host supports scatter and it meets our requirements */
        if (ar_sdio->func->card->host->max_segs < MAX_SCATTER_ENTRIES_PER_REQ) {
-               ath6kl_err("hif-scatter: host only supports scatter of : %d entries, need: %d\n",
+               ath6kl_err("host only supports scatter of :%d entries, need: %d\n",
                           ar_sdio->func->card->host->max_segs,
                           MAX_SCATTER_ENTRIES_PER_REQ);
-               return -EINVAL;
+               virt_scat = true;
+       }
+
+       if (!virt_scat) {
+               ret = ath6kl_sdio_alloc_prep_scat_req(ar_sdio,
+                               MAX_SCATTER_ENTRIES_PER_REQ,
+                               MAX_SCATTER_REQUESTS, virt_scat);
+
+               if (!ret) {
+                       ath6kl_dbg(ATH6KL_DBG_ANY,
+                                  "hif-scatter enabled: max scatter req : %d entries: %d\n",
+                                  MAX_SCATTER_REQUESTS,
+                                  MAX_SCATTER_ENTRIES_PER_REQ);
+
+                       pinfo->max_scat_entries = MAX_SCATTER_ENTRIES_PER_REQ;
+                       pinfo->max_xfer_szper_scatreq =
+                                               MAX_SCATTER_REQ_TRANSFER_SIZE;
+               } else {
+                       ath6kl_sdio_cleanup_scatter(ar);
+                       ath6kl_warn("hif scatter resource setup failed, trying virtual scatter method\n");
+               }
        }
 
-       ath6kl_dbg(ATH6KL_DBG_ANY,
-                  "hif-scatter enabled: max scatter req : %d entries: %d\n",
-                  MAX_SCATTER_REQUESTS, MAX_SCATTER_ENTRIES_PER_REQ);
+       if (virt_scat || ret) {
+               ret = ath6kl_sdio_alloc_prep_scat_req(ar_sdio,
+                               ATH6KL_SCATTER_ENTRIES_PER_REQ,
+                               ATH6KL_SCATTER_REQS, virt_scat);
 
-       ret = ath6kl_sdio_alloc_prep_scat_req(ar_sdio,
-                                             MAX_SCATTER_ENTRIES_PER_REQ,
-                                             MAX_SCATTER_REQUESTS, 0);
-       if (ret) {
-               ath6kl_err("hif-scatter: failed to alloc scatter resources !\n");
-               ath6kl_sdio_cleanup_scatter(ar);
-               return ret;
+               if (ret) {
+                       ath6kl_err("failed to alloc virtual scatter resources !\n");
+                       ath6kl_sdio_cleanup_scatter(ar);
+                       return ret;
+               }
+
+               ath6kl_dbg(ATH6KL_DBG_ANY,
+                          "Vitual scatter enabled, max_scat_req:%d, entries:%d\n",
+                          ATH6KL_SCATTER_REQS, ATH6KL_SCATTER_ENTRIES_PER_REQ);
+
+               pinfo->max_scat_entries = ATH6KL_SCATTER_ENTRIES_PER_REQ;
+               pinfo->max_xfer_szper_scatreq =
+                                       ATH6KL_MAX_TRANSFER_SIZE_PER_SCATTER;
        }
 
-       pinfo->max_scat_entries = MAX_SCATTER_ENTRIES_PER_REQ;
-       pinfo->max_xfer_szper_scatreq = MAX_SCATTER_REQ_TRANSFER_SIZE;
+       pinfo->virt_scat = virt_scat;
 
        return 0;
 }