ath10k: make CE layer bus agnostic

Remove bus specific dependencies from CE layer
to have common CE layer across multiple targets.
This is required for adding support for WCN3990
chipset support as WCN3990 chipset uses SNOC
bus interface with Copy Engine endpoint.

Signed-off-by: Govind Singh <govinds@qti.qualcomm.com>
Signed-off-by: Kalle Valo <kvalo@qca.qualcomm.com>

diff --git a/drivers/net/wireless/ath/ath10k/ahb.c b/drivers/net/wireless/ath/ath10k/ahb.c
index da770af830369ffa66cfe7511786e05797d559d0..b36dd792fbb213c05bafc99de315ab59f7496581 100644 (file)
--- a/drivers/net/wireless/ath/ath10k/ahb.c
+++ b/drivers/net/wireless/ath/ath10k/ahb.c
@@ -787,8 +787,9 @@ static int ath10k_ahb_probe(struct platform_device *pdev)
        ar_pci->mem = ar_ahb->mem;
        ar_pci->mem_len = ar_ahb->mem_len;
        ar_pci->ar = ar;
-       ar_pci->bus_ops = &ath10k_ahb_bus_ops;
+       ar_pci->ce.bus_ops = &ath10k_ahb_bus_ops;
        ar_pci->targ_cpu_to_ce_addr = ath10k_ahb_qca4019_targ_cpu_to_ce_addr;
