2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 #include <linux/pci.h>
19 #include <linux/module.h>
20 #include <linux/interrupt.h>
21 #include <linux/spinlock.h>
22 #include <linux/bitops.h>
27 #include "targaddrs.h"
36 enum ath10k_pci_reset_mode {
37 ATH10K_PCI_RESET_AUTO = 0,
38 ATH10K_PCI_RESET_WARM_ONLY = 1,
41 static unsigned int ath10k_pci_irq_mode = ATH10K_PCI_IRQ_AUTO;
42 static unsigned int ath10k_pci_reset_mode = ATH10K_PCI_RESET_AUTO;
44 module_param_named(irq_mode, ath10k_pci_irq_mode, uint, 0644);
45 MODULE_PARM_DESC(irq_mode, "0: auto, 1: legacy, 2: msi (default: 0)");
47 module_param_named(reset_mode, ath10k_pci_reset_mode, uint, 0644);
48 MODULE_PARM_DESC(reset_mode, "0: auto, 1: warm only (default: 0)");
50 /* how long wait to wait for target to initialise, in ms */
51 #define ATH10K_PCI_TARGET_WAIT 3000
52 #define ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS 3
54 static const struct pci_device_id ath10k_pci_id_table[] = {
55 { PCI_VDEVICE(ATHEROS, QCA988X_2_0_DEVICE_ID) }, /* PCI-E QCA988X V2 */
56 { PCI_VDEVICE(ATHEROS, QCA6164_2_1_DEVICE_ID) }, /* PCI-E QCA6164 V2.1 */
57 { PCI_VDEVICE(ATHEROS, QCA6174_2_1_DEVICE_ID) }, /* PCI-E QCA6174 V2.1 */
58 { PCI_VDEVICE(ATHEROS, QCA99X0_2_0_DEVICE_ID) }, /* PCI-E QCA99X0 V2 */
59 { PCI_VDEVICE(ATHEROS, QCA9984_1_0_DEVICE_ID) }, /* PCI-E QCA9984 V1 */
60 { PCI_VDEVICE(ATHEROS, QCA9377_1_0_DEVICE_ID) }, /* PCI-E QCA9377 V1 */
61 { PCI_VDEVICE(ATHEROS, QCA9887_1_0_DEVICE_ID) }, /* PCI-E QCA9887 */
65 static const struct ath10k_pci_supp_chip ath10k_pci_supp_chips[] = {
66 /* QCA988X pre 2.0 chips are not supported because they need some nasty
67 * hacks. ath10k doesn't have them and these devices crash horribly
70 { QCA988X_2_0_DEVICE_ID, QCA988X_HW_2_0_CHIP_ID_REV },
72 { QCA6164_2_1_DEVICE_ID, QCA6174_HW_2_1_CHIP_ID_REV },
73 { QCA6164_2_1_DEVICE_ID, QCA6174_HW_2_2_CHIP_ID_REV },
74 { QCA6164_2_1_DEVICE_ID, QCA6174_HW_3_0_CHIP_ID_REV },
75 { QCA6164_2_1_DEVICE_ID, QCA6174_HW_3_1_CHIP_ID_REV },
76 { QCA6164_2_1_DEVICE_ID, QCA6174_HW_3_2_CHIP_ID_REV },
78 { QCA6174_2_1_DEVICE_ID, QCA6174_HW_2_1_CHIP_ID_REV },
79 { QCA6174_2_1_DEVICE_ID, QCA6174_HW_2_2_CHIP_ID_REV },
80 { QCA6174_2_1_DEVICE_ID, QCA6174_HW_3_0_CHIP_ID_REV },
81 { QCA6174_2_1_DEVICE_ID, QCA6174_HW_3_1_CHIP_ID_REV },
82 { QCA6174_2_1_DEVICE_ID, QCA6174_HW_3_2_CHIP_ID_REV },
84 { QCA99X0_2_0_DEVICE_ID, QCA99X0_HW_2_0_CHIP_ID_REV },
86 { QCA9984_1_0_DEVICE_ID, QCA9984_HW_1_0_CHIP_ID_REV },
88 { QCA9377_1_0_DEVICE_ID, QCA9377_HW_1_0_CHIP_ID_REV },
89 { QCA9377_1_0_DEVICE_ID, QCA9377_HW_1_1_CHIP_ID_REV },
91 { QCA9887_1_0_DEVICE_ID, QCA9887_HW_1_0_CHIP_ID_REV },
94 static void ath10k_pci_buffer_cleanup(struct ath10k *ar);
95 static int ath10k_pci_cold_reset(struct ath10k *ar);
96 static int ath10k_pci_safe_chip_reset(struct ath10k *ar);
97 static int ath10k_pci_init_irq(struct ath10k *ar);
98 static int ath10k_pci_deinit_irq(struct ath10k *ar);
99 static int ath10k_pci_request_irq(struct ath10k *ar);
100 static void ath10k_pci_free_irq(struct ath10k *ar);
101 static int ath10k_pci_bmi_wait(struct ath10k_ce_pipe *tx_pipe,
102 struct ath10k_ce_pipe *rx_pipe,
103 struct bmi_xfer *xfer);
104 static int ath10k_pci_qca99x0_chip_reset(struct ath10k *ar);
105 static void ath10k_pci_htc_tx_cb(struct ath10k_ce_pipe *ce_state);
106 static void ath10k_pci_htc_rx_cb(struct ath10k_ce_pipe *ce_state);
107 static void ath10k_pci_htt_tx_cb(struct ath10k_ce_pipe *ce_state);
108 static void ath10k_pci_htt_rx_cb(struct ath10k_ce_pipe *ce_state);
109 static void ath10k_pci_htt_htc_rx_cb(struct ath10k_ce_pipe *ce_state);
110 static void ath10k_pci_pktlog_rx_cb(struct ath10k_ce_pipe *ce_state);
112 static struct ce_attr host_ce_config_wlan[] = {
113 /* CE0: host->target HTC control and raw streams */
115 .flags = CE_ATTR_FLAGS,
119 .send_cb = ath10k_pci_htc_tx_cb,
122 /* CE1: target->host HTT + HTC control */
124 .flags = CE_ATTR_FLAGS,
127 .dest_nentries = 512,
128 .recv_cb = ath10k_pci_htt_htc_rx_cb,
131 /* CE2: target->host WMI */
133 .flags = CE_ATTR_FLAGS,
136 .dest_nentries = 128,
137 .recv_cb = ath10k_pci_htc_rx_cb,
140 /* CE3: host->target WMI */
142 .flags = CE_ATTR_FLAGS,
146 .send_cb = ath10k_pci_htc_tx_cb,
149 /* CE4: host->target HTT */
151 .flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,
152 .src_nentries = CE_HTT_H2T_MSG_SRC_NENTRIES,
155 .send_cb = ath10k_pci_htt_tx_cb,
158 /* CE5: target->host HTT (HIF->HTT) */
160 .flags = CE_ATTR_FLAGS,
163 .dest_nentries = 512,
164 .recv_cb = ath10k_pci_htt_rx_cb,
167 /* CE6: target autonomous hif_memcpy */
169 .flags = CE_ATTR_FLAGS,
175 /* CE7: ce_diag, the Diagnostic Window */
177 .flags = CE_ATTR_FLAGS,
179 .src_sz_max = DIAG_TRANSFER_LIMIT,
183 /* CE8: target->host pktlog */
185 .flags = CE_ATTR_FLAGS,
188 .dest_nentries = 128,
189 .recv_cb = ath10k_pci_pktlog_rx_cb,
192 /* CE9 target autonomous qcache memcpy */
194 .flags = CE_ATTR_FLAGS,
200 /* CE10: target autonomous hif memcpy */
202 .flags = CE_ATTR_FLAGS,
208 /* CE11: target autonomous hif memcpy */
210 .flags = CE_ATTR_FLAGS,
217 /* Target firmware's Copy Engine configuration. */
218 static struct ce_pipe_config target_ce_config_wlan[] = {
219 /* CE0: host->target HTC control and raw streams */
221 .pipenum = __cpu_to_le32(0),
222 .pipedir = __cpu_to_le32(PIPEDIR_OUT),
223 .nentries = __cpu_to_le32(32),
224 .nbytes_max = __cpu_to_le32(256),
225 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
226 .reserved = __cpu_to_le32(0),
229 /* CE1: target->host HTT + HTC control */
231 .pipenum = __cpu_to_le32(1),
232 .pipedir = __cpu_to_le32(PIPEDIR_IN),
233 .nentries = __cpu_to_le32(32),
234 .nbytes_max = __cpu_to_le32(2048),
235 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
236 .reserved = __cpu_to_le32(0),
239 /* CE2: target->host WMI */
241 .pipenum = __cpu_to_le32(2),
242 .pipedir = __cpu_to_le32(PIPEDIR_IN),
243 .nentries = __cpu_to_le32(64),
244 .nbytes_max = __cpu_to_le32(2048),
245 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
246 .reserved = __cpu_to_le32(0),
249 /* CE3: host->target WMI */
251 .pipenum = __cpu_to_le32(3),
252 .pipedir = __cpu_to_le32(PIPEDIR_OUT),
253 .nentries = __cpu_to_le32(32),
254 .nbytes_max = __cpu_to_le32(2048),
255 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
256 .reserved = __cpu_to_le32(0),
259 /* CE4: host->target HTT */
261 .pipenum = __cpu_to_le32(4),
262 .pipedir = __cpu_to_le32(PIPEDIR_OUT),
263 .nentries = __cpu_to_le32(256),
264 .nbytes_max = __cpu_to_le32(256),
265 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
266 .reserved = __cpu_to_le32(0),
269 /* NB: 50% of src nentries, since tx has 2 frags */
271 /* CE5: target->host HTT (HIF->HTT) */
273 .pipenum = __cpu_to_le32(5),
274 .pipedir = __cpu_to_le32(PIPEDIR_IN),
275 .nentries = __cpu_to_le32(32),
276 .nbytes_max = __cpu_to_le32(512),
277 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
278 .reserved = __cpu_to_le32(0),
281 /* CE6: Reserved for target autonomous hif_memcpy */
283 .pipenum = __cpu_to_le32(6),
284 .pipedir = __cpu_to_le32(PIPEDIR_INOUT),
285 .nentries = __cpu_to_le32(32),
286 .nbytes_max = __cpu_to_le32(4096),
287 .flags = __cpu_to_le32(CE_ATTR_FLAGS),
288 .reserved = __cpu_to_le32(0),
291 /* CE7 used only by Host */
293 .pipenum = __cpu_to_le32(7),
294 .pipedir = __cpu_to_le32(PIPEDIR_INOUT),
295 .nentries = __cpu_to_le32(0),
296 .nbytes_max = __cpu_to_le32(0),
297 .flags = __cpu_to_le32(0),
298 .reserved = __cpu_to_le32(0),
301 /* CE8 target->host packtlog */
303 .pipenum = __cpu_to_le32(8),
304 .pipedir = __cpu_to_le32(PIPEDIR_IN),
305 .nentries = __cpu_to_le32(64),
306 .nbytes_max = __cpu_to_le32(2048),
307 .flags = __cpu_to_le32(CE_ATTR_FLAGS | CE_ATTR_DIS_INTR),
308 .reserved = __cpu_to_le32(0),
311 /* CE9 target autonomous qcache memcpy */
313 .pipenum = __cpu_to_le32(9),
314 .pipedir = __cpu_to_le32(PIPEDIR_INOUT),
315 .nentries = __cpu_to_le32(32),
316 .nbytes_max = __cpu_to_le32(2048),
317 .flags = __cpu_to_le32(CE_ATTR_FLAGS | CE_ATTR_DIS_INTR),
318 .reserved = __cpu_to_le32(0),
321 /* It not necessary to send target wlan configuration for CE10 & CE11
322 * as these CEs are not actively used in target.
327 * Map from service/endpoint to Copy Engine.
328 * This table is derived from the CE_PCI TABLE, above.
329 * It is passed to the Target at startup for use by firmware.
331 static struct service_to_pipe target_service_to_ce_map_wlan[] = {
333 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VO),
334 __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
338 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VO),
339 __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
343 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BK),
344 __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
348 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BK),
349 __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
353 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BE),
354 __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
358 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BE),
359 __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
363 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VI),
364 __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
368 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VI),
369 __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
373 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_CONTROL),
374 __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
378 __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_CONTROL),
379 __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
383 __cpu_to_le32(ATH10K_HTC_SVC_ID_RSVD_CTRL),
384 __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
388 __cpu_to_le32(ATH10K_HTC_SVC_ID_RSVD_CTRL),
389 __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
393 __cpu_to_le32(ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS),
394 __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
398 __cpu_to_le32(ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS),
399 __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
403 __cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA_MSG),
404 __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
408 __cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA_MSG),
409 __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
413 /* (Additions here) */
422 static bool ath10k_pci_is_awake(struct ath10k *ar)
424 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
425 u32 val = ioread32(ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
428 return RTC_STATE_V_GET(val) == RTC_STATE_V_ON;
431 static void __ath10k_pci_wake(struct ath10k *ar)
433 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
435 lockdep_assert_held(&ar_pci->ps_lock);
437 ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps wake reg refcount %lu awake %d\n",
438 ar_pci->ps_wake_refcount, ar_pci->ps_awake);
440 iowrite32(PCIE_SOC_WAKE_V_MASK,
441 ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
442 PCIE_SOC_WAKE_ADDRESS);
445 static void __ath10k_pci_sleep(struct ath10k *ar)
447 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
449 lockdep_assert_held(&ar_pci->ps_lock);
451 ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps sleep reg refcount %lu awake %d\n",
452 ar_pci->ps_wake_refcount, ar_pci->ps_awake);
454 iowrite32(PCIE_SOC_WAKE_RESET,
455 ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
456 PCIE_SOC_WAKE_ADDRESS);
457 ar_pci->ps_awake = false;
460 static int ath10k_pci_wake_wait(struct ath10k *ar)
465 while (tot_delay < PCIE_WAKE_TIMEOUT) {
466 if (ath10k_pci_is_awake(ar)) {
467 if (tot_delay > PCIE_WAKE_LATE_US)
468 ath10k_warn(ar, "device wakeup took %d ms which is unusally long, otherwise it works normally.\n",
474 tot_delay += curr_delay;
483 static int ath10k_pci_force_wake(struct ath10k *ar)
485 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
492 spin_lock_irqsave(&ar_pci->ps_lock, flags);
494 if (!ar_pci->ps_awake) {
495 iowrite32(PCIE_SOC_WAKE_V_MASK,
496 ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
497 PCIE_SOC_WAKE_ADDRESS);
499 ret = ath10k_pci_wake_wait(ar);
501 ar_pci->ps_awake = true;
504 spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
509 static void ath10k_pci_force_sleep(struct ath10k *ar)
511 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
514 spin_lock_irqsave(&ar_pci->ps_lock, flags);
516 iowrite32(PCIE_SOC_WAKE_RESET,
517 ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
518 PCIE_SOC_WAKE_ADDRESS);
519 ar_pci->ps_awake = false;
521 spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
524 static int ath10k_pci_wake(struct ath10k *ar)
526 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
530 if (ar_pci->pci_ps == 0)
533 spin_lock_irqsave(&ar_pci->ps_lock, flags);
535 ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps wake refcount %lu awake %d\n",
536 ar_pci->ps_wake_refcount, ar_pci->ps_awake);
538 /* This function can be called very frequently. To avoid excessive
539 * CPU stalls for MMIO reads use a cache var to hold the device state.
541 if (!ar_pci->ps_awake) {
542 __ath10k_pci_wake(ar);
544 ret = ath10k_pci_wake_wait(ar);
546 ar_pci->ps_awake = true;
550 ar_pci->ps_wake_refcount++;
551 WARN_ON(ar_pci->ps_wake_refcount == 0);
554 spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
559 static void ath10k_pci_sleep(struct ath10k *ar)
561 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
564 if (ar_pci->pci_ps == 0)
567 spin_lock_irqsave(&ar_pci->ps_lock, flags);
569 ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps sleep refcount %lu awake %d\n",
570 ar_pci->ps_wake_refcount, ar_pci->ps_awake);
572 if (WARN_ON(ar_pci->ps_wake_refcount == 0))
575 ar_pci->ps_wake_refcount--;
577 mod_timer(&ar_pci->ps_timer, jiffies +
578 msecs_to_jiffies(ATH10K_PCI_SLEEP_GRACE_PERIOD_MSEC));
581 spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
584 static void ath10k_pci_ps_timer(unsigned long ptr)
586 struct ath10k *ar = (void *)ptr;
587 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
590 spin_lock_irqsave(&ar_pci->ps_lock, flags);
592 ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps timer refcount %lu awake %d\n",
593 ar_pci->ps_wake_refcount, ar_pci->ps_awake);
595 if (ar_pci->ps_wake_refcount > 0)
598 __ath10k_pci_sleep(ar);
601 spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
604 static void ath10k_pci_sleep_sync(struct ath10k *ar)
606 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
609 if (ar_pci->pci_ps == 0) {
610 ath10k_pci_force_sleep(ar);
614 del_timer_sync(&ar_pci->ps_timer);
616 spin_lock_irqsave(&ar_pci->ps_lock, flags);
617 WARN_ON(ar_pci->ps_wake_refcount > 0);
618 __ath10k_pci_sleep(ar);
619 spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
622 static void ath10k_bus_pci_write32(struct ath10k *ar, u32 offset, u32 value)
624 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
627 if (unlikely(offset + sizeof(value) > ar_pci->mem_len)) {
628 ath10k_warn(ar, "refusing to write mmio out of bounds at 0x%08x - 0x%08zx (max 0x%08zx)\n",
629 offset, offset + sizeof(value), ar_pci->mem_len);
633 ret = ath10k_pci_wake(ar);
635 ath10k_warn(ar, "failed to wake target for write32 of 0x%08x at 0x%08x: %d\n",
640 iowrite32(value, ar_pci->mem + offset);
641 ath10k_pci_sleep(ar);
644 static u32 ath10k_bus_pci_read32(struct ath10k *ar, u32 offset)
646 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
650 if (unlikely(offset + sizeof(val) > ar_pci->mem_len)) {
651 ath10k_warn(ar, "refusing to read mmio out of bounds at 0x%08x - 0x%08zx (max 0x%08zx)\n",
652 offset, offset + sizeof(val), ar_pci->mem_len);
656 ret = ath10k_pci_wake(ar);
658 ath10k_warn(ar, "failed to wake target for read32 at 0x%08x: %d\n",
663 val = ioread32(ar_pci->mem + offset);
664 ath10k_pci_sleep(ar);
669 inline void ath10k_pci_write32(struct ath10k *ar, u32 offset, u32 value)
671 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
673 ar_pci->bus_ops->write32(ar, offset, value);
676 inline u32 ath10k_pci_read32(struct ath10k *ar, u32 offset)
678 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
680 return ar_pci->bus_ops->read32(ar, offset);
683 u32 ath10k_pci_soc_read32(struct ath10k *ar, u32 addr)
685 return ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS + addr);
688 void ath10k_pci_soc_write32(struct ath10k *ar, u32 addr, u32 val)
690 ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + addr, val);
693 u32 ath10k_pci_reg_read32(struct ath10k *ar, u32 addr)
695 return ath10k_pci_read32(ar, PCIE_LOCAL_BASE_ADDRESS + addr);
698 void ath10k_pci_reg_write32(struct ath10k *ar, u32 addr, u32 val)
700 ath10k_pci_write32(ar, PCIE_LOCAL_BASE_ADDRESS + addr, val);
703 bool ath10k_pci_irq_pending(struct ath10k *ar)
707 /* Check if the shared legacy irq is for us */
708 cause = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
709 PCIE_INTR_CAUSE_ADDRESS);
710 if (cause & (PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL))
716 void ath10k_pci_disable_and_clear_legacy_irq(struct ath10k *ar)
718 /* IMPORTANT: INTR_CLR register has to be set after
719 * INTR_ENABLE is set to 0, otherwise interrupt can not be
721 ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
723 ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_CLR_ADDRESS,
724 PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
726 /* IMPORTANT: this extra read transaction is required to
727 * flush the posted write buffer. */
728 (void)ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
729 PCIE_INTR_ENABLE_ADDRESS);
732 void ath10k_pci_enable_legacy_irq(struct ath10k *ar)
734 ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS +
735 PCIE_INTR_ENABLE_ADDRESS,
736 PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
738 /* IMPORTANT: this extra read transaction is required to
739 * flush the posted write buffer. */
740 (void)ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
741 PCIE_INTR_ENABLE_ADDRESS);
744 static inline const char *ath10k_pci_get_irq_method(struct ath10k *ar)
746 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
748 if (ar_pci->oper_irq_mode == ATH10K_PCI_IRQ_MSI)
754 static int __ath10k_pci_rx_post_buf(struct ath10k_pci_pipe *pipe)
756 struct ath10k *ar = pipe->hif_ce_state;
757 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
758 struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;
763 skb = dev_alloc_skb(pipe->buf_sz);
767 WARN_ONCE((unsigned long)skb->data & 3, "unaligned skb");
769 paddr = dma_map_single(ar->dev, skb->data,
770 skb->len + skb_tailroom(skb),
772 if (unlikely(dma_mapping_error(ar->dev, paddr))) {
773 ath10k_warn(ar, "failed to dma map pci rx buf\n");
774 dev_kfree_skb_any(skb);
778 ATH10K_SKB_RXCB(skb)->paddr = paddr;
780 spin_lock_bh(&ar_pci->ce_lock);
781 ret = __ath10k_ce_rx_post_buf(ce_pipe, skb, paddr);
782 spin_unlock_bh(&ar_pci->ce_lock);
784 dma_unmap_single(ar->dev, paddr, skb->len + skb_tailroom(skb),
786 dev_kfree_skb_any(skb);
793 static void ath10k_pci_rx_post_pipe(struct ath10k_pci_pipe *pipe)
795 struct ath10k *ar = pipe->hif_ce_state;
796 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
797 struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;
800 if (pipe->buf_sz == 0)
803 if (!ce_pipe->dest_ring)
806 spin_lock_bh(&ar_pci->ce_lock);
807 num = __ath10k_ce_rx_num_free_bufs(ce_pipe);
808 spin_unlock_bh(&ar_pci->ce_lock);
811 ret = __ath10k_pci_rx_post_buf(pipe);
815 ath10k_warn(ar, "failed to post pci rx buf: %d\n", ret);
816 mod_timer(&ar_pci->rx_post_retry, jiffies +
817 ATH10K_PCI_RX_POST_RETRY_MS);
824 void ath10k_pci_rx_post(struct ath10k *ar)
826 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
829 for (i = 0; i < CE_COUNT; i++)
830 ath10k_pci_rx_post_pipe(&ar_pci->pipe_info[i]);
833 void ath10k_pci_rx_replenish_retry(unsigned long ptr)
835 struct ath10k *ar = (void *)ptr;
837 ath10k_pci_rx_post(ar);
840 static u32 ath10k_pci_targ_cpu_to_ce_addr(struct ath10k *ar, u32 addr)
844 switch (ar->hw_rev) {
845 case ATH10K_HW_QCA988X:
846 case ATH10K_HW_QCA9887:
847 case ATH10K_HW_QCA6174:
848 case ATH10K_HW_QCA9377:
849 val = (ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
853 case ATH10K_HW_QCA99X0:
854 case ATH10K_HW_QCA9984:
855 case ATH10K_HW_QCA4019:
856 val = ath10k_pci_read32(ar, PCIE_BAR_REG_ADDRESS);
860 val |= 0x100000 | (addr & 0xfffff);
865 * Diagnostic read/write access is provided for startup/config/debug usage.
866 * Caller must guarantee proper alignment, when applicable, and single user
869 static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
872 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
875 unsigned int completed_nbytes, alloc_nbytes, remaining_bytes;
876 struct ath10k_ce_pipe *ce_diag;
877 /* Host buffer address in CE space */
879 dma_addr_t ce_data_base = 0;
880 void *data_buf = NULL;
883 spin_lock_bh(&ar_pci->ce_lock);
885 ce_diag = ar_pci->ce_diag;
888 * Allocate a temporary bounce buffer to hold caller's data
889 * to be DMA'ed from Target. This guarantees
890 * 1) 4-byte alignment
891 * 2) Buffer in DMA-able space
893 alloc_nbytes = min_t(unsigned int, nbytes, DIAG_TRANSFER_LIMIT);
895 data_buf = (unsigned char *)dma_alloc_coherent(ar->dev,
904 memset(data_buf, 0, alloc_nbytes);
906 remaining_bytes = nbytes;
907 ce_data = ce_data_base;
908 while (remaining_bytes) {
909 nbytes = min_t(unsigned int, remaining_bytes,
910 DIAG_TRANSFER_LIMIT);
912 ret = __ath10k_ce_rx_post_buf(ce_diag, &ce_data, ce_data);
916 /* Request CE to send from Target(!) address to Host buffer */
918 * The address supplied by the caller is in the
919 * Target CPU virtual address space.
921 * In order to use this address with the diagnostic CE,
922 * convert it from Target CPU virtual address space
923 * to CE address space
925 address = ath10k_pci_targ_cpu_to_ce_addr(ar, address);
927 ret = ath10k_ce_send_nolock(ce_diag, NULL, (u32)address, nbytes, 0,
933 while (ath10k_ce_completed_send_next_nolock(ce_diag,
936 if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
943 while (ath10k_ce_completed_recv_next_nolock(ce_diag,
949 if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
955 if (nbytes != completed_nbytes) {
960 if (*buf != ce_data) {
965 remaining_bytes -= nbytes;
968 ath10k_warn(ar, "failed to read diag value at 0x%x: %d\n",
972 memcpy(data, data_buf, nbytes);
981 dma_free_coherent(ar->dev, alloc_nbytes, data_buf,
984 spin_unlock_bh(&ar_pci->ce_lock);
989 static int ath10k_pci_diag_read32(struct ath10k *ar, u32 address, u32 *value)
994 ret = ath10k_pci_diag_read_mem(ar, address, &val, sizeof(val));
995 *value = __le32_to_cpu(val);
1000 static int __ath10k_pci_diag_read_hi(struct ath10k *ar, void *dest,
1003 u32 host_addr, addr;
1006 host_addr = host_interest_item_address(src);
1008 ret = ath10k_pci_diag_read32(ar, host_addr, &addr);
1010 ath10k_warn(ar, "failed to get memcpy hi address for firmware address %d: %d\n",
1015 ret = ath10k_pci_diag_read_mem(ar, addr, dest, len);
1017 ath10k_warn(ar, "failed to memcpy firmware memory from %d (%d B): %d\n",
1025 #define ath10k_pci_diag_read_hi(ar, dest, src, len) \
1026 __ath10k_pci_diag_read_hi(ar, dest, HI_ITEM(src), len)
1028 int ath10k_pci_diag_write_mem(struct ath10k *ar, u32 address,
1029 const void *data, int nbytes)
1031 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1034 unsigned int completed_nbytes, orig_nbytes, remaining_bytes;
1035 struct ath10k_ce_pipe *ce_diag;
1036 void *data_buf = NULL;
1037 u32 ce_data; /* Host buffer address in CE space */
1038 dma_addr_t ce_data_base = 0;
1041 spin_lock_bh(&ar_pci->ce_lock);
1043 ce_diag = ar_pci->ce_diag;
1046 * Allocate a temporary bounce buffer to hold caller's data
1047 * to be DMA'ed to Target. This guarantees
1048 * 1) 4-byte alignment
1049 * 2) Buffer in DMA-able space
1051 orig_nbytes = nbytes;
1052 data_buf = (unsigned char *)dma_alloc_coherent(ar->dev,
1061 /* Copy caller's data to allocated DMA buf */
1062 memcpy(data_buf, data, orig_nbytes);
1065 * The address supplied by the caller is in the
1066 * Target CPU virtual address space.
1068 * In order to use this address with the diagnostic CE,
1070 * Target CPU virtual address space
1074 address = ath10k_pci_targ_cpu_to_ce_addr(ar, address);
1076 remaining_bytes = orig_nbytes;
1077 ce_data = ce_data_base;
1078 while (remaining_bytes) {
1079 /* FIXME: check cast */
1080 nbytes = min_t(int, remaining_bytes, DIAG_TRANSFER_LIMIT);
1082 /* Set up to receive directly into Target(!) address */
1083 ret = __ath10k_ce_rx_post_buf(ce_diag, &address, address);
1088 * Request CE to send caller-supplied data that
1089 * was copied to bounce buffer to Target(!) address.
1091 ret = ath10k_ce_send_nolock(ce_diag, NULL, (u32)ce_data,
1097 while (ath10k_ce_completed_send_next_nolock(ce_diag,
1101 if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
1108 while (ath10k_ce_completed_recv_next_nolock(ce_diag,
1114 if (i++ > DIAG_ACCESS_CE_TIMEOUT_MS) {
1120 if (nbytes != completed_nbytes) {
1125 if (*buf != address) {
1130 remaining_bytes -= nbytes;
1137 dma_free_coherent(ar->dev, orig_nbytes, data_buf,
1142 ath10k_warn(ar, "failed to write diag value at 0x%x: %d\n",
1145 spin_unlock_bh(&ar_pci->ce_lock);
1150 static int ath10k_pci_diag_write32(struct ath10k *ar, u32 address, u32 value)
1152 __le32 val = __cpu_to_le32(value);
1154 return ath10k_pci_diag_write_mem(ar, address, &val, sizeof(val));
1157 /* Called by lower (CE) layer when a send to Target completes. */
1158 static void ath10k_pci_htc_tx_cb(struct ath10k_ce_pipe *ce_state)
1160 struct ath10k *ar = ce_state->ar;
1161 struct sk_buff_head list;
1162 struct sk_buff *skb;
1164 __skb_queue_head_init(&list);
1165 while (ath10k_ce_completed_send_next(ce_state, (void **)&skb) == 0) {
1166 /* no need to call tx completion for NULL pointers */
1170 __skb_queue_tail(&list, skb);
1173 while ((skb = __skb_dequeue(&list)))
1174 ath10k_htc_tx_completion_handler(ar, skb);
1177 static void ath10k_pci_process_rx_cb(struct ath10k_ce_pipe *ce_state,
1178 void (*callback)(struct ath10k *ar,
1179 struct sk_buff *skb))
1181 struct ath10k *ar = ce_state->ar;
1182 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1183 struct ath10k_pci_pipe *pipe_info = &ar_pci->pipe_info[ce_state->id];
1184 struct sk_buff *skb;
1185 struct sk_buff_head list;
1186 void *transfer_context;
1187 unsigned int nbytes, max_nbytes;
1189 __skb_queue_head_init(&list);
1190 while (ath10k_ce_completed_recv_next(ce_state, &transfer_context,
1192 skb = transfer_context;
1193 max_nbytes = skb->len + skb_tailroom(skb);
1194 dma_unmap_single(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
1195 max_nbytes, DMA_FROM_DEVICE);
1197 if (unlikely(max_nbytes < nbytes)) {
1198 ath10k_warn(ar, "rxed more than expected (nbytes %d, max %d)",
1199 nbytes, max_nbytes);
1200 dev_kfree_skb_any(skb);
1204 skb_put(skb, nbytes);
1205 __skb_queue_tail(&list, skb);
1208 while ((skb = __skb_dequeue(&list))) {
1209 ath10k_dbg(ar, ATH10K_DBG_PCI, "pci rx ce pipe %d len %d\n",
1210 ce_state->id, skb->len);
1211 ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci rx: ",
1212 skb->data, skb->len);
1217 ath10k_pci_rx_post_pipe(pipe_info);
1220 static void ath10k_pci_process_htt_rx_cb(struct ath10k_ce_pipe *ce_state,
1221 void (*callback)(struct ath10k *ar,
1222 struct sk_buff *skb))
1224 struct ath10k *ar = ce_state->ar;
1225 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1226 struct ath10k_pci_pipe *pipe_info = &ar_pci->pipe_info[ce_state->id];
1227 struct ath10k_ce_pipe *ce_pipe = pipe_info->ce_hdl;
1228 struct sk_buff *skb;
1229 struct sk_buff_head list;
1230 void *transfer_context;
1231 unsigned int nbytes, max_nbytes, nentries;
1234 /* No need to aquire ce_lock for CE5, since this is the only place CE5
1235 * is processed other than init and deinit. Before releasing CE5
1236 * buffers, interrupts are disabled. Thus CE5 access is serialized.
1238 __skb_queue_head_init(&list);
1239 while (ath10k_ce_completed_recv_next_nolock(ce_state, &transfer_context,
1241 skb = transfer_context;
1242 max_nbytes = skb->len + skb_tailroom(skb);
1244 if (unlikely(max_nbytes < nbytes)) {
1245 ath10k_warn(ar, "rxed more than expected (nbytes %d, max %d)",
1246 nbytes, max_nbytes);
1250 dma_sync_single_for_cpu(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
1251 max_nbytes, DMA_FROM_DEVICE);
1252 skb_put(skb, nbytes);
1253 __skb_queue_tail(&list, skb);
1256 nentries = skb_queue_len(&list);
1257 while ((skb = __skb_dequeue(&list))) {
1258 ath10k_dbg(ar, ATH10K_DBG_PCI, "pci rx ce pipe %d len %d\n",
1259 ce_state->id, skb->len);
1260 ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci rx: ",
1261 skb->data, skb->len);
1263 orig_len = skb->len;
1265 skb_push(skb, orig_len - skb->len);
1266 skb_reset_tail_pointer(skb);
1269 /*let device gain the buffer again*/
1270 dma_sync_single_for_device(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
1271 skb->len + skb_tailroom(skb),
1274 ath10k_ce_rx_update_write_idx(ce_pipe, nentries);
1277 /* Called by lower (CE) layer when data is received from the Target. */
1278 static void ath10k_pci_htc_rx_cb(struct ath10k_ce_pipe *ce_state)
1280 ath10k_pci_process_rx_cb(ce_state, ath10k_htc_rx_completion_handler);
1283 static void ath10k_pci_htt_htc_rx_cb(struct ath10k_ce_pipe *ce_state)
1285 /* CE4 polling needs to be done whenever CE pipe which transports
1286 * HTT Rx (target->host) is processed.
1288 ath10k_ce_per_engine_service(ce_state->ar, 4);
1290 ath10k_pci_process_rx_cb(ce_state, ath10k_htc_rx_completion_handler);
1293 /* Called by lower (CE) layer when data is received from the Target.
1294 * Only 10.4 firmware uses separate CE to transfer pktlog data.
1296 static void ath10k_pci_pktlog_rx_cb(struct ath10k_ce_pipe *ce_state)
1298 ath10k_pci_process_rx_cb(ce_state,
1299 ath10k_htt_rx_pktlog_completion_handler);
1302 /* Called by lower (CE) layer when a send to HTT Target completes. */
1303 static void ath10k_pci_htt_tx_cb(struct ath10k_ce_pipe *ce_state)
1305 struct ath10k *ar = ce_state->ar;
1306 struct sk_buff *skb;
1308 while (ath10k_ce_completed_send_next(ce_state, (void **)&skb) == 0) {
1309 /* no need to call tx completion for NULL pointers */
1313 dma_unmap_single(ar->dev, ATH10K_SKB_CB(skb)->paddr,
1314 skb->len, DMA_TO_DEVICE);
1315 ath10k_htt_hif_tx_complete(ar, skb);
1319 static void ath10k_pci_htt_rx_deliver(struct ath10k *ar, struct sk_buff *skb)
1321 skb_pull(skb, sizeof(struct ath10k_htc_hdr));
1322 ath10k_htt_t2h_msg_handler(ar, skb);
1325 /* Called by lower (CE) layer when HTT data is received from the Target. */
1326 static void ath10k_pci_htt_rx_cb(struct ath10k_ce_pipe *ce_state)
1328 /* CE4 polling needs to be done whenever CE pipe which transports
1329 * HTT Rx (target->host) is processed.
1331 ath10k_ce_per_engine_service(ce_state->ar, 4);
1333 ath10k_pci_process_htt_rx_cb(ce_state, ath10k_pci_htt_rx_deliver);
1336 int ath10k_pci_hif_tx_sg(struct ath10k *ar, u8 pipe_id,
1337 struct ath10k_hif_sg_item *items, int n_items)
1339 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1340 struct ath10k_pci_pipe *pci_pipe = &ar_pci->pipe_info[pipe_id];
1341 struct ath10k_ce_pipe *ce_pipe = pci_pipe->ce_hdl;
1342 struct ath10k_ce_ring *src_ring = ce_pipe->src_ring;
1343 unsigned int nentries_mask;
1344 unsigned int sw_index;
1345 unsigned int write_index;
1348 spin_lock_bh(&ar_pci->ce_lock);
1350 nentries_mask = src_ring->nentries_mask;
1351 sw_index = src_ring->sw_index;
1352 write_index = src_ring->write_index;
1354 if (unlikely(CE_RING_DELTA(nentries_mask,
1355 write_index, sw_index - 1) < n_items)) {
1360 for (i = 0; i < n_items - 1; i++) {
1361 ath10k_dbg(ar, ATH10K_DBG_PCI,
1362 "pci tx item %d paddr 0x%08x len %d n_items %d\n",
1363 i, items[i].paddr, items[i].len, n_items);
1364 ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci tx data: ",
1365 items[i].vaddr, items[i].len);
1367 err = ath10k_ce_send_nolock(ce_pipe,
1368 items[i].transfer_context,
1371 items[i].transfer_id,
1372 CE_SEND_FLAG_GATHER);
1377 /* `i` is equal to `n_items -1` after for() */
1379 ath10k_dbg(ar, ATH10K_DBG_PCI,
1380 "pci tx item %d paddr 0x%08x len %d n_items %d\n",
1381 i, items[i].paddr, items[i].len, n_items);
1382 ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci tx data: ",
1383 items[i].vaddr, items[i].len);
1385 err = ath10k_ce_send_nolock(ce_pipe,
1386 items[i].transfer_context,
1389 items[i].transfer_id,
1394 spin_unlock_bh(&ar_pci->ce_lock);
1399 __ath10k_ce_send_revert(ce_pipe);
1401 spin_unlock_bh(&ar_pci->ce_lock);
1405 int ath10k_pci_hif_diag_read(struct ath10k *ar, u32 address, void *buf,
1408 return ath10k_pci_diag_read_mem(ar, address, buf, buf_len);
1411 u16 ath10k_pci_hif_get_free_queue_number(struct ath10k *ar, u8 pipe)
1413 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1415 ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif get free queue number\n");
1417 return ath10k_ce_num_free_src_entries(ar_pci->pipe_info[pipe].ce_hdl);
1420 static void ath10k_pci_dump_registers(struct ath10k *ar,
1421 struct ath10k_fw_crash_data *crash_data)
1423 __le32 reg_dump_values[REG_DUMP_COUNT_QCA988X] = {};
1426 lockdep_assert_held(&ar->data_lock);
1428 ret = ath10k_pci_diag_read_hi(ar, ®_dump_values[0],
1430 REG_DUMP_COUNT_QCA988X * sizeof(__le32));
1432 ath10k_err(ar, "failed to read firmware dump area: %d\n", ret);
1436 BUILD_BUG_ON(REG_DUMP_COUNT_QCA988X % 4);
1438 ath10k_err(ar, "firmware register dump:\n");
1439 for (i = 0; i < REG_DUMP_COUNT_QCA988X; i += 4)
1440 ath10k_err(ar, "[%02d]: 0x%08X 0x%08X 0x%08X 0x%08X\n",
1442 __le32_to_cpu(reg_dump_values[i]),
1443 __le32_to_cpu(reg_dump_values[i + 1]),
1444 __le32_to_cpu(reg_dump_values[i + 2]),
1445 __le32_to_cpu(reg_dump_values[i + 3]));
1450 for (i = 0; i < REG_DUMP_COUNT_QCA988X; i++)
1451 crash_data->registers[i] = reg_dump_values[i];
1454 static void ath10k_pci_fw_crashed_dump(struct ath10k *ar)
1456 struct ath10k_fw_crash_data *crash_data;
1459 spin_lock_bh(&ar->data_lock);
1461 ar->stats.fw_crash_counter++;
1463 crash_data = ath10k_debug_get_new_fw_crash_data(ar);
1466 scnprintf(uuid, sizeof(uuid), "%pUl", &crash_data->uuid);
1468 scnprintf(uuid, sizeof(uuid), "n/a");
1470 ath10k_err(ar, "firmware crashed! (uuid %s)\n", uuid);
1471 ath10k_print_driver_info(ar);
1472 ath10k_pci_dump_registers(ar, crash_data);
1474 spin_unlock_bh(&ar->data_lock);
1476 queue_work(ar->workqueue, &ar->restart_work);
1479 void ath10k_pci_hif_send_complete_check(struct ath10k *ar, u8 pipe,
1482 ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif send complete check\n");
1487 * Decide whether to actually poll for completions, or just
1488 * wait for a later chance.
1489 * If there seem to be plenty of resources left, then just wait
1490 * since checking involves reading a CE register, which is a
1491 * relatively expensive operation.
1493 resources = ath10k_pci_hif_get_free_queue_number(ar, pipe);
1496 * If at least 50% of the total resources are still available,
1497 * don't bother checking again yet.
1499 if (resources > (host_ce_config_wlan[pipe].src_nentries >> 1))
1502 ath10k_ce_per_engine_service(ar, pipe);
1505 void ath10k_pci_kill_tasklet(struct ath10k *ar)
1507 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1509 tasklet_kill(&ar_pci->intr_tq);
1511 del_timer_sync(&ar_pci->rx_post_retry);
1514 int ath10k_pci_hif_map_service_to_pipe(struct ath10k *ar, u16 service_id,
1515 u8 *ul_pipe, u8 *dl_pipe)
1517 const struct service_to_pipe *entry;
1518 bool ul_set = false, dl_set = false;
1521 ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif map service\n");
1523 for (i = 0; i < ARRAY_SIZE(target_service_to_ce_map_wlan); i++) {
1524 entry = &target_service_to_ce_map_wlan[i];
1526 if (__le32_to_cpu(entry->service_id) != service_id)
1529 switch (__le32_to_cpu(entry->pipedir)) {
1534 *dl_pipe = __le32_to_cpu(entry->pipenum);
1539 *ul_pipe = __le32_to_cpu(entry->pipenum);
1545 *dl_pipe = __le32_to_cpu(entry->pipenum);
1546 *ul_pipe = __le32_to_cpu(entry->pipenum);
1553 if (WARN_ON(!ul_set || !dl_set))
1559 void ath10k_pci_hif_get_default_pipe(struct ath10k *ar,
1560 u8 *ul_pipe, u8 *dl_pipe)
1562 ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif get default pipe\n");
1564 (void)ath10k_pci_hif_map_service_to_pipe(ar,
1565 ATH10K_HTC_SVC_ID_RSVD_CTRL,
1569 static void ath10k_pci_irq_msi_fw_mask(struct ath10k *ar)
1573 switch (ar->hw_rev) {
1574 case ATH10K_HW_QCA988X:
1575 case ATH10K_HW_QCA9887:
1576 case ATH10K_HW_QCA6174:
1577 case ATH10K_HW_QCA9377:
1578 val = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
1580 val &= ~CORE_CTRL_PCIE_REG_31_MASK;
1581 ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS +
1582 CORE_CTRL_ADDRESS, val);
1584 case ATH10K_HW_QCA99X0:
1585 case ATH10K_HW_QCA9984:
1586 case ATH10K_HW_QCA4019:
1587 /* TODO: Find appropriate register configuration for QCA99X0
1594 static void ath10k_pci_irq_msi_fw_unmask(struct ath10k *ar)
1598 switch (ar->hw_rev) {
1599 case ATH10K_HW_QCA988X:
1600 case ATH10K_HW_QCA9887:
1601 case ATH10K_HW_QCA6174:
1602 case ATH10K_HW_QCA9377:
1603 val = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
1605 val |= CORE_CTRL_PCIE_REG_31_MASK;
1606 ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS +
1607 CORE_CTRL_ADDRESS, val);
1609 case ATH10K_HW_QCA99X0:
1610 case ATH10K_HW_QCA9984:
1611 case ATH10K_HW_QCA4019:
1612 /* TODO: Find appropriate register configuration for QCA99X0
1613 * to unmask irq/MSI.
1619 static void ath10k_pci_irq_disable(struct ath10k *ar)
1621 ath10k_ce_disable_interrupts(ar);
1622 ath10k_pci_disable_and_clear_legacy_irq(ar);
1623 ath10k_pci_irq_msi_fw_mask(ar);
1626 static void ath10k_pci_irq_sync(struct ath10k *ar)
1628 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1630 synchronize_irq(ar_pci->pdev->irq);
1633 static void ath10k_pci_irq_enable(struct ath10k *ar)
1635 ath10k_ce_enable_interrupts(ar);
1636 ath10k_pci_enable_legacy_irq(ar);
1637 ath10k_pci_irq_msi_fw_unmask(ar);
1640 static int ath10k_pci_hif_start(struct ath10k *ar)
1642 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1644 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif start\n");
1646 ath10k_pci_irq_enable(ar);
1647 ath10k_pci_rx_post(ar);
1649 pcie_capability_write_word(ar_pci->pdev, PCI_EXP_LNKCTL,
1655 static void ath10k_pci_rx_pipe_cleanup(struct ath10k_pci_pipe *pci_pipe)
1658 struct ath10k_ce_pipe *ce_pipe;
1659 struct ath10k_ce_ring *ce_ring;
1660 struct sk_buff *skb;
1663 ar = pci_pipe->hif_ce_state;
1664 ce_pipe = pci_pipe->ce_hdl;
1665 ce_ring = ce_pipe->dest_ring;
1670 if (!pci_pipe->buf_sz)
1673 for (i = 0; i < ce_ring->nentries; i++) {
1674 skb = ce_ring->per_transfer_context[i];
1678 ce_ring->per_transfer_context[i] = NULL;
1680 dma_unmap_single(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
1681 skb->len + skb_tailroom(skb),
1683 dev_kfree_skb_any(skb);
1687 static void ath10k_pci_tx_pipe_cleanup(struct ath10k_pci_pipe *pci_pipe)
1690 struct ath10k_pci *ar_pci;
1691 struct ath10k_ce_pipe *ce_pipe;
1692 struct ath10k_ce_ring *ce_ring;
1693 struct sk_buff *skb;
1696 ar = pci_pipe->hif_ce_state;
1697 ar_pci = ath10k_pci_priv(ar);
1698 ce_pipe = pci_pipe->ce_hdl;
1699 ce_ring = ce_pipe->src_ring;
1704 if (!pci_pipe->buf_sz)
1707 for (i = 0; i < ce_ring->nentries; i++) {
1708 skb = ce_ring->per_transfer_context[i];
1712 ce_ring->per_transfer_context[i] = NULL;
1714 ath10k_htc_tx_completion_handler(ar, skb);
1719 * Cleanup residual buffers for device shutdown:
1720 * buffers that were enqueued for receive
1721 * buffers that were to be sent
1722 * Note: Buffers that had completed but which were
1723 * not yet processed are on a completion queue. They
1724 * are handled when the completion thread shuts down.
1726 static void ath10k_pci_buffer_cleanup(struct ath10k *ar)
1728 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1731 for (pipe_num = 0; pipe_num < CE_COUNT; pipe_num++) {
1732 struct ath10k_pci_pipe *pipe_info;
1734 pipe_info = &ar_pci->pipe_info[pipe_num];
1735 ath10k_pci_rx_pipe_cleanup(pipe_info);
1736 ath10k_pci_tx_pipe_cleanup(pipe_info);
1740 void ath10k_pci_ce_deinit(struct ath10k *ar)
1744 for (i = 0; i < CE_COUNT; i++)
1745 ath10k_ce_deinit_pipe(ar, i);
1748 void ath10k_pci_flush(struct ath10k *ar)
1750 ath10k_pci_kill_tasklet(ar);
1751 ath10k_pci_buffer_cleanup(ar);
1754 static void ath10k_pci_hif_stop(struct ath10k *ar)
1756 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1757 unsigned long flags;
1759 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif stop\n");
1761 /* Most likely the device has HTT Rx ring configured. The only way to
1762 * prevent the device from accessing (and possible corrupting) host
1763 * memory is to reset the chip now.
1765 * There's also no known way of masking MSI interrupts on the device.
1766 * For ranged MSI the CE-related interrupts can be masked. However
1767 * regardless how many MSI interrupts are assigned the first one
1768 * is always used for firmware indications (crashes) and cannot be
1769 * masked. To prevent the device from asserting the interrupt reset it
1770 * before proceeding with cleanup.
1772 ath10k_pci_safe_chip_reset(ar);
1774 ath10k_pci_irq_disable(ar);
1775 ath10k_pci_irq_sync(ar);
1776 ath10k_pci_flush(ar);
1778 spin_lock_irqsave(&ar_pci->ps_lock, flags);
1779 WARN_ON(ar_pci->ps_wake_refcount > 0);
1780 spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
1783 int ath10k_pci_hif_exchange_bmi_msg(struct ath10k *ar,
1784 void *req, u32 req_len,
1785 void *resp, u32 *resp_len)
1787 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1788 struct ath10k_pci_pipe *pci_tx = &ar_pci->pipe_info[BMI_CE_NUM_TO_TARG];
1789 struct ath10k_pci_pipe *pci_rx = &ar_pci->pipe_info[BMI_CE_NUM_TO_HOST];
1790 struct ath10k_ce_pipe *ce_tx = pci_tx->ce_hdl;
1791 struct ath10k_ce_pipe *ce_rx = pci_rx->ce_hdl;
1792 dma_addr_t req_paddr = 0;
1793 dma_addr_t resp_paddr = 0;
1794 struct bmi_xfer xfer = {};
1795 void *treq, *tresp = NULL;
1800 if (resp && !resp_len)
1803 if (resp && resp_len && *resp_len == 0)
1806 treq = kmemdup(req, req_len, GFP_KERNEL);
1810 req_paddr = dma_map_single(ar->dev, treq, req_len, DMA_TO_DEVICE);
1811 ret = dma_mapping_error(ar->dev, req_paddr);
1817 if (resp && resp_len) {
1818 tresp = kzalloc(*resp_len, GFP_KERNEL);
1824 resp_paddr = dma_map_single(ar->dev, tresp, *resp_len,
1826 ret = dma_mapping_error(ar->dev, resp_paddr);
1832 xfer.wait_for_resp = true;
1835 ath10k_ce_rx_post_buf(ce_rx, &xfer, resp_paddr);
1838 ret = ath10k_ce_send(ce_tx, &xfer, req_paddr, req_len, -1, 0);
1842 ret = ath10k_pci_bmi_wait(ce_tx, ce_rx, &xfer);
1845 unsigned int unused_nbytes;
1846 unsigned int unused_id;
1848 ath10k_ce_cancel_send_next(ce_tx, NULL, &unused_buffer,
1849 &unused_nbytes, &unused_id);
1851 /* non-zero means we did not time out */
1859 ath10k_ce_revoke_recv_next(ce_rx, NULL, &unused_buffer);
1860 dma_unmap_single(ar->dev, resp_paddr,
1861 *resp_len, DMA_FROM_DEVICE);
1864 dma_unmap_single(ar->dev, req_paddr, req_len, DMA_TO_DEVICE);
1866 if (ret == 0 && resp_len) {
1867 *resp_len = min(*resp_len, xfer.resp_len);
1868 memcpy(resp, tresp, xfer.resp_len);
1877 static void ath10k_pci_bmi_send_done(struct ath10k_ce_pipe *ce_state)
1879 struct bmi_xfer *xfer;
1881 if (ath10k_ce_completed_send_next(ce_state, (void **)&xfer))
1884 xfer->tx_done = true;
1887 static void ath10k_pci_bmi_recv_data(struct ath10k_ce_pipe *ce_state)
1889 struct ath10k *ar = ce_state->ar;
1890 struct bmi_xfer *xfer;
1891 unsigned int nbytes;
1893 if (ath10k_ce_completed_recv_next(ce_state, (void **)&xfer,
1897 if (WARN_ON_ONCE(!xfer))
1900 if (!xfer->wait_for_resp) {
1901 ath10k_warn(ar, "unexpected: BMI data received; ignoring\n");
1905 xfer->resp_len = nbytes;
1906 xfer->rx_done = true;
1909 static int ath10k_pci_bmi_wait(struct ath10k_ce_pipe *tx_pipe,
1910 struct ath10k_ce_pipe *rx_pipe,
1911 struct bmi_xfer *xfer)
1913 unsigned long timeout = jiffies + BMI_COMMUNICATION_TIMEOUT_HZ;
1915 while (time_before_eq(jiffies, timeout)) {
1916 ath10k_pci_bmi_send_done(tx_pipe);
1917 ath10k_pci_bmi_recv_data(rx_pipe);
1919 if (xfer->tx_done && (xfer->rx_done == xfer->wait_for_resp))
1929 * Send an interrupt to the device to wake up the Target CPU
1930 * so it has an opportunity to notice any changed state.
1932 static int ath10k_pci_wake_target_cpu(struct ath10k *ar)
1936 addr = SOC_CORE_BASE_ADDRESS | CORE_CTRL_ADDRESS;
1937 val = ath10k_pci_read32(ar, addr);
1938 val |= CORE_CTRL_CPU_INTR_MASK;
1939 ath10k_pci_write32(ar, addr, val);
1944 static int ath10k_pci_get_num_banks(struct ath10k *ar)
1946 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1948 switch (ar_pci->pdev->device) {
1949 case QCA988X_2_0_DEVICE_ID:
1950 case QCA99X0_2_0_DEVICE_ID:
1951 case QCA9984_1_0_DEVICE_ID:
1952 case QCA9887_1_0_DEVICE_ID:
1954 case QCA6164_2_1_DEVICE_ID:
1955 case QCA6174_2_1_DEVICE_ID:
1956 switch (MS(ar->chip_id, SOC_CHIP_ID_REV)) {
1957 case QCA6174_HW_1_0_CHIP_ID_REV:
1958 case QCA6174_HW_1_1_CHIP_ID_REV:
1959 case QCA6174_HW_2_1_CHIP_ID_REV:
1960 case QCA6174_HW_2_2_CHIP_ID_REV:
1962 case QCA6174_HW_1_3_CHIP_ID_REV:
1964 case QCA6174_HW_3_0_CHIP_ID_REV:
1965 case QCA6174_HW_3_1_CHIP_ID_REV:
1966 case QCA6174_HW_3_2_CHIP_ID_REV:
1970 case QCA9377_1_0_DEVICE_ID:
1974 ath10k_warn(ar, "unknown number of banks, assuming 1\n");
1978 static int ath10k_bus_get_num_banks(struct ath10k *ar)
1980 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1982 return ar_pci->bus_ops->get_num_banks(ar);
1985 int ath10k_pci_init_config(struct ath10k *ar)
1987 u32 interconnect_targ_addr;
1988 u32 pcie_state_targ_addr = 0;
1989 u32 pipe_cfg_targ_addr = 0;
1990 u32 svc_to_pipe_map = 0;
1991 u32 pcie_config_flags = 0;
1993 u32 ealloc_targ_addr;
1995 u32 flag2_targ_addr;
1998 /* Download to Target the CE Config and the service-to-CE map */
1999 interconnect_targ_addr =
2000 host_interest_item_address(HI_ITEM(hi_interconnect_state));
2002 /* Supply Target-side CE configuration */
2003 ret = ath10k_pci_diag_read32(ar, interconnect_targ_addr,
2004 &pcie_state_targ_addr);
2006 ath10k_err(ar, "Failed to get pcie state addr: %d\n", ret);
2010 if (pcie_state_targ_addr == 0) {
2012 ath10k_err(ar, "Invalid pcie state addr\n");
2016 ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
2017 offsetof(struct pcie_state,
2019 &pipe_cfg_targ_addr);
2021 ath10k_err(ar, "Failed to get pipe cfg addr: %d\n", ret);
2025 if (pipe_cfg_targ_addr == 0) {
2027 ath10k_err(ar, "Invalid pipe cfg addr\n");
2031 ret = ath10k_pci_diag_write_mem(ar, pipe_cfg_targ_addr,
2032 target_ce_config_wlan,
2033 sizeof(struct ce_pipe_config) *
2034 NUM_TARGET_CE_CONFIG_WLAN);
2037 ath10k_err(ar, "Failed to write pipe cfg: %d\n", ret);
2041 ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
2042 offsetof(struct pcie_state,
2046 ath10k_err(ar, "Failed to get svc/pipe map: %d\n", ret);
2050 if (svc_to_pipe_map == 0) {
2052 ath10k_err(ar, "Invalid svc_to_pipe map\n");
2056 ret = ath10k_pci_diag_write_mem(ar, svc_to_pipe_map,
2057 target_service_to_ce_map_wlan,
2058 sizeof(target_service_to_ce_map_wlan));
2060 ath10k_err(ar, "Failed to write svc/pipe map: %d\n", ret);
2064 ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
2065 offsetof(struct pcie_state,
2067 &pcie_config_flags);
2069 ath10k_err(ar, "Failed to get pcie config_flags: %d\n", ret);
2073 pcie_config_flags &= ~PCIE_CONFIG_FLAG_ENABLE_L1;
2075 ret = ath10k_pci_diag_write32(ar, (pcie_state_targ_addr +
2076 offsetof(struct pcie_state,
2080 ath10k_err(ar, "Failed to write pcie config_flags: %d\n", ret);
2084 /* configure early allocation */
2085 ealloc_targ_addr = host_interest_item_address(HI_ITEM(hi_early_alloc));
2087 ret = ath10k_pci_diag_read32(ar, ealloc_targ_addr, &ealloc_value);
2089 ath10k_err(ar, "Faile to get early alloc val: %d\n", ret);
2093 /* first bank is switched to IRAM */
2094 ealloc_value |= ((HI_EARLY_ALLOC_MAGIC << HI_EARLY_ALLOC_MAGIC_SHIFT) &
2095 HI_EARLY_ALLOC_MAGIC_MASK);
2096 ealloc_value |= ((ath10k_bus_get_num_banks(ar) <<
2097 HI_EARLY_ALLOC_IRAM_BANKS_SHIFT) &
2098 HI_EARLY_ALLOC_IRAM_BANKS_MASK);
2100 ret = ath10k_pci_diag_write32(ar, ealloc_targ_addr, ealloc_value);
2102 ath10k_err(ar, "Failed to set early alloc val: %d\n", ret);
2106 /* Tell Target to proceed with initialization */
2107 flag2_targ_addr = host_interest_item_address(HI_ITEM(hi_option_flag2));
2109 ret = ath10k_pci_diag_read32(ar, flag2_targ_addr, &flag2_value);
2111 ath10k_err(ar, "Failed to get option val: %d\n", ret);
2115 flag2_value |= HI_OPTION_EARLY_CFG_DONE;
2117 ret = ath10k_pci_diag_write32(ar, flag2_targ_addr, flag2_value);
2119 ath10k_err(ar, "Failed to set option val: %d\n", ret);
2126 static void ath10k_pci_override_ce_config(struct ath10k *ar)
2128 struct ce_attr *attr;
2129 struct ce_pipe_config *config;
2131 /* For QCA6174 we're overriding the Copy Engine 5 configuration,
2132 * since it is currently used for other feature.
2135 /* Override Host's Copy Engine 5 configuration */
2136 attr = &host_ce_config_wlan[5];
2137 attr->src_sz_max = 0;
2138 attr->dest_nentries = 0;
2140 /* Override Target firmware's Copy Engine configuration */
2141 config = &target_ce_config_wlan[5];
2142 config->pipedir = __cpu_to_le32(PIPEDIR_OUT);
2143 config->nbytes_max = __cpu_to_le32(2048);
2145 /* Map from service/endpoint to Copy Engine */
2146 target_service_to_ce_map_wlan[15].pipenum = __cpu_to_le32(1);
2149 int ath10k_pci_alloc_pipes(struct ath10k *ar)
2151 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2152 struct ath10k_pci_pipe *pipe;
2155 for (i = 0; i < CE_COUNT; i++) {
2156 pipe = &ar_pci->pipe_info[i];
2157 pipe->ce_hdl = &ar_pci->ce_states[i];
2159 pipe->hif_ce_state = ar;
2161 ret = ath10k_ce_alloc_pipe(ar, i, &host_ce_config_wlan[i]);
2163 ath10k_err(ar, "failed to allocate copy engine pipe %d: %d\n",
2168 /* Last CE is Diagnostic Window */
2169 if (i == CE_DIAG_PIPE) {
2170 ar_pci->ce_diag = pipe->ce_hdl;
2174 pipe->buf_sz = (size_t)(host_ce_config_wlan[i].src_sz_max);
2180 void ath10k_pci_free_pipes(struct ath10k *ar)
2184 for (i = 0; i < CE_COUNT; i++)
2185 ath10k_ce_free_pipe(ar, i);
2188 int ath10k_pci_init_pipes(struct ath10k *ar)
2192 for (i = 0; i < CE_COUNT; i++) {
2193 ret = ath10k_ce_init_pipe(ar, i, &host_ce_config_wlan[i]);
2195 ath10k_err(ar, "failed to initialize copy engine pipe %d: %d\n",
2204 static bool ath10k_pci_has_fw_crashed(struct ath10k *ar)
2206 return ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS) &
2207 FW_IND_EVENT_PENDING;
2210 static void ath10k_pci_fw_crashed_clear(struct ath10k *ar)
2214 val = ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS);
2215 val &= ~FW_IND_EVENT_PENDING;
2216 ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS, val);
2219 /* this function effectively clears target memory controller assert line */
2220 static void ath10k_pci_warm_reset_si0(struct ath10k *ar)
2224 val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2225 ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
2226 val | SOC_RESET_CONTROL_SI0_RST_MASK);
2227 val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2231 val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2232 ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
2233 val & ~SOC_RESET_CONTROL_SI0_RST_MASK);
2234 val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2239 static void ath10k_pci_warm_reset_cpu(struct ath10k *ar)
2243 ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS, 0);
2245 val = ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS +
2246 SOC_RESET_CONTROL_ADDRESS);
2247 ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + SOC_RESET_CONTROL_ADDRESS,
2248 val | SOC_RESET_CONTROL_CPU_WARM_RST_MASK);
2251 static void ath10k_pci_warm_reset_ce(struct ath10k *ar)
2255 val = ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS +
2256 SOC_RESET_CONTROL_ADDRESS);
2258 ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + SOC_RESET_CONTROL_ADDRESS,
2259 val | SOC_RESET_CONTROL_CE_RST_MASK);
2261 ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + SOC_RESET_CONTROL_ADDRESS,
2262 val & ~SOC_RESET_CONTROL_CE_RST_MASK);
2265 static void ath10k_pci_warm_reset_clear_lf(struct ath10k *ar)
2269 val = ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS +
2270 SOC_LF_TIMER_CONTROL0_ADDRESS);
2271 ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS +
2272 SOC_LF_TIMER_CONTROL0_ADDRESS,
2273 val & ~SOC_LF_TIMER_CONTROL0_ENABLE_MASK);
2276 static int ath10k_pci_warm_reset(struct ath10k *ar)
2280 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot warm reset\n");
2282 spin_lock_bh(&ar->data_lock);
2283 ar->stats.fw_warm_reset_counter++;
2284 spin_unlock_bh(&ar->data_lock);
2286 ath10k_pci_irq_disable(ar);
2288 /* Make sure the target CPU is not doing anything dangerous, e.g. if it
2289 * were to access copy engine while host performs copy engine reset
2290 * then it is possible for the device to confuse pci-e controller to
2291 * the point of bringing host system to a complete stop (i.e. hang).
2293 ath10k_pci_warm_reset_si0(ar);
2294 ath10k_pci_warm_reset_cpu(ar);
2295 ath10k_pci_init_pipes(ar);
2296 ath10k_pci_wait_for_target_init(ar);
2298 ath10k_pci_warm_reset_clear_lf(ar);
2299 ath10k_pci_warm_reset_ce(ar);
2300 ath10k_pci_warm_reset_cpu(ar);
2301 ath10k_pci_init_pipes(ar);
2303 ret = ath10k_pci_wait_for_target_init(ar);
2305 ath10k_warn(ar, "failed to wait for target init: %d\n", ret);
2309 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot warm reset complete\n");
2314 static int ath10k_pci_qca99x0_soft_chip_reset(struct ath10k *ar)
2316 ath10k_pci_irq_disable(ar);
2317 return ath10k_pci_qca99x0_chip_reset(ar);
2320 static int ath10k_pci_safe_chip_reset(struct ath10k *ar)
2322 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2324 if (!ar_pci->pci_soft_reset)
2327 return ar_pci->pci_soft_reset(ar);
2330 static int ath10k_pci_qca988x_chip_reset(struct ath10k *ar)
2335 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot 988x chip reset\n");
2337 /* Some hardware revisions (e.g. CUS223v2) has issues with cold reset.
2338 * It is thus preferred to use warm reset which is safer but may not be
2339 * able to recover the device from all possible fail scenarios.
2341 * Warm reset doesn't always work on first try so attempt it a few
2342 * times before giving up.
2344 for (i = 0; i < ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS; i++) {
2345 ret = ath10k_pci_warm_reset(ar);
2347 ath10k_warn(ar, "failed to warm reset attempt %d of %d: %d\n",
2348 i + 1, ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS,
2353 /* FIXME: Sometimes copy engine doesn't recover after warm
2354 * reset. In most cases this needs cold reset. In some of these
2355 * cases the device is in such a state that a cold reset may
2358 * Reading any host interest register via copy engine is
2359 * sufficient to verify if device is capable of booting
2362 ret = ath10k_pci_init_pipes(ar);
2364 ath10k_warn(ar, "failed to init copy engine: %d\n",
2369 ret = ath10k_pci_diag_read32(ar, QCA988X_HOST_INTEREST_ADDRESS,
2372 ath10k_warn(ar, "failed to poke copy engine: %d\n",
2377 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot chip reset complete (warm)\n");
2381 if (ath10k_pci_reset_mode == ATH10K_PCI_RESET_WARM_ONLY) {
2382 ath10k_warn(ar, "refusing cold reset as requested\n");
2386 ret = ath10k_pci_cold_reset(ar);
2388 ath10k_warn(ar, "failed to cold reset: %d\n", ret);
2392 ret = ath10k_pci_wait_for_target_init(ar);
2394 ath10k_warn(ar, "failed to wait for target after cold reset: %d\n",
2399 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca988x chip reset complete (cold)\n");
2404 static int ath10k_pci_qca6174_chip_reset(struct ath10k *ar)
2408 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca6174 chip reset\n");
2410 /* FIXME: QCA6174 requires cold + warm reset to work. */
2412 ret = ath10k_pci_cold_reset(ar);
2414 ath10k_warn(ar, "failed to cold reset: %d\n", ret);
2418 ret = ath10k_pci_wait_for_target_init(ar);
2420 ath10k_warn(ar, "failed to wait for target after cold reset: %d\n",
2425 ret = ath10k_pci_warm_reset(ar);
2427 ath10k_warn(ar, "failed to warm reset: %d\n", ret);
2431 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca6174 chip reset complete (cold)\n");
2436 static int ath10k_pci_qca99x0_chip_reset(struct ath10k *ar)
2440 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca99x0 chip reset\n");
2442 ret = ath10k_pci_cold_reset(ar);
2444 ath10k_warn(ar, "failed to cold reset: %d\n", ret);
2448 ret = ath10k_pci_wait_for_target_init(ar);
2450 ath10k_warn(ar, "failed to wait for target after cold reset: %d\n",
2455 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca99x0 chip reset complete (cold)\n");
2460 static int ath10k_pci_chip_reset(struct ath10k *ar)
2462 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2464 if (WARN_ON(!ar_pci->pci_hard_reset))
2467 return ar_pci->pci_hard_reset(ar);
2470 static int ath10k_pci_hif_power_up(struct ath10k *ar)
2472 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2475 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif power up\n");
2477 pcie_capability_read_word(ar_pci->pdev, PCI_EXP_LNKCTL,
2479 pcie_capability_write_word(ar_pci->pdev, PCI_EXP_LNKCTL,
2480 ar_pci->link_ctl & ~PCI_EXP_LNKCTL_ASPMC);
2483 * Bring the target up cleanly.
2485 * The target may be in an undefined state with an AUX-powered Target
2486 * and a Host in WoW mode. If the Host crashes, loses power, or is
2487 * restarted (without unloading the driver) then the Target is left
2488 * (aux) powered and running. On a subsequent driver load, the Target
2489 * is in an unexpected state. We try to catch that here in order to
2490 * reset the Target and retry the probe.
2492 ret = ath10k_pci_chip_reset(ar);
2494 if (ath10k_pci_has_fw_crashed(ar)) {
2495 ath10k_warn(ar, "firmware crashed during chip reset\n");
2496 ath10k_pci_fw_crashed_clear(ar);
2497 ath10k_pci_fw_crashed_dump(ar);
2500 ath10k_err(ar, "failed to reset chip: %d\n", ret);
2504 ret = ath10k_pci_init_pipes(ar);
2506 ath10k_err(ar, "failed to initialize CE: %d\n", ret);
2510 ret = ath10k_pci_init_config(ar);
2512 ath10k_err(ar, "failed to setup init config: %d\n", ret);
2516 ret = ath10k_pci_wake_target_cpu(ar);
2518 ath10k_err(ar, "could not wake up target CPU: %d\n", ret);
2525 ath10k_pci_ce_deinit(ar);
2531 void ath10k_pci_hif_power_down(struct ath10k *ar)
2533 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif power down\n");
2535 /* Currently hif_power_up performs effectively a reset and hif_stop
2536 * resets the chip as well so there's no point in resetting here.
2542 static int ath10k_pci_hif_suspend(struct ath10k *ar)
2544 /* The grace timer can still be counting down and ar->ps_awake be true.
2545 * It is known that the device may be asleep after resuming regardless
2546 * of the SoC powersave state before suspending. Hence make sure the
2547 * device is asleep before proceeding.
2549 ath10k_pci_sleep_sync(ar);
2554 static int ath10k_pci_hif_resume(struct ath10k *ar)
2556 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2557 struct pci_dev *pdev = ar_pci->pdev;
2561 ret = ath10k_pci_force_wake(ar);
2563 ath10k_err(ar, "failed to wake up target: %d\n", ret);
2567 /* Suspend/Resume resets the PCI configuration space, so we have to
2568 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
2569 * from interfering with C3 CPU state. pci_restore_state won't help
2570 * here since it only restores the first 64 bytes pci config header.
2572 pci_read_config_dword(pdev, 0x40, &val);
2573 if ((val & 0x0000ff00) != 0)
2574 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
2580 static bool ath10k_pci_validate_cal(void *data, size_t size)
2582 __le16 *cal_words = data;
2589 for (i = 0; i < size / 2; i++)
2590 checksum ^= le16_to_cpu(cal_words[i]);
2592 return checksum == 0xffff;
2595 static void ath10k_pci_enable_eeprom(struct ath10k *ar)
2597 /* Enable SI clock */
2598 ath10k_pci_soc_write32(ar, CLOCK_CONTROL_OFFSET, 0x0);
2600 /* Configure GPIOs for I2C operation */
2601 ath10k_pci_write32(ar,
2602 GPIO_BASE_ADDRESS + GPIO_PIN0_OFFSET +
2603 4 * QCA9887_1_0_I2C_SDA_GPIO_PIN,
2604 SM(QCA9887_1_0_I2C_SDA_PIN_CONFIG,
2606 SM(1, GPIO_PIN0_PAD_PULL));
2608 ath10k_pci_write32(ar,
2609 GPIO_BASE_ADDRESS + GPIO_PIN0_OFFSET +
2610 4 * QCA9887_1_0_SI_CLK_GPIO_PIN,
2611 SM(QCA9887_1_0_SI_CLK_PIN_CONFIG, GPIO_PIN0_CONFIG) |
2612 SM(1, GPIO_PIN0_PAD_PULL));
2614 ath10k_pci_write32(ar,
2616 QCA9887_1_0_GPIO_ENABLE_W1TS_LOW_ADDRESS,
2617 1u << QCA9887_1_0_SI_CLK_GPIO_PIN);
2619 /* In Swift ASIC - EEPROM clock will be (110MHz/512) = 214KHz */
2620 ath10k_pci_write32(ar,
2621 SI_BASE_ADDRESS + SI_CONFIG_OFFSET,
2622 SM(1, SI_CONFIG_ERR_INT) |
2623 SM(1, SI_CONFIG_BIDIR_OD_DATA) |
2624 SM(1, SI_CONFIG_I2C) |
2625 SM(1, SI_CONFIG_POS_SAMPLE) |
2626 SM(1, SI_CONFIG_INACTIVE_DATA) |
2627 SM(1, SI_CONFIG_INACTIVE_CLK) |
2628 SM(8, SI_CONFIG_DIVIDER));
2631 static int ath10k_pci_read_eeprom(struct ath10k *ar, u16 addr, u8 *out)
2636 /* set device select byte and for the read operation */
2637 reg = QCA9887_EEPROM_SELECT_READ |
2638 SM(addr, QCA9887_EEPROM_ADDR_LO) |
2639 SM(addr >> 8, QCA9887_EEPROM_ADDR_HI);
2640 ath10k_pci_write32(ar, SI_BASE_ADDRESS + SI_TX_DATA0_OFFSET, reg);
2642 /* write transmit data, transfer length, and START bit */
2643 ath10k_pci_write32(ar, SI_BASE_ADDRESS + SI_CS_OFFSET,
2644 SM(1, SI_CS_START) | SM(1, SI_CS_RX_CNT) |
2645 SM(4, SI_CS_TX_CNT));
2647 /* wait max 1 sec */
2648 wait_limit = 100000;
2650 /* wait for SI_CS_DONE_INT */
2652 reg = ath10k_pci_read32(ar, SI_BASE_ADDRESS + SI_CS_OFFSET);
2653 if (MS(reg, SI_CS_DONE_INT))
2658 } while (wait_limit > 0);
2660 if (!MS(reg, SI_CS_DONE_INT)) {
2661 ath10k_err(ar, "timeout while reading device EEPROM at %04x\n",
2666 /* clear SI_CS_DONE_INT */
2667 ath10k_pci_write32(ar, SI_BASE_ADDRESS + SI_CS_OFFSET, reg);
2669 if (MS(reg, SI_CS_DONE_ERR)) {
2670 ath10k_err(ar, "failed to read device EEPROM at %04x\n", addr);
2674 /* extract receive data */
2675 reg = ath10k_pci_read32(ar, SI_BASE_ADDRESS + SI_RX_DATA0_OFFSET);
2681 static int ath10k_pci_hif_fetch_cal_eeprom(struct ath10k *ar, void **data,
2688 if (!QCA_REV_9887(ar))
2691 calsize = ar->hw_params.cal_data_len;
2692 caldata = kmalloc(calsize, GFP_KERNEL);
2696 ath10k_pci_enable_eeprom(ar);
2698 for (i = 0; i < calsize; i++) {
2699 ret = ath10k_pci_read_eeprom(ar, i, &caldata[i]);
2704 if (!ath10k_pci_validate_cal(caldata, calsize))
2708 *data_len = calsize;
2718 static const struct ath10k_hif_ops ath10k_pci_hif_ops = {
2719 .tx_sg = ath10k_pci_hif_tx_sg,
2720 .diag_read = ath10k_pci_hif_diag_read,
2721 .diag_write = ath10k_pci_diag_write_mem,
2722 .exchange_bmi_msg = ath10k_pci_hif_exchange_bmi_msg,
2723 .start = ath10k_pci_hif_start,
2724 .stop = ath10k_pci_hif_stop,
2725 .map_service_to_pipe = ath10k_pci_hif_map_service_to_pipe,
2726 .get_default_pipe = ath10k_pci_hif_get_default_pipe,
2727 .send_complete_check = ath10k_pci_hif_send_complete_check,
2728 .get_free_queue_number = ath10k_pci_hif_get_free_queue_number,
2729 .power_up = ath10k_pci_hif_power_up,
2730 .power_down = ath10k_pci_hif_power_down,
2731 .read32 = ath10k_pci_read32,
2732 .write32 = ath10k_pci_write32,
2734 .suspend = ath10k_pci_hif_suspend,
2735 .resume = ath10k_pci_hif_resume,
2737 .fetch_cal_eeprom = ath10k_pci_hif_fetch_cal_eeprom,
2741 * Top-level interrupt handler for all PCI interrupts from a Target.
2742 * When a block of MSI interrupts is allocated, this top-level handler
2743 * is not used; instead, we directly call the correct sub-handler.
2745 static irqreturn_t ath10k_pci_interrupt_handler(int irq, void *arg)
2747 struct ath10k *ar = arg;
2748 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2751 ret = ath10k_pci_force_wake(ar);
2753 ath10k_warn(ar, "failed to wake device up on irq: %d\n", ret);
2757 if (ar_pci->oper_irq_mode == ATH10K_PCI_IRQ_LEGACY) {
2758 if (!ath10k_pci_irq_pending(ar))
2761 ath10k_pci_disable_and_clear_legacy_irq(ar);
2764 tasklet_schedule(&ar_pci->intr_tq);
2769 static void ath10k_pci_tasklet(unsigned long data)
2771 struct ath10k *ar = (struct ath10k *)data;
2772 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2774 if (ath10k_pci_has_fw_crashed(ar)) {
2775 ath10k_pci_irq_disable(ar);
2776 ath10k_pci_fw_crashed_clear(ar);
2777 ath10k_pci_fw_crashed_dump(ar);
2781 ath10k_ce_per_engine_service_any(ar);
2783 /* Re-enable legacy irq that was disabled in the irq handler */
2784 if (ar_pci->oper_irq_mode == ATH10K_PCI_IRQ_LEGACY)
2785 ath10k_pci_enable_legacy_irq(ar);
2788 static int ath10k_pci_request_irq_msi(struct ath10k *ar)
2790 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2793 ret = request_irq(ar_pci->pdev->irq,
2794 ath10k_pci_interrupt_handler,
2795 IRQF_SHARED, "ath10k_pci", ar);
2797 ath10k_warn(ar, "failed to request MSI irq %d: %d\n",
2798 ar_pci->pdev->irq, ret);
2805 static int ath10k_pci_request_irq_legacy(struct ath10k *ar)
2807 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2810 ret = request_irq(ar_pci->pdev->irq,
2811 ath10k_pci_interrupt_handler,
2812 IRQF_SHARED, "ath10k_pci", ar);
2814 ath10k_warn(ar, "failed to request legacy irq %d: %d\n",
2815 ar_pci->pdev->irq, ret);
2822 static int ath10k_pci_request_irq(struct ath10k *ar)
2824 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2826 switch (ar_pci->oper_irq_mode) {
2827 case ATH10K_PCI_IRQ_LEGACY:
2828 return ath10k_pci_request_irq_legacy(ar);
2829 case ATH10K_PCI_IRQ_MSI:
2830 return ath10k_pci_request_irq_msi(ar);
2836 static void ath10k_pci_free_irq(struct ath10k *ar)
2838 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2840 free_irq(ar_pci->pdev->irq, ar);
2843 void ath10k_pci_init_irq_tasklets(struct ath10k *ar)
2845 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2847 tasklet_init(&ar_pci->intr_tq, ath10k_pci_tasklet, (unsigned long)ar);
2850 static int ath10k_pci_init_irq(struct ath10k *ar)
2852 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2855 ath10k_pci_init_irq_tasklets(ar);
2857 if (ath10k_pci_irq_mode != ATH10K_PCI_IRQ_AUTO)
2858 ath10k_info(ar, "limiting irq mode to: %d\n",
2859 ath10k_pci_irq_mode);
2862 if (ath10k_pci_irq_mode != ATH10K_PCI_IRQ_LEGACY) {
2863 ar_pci->oper_irq_mode = ATH10K_PCI_IRQ_MSI;
2864 ret = pci_enable_msi(ar_pci->pdev);
2873 * A potential race occurs here: The CORE_BASE write
2874 * depends on target correctly decoding AXI address but
2875 * host won't know when target writes BAR to CORE_CTRL.
2876 * This write might get lost if target has NOT written BAR.
2877 * For now, fix the race by repeating the write in below
2878 * synchronization checking. */
2879 ar_pci->oper_irq_mode = ATH10K_PCI_IRQ_LEGACY;
2881 ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
2882 PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
2887 static void ath10k_pci_deinit_irq_legacy(struct ath10k *ar)
2889 ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
2893 static int ath10k_pci_deinit_irq(struct ath10k *ar)
2895 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2897 switch (ar_pci->oper_irq_mode) {
2898 case ATH10K_PCI_IRQ_LEGACY:
2899 ath10k_pci_deinit_irq_legacy(ar);
2902 pci_disable_msi(ar_pci->pdev);
2909 int ath10k_pci_wait_for_target_init(struct ath10k *ar)
2911 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2912 unsigned long timeout;
2915 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot waiting target to initialise\n");
2917 timeout = jiffies + msecs_to_jiffies(ATH10K_PCI_TARGET_WAIT);
2920 val = ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS);
2922 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot target indicator %x\n",
2925 /* target should never return this */
2926 if (val == 0xffffffff)
2929 /* the device has crashed so don't bother trying anymore */
2930 if (val & FW_IND_EVENT_PENDING)
2933 if (val & FW_IND_INITIALIZED)
2936 if (ar_pci->oper_irq_mode == ATH10K_PCI_IRQ_LEGACY)
2937 /* Fix potential race by repeating CORE_BASE writes */
2938 ath10k_pci_enable_legacy_irq(ar);
2941 } while (time_before(jiffies, timeout));
2943 ath10k_pci_disable_and_clear_legacy_irq(ar);
2944 ath10k_pci_irq_msi_fw_mask(ar);
2946 if (val == 0xffffffff) {
2947 ath10k_err(ar, "failed to read device register, device is gone\n");
2951 if (val & FW_IND_EVENT_PENDING) {
2952 ath10k_warn(ar, "device has crashed during init\n");
2956 if (!(val & FW_IND_INITIALIZED)) {
2957 ath10k_err(ar, "failed to receive initialized event from target: %08x\n",
2962 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot target initialised\n");
2966 static int ath10k_pci_cold_reset(struct ath10k *ar)
2970 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cold reset\n");
2972 spin_lock_bh(&ar->data_lock);
2974 ar->stats.fw_cold_reset_counter++;
2976 spin_unlock_bh(&ar->data_lock);
2978 /* Put Target, including PCIe, into RESET. */
2979 val = ath10k_pci_reg_read32(ar, SOC_GLOBAL_RESET_ADDRESS);
2981 ath10k_pci_reg_write32(ar, SOC_GLOBAL_RESET_ADDRESS, val);
2983 /* After writing into SOC_GLOBAL_RESET to put device into
2984 * reset and pulling out of reset pcie may not be stable
2985 * for any immediate pcie register access and cause bus error,
2986 * add delay before any pcie access request to fix this issue.
2990 /* Pull Target, including PCIe, out of RESET. */
2992 ath10k_pci_reg_write32(ar, SOC_GLOBAL_RESET_ADDRESS, val);
2996 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cold reset complete\n");
3001 static int ath10k_pci_claim(struct ath10k *ar)
3003 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3004 struct pci_dev *pdev = ar_pci->pdev;
3007 pci_set_drvdata(pdev, ar);
3009 ret = pci_enable_device(pdev);
3011 ath10k_err(ar, "failed to enable pci device: %d\n", ret);
3015 ret = pci_request_region(pdev, BAR_NUM, "ath");
3017 ath10k_err(ar, "failed to request region BAR%d: %d\n", BAR_NUM,
3022 /* Target expects 32 bit DMA. Enforce it. */
3023 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
3025 ath10k_err(ar, "failed to set dma mask to 32-bit: %d\n", ret);
3029 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
3031 ath10k_err(ar, "failed to set consistent dma mask to 32-bit: %d\n",
3036 pci_set_master(pdev);
3038 /* Arrange for access to Target SoC registers. */
3039 ar_pci->mem_len = pci_resource_len(pdev, BAR_NUM);
3040 ar_pci->mem = pci_iomap(pdev, BAR_NUM, 0);
3042 ath10k_err(ar, "failed to iomap BAR%d\n", BAR_NUM);
3047 ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot pci_mem 0x%p\n", ar_pci->mem);
3051 pci_clear_master(pdev);
3054 pci_release_region(pdev, BAR_NUM);
3057 pci_disable_device(pdev);
3062 static void ath10k_pci_release(struct ath10k *ar)
3064 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3065 struct pci_dev *pdev = ar_pci->pdev;
3067 pci_iounmap(pdev, ar_pci->mem);
3068 pci_release_region(pdev, BAR_NUM);
3069 pci_clear_master(pdev);
3070 pci_disable_device(pdev);
3073 static bool ath10k_pci_chip_is_supported(u32 dev_id, u32 chip_id)
3075 const struct ath10k_pci_supp_chip *supp_chip;
3077 u32 rev_id = MS(chip_id, SOC_CHIP_ID_REV);
3079 for (i = 0; i < ARRAY_SIZE(ath10k_pci_supp_chips); i++) {
3080 supp_chip = &ath10k_pci_supp_chips[i];
3082 if (supp_chip->dev_id == dev_id &&
3083 supp_chip->rev_id == rev_id)
3090 int ath10k_pci_setup_resource(struct ath10k *ar)
3092 struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3095 spin_lock_init(&ar_pci->ce_lock);
3096 spin_lock_init(&ar_pci->ps_lock);
3098 setup_timer(&ar_pci->rx_post_retry, ath10k_pci_rx_replenish_retry,
3101 if (QCA_REV_6174(ar))
3102 ath10k_pci_override_ce_config(ar);
3104 ret = ath10k_pci_alloc_pipes(ar);
3106 ath10k_err(ar, "failed to allocate copy engine pipes: %d\n",
3114 void ath10k_pci_release_resource(struct ath10k *ar)
3116 ath10k_pci_kill_tasklet(ar);
3117 ath10k_pci_ce_deinit(ar);
3118 ath10k_pci_free_pipes(ar);
3121 static const struct ath10k_bus_ops ath10k_pci_bus_ops = {
3122 .read32 = ath10k_bus_pci_read32,
3123 .write32 = ath10k_bus_pci_write32,
3124 .get_num_banks = ath10k_pci_get_num_banks,
3127 static int ath10k_pci_probe(struct pci_dev *pdev,
3128 const struct pci_device_id *pci_dev)
3132 struct ath10k_pci *ar_pci;
3133 enum ath10k_hw_rev hw_rev;
3136 int (*pci_soft_reset)(struct ath10k *ar);
3137 int (*pci_hard_reset)(struct ath10k *ar);
3139 switch (pci_dev->device) {
3140 case QCA988X_2_0_DEVICE_ID:
3141 hw_rev = ATH10K_HW_QCA988X;
3143 pci_soft_reset = ath10k_pci_warm_reset;
3144 pci_hard_reset = ath10k_pci_qca988x_chip_reset;
3146 case QCA9887_1_0_DEVICE_ID:
3147 dev_warn(&pdev->dev, "QCA9887 support is still experimental, there are likely bugs. You have been warned.\n");
3148 hw_rev = ATH10K_HW_QCA9887;
3150 pci_soft_reset = ath10k_pci_warm_reset;
3151 pci_hard_reset = ath10k_pci_qca988x_chip_reset;
3153 case QCA6164_2_1_DEVICE_ID:
3154 case QCA6174_2_1_DEVICE_ID:
3155 hw_rev = ATH10K_HW_QCA6174;
3157 pci_soft_reset = ath10k_pci_warm_reset;
3158 pci_hard_reset = ath10k_pci_qca6174_chip_reset;
3160 case QCA99X0_2_0_DEVICE_ID:
3161 hw_rev = ATH10K_HW_QCA99X0;
3163 pci_soft_reset = ath10k_pci_qca99x0_soft_chip_reset;
3164 pci_hard_reset = ath10k_pci_qca99x0_chip_reset;
3166 case QCA9984_1_0_DEVICE_ID:
3167 hw_rev = ATH10K_HW_QCA9984;
3169 pci_soft_reset = ath10k_pci_qca99x0_soft_chip_reset;
3170 pci_hard_reset = ath10k_pci_qca99x0_chip_reset;
3172 case QCA9377_1_0_DEVICE_ID:
3173 hw_rev = ATH10K_HW_QCA9377;
3175 pci_soft_reset = NULL;
3176 pci_hard_reset = ath10k_pci_qca6174_chip_reset;
3183 ar = ath10k_core_create(sizeof(*ar_pci), &pdev->dev, ATH10K_BUS_PCI,
3184 hw_rev, &ath10k_pci_hif_ops);
3186 dev_err(&pdev->dev, "failed to allocate core\n");
3190 ath10k_dbg(ar, ATH10K_DBG_BOOT, "pci probe %04x:%04x %04x:%04x\n",
3191 pdev->vendor, pdev->device,
3192 pdev->subsystem_vendor, pdev->subsystem_device);
3194 ar_pci = ath10k_pci_priv(ar);
3195 ar_pci->pdev = pdev;
3196 ar_pci->dev = &pdev->dev;
3198 ar->dev_id = pci_dev->device;
3199 ar_pci->pci_ps = pci_ps;
3200 ar_pci->bus_ops = &ath10k_pci_bus_ops;
3201 ar_pci->pci_soft_reset = pci_soft_reset;
3202 ar_pci->pci_hard_reset = pci_hard_reset;
3204 ar->id.vendor = pdev->vendor;
3205 ar->id.device = pdev->device;
3206 ar->id.subsystem_vendor = pdev->subsystem_vendor;
3207 ar->id.subsystem_device = pdev->subsystem_device;
3209 setup_timer(&ar_pci->ps_timer, ath10k_pci_ps_timer,
3212 ret = ath10k_pci_setup_resource(ar);
3214 ath10k_err(ar, "failed to setup resource: %d\n", ret);
3215 goto err_core_destroy;
3218 ret = ath10k_pci_claim(ar);
3220 ath10k_err(ar, "failed to claim device: %d\n", ret);
3221 goto err_free_pipes;
3224 ret = ath10k_pci_force_wake(ar);
3226 ath10k_warn(ar, "failed to wake up device : %d\n", ret);
3230 ath10k_pci_ce_deinit(ar);
3231 ath10k_pci_irq_disable(ar);
3233 ret = ath10k_pci_init_irq(ar);
3235 ath10k_err(ar, "failed to init irqs: %d\n", ret);
3239 ath10k_info(ar, "pci irq %s oper_irq_mode %d irq_mode %d reset_mode %d\n",
3240 ath10k_pci_get_irq_method(ar), ar_pci->oper_irq_mode,
3241 ath10k_pci_irq_mode, ath10k_pci_reset_mode);
3243 ret = ath10k_pci_request_irq(ar);
3245 ath10k_warn(ar, "failed to request irqs: %d\n", ret);
3246 goto err_deinit_irq;
3249 ret = ath10k_pci_chip_reset(ar);
3251 ath10k_err(ar, "failed to reset chip: %d\n", ret);
3255 chip_id = ath10k_pci_soc_read32(ar, SOC_CHIP_ID_ADDRESS);
3256 if (chip_id == 0xffffffff) {
3257 ath10k_err(ar, "failed to get chip id\n");
3261 if (!ath10k_pci_chip_is_supported(pdev->device, chip_id)) {
3262 ath10k_err(ar, "device %04x with chip_id %08x isn't supported\n",
3263 pdev->device, chip_id);
3267 ret = ath10k_core_register(ar, chip_id);
3269 ath10k_err(ar, "failed to register driver core: %d\n", ret);
3276 ath10k_pci_free_irq(ar);
3277 ath10k_pci_kill_tasklet(ar);
3280 ath10k_pci_deinit_irq(ar);
3283 ath10k_pci_sleep_sync(ar);
3284 ath10k_pci_release(ar);
3287 ath10k_pci_free_pipes(ar);
3290 ath10k_core_destroy(ar);
3295 static void ath10k_pci_remove(struct pci_dev *pdev)
3297 struct ath10k *ar = pci_get_drvdata(pdev);
3298 struct ath10k_pci *ar_pci;
3300 ath10k_dbg(ar, ATH10K_DBG_PCI, "pci remove\n");
3305 ar_pci = ath10k_pci_priv(ar);
3310 ath10k_core_unregister(ar);
3311 ath10k_pci_free_irq(ar);
3312 ath10k_pci_deinit_irq(ar);
3313 ath10k_pci_release_resource(ar);
3314 ath10k_pci_sleep_sync(ar);
3315 ath10k_pci_release(ar);
3316 ath10k_core_destroy(ar);
3319 MODULE_DEVICE_TABLE(pci, ath10k_pci_id_table);
3321 static struct pci_driver ath10k_pci_driver = {
3322 .name = "ath10k_pci",
3323 .id_table = ath10k_pci_id_table,
3324 .probe = ath10k_pci_probe,
3325 .remove = ath10k_pci_remove,
3328 static int __init ath10k_pci_init(void)
3332 ret = pci_register_driver(&ath10k_pci_driver);
3334 printk(KERN_ERR "failed to register ath10k pci driver: %d\n",
3337 ret = ath10k_ahb_init();
3339 printk(KERN_ERR "ahb init failed: %d\n", ret);
3343 module_init(ath10k_pci_init);
3345 static void __exit ath10k_pci_exit(void)
3347 pci_unregister_driver(&ath10k_pci_driver);
3351 module_exit(ath10k_pci_exit);
3353 MODULE_AUTHOR("Qualcomm Atheros");
3354 MODULE_DESCRIPTION("Driver support for Qualcomm Atheros 802.11ac WLAN PCIe/AHB devices");
3355 MODULE_LICENSE("Dual BSD/GPL");
3357 /* QCA988x 2.0 firmware files */
3358 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API2_FILE);
3359 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API3_FILE);
3360 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API4_FILE);
3361 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API5_FILE);
3362 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" QCA988X_HW_2_0_BOARD_DATA_FILE);
3363 MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_BOARD_API2_FILE);
3365 /* QCA9887 1.0 firmware files */
3366 MODULE_FIRMWARE(QCA9887_HW_1_0_FW_DIR "/" ATH10K_FW_API5_FILE);
3367 MODULE_FIRMWARE(QCA9887_HW_1_0_FW_DIR "/" QCA9887_HW_1_0_BOARD_DATA_FILE);
3368 MODULE_FIRMWARE(QCA9887_HW_1_0_FW_DIR "/" ATH10K_BOARD_API2_FILE);
3370 /* QCA6174 2.1 firmware files */
3371 MODULE_FIRMWARE(QCA6174_HW_2_1_FW_DIR "/" ATH10K_FW_API4_FILE);
3372 MODULE_FIRMWARE(QCA6174_HW_2_1_FW_DIR "/" ATH10K_FW_API5_FILE);
3373 MODULE_FIRMWARE(QCA6174_HW_2_1_FW_DIR "/" QCA6174_HW_2_1_BOARD_DATA_FILE);
3374 MODULE_FIRMWARE(QCA6174_HW_2_1_FW_DIR "/" ATH10K_BOARD_API2_FILE);
3376 /* QCA6174 3.1 firmware files */
3377 MODULE_FIRMWARE(QCA6174_HW_3_0_FW_DIR "/" ATH10K_FW_API4_FILE);
3378 MODULE_FIRMWARE(QCA6174_HW_3_0_FW_DIR "/" ATH10K_FW_API5_FILE);
3379 MODULE_FIRMWARE(QCA6174_HW_3_0_FW_DIR "/" QCA6174_HW_3_0_BOARD_DATA_FILE);
3380 MODULE_FIRMWARE(QCA6174_HW_3_0_FW_DIR "/" ATH10K_BOARD_API2_FILE);
3382 /* QCA9377 1.0 firmware files */
3383 MODULE_FIRMWARE(QCA9377_HW_1_0_FW_DIR "/" ATH10K_FW_API5_FILE);
3384 MODULE_FIRMWARE(QCA9377_HW_1_0_FW_DIR "/" QCA9377_HW_1_0_BOARD_DATA_FILE);