+       ar->ce_priv = &ar_pci->ce;
 
        ret = ath10k_pci_setup_resource(ar);
        if (ret) {

diff --git a/drivers/net/wireless/ath/ath10k/ce.c b/drivers/net/wireless/ath/ath10k/ce.c
index 08b84c8c36141d579fc09851d3034d6f06ce14cd..a8afd690290f642f5cf8f3b233a9906120204020 100644 (file)
--- a/drivers/net/wireless/ath/ath10k/ce.c
+++ b/drivers/net/wireless/ath/ath10k/ce.c
@@ -16,7 +16,6 @@
  */
 
 #include "hif.h"
-#include "pci.h"
 #include "ce.h"
 #include "debug.h"
 
@@ -33,7 +32,7 @@
  * Each ring consists of a number of descriptors which specify
  * an address, length, and meta-data.
  *
- * Typically, one side of the PCIe interconnect (Host or Target)
+ * Typically, one side of the PCIe/AHB/SNOC interconnect (Host or Target)
  * controls one ring and the other side controls the other ring.
  * The source side chooses when to initiate a transfer and it
  * chooses what to send (buffer address, length). The destination
@@ -73,57 +72,71 @@ ath10k_get_ring_byte(unsigned int offset,
        return ((offset & addr_map->mask) >> (addr_map->lsb));
 }
 
+static inline u32 ath10k_ce_read32(struct ath10k *ar, u32 offset)
+{
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
+
+       return ce->bus_ops->read32(ar, offset);
+}
+
+static inline void ath10k_ce_write32(struct ath10k *ar, u32 offset, u32 value)
+{
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
+
+       ce->bus_ops->write32(ar, offset, value);
+}
+
 static inline void ath10k_ce_dest_ring_write_index_set(struct ath10k *ar,
                                                       u32 ce_ctrl_addr,
                                                       unsigned int n)
 {
-       ath10k_pci_write32(ar, ce_ctrl_addr +
-                       ar->hw_ce_regs->dst_wr_index_addr, n);
+       ath10k_ce_write32(ar, ce_ctrl_addr +
+                         ar->hw_ce_regs->dst_wr_index_addr, n);
 }
 
 static inline u32 ath10k_ce_dest_ring_write_index_get(struct ath10k *ar,
                                                      u32 ce_ctrl_addr)
 {
-       return ath10k_pci_read32(ar, ce_ctrl_addr +
-                       ar->hw_ce_regs->dst_wr_index_addr);
+       return ath10k_ce_read32(ar, ce_ctrl_addr +
+                               ar->hw_ce_regs->dst_wr_index_addr);
 }
 
 static inline void ath10k_ce_src_ring_write_index_set(struct ath10k *ar,
                                                      u32 ce_ctrl_addr,
                                                      unsigned int n)
 {
-       ath10k_pci_write32(ar, ce_ctrl_addr +
-                       ar->hw_ce_regs->sr_wr_index_addr, n);
+       ath10k_ce_write32(ar, ce_ctrl_addr +
+                         ar->hw_ce_regs->sr_wr_index_addr, n);
 }
 
 static inline u32 ath10k_ce_src_ring_write_index_get(struct ath10k *ar,
                                                     u32 ce_ctrl_addr)
 {
-       return ath10k_pci_read32(ar, ce_ctrl_addr +
-                       ar->hw_ce_regs->sr_wr_index_addr);
+       return ath10k_ce_read32(ar, ce_ctrl_addr +
+                               ar->hw_ce_regs->sr_wr_index_addr);
 }
 
 static inline u32 ath10k_ce_src_ring_read_index_get(struct ath10k *ar,
                                                    u32 ce_ctrl_addr)
 {
-       return ath10k_pci_read32(ar, ce_ctrl_addr +
-                       ar->hw_ce_regs->current_srri_addr);
+       return ath10k_ce_read32(ar, ce_ctrl_addr +
+                               ar->hw_ce_regs->current_srri_addr);
 }
 
 static inline void ath10k_ce_src_ring_base_addr_set(struct ath10k *ar,
                                                    u32 ce_ctrl_addr,
                                                    unsigned int addr)
 {
-       ath10k_pci_write32(ar, ce_ctrl_addr +
-                       ar->hw_ce_regs->sr_base_addr, addr);
+       ath10k_ce_write32(ar, ce_ctrl_addr +
+                         ar->hw_ce_regs->sr_base_addr, addr);
 }
 
 static inline void ath10k_ce_src_ring_size_set(struct ath10k *ar,
                                               u32 ce_ctrl_addr,
                                               unsigned int n)
 {
-       ath10k_pci_write32(ar, ce_ctrl_addr +
-                       ar->hw_ce_regs->sr_size_addr, n);
+       ath10k_ce_write32(ar, ce_ctrl_addr +
+                         ar->hw_ce_regs->sr_size_addr, n);
 }
 
 static inline void ath10k_ce_src_ring_dmax_set(struct ath10k *ar,
@@ -131,12 +144,13 @@ static inline void ath10k_ce_src_ring_dmax_set(struct ath10k *ar,
                                               unsigned int n)
 {
        struct ath10k_hw_ce_ctrl1 *ctrl_regs = ar->hw_ce_regs->ctrl1_regs;
-       u32 ctrl1_addr = ath10k_pci_read32(ar,
-                                          ce_ctrl_addr + ctrl_regs->addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + ctrl_regs->addr,
-                          (ctrl1_addr &  ~(ctrl_regs->dmax->mask)) |
-                          ath10k_set_ring_byte(n, ctrl_regs->dmax));
+       u32 ctrl1_addr = ath10k_ce_read32(ar, ce_ctrl_addr +
+                                         ctrl_regs->addr);
+
+       ath10k_ce_write32(ar, ce_ctrl_addr + ctrl_regs->addr,
+                         (ctrl1_addr &  ~(ctrl_regs->dmax->mask)) |
+                         ath10k_set_ring_byte(n, ctrl_regs->dmax));
 }
 
 static inline void ath10k_ce_src_ring_byte_swap_set(struct ath10k *ar,
@@ -144,11 +158,13 @@ static inline void ath10k_ce_src_ring_byte_swap_set(struct ath10k *ar,
                                                    unsigned int n)
 {
        struct ath10k_hw_ce_ctrl1 *ctrl_regs = ar->hw_ce_regs->ctrl1_regs;
-       u32 ctrl1_addr = ath10k_pci_read32(ar, ce_ctrl_addr + ctrl_regs->addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + ctrl_regs->addr,
-                          (ctrl1_addr & ~(ctrl_regs->src_ring->mask)) |
-                          ath10k_set_ring_byte(n, ctrl_regs->src_ring));
+       u32 ctrl1_addr = ath10k_ce_read32(ar, ce_ctrl_addr +
+                                         ctrl_regs->addr);
+
+       ath10k_ce_write32(ar, ce_ctrl_addr + ctrl_regs->addr,
+                         (ctrl1_addr & ~(ctrl_regs->src_ring->mask)) |
+                         ath10k_set_ring_byte(n, ctrl_regs->src_ring));
 }
 
 static inline void ath10k_ce_dest_ring_byte_swap_set(struct ath10k *ar,
@@ -156,34 +172,36 @@ static inline void ath10k_ce_dest_ring_byte_swap_set(struct ath10k *ar,
                                                     unsigned int n)
 {
        struct ath10k_hw_ce_ctrl1 *ctrl_regs = ar->hw_ce_regs->ctrl1_regs;
-       u32 ctrl1_addr = ath10k_pci_read32(ar, ce_ctrl_addr + ctrl_regs->addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + ctrl_regs->addr,
-                          (ctrl1_addr & ~(ctrl_regs->dst_ring->mask)) |
-                          ath10k_set_ring_byte(n, ctrl_regs->dst_ring));
+       u32 ctrl1_addr = ath10k_ce_read32(ar, ce_ctrl_addr +
+                                         ctrl_regs->addr);
+
+       ath10k_ce_write32(ar, ce_ctrl_addr + ctrl_regs->addr,
+                         (ctrl1_addr & ~(ctrl_regs->dst_ring->mask)) |
+                         ath10k_set_ring_byte(n, ctrl_regs->dst_ring));
 }
 
 static inline u32 ath10k_ce_dest_ring_read_index_get(struct ath10k *ar,
                                                     u32 ce_ctrl_addr)
 {
-       return ath10k_pci_read32(ar, ce_ctrl_addr +
-                                ar->hw_ce_regs->current_drri_addr);
+       return ath10k_ce_read32(ar, ce_ctrl_addr +
+                               ar->hw_ce_regs->current_drri_addr);
 }
 
 static inline void ath10k_ce_dest_ring_base_addr_set(struct ath10k *ar,
                                                     u32 ce_ctrl_addr,
                                                     u32 addr)
 {
-       ath10k_pci_write32(ar, ce_ctrl_addr +
-                       ar->hw_ce_regs->dr_base_addr, addr);
+       ath10k_ce_write32(ar, ce_ctrl_addr +
+                         ar->hw_ce_regs->dr_base_addr, addr);
 }
 
 static inline void ath10k_ce_dest_ring_size_set(struct ath10k *ar,
                                                u32 ce_ctrl_addr,
                                                unsigned int n)
 {
-       ath10k_pci_write32(ar, ce_ctrl_addr +
-                       ar->hw_ce_regs->dr_size_addr, n);
+       ath10k_ce_write32(ar, ce_ctrl_addr +
+                         ar->hw_ce_regs->dr_size_addr, n);
 }
 
 static inline void ath10k_ce_src_ring_highmark_set(struct ath10k *ar,
@@ -191,11 +209,11 @@ static inline void ath10k_ce_src_ring_highmark_set(struct ath10k *ar,
                                                   unsigned int n)
 {
        struct ath10k_hw_ce_dst_src_wm_regs *srcr_wm = ar->hw_ce_regs->wm_srcr;
-       u32 addr = ath10k_pci_read32(ar, ce_ctrl_addr + srcr_wm->addr);
+       u32 addr = ath10k_ce_read32(ar, ce_ctrl_addr + srcr_wm->addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + srcr_wm->addr,
-                          (addr & ~(srcr_wm->wm_high->mask)) |
-                          (ath10k_set_ring_byte(n, srcr_wm->wm_high)));
+       ath10k_ce_write32(ar, ce_ctrl_addr + srcr_wm->addr,
+                         (addr & ~(srcr_wm->wm_high->mask)) |
+                         (ath10k_set_ring_byte(n, srcr_wm->wm_high)));
 }
 
 static inline void ath10k_ce_src_ring_lowmark_set(struct ath10k *ar,
@@ -203,11 +221,11 @@ static inline void ath10k_ce_src_ring_lowmark_set(struct ath10k *ar,
                                                  unsigned int n)
 {
        struct ath10k_hw_ce_dst_src_wm_regs *srcr_wm = ar->hw_ce_regs->wm_srcr;
-       u32 addr = ath10k_pci_read32(ar, ce_ctrl_addr + srcr_wm->addr);
+       u32 addr = ath10k_ce_read32(ar, ce_ctrl_addr + srcr_wm->addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + srcr_wm->addr,
-                          (addr & ~(srcr_wm->wm_low->mask)) |
-                          (ath10k_set_ring_byte(n, srcr_wm->wm_low)));
+       ath10k_ce_write32(ar, ce_ctrl_addr + srcr_wm->addr,
+                         (addr & ~(srcr_wm->wm_low->mask)) |
+                         (ath10k_set_ring_byte(n, srcr_wm->wm_low)));
 }
 
 static inline void ath10k_ce_dest_ring_highmark_set(struct ath10k *ar,
@@ -215,11 +233,11 @@ static inline void ath10k_ce_dest_ring_highmark_set(struct ath10k *ar,
                                                    unsigned int n)
 {
        struct ath10k_hw_ce_dst_src_wm_regs *dstr_wm = ar->hw_ce_regs->wm_dstr;
-       u32 addr = ath10k_pci_read32(ar, ce_ctrl_addr + dstr_wm->addr);
+       u32 addr = ath10k_ce_read32(ar, ce_ctrl_addr + dstr_wm->addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + dstr_wm->addr,
-                          (addr & ~(dstr_wm->wm_high->mask)) |
-                          (ath10k_set_ring_byte(n, dstr_wm->wm_high)));
+       ath10k_ce_write32(ar, ce_ctrl_addr + dstr_wm->addr,
+                         (addr & ~(dstr_wm->wm_high->mask)) |
+                         (ath10k_set_ring_byte(n, dstr_wm->wm_high)));
 }
 
 static inline void ath10k_ce_dest_ring_lowmark_set(struct ath10k *ar,
@@ -227,66 +245,73 @@ static inline void ath10k_ce_dest_ring_lowmark_set(struct ath10k *ar,
                                                   unsigned int n)
 {
        struct ath10k_hw_ce_dst_src_wm_regs *dstr_wm = ar->hw_ce_regs->wm_dstr;
-       u32 addr = ath10k_pci_read32(ar, ce_ctrl_addr + dstr_wm->addr);
+       u32 addr = ath10k_ce_read32(ar, ce_ctrl_addr + dstr_wm->addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + dstr_wm->addr,
-                          (addr & ~(dstr_wm->wm_low->mask)) |
-                          (ath10k_set_ring_byte(n, dstr_wm->wm_low)));
+       ath10k_ce_write32(ar, ce_ctrl_addr + dstr_wm->addr,
+                         (addr & ~(dstr_wm->wm_low->mask)) |
+                         (ath10k_set_ring_byte(n, dstr_wm->wm_low)));
 }
 
 static inline void ath10k_ce_copy_complete_inter_enable(struct ath10k *ar,
                                                        u32 ce_ctrl_addr)
 {
        struct ath10k_hw_ce_host_ie *host_ie = ar->hw_ce_regs->host_ie;
-       u32 host_ie_addr = ath10k_pci_read32(ar, ce_ctrl_addr +
-                                       ar->hw_ce_regs->host_ie_addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + ar->hw_ce_regs->host_ie_addr,
-                          host_ie_addr | host_ie->copy_complete->mask);
+       u32 host_ie_addr = ath10k_ce_read32(ar, ce_ctrl_addr +
+                                           ar->hw_ce_regs->host_ie_addr);
+
+       ath10k_ce_write32(ar, ce_ctrl_addr + ar->hw_ce_regs->host_ie_addr,
+                         host_ie_addr | host_ie->copy_complete->mask);
 }
 
 static inline void ath10k_ce_copy_complete_intr_disable(struct ath10k *ar,
                                                        u32 ce_ctrl_addr)
 {
        struct ath10k_hw_ce_host_ie *host_ie = ar->hw_ce_regs->host_ie;
-       u32 host_ie_addr = ath10k_pci_read32(ar, ce_ctrl_addr +
-                                       ar->hw_ce_regs->host_ie_addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + ar->hw_ce_regs->host_ie_addr,
-                          host_ie_addr & ~(host_ie->copy_complete->mask));
+       u32 host_ie_addr = ath10k_ce_read32(ar, ce_ctrl_addr +
+                                           ar->hw_ce_regs->host_ie_addr);
+
+       ath10k_ce_write32(ar, ce_ctrl_addr + ar->hw_ce_regs->host_ie_addr,
+                         host_ie_addr & ~(host_ie->copy_complete->mask));
 }
 
 static inline void ath10k_ce_watermark_intr_disable(struct ath10k *ar,
                                                    u32 ce_ctrl_addr)
 {
        struct ath10k_hw_ce_host_wm_regs *wm_regs = ar->hw_ce_regs->wm_regs;
-       u32 host_ie_addr = ath10k_pci_read32(ar, ce_ctrl_addr +
-                                       ar->hw_ce_regs->host_ie_addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + ar->hw_ce_regs->host_ie_addr,
-                          host_ie_addr & ~(wm_regs->wm_mask));
+       u32 host_ie_addr = ath10k_ce_read32(ar, ce_ctrl_addr +
+                                           ar->hw_ce_regs->host_ie_addr);
+
+       ath10k_ce_write32(ar, ce_ctrl_addr + ar->hw_ce_regs->host_ie_addr,
+                         host_ie_addr & ~(wm_regs->wm_mask));
 }
 
 static inline void ath10k_ce_error_intr_enable(struct ath10k *ar,
                                               u32 ce_ctrl_addr)
 {
        struct ath10k_hw_ce_misc_regs *misc_regs = ar->hw_ce_regs->misc_regs;
-       u32 misc_ie_addr = ath10k_pci_read32(ar, ce_ctrl_addr +
-                                       ar->hw_ce_regs->misc_ie_addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + ar->hw_ce_regs->misc_ie_addr,
-                          misc_ie_addr | misc_regs->err_mask);
+       u32 misc_ie_addr = ath10k_ce_read32(ar, ce_ctrl_addr +
+                                           ar->hw_ce_regs->misc_ie_addr);
+
+       ath10k_ce_write32(ar,
+                         ce_ctrl_addr + ar->hw_ce_regs->misc_ie_addr,
+                         misc_ie_addr | misc_regs->err_mask);
 }
 
 static inline void ath10k_ce_error_intr_disable(struct ath10k *ar,
                                                u32 ce_ctrl_addr)
 {
        struct ath10k_hw_ce_misc_regs *misc_regs = ar->hw_ce_regs->misc_regs;
-       u32 misc_ie_addr = ath10k_pci_read32(ar, ce_ctrl_addr +
-                                       ar->hw_ce_regs->misc_ie_addr);
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + ar->hw_ce_regs->misc_ie_addr,
-                          misc_ie_addr & ~(misc_regs->err_mask));
+       u32 misc_ie_addr = ath10k_ce_read32(ar,
+                       ce_ctrl_addr + ar->hw_ce_regs->misc_ie_addr);
+
+       ath10k_ce_write32(ar,
+                         ce_ctrl_addr + ar->hw_ce_regs->misc_ie_addr,
+                         misc_ie_addr & ~(misc_regs->err_mask));
 }
 
 static inline void ath10k_ce_engine_int_status_clear(struct ath10k *ar,
@@ -295,7 +320,7 @@ static inline void ath10k_ce_engine_int_status_clear(struct ath10k *ar,
 {
        struct ath10k_hw_ce_host_wm_regs *wm_regs = ar->hw_ce_regs->wm_regs;
 
-       ath10k_pci_write32(ar, ce_ctrl_addr + wm_regs->addr, mask);
+       ath10k_ce_write32(ar, ce_ctrl_addr + wm_regs->addr, mask);
 }
 
 /*
@@ -362,11 +387,11 @@ exit:
 void __ath10k_ce_send_revert(struct ath10k_ce_pipe *pipe)
 {
        struct ath10k *ar = pipe->ar;
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        struct ath10k_ce_ring *src_ring = pipe->src_ring;
        u32 ctrl_addr = pipe->ctrl_addr;
 
-       lockdep_assert_held(&ar_pci->ce_lock);
+       lockdep_assert_held(&ce->ce_lock);
 
        /*
         * This function must be called only if there is an incomplete
@@ -394,13 +419,13 @@ int ath10k_ce_send(struct ath10k_ce_pipe *ce_state,
                   unsigned int flags)
 {
        struct ath10k *ar = ce_state->ar;
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int ret;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
        ret = ath10k_ce_send_nolock(ce_state, per_transfer_context,
                                    buffer, nbytes, transfer_id, flags);
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        return ret;
 }
@@ -408,14 +433,14 @@ int ath10k_ce_send(struct ath10k_ce_pipe *ce_state,
 int ath10k_ce_num_free_src_entries(struct ath10k_ce_pipe *pipe)
 {
        struct ath10k *ar = pipe->ar;
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int delta;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
        delta = CE_RING_DELTA(pipe->src_ring->nentries_mask,
                              pipe->src_ring->write_index,
                              pipe->src_ring->sw_index - 1);
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        return delta;
 }
@@ -423,13 +448,13 @@ int ath10k_ce_num_free_src_entries(struct ath10k_ce_pipe *pipe)
 int __ath10k_ce_rx_num_free_bufs(struct ath10k_ce_pipe *pipe)
 {
        struct ath10k *ar = pipe->ar;
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        struct ath10k_ce_ring *dest_ring = pipe->dest_ring;
        unsigned int nentries_mask = dest_ring->nentries_mask;
        unsigned int write_index = dest_ring->write_index;
        unsigned int sw_index = dest_ring->sw_index;
 
-       lockdep_assert_held(&ar_pci->ce_lock);
+       lockdep_assert_held(&ce->ce_lock);
 
        return CE_RING_DELTA(nentries_mask, write_index, sw_index - 1);
 }
@@ -437,7 +462,7 @@ int __ath10k_ce_rx_num_free_bufs(struct ath10k_ce_pipe *pipe)
 int __ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr)
 {
        struct ath10k *ar = pipe->ar;
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        struct ath10k_ce_ring *dest_ring = pipe->dest_ring;
        unsigned int nentries_mask = dest_ring->nentries_mask;
        unsigned int write_index = dest_ring->write_index;
@@ -446,7 +471,7 @@ int __ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr)
        struct ce_desc *desc = CE_DEST_RING_TO_DESC(base, write_index);
        u32 ctrl_addr = pipe->ctrl_addr;
 
-       lockdep_assert_held(&ar_pci->ce_lock);
+       lockdep_assert_held(&ce->ce_lock);
 
        if ((pipe->id != 5) &&
            CE_RING_DELTA(nentries_mask, write_index, sw_index - 1) == 0)
@@ -486,12 +511,12 @@ void ath10k_ce_rx_update_write_idx(struct ath10k_ce_pipe *pipe, u32 nentries)
 int ath10k_ce_rx_post_buf(struct ath10k_ce_pipe *pipe, void *ctx, u32 paddr)
 {
        struct ath10k *ar = pipe->ar;
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int ret;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
        ret = __ath10k_ce_rx_post_buf(pipe, ctx, paddr);
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        return ret;
 }
@@ -554,14 +579,14 @@ int ath10k_ce_completed_recv_next(struct ath10k_ce_pipe *ce_state,
                                  unsigned int *nbytesp)
 {
        struct ath10k *ar = ce_state->ar;
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int ret;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
        ret = ath10k_ce_completed_recv_next_nolock(ce_state,
                                                   per_transfer_contextp,
                                                   nbytesp);
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        return ret;
 }
@@ -576,7 +601,7 @@ int ath10k_ce_revoke_recv_next(struct ath10k_ce_pipe *ce_state,
        unsigned int write_index;
        int ret;
        struct ath10k *ar;
-       struct ath10k_pci *ar_pci;
+       struct ath10k_ce *ce;
 
        dest_ring = ce_state->dest_ring;
 
@@ -584,9 +609,9 @@ int ath10k_ce_revoke_recv_next(struct ath10k_ce_pipe *ce_state,
                return -EIO;
 
        ar = ce_state->ar;
-       ar_pci = ath10k_pci_priv(ar);
+       ce = ath10k_ce_priv(ar);
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
 
        nentries_mask = dest_ring->nentries_mask;
        sw_index = dest_ring->sw_index;
@@ -614,7 +639,7 @@ int ath10k_ce_revoke_recv_next(struct ath10k_ce_pipe *ce_state,
                ret = -EIO;
        }
 
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        return ret;
 }
@@ -686,7 +711,7 @@ int ath10k_ce_cancel_send_next(struct ath10k_ce_pipe *ce_state,
        unsigned int write_index;
        int ret;
        struct ath10k *ar;
-       struct ath10k_pci *ar_pci;
+       struct ath10k_ce *ce;
 
        src_ring = ce_state->src_ring;
 
@@ -694,9 +719,9 @@ int ath10k_ce_cancel_send_next(struct ath10k_ce_pipe *ce_state,
                return -EIO;
 
        ar = ce_state->ar;
-       ar_pci = ath10k_pci_priv(ar);
+       ce = ath10k_ce_priv(ar);
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
 
        nentries_mask = src_ring->nentries_mask;
        sw_index = src_ring->sw_index;
@@ -727,7 +752,7 @@ int ath10k_ce_cancel_send_next(struct ath10k_ce_pipe *ce_state,
                ret = -EIO;
        }
 
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        return ret;
 }
@@ -736,13 +761,13 @@ int ath10k_ce_completed_send_next(struct ath10k_ce_pipe *ce_state,
                                  void **per_transfer_contextp)
 {
        struct ath10k *ar = ce_state->ar;
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int ret;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
        ret = ath10k_ce_completed_send_next_nolock(ce_state,
                                                   per_transfer_contextp);
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        return ret;
 }
@@ -755,17 +780,18 @@ int ath10k_ce_completed_send_next(struct ath10k_ce_pipe *ce_state,
  */
 void ath10k_ce_per_engine_service(struct ath10k *ar, unsigned int ce_id)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
-       struct ath10k_ce_pipe *ce_state = &ar_pci->ce_states[ce_id];
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
+       struct ath10k_ce_pipe *ce_state = &ce->ce_states[ce_id];
        struct ath10k_hw_ce_host_wm_regs *wm_regs = ar->hw_ce_regs->wm_regs;
        u32 ctrl_addr = ce_state->ctrl_addr;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
 
        /* Clear the copy-complete interrupts that will be handled here. */
-       ath10k_ce_engine_int_status_clear(ar, ctrl_addr, wm_regs->cc_mask);
+       ath10k_ce_engine_int_status_clear(ar, ctrl_addr,
+                                         wm_regs->cc_mask);
 
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        if (ce_state->recv_cb)
                ce_state->recv_cb(ce_state);
@@ -773,7 +799,7 @@ void ath10k_ce_per_engine_service(struct ath10k *ar, unsigned int ce_id)
        if (ce_state->send_cb)
                ce_state->send_cb(ce_state);
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
 
        /*
         * Misc CE interrupts are not being handled, but still need
@@ -781,7 +807,7 @@ void ath10k_ce_per_engine_service(struct ath10k *ar, unsigned int ce_id)
         */
        ath10k_ce_engine_int_status_clear(ar, ctrl_addr, wm_regs->wm_mask);
 
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 }
 
 /*
@@ -795,7 +821,7 @@ void ath10k_ce_per_engine_service_any(struct ath10k *ar)
        int ce_id;
        u32 intr_summary;
 
-       intr_summary = CE_INTERRUPT_SUMMARY(ar);
+       intr_summary = ath10k_ce_interrupt_summary(ar);
 
        for (ce_id = 0; intr_summary && (ce_id < CE_COUNT); ce_id++) {
                if (intr_summary & (1 << ce_id))
@@ -847,22 +873,25 @@ int ath10k_ce_disable_interrupts(struct ath10k *ar)
 
 void ath10k_ce_enable_interrupts(struct ath10k *ar)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int ce_id;
+       struct ath10k_ce_pipe *ce_state;
 
        /* Skip the last copy engine, CE7 the diagnostic window, as that
         * uses polling and isn't initialized for interrupts.
         */
-       for (ce_id = 0; ce_id < CE_COUNT - 1; ce_id++)
-               ath10k_ce_per_engine_handler_adjust(&ar_pci->ce_states[ce_id]);
+       for (ce_id = 0; ce_id < CE_COUNT - 1; ce_id++) {
+               ce_state  = &ce->ce_states[ce_id];
+               ath10k_ce_per_engine_handler_adjust(ce_state);
+       }
 }
 
 static int ath10k_ce_init_src_ring(struct ath10k *ar,
                                   unsigned int ce_id,
                                   const struct ce_attr *attr)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
-       struct ath10k_ce_pipe *ce_state = &ar_pci->ce_states[ce_id];
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
+       struct ath10k_ce_pipe *ce_state = &ce->ce_states[ce_id];
        struct ath10k_ce_ring *src_ring = ce_state->src_ring;
        u32 nentries, ctrl_addr = ath10k_ce_base_address(ar, ce_id);
 
@@ -898,8 +927,8 @@ static int ath10k_ce_init_dest_ring(struct ath10k *ar,
                                    unsigned int ce_id,
                                    const struct ce_attr *attr)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
-       struct ath10k_ce_pipe *ce_state = &ar_pci->ce_states[ce_id];
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
+       struct ath10k_ce_pipe *ce_state = &ce->ce_states[ce_id];
        struct ath10k_ce_ring *dest_ring = ce_state->dest_ring;
        u32 nentries, ctrl_addr = ath10k_ce_base_address(ar, ce_id);
 
@@ -1081,8 +1110,8 @@ void ath10k_ce_deinit_pipe(struct ath10k *ar, unsigned int ce_id)
 int ath10k_ce_alloc_pipe(struct ath10k *ar, int ce_id,
                         const struct ce_attr *attr)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
-       struct ath10k_ce_pipe *ce_state = &ar_pci->ce_states[ce_id];
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
+       struct ath10k_ce_pipe *ce_state = &ce->ce_states[ce_id];
        int ret;
 
        /*
@@ -1138,8 +1167,8 @@ int ath10k_ce_alloc_pipe(struct ath10k *ar, int ce_id,
 
 void ath10k_ce_free_pipe(struct ath10k *ar, int ce_id)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
-       struct ath10k_ce_pipe *ce_state = &ar_pci->ce_states[ce_id];
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
+       struct ath10k_ce_pipe *ce_state = &ce->ce_states[ce_id];
 
        if (ce_state->src_ring) {
                dma_free_coherent(ar->dev,
@@ -1168,38 +1197,38 @@ void ath10k_ce_free_pipe(struct ath10k *ar, int ce_id)
 void ath10k_ce_dump_registers(struct ath10k *ar,
                              struct ath10k_fw_crash_data *crash_data)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
-       struct ath10k_ce_crash_data ce;
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
+       struct ath10k_ce_crash_data ce_data;
        u32 addr, id;
 
        lockdep_assert_held(&ar->data_lock);
 
        ath10k_err(ar, "Copy Engine register dump:\n");
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
        for (id = 0; id < CE_COUNT; id++) {
                addr = ath10k_ce_base_address(ar, id);
-               ce.base_addr = cpu_to_le32(addr);
+               ce_data.base_addr = cpu_to_le32(addr);
 
-               ce.src_wr_idx =
+               ce_data.src_wr_idx =
                        cpu_to_le32(ath10k_ce_src_ring_write_index_get(ar, addr));
-               ce.src_r_idx =
+               ce_data.src_r_idx =
                        cpu_to_le32(ath10k_ce_src_ring_read_index_get(ar, addr));
-               ce.dst_wr_idx =
+               ce_data.dst_wr_idx =
                        cpu_to_le32(ath10k_ce_dest_ring_write_index_get(ar, addr));
-               ce.dst_r_idx =
+               ce_data.dst_r_idx =
                        cpu_to_le32(ath10k_ce_dest_ring_read_index_get(ar, addr));
 
                if (crash_data)
-                       crash_data->ce_crash_data[id] = ce;
+                       crash_data->ce_crash_data[id] = ce_data;
 
                ath10k_err(ar, "[%02d]: 0x%08x %3u %3u %3u %3u", id,
-                          le32_to_cpu(ce.base_addr),
-                          le32_to_cpu(ce.src_wr_idx),
-                          le32_to_cpu(ce.src_r_idx),
-                          le32_to_cpu(ce.dst_wr_idx),
-                          le32_to_cpu(ce.dst_r_idx));
+                          le32_to_cpu(ce_data.base_addr),
+                          le32_to_cpu(ce_data.src_wr_idx),
+                          le32_to_cpu(ce_data.src_r_idx),
+                          le32_to_cpu(ce_data.dst_wr_idx),
+                          le32_to_cpu(ce_data.dst_r_idx));
        }
 
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 }

diff --git a/drivers/net/wireless/ath/ath10k/ce.h b/drivers/net/wireless/ath/ath10k/ce.h
index 95743a57525dbd3779832c30bae7a35be045277f..bdec794704d9c18c50fc23b008e110ae177d190a 100644 (file)
--- a/drivers/net/wireless/ath/ath10k/ce.h
+++ b/drivers/net/wireless/ath/ath10k/ce.h
@@ -122,6 +122,24 @@ struct ath10k_ce_pipe {
 /* Copy Engine settable attributes */
 struct ce_attr;
 
+struct ath10k_bus_ops {
+       u32 (*read32)(struct ath10k *ar, u32 offset);
+       void (*write32)(struct ath10k *ar, u32 offset, u32 value);
+       int (*get_num_banks)(struct ath10k *ar);
+};
+
+static inline struct ath10k_ce *ath10k_ce_priv(struct ath10k *ar)
+{
+       return (struct ath10k_ce *)ar->ce_priv;
+}
+
+struct ath10k_ce {
+       /* protects CE info */
+       spinlock_t ce_lock;
+       const struct ath10k_bus_ops *bus_ops;
+       struct ath10k_ce_pipe ce_states[CE_COUNT_MAX];
+};
+
 /*==================Send====================*/
 
 /* ath10k_ce_send flags */
@@ -291,9 +309,13 @@ static inline u32 ath10k_ce_base_address(struct ath10k *ar, unsigned int ce_id)
                CE_WRAPPER_INTERRUPT_SUMMARY_HOST_MSI_LSB)
 #define CE_WRAPPER_INTERRUPT_SUMMARY_ADDRESS                   0x0000
 
-#define CE_INTERRUPT_SUMMARY(ar) \
-       CE_WRAPPER_INTERRUPT_SUMMARY_HOST_MSI_GET( \
-               ath10k_pci_read32((ar), CE_WRAPPER_BASE_ADDRESS + \
-               CE_WRAPPER_INTERRUPT_SUMMARY_ADDRESS))
+static inline u32 ath10k_ce_interrupt_summary(struct ath10k *ar)
+{
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
+
+       return CE_WRAPPER_INTERRUPT_SUMMARY_HOST_MSI_GET(
+               ce->bus_ops->read32((ar), CE_WRAPPER_BASE_ADDRESS +
+               CE_WRAPPER_INTERRUPT_SUMMARY_ADDRESS));
+}
 
 #endif /* _CE_H_ */

diff --git a/drivers/net/wireless/ath/ath10k/core.h b/drivers/net/wireless/ath/ath10k/core.h
index 1aa5cf12fce0864b931c43d71f43bce2b69f5630..2b499af722ad2856083b907c350202cdbd4afa69 100644 (file)
--- a/drivers/net/wireless/ath/ath10k/core.h
+++ b/drivers/net/wireless/ath/ath10k/core.h
@@ -993,6 +993,8 @@ struct ath10k {
                u32 reg_ack_cts_timeout_orig;
        } fw_coverage;
 
+       void *ce_priv;
+
        /* must be last */
        u8 drv_priv[0] __aligned(sizeof(void *));
 };

diff --git a/drivers/net/wireless/ath/ath10k/pci.c b/drivers/net/wireless/ath/ath10k/pci.c
index 7ebfc409018d4cb0ac60599a9350ab57e0b4ff77..6a91276ce4d7ef806adb67b0feecfd89e3111d9b 100644 (file)
--- a/drivers/net/wireless/ath/ath10k/pci.c
+++ b/drivers/net/wireless/ath/ath10k/pci.c
@@ -672,16 +672,16 @@ static u32 ath10k_bus_pci_read32(struct ath10k *ar, u32 offset)
 
 inline void ath10k_pci_write32(struct ath10k *ar, u32 offset, u32 value)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
 
-       ar_pci->bus_ops->write32(ar, offset, value);
+       ce->bus_ops->write32(ar, offset, value);
 }
 
 inline u32 ath10k_pci_read32(struct ath10k *ar, u32 offset)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
 
-       return ar_pci->bus_ops->read32(ar, offset);
+       return ce->bus_ops->read32(ar, offset);
 }
 
 u32 ath10k_pci_soc_read32(struct ath10k *ar, u32 addr)
@@ -761,7 +761,7 @@ static inline const char *ath10k_pci_get_irq_method(struct ath10k *ar)
 static int __ath10k_pci_rx_post_buf(struct ath10k_pci_pipe *pipe)
 {
        struct ath10k *ar = pipe->hif_ce_state;
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;
        struct sk_buff *skb;
        dma_addr_t paddr;
@@ -784,9 +784,9 @@ static int __ath10k_pci_rx_post_buf(struct ath10k_pci_pipe *pipe)
 
        ATH10K_SKB_RXCB(skb)->paddr = paddr;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
        ret = __ath10k_ce_rx_post_buf(ce_pipe, skb, paddr);
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
        if (ret) {
                dma_unmap_single(ar->dev, paddr, skb->len + skb_tailroom(skb),
                                 DMA_FROM_DEVICE);
@@ -801,6 +801,7 @@ static void ath10k_pci_rx_post_pipe(struct ath10k_pci_pipe *pipe)
 {
        struct ath10k *ar = pipe->hif_ce_state;
        struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;
        int ret, num;
 
@@ -810,9 +811,9 @@ static void ath10k_pci_rx_post_pipe(struct ath10k_pci_pipe *pipe)
        if (!ce_pipe->dest_ring)
                return;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
        num = __ath10k_ce_rx_num_free_bufs(ce_pipe);
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        while (num >= 0) {
                ret = __ath10k_pci_rx_post_buf(pipe);
@@ -882,6 +883,7 @@ static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
                                    int nbytes)
 {
        struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int ret = 0;
        u32 *buf;
        unsigned int completed_nbytes, alloc_nbytes, remaining_bytes;
@@ -892,7 +894,7 @@ static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
        void *data_buf = NULL;
        int i;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
 
        ce_diag = ar_pci->ce_diag;
 
@@ -986,7 +988,7 @@ done:
                dma_free_coherent(ar->dev, alloc_nbytes, data_buf,
                                  ce_data_base);
 
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        return ret;
 }
@@ -1034,6 +1036,7 @@ int ath10k_pci_diag_write_mem(struct ath10k *ar, u32 address,
                              const void *data, int nbytes)
 {
        struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int ret = 0;
        u32 *buf;
        unsigned int completed_nbytes, orig_nbytes, remaining_bytes;
@@ -1043,7 +1046,7 @@ int ath10k_pci_diag_write_mem(struct ath10k *ar, u32 address,
        dma_addr_t ce_data_base = 0;
        int i;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
 
        ce_diag = ar_pci->ce_diag;
 
@@ -1147,7 +1150,7 @@ done:
                ath10k_warn(ar, "failed to write diag value at 0x%x: %d\n",
                            address, ret);
 
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
 
        return ret;
 }
@@ -1342,6 +1345,7 @@ int ath10k_pci_hif_tx_sg(struct ath10k *ar, u8 pipe_id,
                         struct ath10k_hif_sg_item *items, int n_items)
 {
        struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        struct ath10k_pci_pipe *pci_pipe = &ar_pci->pipe_info[pipe_id];
        struct ath10k_ce_pipe *ce_pipe = pci_pipe->ce_hdl;
        struct ath10k_ce_ring *src_ring = ce_pipe->src_ring;
@@ -1350,7 +1354,7 @@ int ath10k_pci_hif_tx_sg(struct ath10k *ar, u8 pipe_id,
        unsigned int write_index;
        int err, i = 0;
 
-       spin_lock_bh(&ar_pci->ce_lock);
+       spin_lock_bh(&ce->ce_lock);
 
        nentries_mask = src_ring->nentries_mask;
        sw_index = src_ring->sw_index;
@@ -1396,14 +1400,14 @@ int ath10k_pci_hif_tx_sg(struct ath10k *ar, u8 pipe_id,
        if (err)
                goto err;
 
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
        return 0;
 
 err:
        for (; i > 0; i--)
                __ath10k_ce_send_revert(ce_pipe);
 
-       spin_unlock_bh(&ar_pci->ce_lock);
+       spin_unlock_bh(&ce->ce_lock);
        return err;
 }
 
@@ -2000,9 +2004,9 @@ static int ath10k_pci_get_num_banks(struct ath10k *ar)
 
 static int ath10k_bus_get_num_banks(struct ath10k *ar)
 {
-       struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
 
-       return ar_pci->bus_ops->get_num_banks(ar);
+       return ce->bus_ops->get_num_banks(ar);
 }
 
 int ath10k_pci_init_config(struct ath10k *ar)
@@ -2173,11 +2177,12 @@ int ath10k_pci_alloc_pipes(struct ath10k *ar)
 {
        struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
        struct ath10k_pci_pipe *pipe;
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int i, ret;
 
        for (i = 0; i < CE_COUNT; i++) {
                pipe = &ar_pci->pipe_info[i];
-               pipe->ce_hdl = &ar_pci->ce_states[i];
+               pipe->ce_hdl = &ce->ce_states[i];
                pipe->pipe_num = i;
                pipe->hif_ce_state = ar;
 
@@ -2825,7 +2830,7 @@ static int ath10k_pci_napi_poll(struct napi_struct *ctx, int budget)
                 * interrupts safer to check for pending interrupts for
                 * immediate servicing.
                 */
-               if (CE_INTERRUPT_SUMMARY(ar)) {
+               if (ath10k_ce_interrupt_summary(ar)) {
                        napi_reschedule(ctx);
                        goto out;
                }
@@ -3142,9 +3147,10 @@ static bool ath10k_pci_chip_is_supported(u32 dev_id, u32 chip_id)
 int ath10k_pci_setup_resource(struct ath10k *ar)
 {
        struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
+       struct ath10k_ce *ce = ath10k_ce_priv(ar);
        int ret;
 
-       spin_lock_init(&ar_pci->ce_lock);
+       spin_lock_init(&ce->ce_lock);
        spin_lock_init(&ar_pci->ps_lock);
 
        setup_timer(&ar_pci->rx_post_retry, ath10k_pci_rx_replenish_retry,
@@ -3263,10 +3269,11 @@ static int ath10k_pci_probe(struct pci_dev *pdev,
        ar_pci->ar = ar;
        ar->dev_id = pci_dev->device;
        ar_pci->pci_ps = pci_ps;
-       ar_pci->bus_ops = &ath10k_pci_bus_ops;
+       ar_pci->ce.bus_ops = &ath10k_pci_bus_ops;
        ar_pci->pci_soft_reset = pci_soft_reset;
        ar_pci->pci_hard_reset = pci_hard_reset;
        ar_pci->targ_cpu_to_ce_addr = targ_cpu_to_ce_addr;
+       ar->ce_priv = &ar_pci->ce;
 
        ar->id.vendor = pdev->vendor;
        ar->id.device = pdev->device;

diff --git a/drivers/net/wireless/ath/ath10k/pci.h b/drivers/net/wireless/ath/ath10k/pci.h
index c1e08ad6394039559045d73d8500cdbf5ee9e521..424ff323b2dc6397727c09344f25f08914eabcda 100644 (file)
--- a/drivers/net/wireless/ath/ath10k/pci.h
+++ b/drivers/net/wireless/ath/ath10k/pci.h
@@ -150,12 +150,6 @@ struct ath10k_pci_supp_chip {
        u32 rev_id;
 };
 
-struct ath10k_bus_ops {
-       u32 (*read32)(struct ath10k *ar, u32 offset);
-       void (*write32)(struct ath10k *ar, u32 offset, u32 value);
-       int (*get_num_banks)(struct ath10k *ar);
-};
-
 enum ath10k_pci_irq_mode {
        ATH10K_PCI_IRQ_AUTO = 0,
        ATH10K_PCI_IRQ_LEGACY = 1,
@@ -177,11 +171,7 @@ struct ath10k_pci {
        /* Copy Engine used for Diagnostic Accesses */
        struct ath10k_ce_pipe *ce_diag;
 
-       /* FIXME: document what this really protects */
-       spinlock_t ce_lock;
-
-       /* Map CE id to ce_state */
-       struct ath10k_ce_pipe ce_states[CE_COUNT_MAX];
+       struct ath10k_ce ce;
        struct timer_list rx_post_retry;
 
        /* Due to HW quirks it is recommended to disable ASPM during device
@@ -225,8 +215,6 @@ struct ath10k_pci {
         */
        bool pci_ps;
 
-       const struct ath10k_bus_ops *bus_ops;
-
        /* Chip specific pci reset routine used to do a safe reset */
        int (*pci_soft_reset)(struct ath10k *ar);