Branch data Line data Source code
1 : : // SPDX-License-Identifier: ISC
2 : : /*
3 : : * Copyright (c) 2005-2011 Atheros Communications Inc.
4 : : * Copyright (c) 2011-2017 Qualcomm Atheros, Inc.
5 : : */
6 : :
7 : : #include <linux/pci.h>
8 : : #include <linux/module.h>
9 : : #include <linux/interrupt.h>
10 : : #include <linux/spinlock.h>
11 : : #include <linux/bitops.h>
12 : :
13 : : #include "core.h"
14 : : #include "debug.h"
15 : : #include "coredump.h"
16 : :
17 : : #include "targaddrs.h"
18 : : #include "bmi.h"
19 : :
20 : : #include "hif.h"
21 : : #include "htc.h"
22 : :
23 : : #include "ce.h"
24 : : #include "pci.h"
25 : :
26 : : enum ath10k_pci_reset_mode {
27 : : ATH10K_PCI_RESET_AUTO = 0,
28 : : ATH10K_PCI_RESET_WARM_ONLY = 1,
29 : : };
30 : :
31 : : static unsigned int ath10k_pci_irq_mode = ATH10K_PCI_IRQ_AUTO;
32 : : static unsigned int ath10k_pci_reset_mode = ATH10K_PCI_RESET_AUTO;
33 : :
34 : : module_param_named(irq_mode, ath10k_pci_irq_mode, uint, 0644);
35 : : MODULE_PARM_DESC(irq_mode, "0: auto, 1: legacy, 2: msi (default: 0)");
36 : :
37 : : module_param_named(reset_mode, ath10k_pci_reset_mode, uint, 0644);
38 : : MODULE_PARM_DESC(reset_mode, "0: auto, 1: warm only (default: 0)");
39 : :
40 : : /* how long wait to wait for target to initialise, in ms */
41 : : #define ATH10K_PCI_TARGET_WAIT 3000
42 : : #define ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS 3
43 : :
44 : : /* Maximum number of bytes that can be handled atomically by
45 : : * diag read and write.
46 : : */
47 : : #define ATH10K_DIAG_TRANSFER_LIMIT 0x5000
48 : :
49 : : #define QCA99X0_PCIE_BAR0_START_REG 0x81030
50 : : #define QCA99X0_CPU_MEM_ADDR_REG 0x4d00c
51 : : #define QCA99X0_CPU_MEM_DATA_REG 0x4d010
52 : :
53 : : static const struct pci_device_id ath10k_pci_id_table[] = {
54 : : /* PCI-E QCA988X V2 (Ubiquiti branded) */
55 : : { PCI_VDEVICE(UBIQUITI, QCA988X_2_0_DEVICE_ID_UBNT) },
56 : :
57 : : { PCI_VDEVICE(ATHEROS, QCA988X_2_0_DEVICE_ID) }, /* PCI-E QCA988X V2 */
58 : : { PCI_VDEVICE(ATHEROS, QCA6164_2_1_DEVICE_ID) }, /* PCI-E QCA6164 V2.1 */
59 : : { PCI_VDEVICE(ATHEROS, QCA6174_2_1_DEVICE_ID) }, /* PCI-E QCA6174 V2.1 */
60 : : { PCI_VDEVICE(ATHEROS, QCA99X0_2_0_DEVICE_ID) }, /* PCI-E QCA99X0 V2 */
61 : : { PCI_VDEVICE(ATHEROS, QCA9888_2_0_DEVICE_ID) }, /* PCI-E QCA9888 V2 */
62 : : { PCI_VDEVICE(ATHEROS, QCA9984_1_0_DEVICE_ID) }, /* PCI-E QCA9984 V1 */
63 : : { PCI_VDEVICE(ATHEROS, QCA9377_1_0_DEVICE_ID) }, /* PCI-E QCA9377 V1 */
64 : : { PCI_VDEVICE(ATHEROS, QCA9887_1_0_DEVICE_ID) }, /* PCI-E QCA9887 */
65 : : {0}
66 : : };
67 : :
68 : : static const struct ath10k_pci_supp_chip ath10k_pci_supp_chips[] = {
69 : : /* QCA988X pre 2.0 chips are not supported because they need some nasty
70 : : * hacks. ath10k doesn't have them and these devices crash horribly
71 : : * because of that.
72 : : */
73 : : { QCA988X_2_0_DEVICE_ID_UBNT, QCA988X_HW_2_0_CHIP_ID_REV },
74 : : { QCA988X_2_0_DEVICE_ID, QCA988X_HW_2_0_CHIP_ID_REV },
75 : :
76 : : { QCA6164_2_1_DEVICE_ID, QCA6174_HW_2_1_CHIP_ID_REV },
77 : : { QCA6164_2_1_DEVICE_ID, QCA6174_HW_2_2_CHIP_ID_REV },
78 : : { QCA6164_2_1_DEVICE_ID, QCA6174_HW_3_0_CHIP_ID_REV },
79 : : { QCA6164_2_1_DEVICE_ID, QCA6174_HW_3_1_CHIP_ID_REV },
80 : : { QCA6164_2_1_DEVICE_ID, QCA6174_HW_3_2_CHIP_ID_REV },
81 : :
82 : : { QCA6174_2_1_DEVICE_ID, QCA6174_HW_2_1_CHIP_ID_REV },
83 : : { QCA6174_2_1_DEVICE_ID, QCA6174_HW_2_2_CHIP_ID_REV },
84 : : { QCA6174_2_1_DEVICE_ID, QCA6174_HW_3_0_CHIP_ID_REV },
85 : : { QCA6174_2_1_DEVICE_ID, QCA6174_HW_3_1_CHIP_ID_REV },
86 : : { QCA6174_2_1_DEVICE_ID, QCA6174_HW_3_2_CHIP_ID_REV },
87 : :
88 : : { QCA99X0_2_0_DEVICE_ID, QCA99X0_HW_2_0_CHIP_ID_REV },
89 : :
90 : : { QCA9984_1_0_DEVICE_ID, QCA9984_HW_1_0_CHIP_ID_REV },
91 : :
92 : : { QCA9888_2_0_DEVICE_ID, QCA9888_HW_2_0_CHIP_ID_REV },
93 : :
94 : : { QCA9377_1_0_DEVICE_ID, QCA9377_HW_1_0_CHIP_ID_REV },
95 : : { QCA9377_1_0_DEVICE_ID, QCA9377_HW_1_1_CHIP_ID_REV },
96 : :
97 : : { QCA9887_1_0_DEVICE_ID, QCA9887_HW_1_0_CHIP_ID_REV },
98 : : };
99 : :
100 : : static void ath10k_pci_buffer_cleanup(struct ath10k *ar);
101 : : static int ath10k_pci_cold_reset(struct ath10k *ar);
102 : : static int ath10k_pci_safe_chip_reset(struct ath10k *ar);
103 : : static int ath10k_pci_init_irq(struct ath10k *ar);
104 : : static int ath10k_pci_deinit_irq(struct ath10k *ar);
105 : : static int ath10k_pci_request_irq(struct ath10k *ar);
106 : : static void ath10k_pci_free_irq(struct ath10k *ar);
107 : : static int ath10k_pci_bmi_wait(struct ath10k *ar,
108 : : struct ath10k_ce_pipe *tx_pipe,
109 : : struct ath10k_ce_pipe *rx_pipe,
110 : : struct bmi_xfer *xfer);
111 : : static int ath10k_pci_qca99x0_chip_reset(struct ath10k *ar);
112 : : static void ath10k_pci_htc_tx_cb(struct ath10k_ce_pipe *ce_state);
113 : : static void ath10k_pci_htc_rx_cb(struct ath10k_ce_pipe *ce_state);
114 : : static void ath10k_pci_htt_tx_cb(struct ath10k_ce_pipe *ce_state);
115 : : static void ath10k_pci_htt_rx_cb(struct ath10k_ce_pipe *ce_state);
116 : : static void ath10k_pci_htt_htc_rx_cb(struct ath10k_ce_pipe *ce_state);
117 : : static void ath10k_pci_pktlog_rx_cb(struct ath10k_ce_pipe *ce_state);
118 : :
119 : : static struct ce_attr host_ce_config_wlan[] = {
120 : : /* CE0: host->target HTC control and raw streams */
121 : : {
122 : : .flags = CE_ATTR_FLAGS,
123 : : .src_nentries = 16,
124 : : .src_sz_max = 256,
125 : : .dest_nentries = 0,
126 : : .send_cb = ath10k_pci_htc_tx_cb,
127 : : },
128 : :
129 : : /* CE1: target->host HTT + HTC control */
130 : : {
131 : : .flags = CE_ATTR_FLAGS,
132 : : .src_nentries = 0,
133 : : .src_sz_max = 2048,
134 : : .dest_nentries = 512,
135 : : .recv_cb = ath10k_pci_htt_htc_rx_cb,
136 : : },
137 : :
138 : : /* CE2: target->host WMI */
139 : : {
140 : : .flags = CE_ATTR_FLAGS,
141 : : .src_nentries = 0,
142 : : .src_sz_max = 2048,
143 : : .dest_nentries = 128,
144 : : .recv_cb = ath10k_pci_htc_rx_cb,
145 : : },
146 : :
147 : : /* CE3: host->target WMI */
148 : : {
149 : : .flags = CE_ATTR_FLAGS,
150 : : .src_nentries = 32,
151 : : .src_sz_max = 2048,
152 : : .dest_nentries = 0,
153 : : .send_cb = ath10k_pci_htc_tx_cb,
154 : : },
155 : :
156 : : /* CE4: host->target HTT */
157 : : {
158 : : .flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR,
159 : : .src_nentries = CE_HTT_H2T_MSG_SRC_NENTRIES,
160 : : .src_sz_max = 256,
161 : : .dest_nentries = 0,
162 : : .send_cb = ath10k_pci_htt_tx_cb,
163 : : },
164 : :
165 : : /* CE5: target->host HTT (HIF->HTT) */
166 : : {
167 : : .flags = CE_ATTR_FLAGS,
168 : : .src_nentries = 0,
169 : : .src_sz_max = 512,
170 : : .dest_nentries = 512,
171 : : .recv_cb = ath10k_pci_htt_rx_cb,
172 : : },
173 : :
174 : : /* CE6: target autonomous hif_memcpy */
175 : : {
176 : : .flags = CE_ATTR_FLAGS,
177 : : .src_nentries = 0,
178 : : .src_sz_max = 0,
179 : : .dest_nentries = 0,
180 : : },
181 : :
182 : : /* CE7: ce_diag, the Diagnostic Window */
183 : : {
184 : : .flags = CE_ATTR_FLAGS | CE_ATTR_POLL,
185 : : .src_nentries = 2,
186 : : .src_sz_max = DIAG_TRANSFER_LIMIT,
187 : : .dest_nentries = 2,
188 : : },
189 : :
190 : : /* CE8: target->host pktlog */
191 : : {
192 : : .flags = CE_ATTR_FLAGS,
193 : : .src_nentries = 0,
194 : : .src_sz_max = 2048,
195 : : .dest_nentries = 128,
196 : : .recv_cb = ath10k_pci_pktlog_rx_cb,
197 : : },
198 : :
199 : : /* CE9 target autonomous qcache memcpy */
200 : : {
201 : : .flags = CE_ATTR_FLAGS,
202 : : .src_nentries = 0,
203 : : .src_sz_max = 0,
204 : : .dest_nentries = 0,
205 : : },
206 : :
207 : : /* CE10: target autonomous hif memcpy */
208 : : {
209 : : .flags = CE_ATTR_FLAGS,
210 : : .src_nentries = 0,
211 : : .src_sz_max = 0,
212 : : .dest_nentries = 0,
213 : : },
214 : :
215 : : /* CE11: target autonomous hif memcpy */
216 : : {
217 : : .flags = CE_ATTR_FLAGS,
218 : : .src_nentries = 0,
219 : : .src_sz_max = 0,
220 : : .dest_nentries = 0,
221 : : },
222 : : };
223 : :
224 : : /* Target firmware's Copy Engine configuration. */
225 : : static struct ce_pipe_config target_ce_config_wlan[] = {
226 : : /* CE0: host->target HTC control and raw streams */
227 : : {
228 : : .pipenum = __cpu_to_le32(0),
229 : : .pipedir = __cpu_to_le32(PIPEDIR_OUT),
230 : : .nentries = __cpu_to_le32(32),
231 : : .nbytes_max = __cpu_to_le32(256),
232 : : .flags = __cpu_to_le32(CE_ATTR_FLAGS),
233 : : .reserved = __cpu_to_le32(0),
234 : : },
235 : :
236 : : /* CE1: target->host HTT + HTC control */
237 : : {
238 : : .pipenum = __cpu_to_le32(1),
239 : : .pipedir = __cpu_to_le32(PIPEDIR_IN),
240 : : .nentries = __cpu_to_le32(32),
241 : : .nbytes_max = __cpu_to_le32(2048),
242 : : .flags = __cpu_to_le32(CE_ATTR_FLAGS),
243 : : .reserved = __cpu_to_le32(0),
244 : : },
245 : :
246 : : /* CE2: target->host WMI */
247 : : {
248 : : .pipenum = __cpu_to_le32(2),
249 : : .pipedir = __cpu_to_le32(PIPEDIR_IN),
250 : : .nentries = __cpu_to_le32(64),
251 : : .nbytes_max = __cpu_to_le32(2048),
252 : : .flags = __cpu_to_le32(CE_ATTR_FLAGS),
253 : : .reserved = __cpu_to_le32(0),
254 : : },
255 : :
256 : : /* CE3: host->target WMI */
257 : : {
258 : : .pipenum = __cpu_to_le32(3),
259 : : .pipedir = __cpu_to_le32(PIPEDIR_OUT),
260 : : .nentries = __cpu_to_le32(32),
261 : : .nbytes_max = __cpu_to_le32(2048),
262 : : .flags = __cpu_to_le32(CE_ATTR_FLAGS),
263 : : .reserved = __cpu_to_le32(0),
264 : : },
265 : :
266 : : /* CE4: host->target HTT */
267 : : {
268 : : .pipenum = __cpu_to_le32(4),
269 : : .pipedir = __cpu_to_le32(PIPEDIR_OUT),
270 : : .nentries = __cpu_to_le32(256),
271 : : .nbytes_max = __cpu_to_le32(256),
272 : : .flags = __cpu_to_le32(CE_ATTR_FLAGS),
273 : : .reserved = __cpu_to_le32(0),
274 : : },
275 : :
276 : : /* NB: 50% of src nentries, since tx has 2 frags */
277 : :
278 : : /* CE5: target->host HTT (HIF->HTT) */
279 : : {
280 : : .pipenum = __cpu_to_le32(5),
281 : : .pipedir = __cpu_to_le32(PIPEDIR_IN),
282 : : .nentries = __cpu_to_le32(32),
283 : : .nbytes_max = __cpu_to_le32(512),
284 : : .flags = __cpu_to_le32(CE_ATTR_FLAGS),
285 : : .reserved = __cpu_to_le32(0),
286 : : },
287 : :
288 : : /* CE6: Reserved for target autonomous hif_memcpy */
289 : : {
290 : : .pipenum = __cpu_to_le32(6),
291 : : .pipedir = __cpu_to_le32(PIPEDIR_INOUT),
292 : : .nentries = __cpu_to_le32(32),
293 : : .nbytes_max = __cpu_to_le32(4096),
294 : : .flags = __cpu_to_le32(CE_ATTR_FLAGS),
295 : : .reserved = __cpu_to_le32(0),
296 : : },
297 : :
298 : : /* CE7 used only by Host */
299 : : {
300 : : .pipenum = __cpu_to_le32(7),
301 : : .pipedir = __cpu_to_le32(PIPEDIR_INOUT),
302 : : .nentries = __cpu_to_le32(0),
303 : : .nbytes_max = __cpu_to_le32(0),
304 : : .flags = __cpu_to_le32(0),
305 : : .reserved = __cpu_to_le32(0),
306 : : },
307 : :
308 : : /* CE8 target->host packtlog */
309 : : {
310 : : .pipenum = __cpu_to_le32(8),
311 : : .pipedir = __cpu_to_le32(PIPEDIR_IN),
312 : : .nentries = __cpu_to_le32(64),
313 : : .nbytes_max = __cpu_to_le32(2048),
314 : : .flags = __cpu_to_le32(CE_ATTR_FLAGS | CE_ATTR_DIS_INTR),
315 : : .reserved = __cpu_to_le32(0),
316 : : },
317 : :
318 : : /* CE9 target autonomous qcache memcpy */
319 : : {
320 : : .pipenum = __cpu_to_le32(9),
321 : : .pipedir = __cpu_to_le32(PIPEDIR_INOUT),
322 : : .nentries = __cpu_to_le32(32),
323 : : .nbytes_max = __cpu_to_le32(2048),
324 : : .flags = __cpu_to_le32(CE_ATTR_FLAGS | CE_ATTR_DIS_INTR),
325 : : .reserved = __cpu_to_le32(0),
326 : : },
327 : :
328 : : /* It not necessary to send target wlan configuration for CE10 & CE11
329 : : * as these CEs are not actively used in target.
330 : : */
331 : : };
332 : :
333 : : /*
334 : : * Map from service/endpoint to Copy Engine.
335 : : * This table is derived from the CE_PCI TABLE, above.
336 : : * It is passed to the Target at startup for use by firmware.
337 : : */
338 : : static struct service_to_pipe target_service_to_ce_map_wlan[] = {
339 : : {
340 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VO),
341 : : __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
342 : : __cpu_to_le32(3),
343 : : },
344 : : {
345 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VO),
346 : : __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
347 : : __cpu_to_le32(2),
348 : : },
349 : : {
350 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BK),
351 : : __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
352 : : __cpu_to_le32(3),
353 : : },
354 : : {
355 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BK),
356 : : __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
357 : : __cpu_to_le32(2),
358 : : },
359 : : {
360 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BE),
361 : : __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
362 : : __cpu_to_le32(3),
363 : : },
364 : : {
365 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_BE),
366 : : __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
367 : : __cpu_to_le32(2),
368 : : },
369 : : {
370 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VI),
371 : : __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
372 : : __cpu_to_le32(3),
373 : : },
374 : : {
375 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_DATA_VI),
376 : : __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
377 : : __cpu_to_le32(2),
378 : : },
379 : : {
380 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_CONTROL),
381 : : __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
382 : : __cpu_to_le32(3),
383 : : },
384 : : {
385 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_WMI_CONTROL),
386 : : __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
387 : : __cpu_to_le32(2),
388 : : },
389 : : {
390 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_RSVD_CTRL),
391 : : __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
392 : : __cpu_to_le32(0),
393 : : },
394 : : {
395 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_RSVD_CTRL),
396 : : __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
397 : : __cpu_to_le32(1),
398 : : },
399 : : { /* not used */
400 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS),
401 : : __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
402 : : __cpu_to_le32(0),
403 : : },
404 : : { /* not used */
405 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS),
406 : : __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
407 : : __cpu_to_le32(1),
408 : : },
409 : : {
410 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA_MSG),
411 : : __cpu_to_le32(PIPEDIR_OUT), /* out = UL = host -> target */
412 : : __cpu_to_le32(4),
413 : : },
414 : : {
415 : : __cpu_to_le32(ATH10K_HTC_SVC_ID_HTT_DATA_MSG),
416 : : __cpu_to_le32(PIPEDIR_IN), /* in = DL = target -> host */
417 : : __cpu_to_le32(5),
418 : : },
419 : :
420 : : /* (Additions here) */
421 : :
422 : : { /* must be last */
423 : : __cpu_to_le32(0),
424 : : __cpu_to_le32(0),
425 : : __cpu_to_le32(0),
426 : : },
427 : : };
428 : :
429 : 585 : static bool ath10k_pci_is_awake(struct ath10k *ar)
430 : : {
431 : 585 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
432 : 585 : u32 val = ioread32(ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
433 : : RTC_STATE_ADDRESS);
434 : :
435 : 585 : return RTC_STATE_V_GET(val) == RTC_STATE_V_ON;
436 : : }
437 : :
438 : 32 : static void __ath10k_pci_wake(struct ath10k *ar)
439 : : {
440 [ + - ]: 32 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
441 : :
442 : 32 : lockdep_assert_held(&ar_pci->ps_lock);
443 : :
444 [ + - ]: 32 : ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps wake reg refcount %lu awake %d\n",
445 : : ar_pci->ps_wake_refcount, ar_pci->ps_awake);
446 : :
447 : 32 : iowrite32(PCIE_SOC_WAKE_V_MASK,
448 : 32 : ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
449 : : PCIE_SOC_WAKE_ADDRESS);
450 : 32 : }
451 : :
452 : 32 : static void __ath10k_pci_sleep(struct ath10k *ar)
453 : : {
454 [ + - ]: 32 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
455 : :
456 : 32 : lockdep_assert_held(&ar_pci->ps_lock);
457 : :
458 [ + - ]: 32 : ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps sleep reg refcount %lu awake %d\n",
459 : : ar_pci->ps_wake_refcount, ar_pci->ps_awake);
460 : :
461 : 32 : iowrite32(PCIE_SOC_WAKE_RESET,
462 : 32 : ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
463 : : PCIE_SOC_WAKE_ADDRESS);
464 : 32 : ar_pci->ps_awake = false;
465 : 32 : }
466 : :
467 : 32 : static int ath10k_pci_wake_wait(struct ath10k *ar)
468 : : {
469 : 32 : int tot_delay = 0;
470 : 32 : int curr_delay = 5;
471 : :
472 [ + - ]: 585 : while (tot_delay < PCIE_WAKE_TIMEOUT) {
473 [ + + ]: 585 : if (ath10k_pci_is_awake(ar)) {
474 [ - + ]: 32 : if (tot_delay > PCIE_WAKE_LATE_US)
475 : 0 : ath10k_warn(ar, "device wakeup took %d ms which is unusually long, otherwise it works normally.\n",
476 : : tot_delay / 1000);
477 : 32 : return 0;
478 : : }
479 : :
480 [ - + - - ]: 553 : udelay(curr_delay);
481 : 553 : tot_delay += curr_delay;
482 : :
483 [ + + ]: 553 : if (curr_delay < 50)
484 : 280 : curr_delay += 5;
485 : : }
486 : :
487 : : return -ETIMEDOUT;
488 : : }
489 : :
490 : 28 : static int ath10k_pci_force_wake(struct ath10k *ar)
491 : : {
492 [ - + ]: 28 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
493 : 28 : unsigned long flags;
494 : 28 : int ret = 0;
495 : :
496 [ - + ]: 28 : if (ar_pci->pci_ps)
497 : : return ret;
498 : :
499 : 0 : spin_lock_irqsave(&ar_pci->ps_lock, flags);
500 : :
501 [ # # ]: 0 : if (!ar_pci->ps_awake) {
502 : 0 : iowrite32(PCIE_SOC_WAKE_V_MASK,
503 : 0 : ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
504 : : PCIE_SOC_WAKE_ADDRESS);
505 : :
506 : 0 : ret = ath10k_pci_wake_wait(ar);
507 [ # # ]: 0 : if (ret == 0)
508 : 0 : ar_pci->ps_awake = true;
509 : : }
510 : :
511 : 0 : spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
512 : :
513 : 0 : return ret;
514 : : }
515 : :
516 : 0 : static void ath10k_pci_force_sleep(struct ath10k *ar)
517 : : {
518 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
519 : 0 : unsigned long flags;
520 : :
521 : 0 : spin_lock_irqsave(&ar_pci->ps_lock, flags);
522 : :
523 : 0 : iowrite32(PCIE_SOC_WAKE_RESET,
524 : 0 : ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +
525 : : PCIE_SOC_WAKE_ADDRESS);
526 : 0 : ar_pci->ps_awake = false;
527 : :
528 : 0 : spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
529 : 0 : }
530 : :
531 : 19269 : static int ath10k_pci_wake(struct ath10k *ar)
532 : : {
533 [ + - ]: 19269 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
534 : 19269 : unsigned long flags;
535 : 19269 : int ret = 0;
536 : :
537 [ + - ]: 19269 : if (ar_pci->pci_ps == 0)
538 : : return ret;
539 : :
540 : 19269 : spin_lock_irqsave(&ar_pci->ps_lock, flags);
541 : :
542 [ + - ]: 19269 : ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps wake refcount %lu awake %d\n",
543 : : ar_pci->ps_wake_refcount, ar_pci->ps_awake);
544 : :
545 : : /* This function can be called very frequently. To avoid excessive
546 : : * CPU stalls for MMIO reads use a cache var to hold the device state.
547 : : */
548 [ + + ]: 19269 : if (!ar_pci->ps_awake) {
549 : 32 : __ath10k_pci_wake(ar);
550 : :
551 : 32 : ret = ath10k_pci_wake_wait(ar);
552 [ + - ]: 32 : if (ret == 0)
553 : 32 : ar_pci->ps_awake = true;
554 : : }
555 : :
556 [ + - ]: 32 : if (ret == 0) {
557 : 19269 : ar_pci->ps_wake_refcount++;
558 [ - + ]: 19269 : WARN_ON(ar_pci->ps_wake_refcount == 0);
559 : : }
560 : :
561 : 19269 : spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
562 : :
563 : 19269 : return ret;
564 : : }
565 : :
566 : 19269 : static void ath10k_pci_sleep(struct ath10k *ar)
567 : : {
568 [ + - ]: 19269 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
569 : 19269 : unsigned long flags;
570 : :
571 [ + - ]: 19269 : if (ar_pci->pci_ps == 0)
572 : : return;
573 : :
574 : 19269 : spin_lock_irqsave(&ar_pci->ps_lock, flags);
575 : :
576 [ + - ]: 19269 : ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps sleep refcount %lu awake %d\n",
577 : : ar_pci->ps_wake_refcount, ar_pci->ps_awake);
578 : :
579 [ - + - + ]: 19269 : if (WARN_ON(ar_pci->ps_wake_refcount == 0))
580 : 0 : goto skip;
581 : :
582 : 19269 : ar_pci->ps_wake_refcount--;
583 : :
584 : 19269 : mod_timer(&ar_pci->ps_timer, jiffies +
585 : : msecs_to_jiffies(ATH10K_PCI_SLEEP_GRACE_PERIOD_MSEC));
586 : :
587 : 19269 : skip:
588 : 19269 : spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
589 : : }
590 : :
591 : 29 : static void ath10k_pci_ps_timer(struct timer_list *t)
592 : : {
593 : 29 : struct ath10k_pci *ar_pci = from_timer(ar_pci, t, ps_timer);
594 : 29 : struct ath10k *ar = ar_pci->ar;
595 : 29 : unsigned long flags;
596 : :
597 : 29 : spin_lock_irqsave(&ar_pci->ps_lock, flags);
598 : :
599 [ + - ]: 29 : ath10k_dbg(ar, ATH10K_DBG_PCI_PS, "pci ps timer refcount %lu awake %d\n",
600 : : ar_pci->ps_wake_refcount, ar_pci->ps_awake);
601 : :
602 [ - + ]: 29 : if (ar_pci->ps_wake_refcount > 0)
603 : 0 : goto skip;
604 : :
605 : 29 : __ath10k_pci_sleep(ar);
606 : :
607 : 29 : skip:
608 : 29 : spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
609 : 29 : }
610 : :
611 : 3 : static void ath10k_pci_sleep_sync(struct ath10k *ar)
612 : : {
613 [ - + ]: 3 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
614 : 3 : unsigned long flags;
615 : :
616 [ - + ]: 3 : if (ar_pci->pci_ps == 0) {
617 : 0 : ath10k_pci_force_sleep(ar);
618 : 0 : return;
619 : : }
620 : :
621 : 3 : del_timer_sync(&ar_pci->ps_timer);
622 : :
623 : 3 : spin_lock_irqsave(&ar_pci->ps_lock, flags);
624 [ - + ]: 3 : WARN_ON(ar_pci->ps_wake_refcount > 0);
625 : 3 : __ath10k_pci_sleep(ar);
626 : 3 : spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
627 : : }
628 : :
629 : 10161 : static void ath10k_bus_pci_write32(struct ath10k *ar, u32 offset, u32 value)
630 : : {
631 [ - + ]: 10161 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
632 : 10161 : int ret;
633 : :
634 [ - + ]: 10161 : if (unlikely(offset + sizeof(value) > ar_pci->mem_len)) {
635 : 0 : ath10k_warn(ar, "refusing to write mmio out of bounds at 0x%08x - 0x%08zx (max 0x%08zx)\n",
636 : : offset, offset + sizeof(value), ar_pci->mem_len);
637 : 0 : return;
638 : : }
639 : :
640 : 10161 : ret = ath10k_pci_wake(ar);
641 [ - + ]: 10161 : if (ret) {
642 : 0 : ath10k_warn(ar, "failed to wake target for write32 of 0x%08x at 0x%08x: %d\n",
643 : : value, offset, ret);
644 : 0 : return;
645 : : }
646 : :
647 : 10161 : iowrite32(value, ar_pci->mem + offset);
648 : 10161 : ath10k_pci_sleep(ar);
649 : : }
650 : :
651 : 9108 : static u32 ath10k_bus_pci_read32(struct ath10k *ar, u32 offset)
652 : : {
653 [ - + ]: 9108 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
654 : 9108 : u32 val;
655 : 9108 : int ret;
656 : :
657 [ - + ]: 9108 : if (unlikely(offset + sizeof(val) > ar_pci->mem_len)) {
658 : 0 : ath10k_warn(ar, "refusing to read mmio out of bounds at 0x%08x - 0x%08zx (max 0x%08zx)\n",
659 : : offset, offset + sizeof(val), ar_pci->mem_len);
660 : 0 : return 0;
661 : : }
662 : :
663 : 9108 : ret = ath10k_pci_wake(ar);
664 [ - + ]: 9108 : if (ret) {
665 : 0 : ath10k_warn(ar, "failed to wake target for read32 at 0x%08x: %d\n",
666 : : offset, ret);
667 : 0 : return 0xffffffff;
668 : : }
669 : :
670 : 9108 : val = ioread32(ar_pci->mem + offset);
671 : 9108 : ath10k_pci_sleep(ar);
672 : :
673 : 9108 : return val;
674 : : }
675 : :
676 : 1278 : inline void ath10k_pci_write32(struct ath10k *ar, u32 offset, u32 value)
677 : : {
678 : 0 : struct ath10k_ce *ce = ath10k_ce_priv(ar);
679 : :
680 : 1044 : ce->bus_ops->write32(ar, offset, value);
681 : 234 : }
682 : :
683 : 1257 : inline u32 ath10k_pci_read32(struct ath10k *ar, u32 offset)
684 : : {
685 : 0 : struct ath10k_ce *ce = ath10k_ce_priv(ar);
686 : :
687 : 1257 : return ce->bus_ops->read32(ar, offset);
688 : : }
689 : :
690 : 434 : u32 ath10k_pci_soc_read32(struct ath10k *ar, u32 addr)
691 : : {
692 : 0 : return ath10k_pci_read32(ar, RTC_SOC_BASE_ADDRESS + addr);
693 : : }
694 : :
695 : 357 : void ath10k_pci_soc_write32(struct ath10k *ar, u32 addr, u32 val)
696 : : {
697 : 0 : ath10k_pci_write32(ar, RTC_SOC_BASE_ADDRESS + addr, val);
698 : 0 : }
699 : :
700 : 53 : u32 ath10k_pci_reg_read32(struct ath10k *ar, u32 addr)
701 : : {
702 : 0 : return ath10k_pci_read32(ar, PCIE_LOCAL_BASE_ADDRESS + addr);
703 : : }
704 : :
705 : 106 : void ath10k_pci_reg_write32(struct ath10k *ar, u32 addr, u32 val)
706 : : {
707 : 0 : ath10k_pci_write32(ar, PCIE_LOCAL_BASE_ADDRESS + addr, val);
708 : 0 : }
709 : :
710 : 0 : bool ath10k_pci_irq_pending(struct ath10k *ar)
711 : : {
712 : 0 : u32 cause;
713 : :
714 : : /* Check if the shared legacy irq is for us */
715 : 0 : cause = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
716 : : PCIE_INTR_CAUSE_ADDRESS);
717 [ # # ]: 0 : if (cause & (PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL))
718 : 0 : return true;
719 : :
720 : : return false;
721 : : }
722 : :
723 : 234 : void ath10k_pci_disable_and_clear_legacy_irq(struct ath10k *ar)
724 : : {
725 : : /* IMPORTANT: INTR_CLR register has to be set after
726 : : * INTR_ENABLE is set to 0, otherwise interrupt can not be
727 : : * really cleared.
728 : : */
729 : 234 : ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
730 : : 0);
731 : 234 : ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_CLR_ADDRESS,
732 : 234 : PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
733 : :
734 : : /* IMPORTANT: this extra read transaction is required to
735 : : * flush the posted write buffer.
736 : : */
737 : 234 : (void)ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
738 : : PCIE_INTR_ENABLE_ADDRESS);
739 : 234 : }
740 : :
741 : 0 : void ath10k_pci_enable_legacy_irq(struct ath10k *ar)
742 : : {
743 : 0 : ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS +
744 : : PCIE_INTR_ENABLE_ADDRESS,
745 : 0 : PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
746 : :
747 : : /* IMPORTANT: this extra read transaction is required to
748 : : * flush the posted write buffer.
749 : : */
750 : 0 : (void)ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
751 : : PCIE_INTR_ENABLE_ADDRESS);
752 : 0 : }
753 : :
754 : 28 : static inline const char *ath10k_pci_get_irq_method(struct ath10k *ar)
755 : : {
756 : 28 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
757 : :
758 [ + - ]: 28 : if (ar_pci->oper_irq_mode == ATH10K_PCI_IRQ_MSI)
759 : 28 : return "msi";
760 : :
761 : : return "legacy";
762 : : }
763 : :
764 : 0 : static int __ath10k_pci_rx_post_buf(struct ath10k_pci_pipe *pipe)
765 : : {
766 : 0 : struct ath10k *ar = pipe->hif_ce_state;
767 : 0 : struct ath10k_ce *ce = ath10k_ce_priv(ar);
768 : 0 : struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;
769 : 0 : struct sk_buff *skb;
770 : 0 : dma_addr_t paddr;
771 : 0 : int ret;
772 : :
773 : 0 : skb = dev_alloc_skb(pipe->buf_sz);
774 [ # # ]: 0 : if (!skb)
775 : : return -ENOMEM;
776 : :
777 [ # # # # ]: 0 : WARN_ONCE((unsigned long)skb->data & 3, "unaligned skb");
778 : :
779 [ # # ]: 0 : paddr = dma_map_single(ar->dev, skb->data,
780 : : skb->len + skb_tailroom(skb),
781 : : DMA_FROM_DEVICE);
782 [ # # ]: 0 : if (unlikely(dma_mapping_error(ar->dev, paddr))) {
783 : 0 : ath10k_warn(ar, "failed to dma map pci rx buf\n");
784 : 0 : dev_kfree_skb_any(skb);
785 : 0 : return -EIO;
786 : : }
787 : :
788 : 0 : ATH10K_SKB_RXCB(skb)->paddr = paddr;
789 : :
790 : 0 : spin_lock_bh(&ce->ce_lock);
791 : 0 : ret = ce_pipe->ops->ce_rx_post_buf(ce_pipe, skb, paddr);
792 : 0 : spin_unlock_bh(&ce->ce_lock);
793 [ # # ]: 0 : if (ret) {
794 [ # # ]: 0 : dma_unmap_single(ar->dev, paddr, skb->len + skb_tailroom(skb),
795 : : DMA_FROM_DEVICE);
796 : 0 : dev_kfree_skb_any(skb);
797 : 0 : return ret;
798 : : }
799 : :
800 : : return 0;
801 : : }
802 : :
803 : 0 : static void ath10k_pci_rx_post_pipe(struct ath10k_pci_pipe *pipe)
804 : : {
805 : 0 : struct ath10k *ar = pipe->hif_ce_state;
806 [ # # ]: 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
807 [ # # ]: 0 : struct ath10k_ce *ce = ath10k_ce_priv(ar);
808 : 0 : struct ath10k_ce_pipe *ce_pipe = pipe->ce_hdl;
809 : 0 : int ret, num;
810 : :
811 [ # # ]: 0 : if (pipe->buf_sz == 0)
812 : : return;
813 : :
814 [ # # ]: 0 : if (!ce_pipe->dest_ring)
815 : : return;
816 : :
817 : 0 : spin_lock_bh(&ce->ce_lock);
818 : 0 : num = __ath10k_ce_rx_num_free_bufs(ce_pipe);
819 : 0 : spin_unlock_bh(&ce->ce_lock);
820 : :
821 [ # # ]: 0 : while (num >= 0) {
822 : 0 : ret = __ath10k_pci_rx_post_buf(pipe);
823 [ # # ]: 0 : if (ret) {
824 [ # # ]: 0 : if (ret == -ENOSPC)
825 : : break;
826 : 0 : ath10k_warn(ar, "failed to post pci rx buf: %d\n", ret);
827 : 0 : mod_timer(&ar_pci->rx_post_retry, jiffies +
828 : : ATH10K_PCI_RX_POST_RETRY_MS);
829 : 0 : break;
830 : : }
831 : 0 : num--;
832 : : }
833 : : }
834 : :
835 : 0 : void ath10k_pci_rx_post(struct ath10k *ar)
836 : : {
837 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
838 : 0 : int i;
839 : :
840 [ # # # # : 0 : for (i = 0; i < CE_COUNT; i++)
# # ]
841 : 0 : ath10k_pci_rx_post_pipe(&ar_pci->pipe_info[i]);
842 : 0 : }
843 : :
844 : 0 : void ath10k_pci_rx_replenish_retry(struct timer_list *t)
845 : : {
846 : 0 : struct ath10k_pci *ar_pci = from_timer(ar_pci, t, rx_post_retry);
847 : 0 : struct ath10k *ar = ar_pci->ar;
848 : :
849 : 0 : ath10k_pci_rx_post(ar);
850 : 0 : }
851 : :
852 : 0 : static u32 ath10k_pci_qca988x_targ_cpu_to_ce_addr(struct ath10k *ar, u32 addr)
853 : : {
854 : 0 : u32 val = 0, region = addr & 0xfffff;
855 : :
856 : 0 : val = (ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS + CORE_CTRL_ADDRESS)
857 : : & 0x7ff) << 21;
858 : 0 : val |= 0x100000 | region;
859 : 0 : return val;
860 : : }
861 : :
862 : : /* Refactor from ath10k_pci_qca988x_targ_cpu_to_ce_addr.
863 : : * Support to access target space below 1M for qca6174 and qca9377.
864 : : * If target space is below 1M, the bit[20] of converted CE addr is 0.
865 : : * Otherwise bit[20] of converted CE addr is 1.
866 : : */
867 : 128 : static u32 ath10k_pci_qca6174_targ_cpu_to_ce_addr(struct ath10k *ar, u32 addr)
868 : : {
869 : 128 : u32 val = 0, region = addr & 0xfffff;
870 : :
871 : 128 : val = (ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS + CORE_CTRL_ADDRESS)
872 : : & 0x7ff) << 21;
873 [ + + ]: 128 : val |= ((addr >= 0x100000) ? 0x100000 : 0) | region;
874 : 128 : return val;
875 : : }
876 : :
877 : 0 : static u32 ath10k_pci_qca99x0_targ_cpu_to_ce_addr(struct ath10k *ar, u32 addr)
878 : : {
879 : 0 : u32 val = 0, region = addr & 0xfffff;
880 : :
881 : 0 : val = ath10k_pci_read32(ar, PCIE_BAR_REG_ADDRESS);
882 : 0 : val |= 0x100000 | region;
883 : 0 : return val;
884 : : }
885 : :
886 : 128 : static u32 ath10k_pci_targ_cpu_to_ce_addr(struct ath10k *ar, u32 addr)
887 : : {
888 : 128 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
889 : :
890 [ - + + - : 128 : if (WARN_ON_ONCE(!ar_pci->targ_cpu_to_ce_addr))
- + + - ]
891 : : return -ENOTSUPP;
892 : :
893 : 128 : return ar_pci->targ_cpu_to_ce_addr(ar, addr);
894 : : }
895 : :
896 : : /*
897 : : * Diagnostic read/write access is provided for startup/config/debug usage.
898 : : * Caller must guarantee proper alignment, when applicable, and single user
899 : : * at any moment.
900 : : */
901 : 79 : static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
902 : : int nbytes)
903 : : {
904 : 79 : DPRINT("");
905 : 79 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
906 : 79 : int ret = 0;
907 : 79 : u32 *buf;
908 : 79 : unsigned int completed_nbytes, alloc_nbytes, remaining_bytes;
909 : 79 : struct ath10k_ce_pipe *ce_diag;
910 : : /* Host buffer address in CE space */
911 : 79 : u32 ce_data;
912 : 79 : dma_addr_t ce_data_base = 0;
913 : 79 : void *data_buf;
914 : 79 : int i;
915 : :
916 : 79 : mutex_lock(&ar_pci->ce_diag_mutex);
917 : 79 : ce_diag = ar_pci->ce_diag;
918 : :
919 : : /*
920 : : * Allocate a temporary bounce buffer to hold caller's data
921 : : * to be DMA'ed from Target. This guarantees
922 : : * 1) 4-byte alignment
923 : : * 2) Buffer in DMA-able space
924 : : */
925 : 79 : alloc_nbytes = min_t(unsigned int, nbytes, DIAG_TRANSFER_LIMIT);
926 : :
927 : 79 : data_buf = dma_alloc_coherent(ar->dev, alloc_nbytes, &ce_data_base,
928 : : GFP_ATOMIC);
929 [ - + ]: 79 : if (!data_buf) {
930 : 0 : ret = -ENOMEM;
931 : 0 : goto done;
932 : : }
933 : :
934 : : /* The address supplied by the caller is in the
935 : : * Target CPU virtual address space.
936 : : *
937 : : * In order to use this address with the diagnostic CE,
938 : : * convert it from Target CPU virtual address space
939 : : * to CE address space
940 : : */
941 [ - + ]: 79 : address = ath10k_pci_targ_cpu_to_ce_addr(ar, address);
942 : :
943 : 79 : remaining_bytes = nbytes;
944 : 79 : ce_data = ce_data_base;
945 [ + + ]: 148 : while (remaining_bytes) {
946 : 79 : nbytes = min_t(unsigned int, remaining_bytes,
947 : : DIAG_TRANSFER_LIMIT);
948 : :
949 : 79 : ret = ath10k_ce_rx_post_buf(ce_diag, &ce_data, ce_data);
950 [ + + ]: 79 : if (ret != 0)
951 : 2 : goto done;
952 : :
953 : : /* Request CE to send from Target(!) address to Host buffer */
954 : 77 : ret = ath10k_ce_send(ce_diag, NULL, (u32)address, nbytes, 0, 0);
955 [ + + ]: 77 : if (ret)
956 : 1 : goto done;
957 : :
958 : : i = 0;
959 [ + + ]: 121 : while (ath10k_ce_completed_send_next(ce_diag, NULL) != 0) {
960 : 45 : udelay(DIAG_ACCESS_CE_WAIT_US);
961 : 45 : i += DIAG_ACCESS_CE_WAIT_US;
962 : :
963 [ - + ]: 45 : if (i > DIAG_ACCESS_CE_TIMEOUT_US) {
964 : 0 : ret = -EBUSY;
965 : 0 : goto done;
966 : : }
967 : : }
968 : :
969 : 76 : i = 0;
970 : 76 : DPRINT("ath10k_ce_completed_recv_next");
971 [ + + ]: 77 : while (ath10k_ce_completed_recv_next(ce_diag, (void **)&buf,
972 : : &completed_nbytes) != 0) {
973 : 1 : udelay(DIAG_ACCESS_CE_WAIT_US);
974 : 1 : i += DIAG_ACCESS_CE_WAIT_US;
975 : :
976 [ - + ]: 1 : if (i > DIAG_ACCESS_CE_TIMEOUT_US) {
977 : 0 : ret = -EBUSY;
978 : 0 : goto done;
979 : : }
980 : : }
981 : 76 : DPRINT("bytes compare %lx vs %lx", nbytes, completed_nbytes);
982 : :
983 [ + + ]: 76 : if (nbytes != completed_nbytes) {
984 : 7 : ret = -EIO;
985 : 7 : goto done;
986 : : }
987 : :
988 : 69 : DPRINT("ce_data compare %x vs %x", *buf, ce_data);
989 [ - + ]: 69 : if (*buf != ce_data) {
990 : 0 : ret = -EIO;
991 : 0 : goto done;
992 : : }
993 : 69 : DPRINT("copy");
994 : 69 : remaining_bytes -= nbytes;
995 : 69 : memcpy(data, data_buf, nbytes);
996 : :
997 : 69 : address += nbytes;
998 : 69 : data += nbytes;
999 : : }
1000 : :
1001 : 69 : done:
1002 : :
1003 [ + - ]: 79 : if (data_buf)
1004 : 79 : dma_free_coherent(ar->dev, alloc_nbytes, data_buf,
1005 : : ce_data_base);
1006 : :
1007 : 79 : mutex_unlock(&ar_pci->ce_diag_mutex);
1008 : :
1009 : 79 : return ret;
1010 : : }
1011 : :
1012 : 76 : static int ath10k_pci_diag_read32(struct ath10k *ar, u32 address, u32 *value)
1013 : : {
1014 : 76 : __le32 val = 0;
1015 : 76 : int ret;
1016 : :
1017 : 76 : ret = ath10k_pci_diag_read_mem(ar, address, &val, sizeof(val));
1018 : 76 : *value = __le32_to_cpu(val);
1019 : :
1020 : 76 : return ret;
1021 : : }
1022 : :
1023 : 4 : static int __ath10k_pci_diag_read_hi(struct ath10k *ar, void *dest,
1024 : : u32 src, u32 len)
1025 : : {
1026 : 4 : u32 host_addr, addr;
1027 : 4 : int ret;
1028 : :
1029 : 4 : host_addr = host_interest_item_address(src);
1030 : :
1031 : 4 : ret = ath10k_pci_diag_read32(ar, host_addr, &addr);
1032 [ + + ]: 4 : if (ret != 0) {
1033 : 1 : ath10k_warn(ar, "failed to get memcpy hi address for firmware address %d: %d\n",
1034 : : src, ret);
1035 : 1 : return ret;
1036 : : }
1037 : :
1038 : 3 : ret = ath10k_pci_diag_read_mem(ar, addr, dest, len);
1039 [ + - ]: 3 : if (ret != 0) {
1040 : 3 : ath10k_warn(ar, "failed to memcpy firmware memory from %d (%d B): %d\n",
1041 : : addr, len, ret);
1042 : 3 : return ret;
1043 : : }
1044 : :
1045 : : return 0;
1046 : : }
1047 : :
1048 : : #define ath10k_pci_diag_read_hi(ar, dest, src, len) \
1049 : : __ath10k_pci_diag_read_hi(ar, dest, HI_ITEM(src), len)
1050 : :
1051 : 49 : int ath10k_pci_diag_write_mem(struct ath10k *ar, u32 address,
1052 : : const void *data, int nbytes)
1053 : : {
1054 : 49 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1055 : 49 : int ret = 0;
1056 : 49 : u32 *buf;
1057 : 49 : unsigned int completed_nbytes, alloc_nbytes, remaining_bytes;
1058 : 49 : struct ath10k_ce_pipe *ce_diag;
1059 : 49 : void *data_buf;
1060 : 49 : dma_addr_t ce_data_base = 0;
1061 : 49 : int i;
1062 : :
1063 : 49 : mutex_lock(&ar_pci->ce_diag_mutex);
1064 : 49 : ce_diag = ar_pci->ce_diag;
1065 : :
1066 : : /*
1067 : : * Allocate a temporary bounce buffer to hold caller's data
1068 : : * to be DMA'ed to Target. This guarantees
1069 : : * 1) 4-byte alignment
1070 : : * 2) Buffer in DMA-able space
1071 : : */
1072 : 49 : alloc_nbytes = min_t(unsigned int, nbytes, DIAG_TRANSFER_LIMIT);
1073 : :
1074 : 49 : data_buf = dma_alloc_coherent(ar->dev, alloc_nbytes, &ce_data_base,
1075 : : GFP_ATOMIC);
1076 [ - + ]: 49 : if (!data_buf) {
1077 : 0 : ret = -ENOMEM;
1078 : 0 : goto done;
1079 : : }
1080 : :
1081 : : /*
1082 : : * The address supplied by the caller is in the
1083 : : * Target CPU virtual address space.
1084 : : *
1085 : : * In order to use this address with the diagnostic CE,
1086 : : * convert it from
1087 : : * Target CPU virtual address space
1088 : : * to
1089 : : * CE address space
1090 : : */
1091 [ - + ]: 49 : address = ath10k_pci_targ_cpu_to_ce_addr(ar, address);
1092 : :
1093 : 49 : remaining_bytes = nbytes;
1094 [ + + ]: 94 : while (remaining_bytes) {
1095 : : /* FIXME: check cast */
1096 : 49 : nbytes = min_t(int, remaining_bytes, DIAG_TRANSFER_LIMIT);
1097 : :
1098 : : /* Copy caller's data to allocated DMA buf */
1099 : 49 : memcpy(data_buf, data, nbytes);
1100 : :
1101 : : /* Set up to receive directly into Target(!) address */
1102 : 49 : ret = ath10k_ce_rx_post_buf(ce_diag, &address, address);
1103 [ - + ]: 49 : if (ret != 0)
1104 : 0 : goto done;
1105 : :
1106 : : /*
1107 : : * Request CE to send caller-supplied data that
1108 : : * was copied to bounce buffer to Target(!) address.
1109 : : */
1110 : 49 : ret = ath10k_ce_send(ce_diag, NULL, ce_data_base, nbytes, 0, 0);
1111 [ - + ]: 49 : if (ret != 0)
1112 : 0 : goto done;
1113 : :
1114 : : i = 0;
1115 [ + + ]: 75 : while (ath10k_ce_completed_send_next(ce_diag, NULL) != 0) {
1116 : 26 : udelay(DIAG_ACCESS_CE_WAIT_US);
1117 : 26 : i += DIAG_ACCESS_CE_WAIT_US;
1118 : :
1119 [ - + ]: 26 : if (i > DIAG_ACCESS_CE_TIMEOUT_US) {
1120 : 0 : ret = -EBUSY;
1121 : 0 : goto done;
1122 : : }
1123 : : }
1124 : :
1125 : : i = 0;
1126 [ + + ]: 50 : while (ath10k_ce_completed_recv_next(ce_diag, (void **)&buf,
1127 : : &completed_nbytes) != 0) {
1128 : 1 : udelay(DIAG_ACCESS_CE_WAIT_US);
1129 : 1 : i += DIAG_ACCESS_CE_WAIT_US;
1130 : :
1131 [ - + ]: 1 : if (i > DIAG_ACCESS_CE_TIMEOUT_US) {
1132 : 0 : ret = -EBUSY;
1133 : 0 : goto done;
1134 : : }
1135 : : }
1136 : :
1137 : 49 : DPRINT("bytes compare %lx vs %lx", nbytes, completed_nbytes);
1138 [ + + ]: 49 : if (nbytes != completed_nbytes) {
1139 : 4 : ret = -EIO;
1140 : 4 : goto done;
1141 : : }
1142 : :
1143 : 45 : DPRINT("address compare %x vs %x", *buf, address);
1144 [ - + ]: 45 : if (*buf != address) {
1145 : 0 : ret = -EIO;
1146 : 0 : goto done;
1147 : : }
1148 : 45 : DPRINT("copy");
1149 : :
1150 : 45 : remaining_bytes -= nbytes;
1151 : 45 : address += nbytes;
1152 : 45 : data += nbytes;
1153 : : }
1154 : :
1155 : 45 : done:
1156 [ + - ]: 49 : if (data_buf) {
1157 : 49 : dma_free_coherent(ar->dev, alloc_nbytes, data_buf,
1158 : : ce_data_base);
1159 : : }
1160 : :
1161 [ + + ]: 49 : if (ret != 0)
1162 : 4 : ath10k_warn(ar, "failed to write diag value at 0x%x: %d\n",
1163 : : address, ret);
1164 : :
1165 : 49 : mutex_unlock(&ar_pci->ce_diag_mutex);
1166 : :
1167 : 49 : return ret;
1168 : : }
1169 : :
1170 : 25 : static int ath10k_pci_diag_write32(struct ath10k *ar, u32 address, u32 value)
1171 : : {
1172 : 25 : __le32 val = __cpu_to_le32(value);
1173 : :
1174 : 25 : return ath10k_pci_diag_write_mem(ar, address, &val, sizeof(val));
1175 : : }
1176 : :
1177 : : /* Called by lower (CE) layer when a send to Target completes. */
1178 : 0 : static void ath10k_pci_htc_tx_cb(struct ath10k_ce_pipe *ce_state)
1179 : : {
1180 : 0 : struct ath10k *ar = ce_state->ar;
1181 : 0 : struct sk_buff_head list;
1182 : 0 : struct sk_buff *skb;
1183 : :
1184 : 0 : __skb_queue_head_init(&list);
1185 [ # # ]: 0 : while (ath10k_ce_completed_send_next(ce_state, (void **)&skb) == 0) {
1186 : : /* no need to call tx completion for NULL pointers */
1187 [ # # ]: 0 : if (skb == NULL)
1188 : 0 : continue;
1189 : :
1190 : 0 : __skb_queue_tail(&list, skb);
1191 : : }
1192 : :
1193 [ # # # # ]: 0 : while ((skb = __skb_dequeue(&list)))
1194 : 0 : ath10k_htc_tx_completion_handler(ar, skb);
1195 : 0 : }
1196 : :
1197 : 0 : static void ath10k_pci_process_rx_cb(struct ath10k_ce_pipe *ce_state,
1198 : : void (*callback)(struct ath10k *ar,
1199 : : struct sk_buff *skb))
1200 : : {
1201 : 0 : struct ath10k *ar = ce_state->ar;
1202 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1203 : 0 : struct ath10k_pci_pipe *pipe_info = &ar_pci->pipe_info[ce_state->id];
1204 : 0 : struct sk_buff *skb;
1205 : 0 : struct sk_buff_head list;
1206 : 0 : void *transfer_context;
1207 : 0 : unsigned int nbytes, max_nbytes;
1208 : :
1209 : 0 : __skb_queue_head_init(&list);
1210 [ # # ]: 0 : while (ath10k_ce_completed_recv_next(ce_state, &transfer_context,
1211 : : &nbytes) == 0) {
1212 : 0 : skb = transfer_context;
1213 [ # # ]: 0 : max_nbytes = skb->len + skb_tailroom(skb);
1214 : 0 : dma_unmap_single(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
1215 : : max_nbytes, DMA_FROM_DEVICE);
1216 : :
1217 [ # # ]: 0 : if (unlikely(max_nbytes < nbytes)) {
1218 : 0 : ath10k_warn(ar, "rxed more than expected (nbytes %d, max %d)",
1219 : : nbytes, max_nbytes);
1220 : 0 : dev_kfree_skb_any(skb);
1221 : 0 : continue;
1222 : : }
1223 : :
1224 : 0 : skb_put(skb, nbytes);
1225 : 0 : __skb_queue_tail(&list, skb);
1226 : : }
1227 : :
1228 [ # # # # ]: 0 : while ((skb = __skb_dequeue(&list))) {
1229 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_PCI, "pci rx ce pipe %d len %d\n",
1230 : : ce_state->id, skb->len);
1231 : 0 : ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci rx: ",
1232 : 0 : skb->data, skb->len);
1233 : :
1234 : 0 : callback(ar, skb);
1235 : : }
1236 : :
1237 : 0 : ath10k_pci_rx_post_pipe(pipe_info);
1238 : 0 : }
1239 : :
1240 : 0 : static void ath10k_pci_process_htt_rx_cb(struct ath10k_ce_pipe *ce_state,
1241 : : void (*callback)(struct ath10k *ar,
1242 : : struct sk_buff *skb))
1243 : : {
1244 : 0 : struct ath10k *ar = ce_state->ar;
1245 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1246 : 0 : struct ath10k_pci_pipe *pipe_info = &ar_pci->pipe_info[ce_state->id];
1247 : 0 : struct ath10k_ce_pipe *ce_pipe = pipe_info->ce_hdl;
1248 : 0 : struct sk_buff *skb;
1249 : 0 : struct sk_buff_head list;
1250 : 0 : void *transfer_context;
1251 : 0 : unsigned int nbytes, max_nbytes, nentries;
1252 : 0 : int orig_len;
1253 : :
1254 : : /* No need to aquire ce_lock for CE5, since this is the only place CE5
1255 : : * is processed other than init and deinit. Before releasing CE5
1256 : : * buffers, interrupts are disabled. Thus CE5 access is serialized.
1257 : : */
1258 : 0 : __skb_queue_head_init(&list);
1259 [ # # ]: 0 : while (ath10k_ce_completed_recv_next_nolock(ce_state, &transfer_context,
1260 : : &nbytes) == 0) {
1261 : 0 : skb = transfer_context;
1262 [ # # ]: 0 : max_nbytes = skb->len + skb_tailroom(skb);
1263 : :
1264 [ # # ]: 0 : if (unlikely(max_nbytes < nbytes)) {
1265 : 0 : ath10k_warn(ar, "rxed more than expected (nbytes %d, max %d)",
1266 : : nbytes, max_nbytes);
1267 : 0 : continue;
1268 : : }
1269 : :
1270 : 0 : dma_sync_single_for_cpu(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
1271 : : max_nbytes, DMA_FROM_DEVICE);
1272 : 0 : skb_put(skb, nbytes);
1273 : 0 : __skb_queue_tail(&list, skb);
1274 : : }
1275 : :
1276 : 0 : nentries = skb_queue_len(&list);
1277 [ # # # # ]: 0 : while ((skb = __skb_dequeue(&list))) {
1278 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_PCI, "pci rx ce pipe %d len %d\n",
1279 : : ce_state->id, skb->len);
1280 : 0 : ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci rx: ",
1281 : 0 : skb->data, skb->len);
1282 : :
1283 : 0 : orig_len = skb->len;
1284 : 0 : callback(ar, skb);
1285 : 0 : skb_push(skb, orig_len - skb->len);
1286 : 0 : skb_reset_tail_pointer(skb);
1287 : 0 : skb_trim(skb, 0);
1288 : :
1289 : : /*let device gain the buffer again*/
1290 : 0 : dma_sync_single_for_device(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
1291 [ # # ]: 0 : skb->len + skb_tailroom(skb),
1292 : : DMA_FROM_DEVICE);
1293 : : }
1294 : 0 : ath10k_ce_rx_update_write_idx(ce_pipe, nentries);
1295 : 0 : }
1296 : :
1297 : : /* Called by lower (CE) layer when data is received from the Target. */
1298 : 0 : static void ath10k_pci_htc_rx_cb(struct ath10k_ce_pipe *ce_state)
1299 : : {
1300 : 0 : ath10k_pci_process_rx_cb(ce_state, ath10k_htc_rx_completion_handler);
1301 : 0 : }
1302 : :
1303 : 0 : static void ath10k_pci_htt_htc_rx_cb(struct ath10k_ce_pipe *ce_state)
1304 : : {
1305 : : /* CE4 polling needs to be done whenever CE pipe which transports
1306 : : * HTT Rx (target->host) is processed.
1307 : : */
1308 : 0 : ath10k_ce_per_engine_service(ce_state->ar, 4);
1309 : :
1310 : 0 : ath10k_pci_process_rx_cb(ce_state, ath10k_htc_rx_completion_handler);
1311 : 0 : }
1312 : :
1313 : : /* Called by lower (CE) layer when data is received from the Target.
1314 : : * Only 10.4 firmware uses separate CE to transfer pktlog data.
1315 : : */
1316 : 0 : static void ath10k_pci_pktlog_rx_cb(struct ath10k_ce_pipe *ce_state)
1317 : : {
1318 : 0 : ath10k_pci_process_rx_cb(ce_state,
1319 : : ath10k_htt_rx_pktlog_completion_handler);
1320 : 0 : }
1321 : :
1322 : : /* Called by lower (CE) layer when a send to HTT Target completes. */
1323 : 0 : static void ath10k_pci_htt_tx_cb(struct ath10k_ce_pipe *ce_state)
1324 : : {
1325 : 0 : struct ath10k *ar = ce_state->ar;
1326 : 0 : struct sk_buff *skb;
1327 : :
1328 [ # # ]: 0 : while (ath10k_ce_completed_send_next(ce_state, (void **)&skb) == 0) {
1329 : : /* no need to call tx completion for NULL pointers */
1330 [ # # ]: 0 : if (!skb)
1331 : 0 : continue;
1332 : :
1333 : 0 : dma_unmap_single(ar->dev, ATH10K_SKB_CB(skb)->paddr,
1334 : : skb->len, DMA_TO_DEVICE);
1335 : 0 : ath10k_htt_hif_tx_complete(ar, skb);
1336 : : }
1337 : 0 : }
1338 : :
1339 : 0 : static void ath10k_pci_htt_rx_deliver(struct ath10k *ar, struct sk_buff *skb)
1340 : : {
1341 : 0 : skb_pull(skb, sizeof(struct ath10k_htc_hdr));
1342 : 0 : ath10k_htt_t2h_msg_handler(ar, skb);
1343 : 0 : }
1344 : :
1345 : : /* Called by lower (CE) layer when HTT data is received from the Target. */
1346 : 0 : static void ath10k_pci_htt_rx_cb(struct ath10k_ce_pipe *ce_state)
1347 : : {
1348 : : /* CE4 polling needs to be done whenever CE pipe which transports
1349 : : * HTT Rx (target->host) is processed.
1350 : : */
1351 : 0 : ath10k_ce_per_engine_service(ce_state->ar, 4);
1352 : :
1353 : 0 : ath10k_pci_process_htt_rx_cb(ce_state, ath10k_pci_htt_rx_deliver);
1354 : 0 : }
1355 : :
1356 : 0 : int ath10k_pci_hif_tx_sg(struct ath10k *ar, u8 pipe_id,
1357 : : struct ath10k_hif_sg_item *items, int n_items)
1358 : : {
1359 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1360 : 0 : struct ath10k_ce *ce = ath10k_ce_priv(ar);
1361 : 0 : struct ath10k_pci_pipe *pci_pipe = &ar_pci->pipe_info[pipe_id];
1362 : 0 : struct ath10k_ce_pipe *ce_pipe = pci_pipe->ce_hdl;
1363 : 0 : struct ath10k_ce_ring *src_ring = ce_pipe->src_ring;
1364 : 0 : unsigned int nentries_mask;
1365 : 0 : unsigned int sw_index;
1366 : 0 : unsigned int write_index;
1367 : 0 : int err, i = 0;
1368 : :
1369 : 0 : spin_lock_bh(&ce->ce_lock);
1370 : :
1371 : 0 : nentries_mask = src_ring->nentries_mask;
1372 : 0 : sw_index = src_ring->sw_index;
1373 : 0 : write_index = src_ring->write_index;
1374 : :
1375 [ # # ]: 0 : if (unlikely(CE_RING_DELTA(nentries_mask,
1376 : : write_index, sw_index - 1) < n_items)) {
1377 : 0 : err = -ENOBUFS;
1378 : 0 : goto err;
1379 : : }
1380 : :
1381 [ # # ]: 0 : for (i = 0; i < n_items - 1; i++) {
1382 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_PCI,
1383 : : "pci tx item %d paddr %pad len %d n_items %d\n",
1384 : : i, &items[i].paddr, items[i].len, n_items);
1385 : 0 : ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci tx data: ",
1386 : 0 : items[i].vaddr, items[i].len);
1387 : :
1388 : 0 : err = ath10k_ce_send_nolock(ce_pipe,
1389 : : items[i].transfer_context,
1390 : : items[i].paddr,
1391 : 0 : items[i].len,
1392 : 0 : items[i].transfer_id,
1393 : : CE_SEND_FLAG_GATHER);
1394 [ # # ]: 0 : if (err)
1395 : 0 : goto err;
1396 : : }
1397 : :
1398 : : /* `i` is equal to `n_items -1` after for() */
1399 : :
1400 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_PCI,
1401 : : "pci tx item %d paddr %pad len %d n_items %d\n",
1402 : : i, &items[i].paddr, items[i].len, n_items);
1403 : 0 : ath10k_dbg_dump(ar, ATH10K_DBG_PCI_DUMP, NULL, "pci tx data: ",
1404 : 0 : items[i].vaddr, items[i].len);
1405 : :
1406 : 0 : err = ath10k_ce_send_nolock(ce_pipe,
1407 : : items[i].transfer_context,
1408 : : items[i].paddr,
1409 : 0 : items[i].len,
1410 : 0 : items[i].transfer_id,
1411 : : 0);
1412 [ # # ]: 0 : if (err)
1413 : 0 : goto err;
1414 : :
1415 : 0 : spin_unlock_bh(&ce->ce_lock);
1416 : 0 : return 0;
1417 : :
1418 : 0 : err:
1419 [ # # ]: 0 : for (; i > 0; i--)
1420 : 0 : __ath10k_ce_send_revert(ce_pipe);
1421 : :
1422 : 0 : spin_unlock_bh(&ce->ce_lock);
1423 : 0 : return err;
1424 : : }
1425 : :
1426 : 0 : int ath10k_pci_hif_diag_read(struct ath10k *ar, u32 address, void *buf,
1427 : : size_t buf_len)
1428 : : {
1429 : 0 : return ath10k_pci_diag_read_mem(ar, address, buf, buf_len);
1430 : : }
1431 : :
1432 : 0 : u16 ath10k_pci_hif_get_free_queue_number(struct ath10k *ar, u8 pipe)
1433 : : {
1434 [ # # ]: 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1435 : :
1436 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif get free queue number\n");
1437 : :
1438 : 0 : return ath10k_ce_num_free_src_entries(ar_pci->pipe_info[pipe].ce_hdl);
1439 : : }
1440 : :
1441 : 4 : static void ath10k_pci_dump_registers(struct ath10k *ar,
1442 : : struct ath10k_fw_crash_data *crash_data)
1443 : : {
1444 : 4 : __le32 reg_dump_values[REG_DUMP_COUNT_QCA988X] = {};
1445 : 4 : int i, ret;
1446 : :
1447 : 4 : lockdep_assert_held(&ar->dump_mutex);
1448 : :
1449 : 4 : ret = ath10k_pci_diag_read_hi(ar, ®_dump_values[0],
1450 : : hi_failure_state,
1451 : : REG_DUMP_COUNT_QCA988X * sizeof(__le32));
1452 [ + - ]: 4 : if (ret) {
1453 : 4 : ath10k_err(ar, "failed to read firmware dump area: %d\n", ret);
1454 : 8 : return;
1455 : : }
1456 : :
1457 : 0 : BUILD_BUG_ON(REG_DUMP_COUNT_QCA988X % 4);
1458 : :
1459 : 0 : ath10k_err(ar, "firmware register dump:\n");
1460 [ # # ]: 0 : for (i = 0; i < REG_DUMP_COUNT_QCA988X; i += 4)
1461 : 0 : ath10k_err(ar, "[%02d]: 0x%08X 0x%08X 0x%08X 0x%08X\n",
1462 : : i,
1463 : 0 : __le32_to_cpu(reg_dump_values[i]),
1464 : 0 : __le32_to_cpu(reg_dump_values[i + 1]),
1465 : 0 : __le32_to_cpu(reg_dump_values[i + 2]),
1466 : 0 : __le32_to_cpu(reg_dump_values[i + 3]));
1467 : :
1468 [ # # ]: 0 : if (!crash_data)
1469 : : return;
1470 : :
1471 [ # # ]: 0 : for (i = 0; i < REG_DUMP_COUNT_QCA988X; i++)
1472 : 0 : crash_data->registers[i] = reg_dump_values[i];
1473 : : }
1474 : :
1475 : 0 : static int ath10k_pci_dump_memory_section(struct ath10k *ar,
1476 : : const struct ath10k_mem_region *mem_region,
1477 : : u8 *buf, size_t buf_len)
1478 : : {
1479 : 0 : const struct ath10k_mem_section *cur_section, *next_section;
1480 : 0 : unsigned int count, section_size, skip_size;
1481 : 0 : int ret, i, j;
1482 : :
1483 [ # # # # ]: 0 : if (!mem_region || !buf)
1484 : : return 0;
1485 : :
1486 : 0 : cur_section = &mem_region->section_table.sections[0];
1487 : :
1488 [ # # ]: 0 : if (mem_region->start > cur_section->start) {
1489 : 0 : ath10k_warn(ar, "incorrect memdump region 0x%x with section start address 0x%x.\n",
1490 : : mem_region->start, cur_section->start);
1491 : 0 : return 0;
1492 : : }
1493 : :
1494 : 0 : skip_size = cur_section->start - mem_region->start;
1495 : :
1496 : : /* fill the gap between the first register section and register
1497 : : * start address
1498 : : */
1499 [ # # ]: 0 : for (i = 0; i < skip_size; i++) {
1500 : 0 : *buf = ATH10K_MAGIC_NOT_COPIED;
1501 : 0 : buf++;
1502 : : }
1503 : :
1504 : : count = 0;
1505 : :
1506 [ # # ]: 0 : for (i = 0; cur_section != NULL; i++) {
1507 : 0 : section_size = cur_section->end - cur_section->start;
1508 : :
1509 [ # # ]: 0 : if (section_size <= 0) {
1510 : 0 : ath10k_warn(ar, "incorrect ramdump format with start address 0x%x and stop address 0x%x\n",
1511 : : cur_section->start,
1512 : : cur_section->end);
1513 : 0 : break;
1514 : : }
1515 : :
1516 [ # # ]: 0 : if ((i + 1) == mem_region->section_table.size) {
1517 : : /* last section */
1518 : : next_section = NULL;
1519 : : skip_size = 0;
1520 : : } else {
1521 : 0 : next_section = cur_section + 1;
1522 : :
1523 [ # # ]: 0 : if (cur_section->end > next_section->start) {
1524 : 0 : ath10k_warn(ar, "next ramdump section 0x%x is smaller than current end address 0x%x\n",
1525 : : next_section->start,
1526 : : cur_section->end);
1527 : 0 : break;
1528 : : }
1529 : :
1530 : 0 : skip_size = next_section->start - cur_section->end;
1531 : : }
1532 : :
1533 [ # # ]: 0 : if (buf_len < (skip_size + section_size)) {
1534 : 0 : ath10k_warn(ar, "ramdump buffer is too small: %zu\n", buf_len);
1535 : 0 : break;
1536 : : }
1537 : :
1538 : 0 : buf_len -= skip_size + section_size;
1539 : :
1540 : : /* read section to dest memory */
1541 : 0 : ret = ath10k_pci_diag_read_mem(ar, cur_section->start,
1542 : : buf, section_size);
1543 [ # # ]: 0 : if (ret) {
1544 : 0 : ath10k_warn(ar, "failed to read ramdump from section 0x%x: %d\n",
1545 : : cur_section->start, ret);
1546 : 0 : break;
1547 : : }
1548 : :
1549 : 0 : buf += section_size;
1550 : 0 : count += section_size;
1551 : :
1552 : : /* fill in the gap between this section and the next */
1553 [ # # ]: 0 : for (j = 0; j < skip_size; j++) {
1554 : 0 : *buf = ATH10K_MAGIC_NOT_COPIED;
1555 : 0 : buf++;
1556 : : }
1557 : :
1558 : 0 : count += skip_size;
1559 : :
1560 [ # # ]: 0 : if (!next_section)
1561 : : /* this was the last section */
1562 : : break;
1563 : :
1564 : : cur_section = next_section;
1565 : : }
1566 : :
1567 : 0 : return count;
1568 : : }
1569 : :
1570 : 0 : static int ath10k_pci_set_ram_config(struct ath10k *ar, u32 config)
1571 : : {
1572 : 0 : u32 val;
1573 : :
1574 : 0 : ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS +
1575 : : FW_RAM_CONFIG_ADDRESS, config);
1576 : :
1577 : 0 : val = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
1578 : : FW_RAM_CONFIG_ADDRESS);
1579 [ # # ]: 0 : if (val != config) {
1580 : 0 : ath10k_warn(ar, "failed to set RAM config from 0x%x to 0x%x\n",
1581 : : val, config);
1582 : 0 : return -EIO;
1583 : : }
1584 : :
1585 : : return 0;
1586 : : }
1587 : :
1588 : : /* Always returns the length */
1589 : : static int ath10k_pci_dump_memory_sram(struct ath10k *ar,
1590 : : const struct ath10k_mem_region *region,
1591 : : u8 *buf)
1592 : : {
1593 : : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1594 : : u32 base_addr, i;
1595 : :
1596 : : base_addr = ioread32(ar_pci->mem + QCA99X0_PCIE_BAR0_START_REG);
1597 : : base_addr += region->start;
1598 : :
1599 : : for (i = 0; i < region->len; i += 4) {
1600 : : iowrite32(base_addr + i, ar_pci->mem + QCA99X0_CPU_MEM_ADDR_REG);
1601 : : *(u32 *)(buf + i) = ioread32(ar_pci->mem + QCA99X0_CPU_MEM_DATA_REG);
1602 : : }
1603 : :
1604 : : return region->len;
1605 : : }
1606 : :
1607 : : /* if an error happened returns < 0, otherwise the length */
1608 : : static int ath10k_pci_dump_memory_reg(struct ath10k *ar,
1609 : : const struct ath10k_mem_region *region,
1610 : : u8 *buf)
1611 : : {
1612 : : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1613 : : u32 i;
1614 : : int ret;
1615 : :
1616 : : mutex_lock(&ar->conf_mutex);
1617 : : if (ar->state != ATH10K_STATE_ON) {
1618 : : ath10k_warn(ar, "Skipping pci_dump_memory_reg invalid state\n");
1619 : : ret = -EIO;
1620 : : goto done;
1621 : : }
1622 : :
1623 : : for (i = 0; i < region->len; i += 4)
1624 : : *(u32 *)(buf + i) = ioread32(ar_pci->mem + region->start + i);
1625 : :
1626 : : ret = region->len;
1627 : : done:
1628 : : mutex_unlock(&ar->conf_mutex);
1629 : : return ret;
1630 : : }
1631 : :
1632 : : /* if an error happened returns < 0, otherwise the length */
1633 : 0 : static int ath10k_pci_dump_memory_generic(struct ath10k *ar,
1634 : : const struct ath10k_mem_region *current_region,
1635 : : u8 *buf)
1636 : : {
1637 : 0 : int ret;
1638 : :
1639 [ # # ]: 0 : if (current_region->section_table.size > 0)
1640 : : /* Copy each section individually. */
1641 : 0 : return ath10k_pci_dump_memory_section(ar,
1642 : : current_region,
1643 : : buf,
1644 : 0 : current_region->len);
1645 : :
1646 : : /* No individiual memory sections defined so we can
1647 : : * copy the entire memory region.
1648 : : */
1649 : 0 : ret = ath10k_pci_diag_read_mem(ar,
1650 : : current_region->start,
1651 : : buf,
1652 : 0 : current_region->len);
1653 [ # # ]: 0 : if (ret) {
1654 : 0 : ath10k_warn(ar, "failed to copy ramdump region %s: %d\n",
1655 : : current_region->name, ret);
1656 : 0 : return ret;
1657 : : }
1658 : :
1659 : 0 : return current_region->len;
1660 : : }
1661 : :
1662 : 4 : static void ath10k_pci_dump_memory(struct ath10k *ar,
1663 : : struct ath10k_fw_crash_data *crash_data)
1664 : : {
1665 : 4 : const struct ath10k_hw_mem_layout *mem_layout;
1666 : 4 : const struct ath10k_mem_region *current_region;
1667 : 4 : struct ath10k_dump_ram_data_hdr *hdr;
1668 : 4 : u32 count, shift;
1669 : 4 : size_t buf_len;
1670 : 4 : int ret, i;
1671 : 4 : u8 *buf;
1672 : :
1673 : 4 : lockdep_assert_held(&ar->dump_mutex);
1674 : :
1675 [ + - ]: 4 : if (!crash_data)
1676 : : return;
1677 : :
1678 : 4 : mem_layout = ath10k_coredump_get_mem_layout(ar);
1679 [ - + ]: 4 : if (!mem_layout)
1680 : : return;
1681 : :
1682 : 0 : current_region = &mem_layout->region_table.regions[0];
1683 : :
1684 : 0 : buf = crash_data->ramdump_buf;
1685 : 0 : buf_len = crash_data->ramdump_buf_len;
1686 : :
1687 : 0 : memset(buf, 0, buf_len);
1688 : :
1689 [ # # ]: 0 : for (i = 0; i < mem_layout->region_table.size; i++) {
1690 : 0 : count = 0;
1691 : :
1692 [ # # ]: 0 : if (current_region->len > buf_len) {
1693 : 0 : ath10k_warn(ar, "memory region %s size %d is larger that remaining ramdump buffer size %zu\n",
1694 : : current_region->name,
1695 : : current_region->len,
1696 : : buf_len);
1697 : 0 : break;
1698 : : }
1699 : :
1700 : : /* To get IRAM dump, the host driver needs to switch target
1701 : : * ram config from DRAM to IRAM.
1702 : : */
1703 [ # # ]: 0 : if (current_region->type == ATH10K_MEM_REGION_TYPE_IRAM1 ||
1704 : : current_region->type == ATH10K_MEM_REGION_TYPE_IRAM2) {
1705 : 0 : shift = current_region->start >> 20;
1706 : :
1707 : 0 : ret = ath10k_pci_set_ram_config(ar, shift);
1708 [ # # ]: 0 : if (ret) {
1709 : 0 : ath10k_warn(ar, "failed to switch ram config to IRAM for section %s: %d\n",
1710 : : current_region->name, ret);
1711 : 0 : break;
1712 : : }
1713 : : }
1714 : :
1715 : : /* Reserve space for the header. */
1716 : 0 : hdr = (void *)buf;
1717 : 0 : buf += sizeof(*hdr);
1718 : 0 : buf_len -= sizeof(*hdr);
1719 : :
1720 [ # # # ]: 0 : switch (current_region->type) {
1721 : 0 : case ATH10K_MEM_REGION_TYPE_IOSRAM:
1722 : 0 : count = ath10k_pci_dump_memory_sram(ar, current_region, buf);
1723 : 0 : break;
1724 : 0 : case ATH10K_MEM_REGION_TYPE_IOREG:
1725 : 0 : ret = ath10k_pci_dump_memory_reg(ar, current_region, buf);
1726 [ # # ]: 0 : if (ret < 0)
1727 : : break;
1728 : :
1729 : 0 : count = ret;
1730 : 0 : break;
1731 : 0 : default:
1732 : 0 : ret = ath10k_pci_dump_memory_generic(ar, current_region, buf);
1733 [ # # ]: 0 : if (ret < 0)
1734 : : break;
1735 : :
1736 : 0 : count = ret;
1737 : 0 : break;
1738 : : }
1739 : :
1740 : 0 : hdr->region_type = cpu_to_le32(current_region->type);
1741 : 0 : hdr->start = cpu_to_le32(current_region->start);
1742 : 0 : hdr->length = cpu_to_le32(count);
1743 : :
1744 [ # # ]: 0 : if (count == 0)
1745 : : /* Note: the header remains, just with zero length. */
1746 : : break;
1747 : :
1748 : 0 : buf += count;
1749 : 0 : buf_len -= count;
1750 : :
1751 : 0 : current_region++;
1752 : : }
1753 : : }
1754 : :
1755 : 4 : static void ath10k_pci_fw_dump_work(struct work_struct *work)
1756 : : {
1757 : 4 : struct ath10k_pci *ar_pci = container_of(work, struct ath10k_pci,
1758 : : dump_work);
1759 : 4 : struct ath10k_fw_crash_data *crash_data;
1760 : 4 : struct ath10k *ar = ar_pci->ar;
1761 : 4 : char guid[UUID_STRING_LEN + 1];
1762 : :
1763 : 4 : mutex_lock(&ar->dump_mutex);
1764 : :
1765 : 4 : spin_lock_bh(&ar->data_lock);
1766 : 4 : ar->stats.fw_crash_counter++;
1767 : 4 : spin_unlock_bh(&ar->data_lock);
1768 : :
1769 : 4 : crash_data = ath10k_coredump_new(ar);
1770 : :
1771 [ + - ]: 4 : if (crash_data)
1772 : 4 : scnprintf(guid, sizeof(guid), "%pUl", &crash_data->guid);
1773 : : else
1774 : 0 : scnprintf(guid, sizeof(guid), "n/a");
1775 : :
1776 : 4 : ath10k_err(ar, "firmware crashed! (guid %s)\n", guid);
1777 : 4 : ath10k_print_driver_info(ar);
1778 : 4 : ath10k_pci_dump_registers(ar, crash_data);
1779 : 4 : ath10k_ce_dump_registers(ar, crash_data);
1780 : 4 : ath10k_pci_dump_memory(ar, crash_data);
1781 : :
1782 : 4 : mutex_unlock(&ar->dump_mutex);
1783 : :
1784 : 4 : queue_work(ar->workqueue, &ar->restart_work);
1785 : 4 : }
1786 : :
1787 : 4 : static void ath10k_pci_fw_crashed_dump(struct ath10k *ar)
1788 : : {
1789 : 4 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1790 : :
1791 : 4 : queue_work(ar->workqueue, &ar_pci->dump_work);
1792 : 4 : }
1793 : :
1794 : 0 : void ath10k_pci_hif_send_complete_check(struct ath10k *ar, u8 pipe,
1795 : : int force)
1796 : : {
1797 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif send complete check\n");
1798 : :
1799 [ # # ]: 0 : if (!force) {
1800 : 0 : int resources;
1801 : : /*
1802 : : * Decide whether to actually poll for completions, or just
1803 : : * wait for a later chance.
1804 : : * If there seem to be plenty of resources left, then just wait
1805 : : * since checking involves reading a CE register, which is a
1806 : : * relatively expensive operation.
1807 : : */
1808 : 0 : resources = ath10k_pci_hif_get_free_queue_number(ar, pipe);
1809 : :
1810 : : /*
1811 : : * If at least 50% of the total resources are still available,
1812 : : * don't bother checking again yet.
1813 : : */
1814 [ # # ]: 0 : if (resources > (host_ce_config_wlan[pipe].src_nentries >> 1))
1815 : : return;
1816 : : }
1817 : 0 : ath10k_ce_per_engine_service(ar, pipe);
1818 : : }
1819 : :
1820 : 3 : static void ath10k_pci_rx_retry_sync(struct ath10k *ar)
1821 : : {
1822 : 3 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1823 : :
1824 : 3 : del_timer_sync(&ar_pci->rx_post_retry);
1825 : 3 : }
1826 : :
1827 : 0 : int ath10k_pci_hif_map_service_to_pipe(struct ath10k *ar, u16 service_id,
1828 : : u8 *ul_pipe, u8 *dl_pipe)
1829 : : {
1830 : 0 : const struct service_to_pipe *entry;
1831 : 0 : bool ul_set = false, dl_set = false;
1832 : 0 : int i;
1833 : :
1834 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif map service\n");
1835 : :
1836 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(target_service_to_ce_map_wlan); i++) {
1837 : 0 : entry = &target_service_to_ce_map_wlan[i];
1838 : :
1839 [ # # ]: 0 : if (__le32_to_cpu(entry->service_id) != service_id)
1840 : 0 : continue;
1841 : :
1842 [ # # # # ]: 0 : switch (__le32_to_cpu(entry->pipedir)) {
1843 : : case PIPEDIR_NONE:
1844 : : break;
1845 : 0 : case PIPEDIR_IN:
1846 [ # # ]: 0 : WARN_ON(dl_set);
1847 : 0 : *dl_pipe = __le32_to_cpu(entry->pipenum);
1848 : 0 : dl_set = true;
1849 : 0 : break;
1850 : 0 : case PIPEDIR_OUT:
1851 [ # # ]: 0 : WARN_ON(ul_set);
1852 : 0 : *ul_pipe = __le32_to_cpu(entry->pipenum);
1853 : 0 : ul_set = true;
1854 : 0 : break;
1855 : 0 : case PIPEDIR_INOUT:
1856 [ # # ]: 0 : WARN_ON(dl_set);
1857 [ # # ]: 0 : WARN_ON(ul_set);
1858 : 0 : *dl_pipe = __le32_to_cpu(entry->pipenum);
1859 : 0 : *ul_pipe = __le32_to_cpu(entry->pipenum);
1860 : 0 : dl_set = true;
1861 : 0 : ul_set = true;
1862 : 0 : break;
1863 : : }
1864 : 0 : }
1865 : :
1866 [ # # # # ]: 0 : if (!ul_set || !dl_set)
1867 : 0 : return -ENOENT;
1868 : :
1869 : : return 0;
1870 : : }
1871 : :
1872 : 0 : void ath10k_pci_hif_get_default_pipe(struct ath10k *ar,
1873 : : u8 *ul_pipe, u8 *dl_pipe)
1874 : : {
1875 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_PCI, "pci hif get default pipe\n");
1876 : :
1877 : 0 : (void)ath10k_pci_hif_map_service_to_pipe(ar,
1878 : : ATH10K_HTC_SVC_ID_RSVD_CTRL,
1879 : : ul_pipe, dl_pipe);
1880 : 0 : }
1881 : :
1882 : 234 : void ath10k_pci_irq_msi_fw_mask(struct ath10k *ar)
1883 : : {
1884 : 234 : u32 val;
1885 : :
1886 [ + - ]: 234 : switch (ar->hw_rev) {
1887 : 234 : case ATH10K_HW_QCA988X:
1888 : : case ATH10K_HW_QCA9887:
1889 : : case ATH10K_HW_QCA6174:
1890 : : case ATH10K_HW_QCA9377:
1891 : 234 : val = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
1892 : : CORE_CTRL_ADDRESS);
1893 : 234 : val &= ~CORE_CTRL_PCIE_REG_31_MASK;
1894 : 234 : ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS +
1895 : : CORE_CTRL_ADDRESS, val);
1896 : : break;
1897 : : case ATH10K_HW_QCA99X0:
1898 : : case ATH10K_HW_QCA9984:
1899 : : case ATH10K_HW_QCA9888:
1900 : : case ATH10K_HW_QCA4019:
1901 : : /* TODO: Find appropriate register configuration for QCA99X0
1902 : : * to mask irq/MSI.
1903 : : */
1904 : : break;
1905 : : case ATH10K_HW_WCN3990:
1906 : : break;
1907 : : }
1908 : 234 : }
1909 : :
1910 : 0 : static void ath10k_pci_irq_msi_fw_unmask(struct ath10k *ar)
1911 : : {
1912 : 0 : u32 val;
1913 : :
1914 [ # # ]: 0 : switch (ar->hw_rev) {
1915 : 0 : case ATH10K_HW_QCA988X:
1916 : : case ATH10K_HW_QCA9887:
1917 : : case ATH10K_HW_QCA6174:
1918 : : case ATH10K_HW_QCA9377:
1919 : 0 : val = ath10k_pci_read32(ar, SOC_CORE_BASE_ADDRESS +
1920 : : CORE_CTRL_ADDRESS);
1921 : 0 : val |= CORE_CTRL_PCIE_REG_31_MASK;
1922 : 0 : ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS +
1923 : : CORE_CTRL_ADDRESS, val);
1924 : : break;
1925 : : case ATH10K_HW_QCA99X0:
1926 : : case ATH10K_HW_QCA9984:
1927 : : case ATH10K_HW_QCA9888:
1928 : : case ATH10K_HW_QCA4019:
1929 : : /* TODO: Find appropriate register configuration for QCA99X0
1930 : : * to unmask irq/MSI.
1931 : : */
1932 : : break;
1933 : : case ATH10K_HW_WCN3990:
1934 : : break;
1935 : : }
1936 : 0 : }
1937 : :
1938 : 79 : static void ath10k_pci_irq_disable(struct ath10k *ar)
1939 : : {
1940 : 79 : ath10k_ce_disable_interrupts(ar);
1941 : 79 : ath10k_pci_disable_and_clear_legacy_irq(ar);
1942 : 79 : ath10k_pci_irq_msi_fw_mask(ar);
1943 : 79 : }
1944 : :
1945 : 0 : static void ath10k_pci_irq_sync(struct ath10k *ar)
1946 : : {
1947 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1948 : :
1949 : 0 : synchronize_irq(ar_pci->pdev->irq);
1950 : : }
1951 : :
1952 : 0 : static void ath10k_pci_irq_enable(struct ath10k *ar)
1953 : : {
1954 : 0 : ath10k_ce_enable_interrupts(ar);
1955 : 0 : ath10k_pci_enable_legacy_irq(ar);
1956 : 0 : ath10k_pci_irq_msi_fw_unmask(ar);
1957 : 0 : }
1958 : :
1959 : 0 : static int ath10k_pci_hif_start(struct ath10k *ar)
1960 : : {
1961 [ # # ]: 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
1962 : :
1963 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif start\n");
1964 : :
1965 : 0 : napi_enable(&ar->napi);
1966 : :
1967 : 0 : ath10k_pci_irq_enable(ar);
1968 : 0 : ath10k_pci_rx_post(ar);
1969 : :
1970 : 0 : pcie_capability_write_word(ar_pci->pdev, PCI_EXP_LNKCTL,
1971 : 0 : ar_pci->link_ctl);
1972 : :
1973 : 0 : return 0;
1974 : : }
1975 : :
1976 : 0 : static void ath10k_pci_rx_pipe_cleanup(struct ath10k_pci_pipe *pci_pipe)
1977 : : {
1978 : 0 : struct ath10k *ar;
1979 : 0 : struct ath10k_ce_pipe *ce_pipe;
1980 : 0 : struct ath10k_ce_ring *ce_ring;
1981 : 0 : struct sk_buff *skb;
1982 : 0 : int i;
1983 : :
1984 : 0 : ar = pci_pipe->hif_ce_state;
1985 : 0 : ce_pipe = pci_pipe->ce_hdl;
1986 : 0 : ce_ring = ce_pipe->dest_ring;
1987 : :
1988 [ # # ]: 0 : if (!ce_ring)
1989 : : return;
1990 : :
1991 [ # # ]: 0 : if (!pci_pipe->buf_sz)
1992 : : return;
1993 : :
1994 [ # # ]: 0 : for (i = 0; i < ce_ring->nentries; i++) {
1995 : 0 : skb = ce_ring->per_transfer_context[i];
1996 [ # # ]: 0 : if (!skb)
1997 : 0 : continue;
1998 : :
1999 : 0 : ce_ring->per_transfer_context[i] = NULL;
2000 : :
2001 [ # # ]: 0 : dma_unmap_single(ar->dev, ATH10K_SKB_RXCB(skb)->paddr,
2002 : : skb->len + skb_tailroom(skb),
2003 : : DMA_FROM_DEVICE);
2004 : 0 : dev_kfree_skb_any(skb);
2005 : : }
2006 : : }
2007 : :
2008 : 0 : static void ath10k_pci_tx_pipe_cleanup(struct ath10k_pci_pipe *pci_pipe)
2009 : : {
2010 : 0 : struct ath10k *ar;
2011 : 0 : struct ath10k_ce_pipe *ce_pipe;
2012 : 0 : struct ath10k_ce_ring *ce_ring;
2013 : 0 : struct sk_buff *skb;
2014 : 0 : int i;
2015 : :
2016 : 0 : ar = pci_pipe->hif_ce_state;
2017 : 0 : ce_pipe = pci_pipe->ce_hdl;
2018 : 0 : ce_ring = ce_pipe->src_ring;
2019 : :
2020 [ # # ]: 0 : if (!ce_ring)
2021 : : return;
2022 : :
2023 [ # # ]: 0 : if (!pci_pipe->buf_sz)
2024 : : return;
2025 : :
2026 [ # # ]: 0 : for (i = 0; i < ce_ring->nentries; i++) {
2027 : 0 : skb = ce_ring->per_transfer_context[i];
2028 [ # # ]: 0 : if (!skb)
2029 : 0 : continue;
2030 : :
2031 : 0 : ce_ring->per_transfer_context[i] = NULL;
2032 : :
2033 : 0 : ath10k_htc_tx_completion_handler(ar, skb);
2034 : : }
2035 : : }
2036 : :
2037 : : /*
2038 : : * Cleanup residual buffers for device shutdown:
2039 : : * buffers that were enqueued for receive
2040 : : * buffers that were to be sent
2041 : : * Note: Buffers that had completed but which were
2042 : : * not yet processed are on a completion queue. They
2043 : : * are handled when the completion thread shuts down.
2044 : : */
2045 : 0 : static void ath10k_pci_buffer_cleanup(struct ath10k *ar)
2046 : : {
2047 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2048 : 0 : int pipe_num;
2049 : :
2050 [ # # ]: 0 : for (pipe_num = 0; pipe_num < CE_COUNT; pipe_num++) {
2051 : 0 : struct ath10k_pci_pipe *pipe_info;
2052 : :
2053 : 0 : pipe_info = &ar_pci->pipe_info[pipe_num];
2054 : 0 : ath10k_pci_rx_pipe_cleanup(pipe_info);
2055 : 0 : ath10k_pci_tx_pipe_cleanup(pipe_info);
2056 : : }
2057 : 0 : }
2058 : :
2059 : 12 : void ath10k_pci_ce_deinit(struct ath10k *ar)
2060 : : {
2061 : 12 : int i;
2062 : :
2063 [ + + - - : 360 : for (i = 0; i < CE_COUNT; i++)
+ + - - ]
2064 : 320 : ath10k_ce_deinit_pipe(ar, i);
2065 : 0 : }
2066 : :
2067 : 0 : void ath10k_pci_flush(struct ath10k *ar)
2068 : : {
2069 : 0 : ath10k_pci_rx_retry_sync(ar);
2070 : 0 : ath10k_pci_buffer_cleanup(ar);
2071 : 0 : }
2072 : :
2073 : 0 : static void ath10k_pci_hif_stop(struct ath10k *ar)
2074 : : {
2075 [ # # ]: 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2076 : 0 : unsigned long flags;
2077 : :
2078 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif stop\n");
2079 : :
2080 : 0 : ath10k_pci_irq_disable(ar);
2081 : 0 : ath10k_pci_irq_sync(ar);
2082 : 0 : napi_synchronize(&ar->napi);
2083 : 0 : napi_disable(&ar->napi);
2084 : :
2085 : : /* Most likely the device has HTT Rx ring configured. The only way to
2086 : : * prevent the device from accessing (and possible corrupting) host
2087 : : * memory is to reset the chip now.
2088 : : *
2089 : : * There's also no known way of masking MSI interrupts on the device.
2090 : : * For ranged MSI the CE-related interrupts can be masked. However
2091 : : * regardless how many MSI interrupts are assigned the first one
2092 : : * is always used for firmware indications (crashes) and cannot be
2093 : : * masked. To prevent the device from asserting the interrupt reset it
2094 : : * before proceeding with cleanup.
2095 : : */
2096 : 0 : ath10k_pci_safe_chip_reset(ar);
2097 : :
2098 : 0 : ath10k_pci_flush(ar);
2099 : :
2100 : 0 : spin_lock_irqsave(&ar_pci->ps_lock, flags);
2101 [ # # ]: 0 : WARN_ON(ar_pci->ps_wake_refcount > 0);
2102 : 0 : spin_unlock_irqrestore(&ar_pci->ps_lock, flags);
2103 : 0 : }
2104 : :
2105 : 7 : int ath10k_pci_hif_exchange_bmi_msg(struct ath10k *ar,
2106 : : void *req, u32 req_len,
2107 : : void *resp, u32 *resp_len)
2108 : : {
2109 : 7 : printk(KERN_INFO "[ath10k_pci_hif_exchange_bmi_msg]\n");
2110 : 7 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2111 : 7 : struct ath10k_pci_pipe *pci_tx = &ar_pci->pipe_info[BMI_CE_NUM_TO_TARG];
2112 : 7 : struct ath10k_pci_pipe *pci_rx = &ar_pci->pipe_info[BMI_CE_NUM_TO_HOST];
2113 : 7 : struct ath10k_ce_pipe *ce_tx = pci_tx->ce_hdl;
2114 : 7 : struct ath10k_ce_pipe *ce_rx = pci_rx->ce_hdl;
2115 : 7 : dma_addr_t req_paddr = 0;
2116 : 7 : dma_addr_t resp_paddr = 0;
2117 : 7 : struct bmi_xfer xfer = {};
2118 : 7 : void *treq, *tresp = NULL;
2119 : 7 : int ret = 0;
2120 : :
2121 : 7 : might_sleep();
2122 : :
2123 : 7 : printk(KERN_INFO "resp && !resp_len\n");
2124 [ + - + - ]: 7 : if (resp && !resp_len)
2125 : : return -EINVAL;
2126 : :
2127 : 7 : printk(KERN_INFO "resp && resp_len && *resp_len == 0\n");
2128 [ + - + - : 7 : if (resp && resp_len && *resp_len == 0)
+ - ]
2129 : : return -EINVAL;
2130 : :
2131 : 7 : printk(KERN_INFO "treq\n");
2132 : 7 : treq = kmemdup(req, req_len, GFP_KERNEL);
2133 [ + - ]: 7 : if (!treq)
2134 : : return -ENOMEM;
2135 : :
2136 : 7 : req_paddr = dma_map_single(ar->dev, treq, req_len, DMA_TO_DEVICE);
2137 : 7 : ret = dma_mapping_error(ar->dev, req_paddr);
2138 : 7 : if (ret) {
2139 : 0 : ret = -EIO;
2140 : 0 : goto err_dma;
2141 : : }
2142 : :
2143 [ + - + - ]: 7 : if (resp && resp_len) {
2144 : 7 : printk(KERN_INFO "resp && resp_len == true\n");
2145 : 7 : tresp = kzalloc(*resp_len, GFP_KERNEL);
2146 [ - + ]: 7 : if (!tresp) {
2147 : 0 : ret = -ENOMEM;
2148 : 0 : goto err_req;
2149 : : }
2150 : :
2151 : 7 : resp_paddr = dma_map_single(ar->dev, tresp, *resp_len,
2152 : : DMA_FROM_DEVICE);
2153 : 7 : ret = dma_mapping_error(ar->dev, resp_paddr);
2154 : 7 : if (ret) {
2155 : 0 : ret = -EIO;
2156 : 0 : goto err_req;
2157 : : }
2158 : :
2159 : 7 : xfer.wait_for_resp = true;
2160 : 7 : xfer.resp_len = 0;
2161 : :
2162 : 7 : printk(KERN_INFO "ath10k_ce_rx_post_buf\n");
2163 : 7 : ath10k_ce_rx_post_buf(ce_rx, &xfer, resp_paddr);
2164 : : }
2165 : :
2166 : 7 : printk(KERN_INFO "ath10k_ce_send\n");
2167 : 7 : ret = ath10k_ce_send(ce_tx, &xfer, req_paddr, req_len, -1, 0);
2168 [ - + ]: 7 : if (ret)
2169 : 0 : goto err_resp;
2170 : :
2171 : 7 : printk(KERN_INFO "ath10k_pci_bmi_wait\n");
2172 : 7 : ret = ath10k_pci_bmi_wait(ar, ce_tx, ce_rx, &xfer);
2173 [ - + ]: 7 : if (ret) {
2174 : 0 : dma_addr_t unused_buffer;
2175 : 0 : unsigned int unused_nbytes;
2176 : 0 : unsigned int unused_id;
2177 : :
2178 : 0 : printk(KERN_INFO "ath10k_ce_cancel_send_next\n");
2179 : 0 : ath10k_ce_cancel_send_next(ce_tx, NULL, &unused_buffer,
2180 : : &unused_nbytes, &unused_id);
2181 : : } else {
2182 : : /* non-zero means we did not time out */
2183 : : ret = 0;
2184 : : }
2185 : :
2186 : 7 : err_resp:
2187 [ - + ]: 7 : if (resp) {
2188 : 7 : dma_addr_t unused_buffer;
2189 : :
2190 : 7 : printk(KERN_INFO "ath10k_ce_revoke_recv_next\n");
2191 : 7 : ath10k_ce_revoke_recv_next(ce_rx, NULL, &unused_buffer);
2192 : 7 : dma_unmap_single(ar->dev, resp_paddr,
2193 : : *resp_len, DMA_FROM_DEVICE);
2194 : : }
2195 : 0 : err_req:
2196 : 7 : dma_unmap_single(ar->dev, req_paddr, req_len, DMA_TO_DEVICE);
2197 : :
2198 [ - + - + ]: 7 : if (ret == 0 && resp_len) {
2199 : 7 : *resp_len = min(*resp_len, xfer.resp_len);
2200 : : // memcpy(resp, tresp, xfer.resp_len);
2201 : 7 : printk(KERN_INFO "VULNERABILITY MEMCPY\n");
2202 : 7 : memcpy(resp, tresp, *resp_len);
2203 : : }
2204 : 0 : err_dma:
2205 : 7 : kfree(treq);
2206 : 7 : kfree(tresp);
2207 : :
2208 : 7 : return ret;
2209 : : }
2210 : :
2211 : 1358 : static void ath10k_pci_bmi_send_done(struct ath10k_ce_pipe *ce_state)
2212 : : {
2213 : 1358 : struct bmi_xfer *xfer;
2214 : :
2215 [ + + ]: 1358 : if (ath10k_ce_completed_send_next(ce_state, (void **)&xfer))
2216 : 1351 : return;
2217 : :
2218 [ + + + + ]: 1344 : if (WARN_ON_ONCE(!xfer))
2219 : : return;
2220 : :
2221 : 7 : xfer->tx_done = true;
2222 : : }
2223 : :
2224 : 1358 : static void ath10k_pci_bmi_recv_data(struct ath10k_ce_pipe *ce_state)
2225 : : {
2226 : 1358 : struct ath10k *ar = ce_state->ar;
2227 : 1358 : struct bmi_xfer *xfer;
2228 : 1358 : unsigned int nbytes;
2229 : :
2230 [ + - ]: 1358 : if (ath10k_ce_completed_recv_next(ce_state, (void **)&xfer,
2231 : : &nbytes))
2232 : 1351 : return;
2233 : :
2234 [ + + + + ]: 1358 : if (WARN_ON_ONCE(!xfer))
2235 : : return;
2236 : :
2237 [ - + ]: 7 : if (!xfer->wait_for_resp) {
2238 : 0 : ath10k_warn(ar, "unexpected: BMI data received; ignoring\n");
2239 : 0 : return;
2240 : : }
2241 : :
2242 : 7 : xfer->resp_len = nbytes;
2243 : 7 : xfer->rx_done = true;
2244 : : }
2245 : :
2246 : 7 : static int ath10k_pci_bmi_wait(struct ath10k *ar,
2247 : : struct ath10k_ce_pipe *tx_pipe,
2248 : : struct ath10k_ce_pipe *rx_pipe,
2249 : : struct bmi_xfer *xfer)
2250 : : {
2251 : 7 : unsigned long timeout = jiffies + BMI_COMMUNICATION_TIMEOUT_HZ;
2252 : 7 : unsigned long started = jiffies;
2253 : 7 : unsigned long dur;
2254 : 7 : int ret;
2255 : :
2256 [ + - ]: 1358 : while (time_before_eq(jiffies, timeout)) {
2257 : 1358 : ath10k_pci_bmi_send_done(tx_pipe);
2258 : 1358 : ath10k_pci_bmi_recv_data(rx_pipe);
2259 : :
2260 [ + - + + ]: 1358 : if (xfer->tx_done && (xfer->rx_done == xfer->wait_for_resp)) {
2261 : 7 : ret = 0;
2262 : 7 : goto out;
2263 : : }
2264 : :
2265 : 1351 : schedule();
2266 : : }
2267 : :
2268 : : ret = -ETIMEDOUT;
2269 : :
2270 : 7 : out:
2271 : 7 : dur = jiffies - started;
2272 [ - + ]: 7 : if (dur > HZ)
2273 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_BMI,
2274 : : "bmi cmd took %lu jiffies hz %d ret %d\n",
2275 : : dur, HZ, ret);
2276 : 7 : return ret;
2277 : : }
2278 : :
2279 : : /*
2280 : : * Send an interrupt to the device to wake up the Target CPU
2281 : : * so it has an opportunity to notice any changed state.
2282 : : */
2283 : 7 : static int ath10k_pci_wake_target_cpu(struct ath10k *ar)
2284 : : {
2285 : 7 : u32 addr, val;
2286 : :
2287 : 7 : addr = SOC_CORE_BASE_ADDRESS + CORE_CTRL_ADDRESS;
2288 : 7 : val = ath10k_pci_read32(ar, addr);
2289 : 7 : val |= CORE_CTRL_CPU_INTR_MASK;
2290 : 7 : ath10k_pci_write32(ar, addr, val);
2291 : :
2292 : 7 : return 0;
2293 : : }
2294 : :
2295 : 8 : static int ath10k_pci_get_num_banks(struct ath10k *ar)
2296 : : {
2297 [ + - - - ]: 8 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2298 : :
2299 [ + - - - ]: 8 : switch (ar_pci->pdev->device) {
2300 : : case QCA988X_2_0_DEVICE_ID_UBNT:
2301 : : case QCA988X_2_0_DEVICE_ID:
2302 : : case QCA99X0_2_0_DEVICE_ID:
2303 : : case QCA9888_2_0_DEVICE_ID:
2304 : : case QCA9984_1_0_DEVICE_ID:
2305 : : case QCA9887_1_0_DEVICE_ID:
2306 : : return 1;
2307 : 8 : case QCA6164_2_1_DEVICE_ID:
2308 : : case QCA6174_2_1_DEVICE_ID:
2309 [ - - - + ]: 8 : switch (MS(ar->bus_param.chip_id, SOC_CHIP_ID_REV)) {
2310 : : case QCA6174_HW_1_0_CHIP_ID_REV:
2311 : : case QCA6174_HW_1_1_CHIP_ID_REV:
2312 : : case QCA6174_HW_2_1_CHIP_ID_REV:
2313 : : case QCA6174_HW_2_2_CHIP_ID_REV:
2314 : : return 3;
2315 : 0 : case QCA6174_HW_1_3_CHIP_ID_REV:
2316 : 0 : return 2;
2317 : 0 : case QCA6174_HW_3_0_CHIP_ID_REV:
2318 : : case QCA6174_HW_3_1_CHIP_ID_REV:
2319 : : case QCA6174_HW_3_2_CHIP_ID_REV:
2320 : 0 : return 9;
2321 : : }
2322 : : break;
2323 : 0 : case QCA9377_1_0_DEVICE_ID:
2324 : 0 : return 9;
2325 : : }
2326 : :
2327 : 0 : ath10k_warn(ar, "unknown number of banks, assuming 1\n");
2328 : 0 : return 1;
2329 : : }
2330 : :
2331 : 8 : static int ath10k_bus_get_num_banks(struct ath10k *ar)
2332 : : {
2333 : 8 : struct ath10k_ce *ce = ath10k_ce_priv(ar);
2334 : :
2335 : 8 : return ce->bus_ops->get_num_banks(ar);
2336 : : }
2337 : :
2338 : 19 : int ath10k_pci_init_config(struct ath10k *ar)
2339 : : {
2340 : 19 : u32 interconnect_targ_addr;
2341 : 19 : u32 pcie_state_targ_addr = 0;
2342 : 19 : u32 pipe_cfg_targ_addr = 0;
2343 : 19 : u32 svc_to_pipe_map = 0;
2344 : 19 : u32 pcie_config_flags = 0;
2345 : 19 : u32 ealloc_value;
2346 : 19 : u32 ealloc_targ_addr;
2347 : 19 : u32 flag2_value;
2348 : 19 : u32 flag2_targ_addr;
2349 : 19 : int ret = 0;
2350 : :
2351 : : /* Download to Target the CE Config and the service-to-CE map */
2352 : 19 : interconnect_targ_addr =
2353 : : host_interest_item_address(HI_ITEM(hi_interconnect_state));
2354 : :
2355 : : /* Supply Target-side CE configuration */
2356 : 19 : ret = ath10k_pci_diag_read32(ar, interconnect_targ_addr,
2357 : : &pcie_state_targ_addr);
2358 [ + + ]: 19 : if (ret != 0) {
2359 : 3 : ath10k_err(ar, "Failed to get pcie state addr: %d\n", ret);
2360 : 3 : return ret;
2361 : : }
2362 : :
2363 [ + + ]: 16 : if (pcie_state_targ_addr == 0) {
2364 : 1 : ret = -EIO;
2365 : 1 : ath10k_err(ar, "Invalid pcie state addr\n");
2366 : 1 : return ret;
2367 : : }
2368 : :
2369 : 15 : ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
2370 : : offsetof(struct pcie_state,
2371 : : pipe_cfg_addr)),
2372 : : &pipe_cfg_targ_addr);
2373 [ + + ]: 15 : if (ret != 0) {
2374 : 1 : ath10k_err(ar, "Failed to get pipe cfg addr: %d\n", ret);
2375 : 1 : return ret;
2376 : : }
2377 : :
2378 [ + + ]: 14 : if (pipe_cfg_targ_addr == 0) {
2379 : 1 : ret = -EIO;
2380 : 1 : ath10k_err(ar, "Invalid pipe cfg addr\n");
2381 : 1 : return ret;
2382 : : }
2383 : :
2384 : 13 : ret = ath10k_pci_diag_write_mem(ar, pipe_cfg_targ_addr,
2385 : : target_ce_config_wlan,
2386 : 13 : sizeof(struct ce_pipe_config) *
2387 : 13 : NUM_TARGET_CE_CONFIG_WLAN);
2388 : :
2389 [ + + ]: 13 : if (ret != 0) {
2390 : 1 : ath10k_err(ar, "Failed to write pipe cfg: %d\n", ret);
2391 : 1 : return ret;
2392 : : }
2393 : :
2394 : 12 : ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
2395 : : offsetof(struct pcie_state,
2396 : : svc_to_pipe_map)),
2397 : : &svc_to_pipe_map);
2398 [ + + ]: 12 : if (ret != 0) {
2399 : 1 : ath10k_err(ar, "Failed to get svc/pipe map: %d\n", ret);
2400 : 1 : return ret;
2401 : : }
2402 : :
2403 [ - + ]: 11 : if (svc_to_pipe_map == 0) {
2404 : 0 : ret = -EIO;
2405 : 0 : ath10k_err(ar, "Invalid svc_to_pipe map\n");
2406 : 0 : return ret;
2407 : : }
2408 : :
2409 : 11 : ret = ath10k_pci_diag_write_mem(ar, svc_to_pipe_map,
2410 : : target_service_to_ce_map_wlan,
2411 : : sizeof(target_service_to_ce_map_wlan));
2412 [ + + ]: 11 : if (ret != 0) {
2413 : 1 : ath10k_err(ar, "Failed to write svc/pipe map: %d\n", ret);
2414 : 1 : return ret;
2415 : : }
2416 : :
2417 : 10 : ret = ath10k_pci_diag_read32(ar, (pcie_state_targ_addr +
2418 : : offsetof(struct pcie_state,
2419 : : config_flags)),
2420 : : &pcie_config_flags);
2421 [ + + ]: 10 : if (ret != 0) {
2422 : 1 : ath10k_err(ar, "Failed to get pcie config_flags: %d\n", ret);
2423 : 1 : return ret;
2424 : : }
2425 : :
2426 : 9 : pcie_config_flags &= ~PCIE_CONFIG_FLAG_ENABLE_L1;
2427 : :
2428 : 9 : ret = ath10k_pci_diag_write32(ar, (pcie_state_targ_addr +
2429 : : offsetof(struct pcie_state,
2430 : : config_flags)),
2431 : : pcie_config_flags);
2432 [ + + ]: 9 : if (ret != 0) {
2433 : 1 : ath10k_err(ar, "Failed to write pcie config_flags: %d\n", ret);
2434 : 1 : return ret;
2435 : : }
2436 : :
2437 : : /* configure early allocation */
2438 : 8 : ealloc_targ_addr = host_interest_item_address(HI_ITEM(hi_early_alloc));
2439 : :
2440 : 8 : ret = ath10k_pci_diag_read32(ar, ealloc_targ_addr, &ealloc_value);
2441 [ - + ]: 8 : if (ret != 0) {
2442 : 0 : ath10k_err(ar, "Failed to get early alloc val: %d\n", ret);
2443 : 0 : return ret;
2444 : : }
2445 : :
2446 : : /* first bank is switched to IRAM */
2447 : 8 : ealloc_value |= ((HI_EARLY_ALLOC_MAGIC << HI_EARLY_ALLOC_MAGIC_SHIFT) &
2448 : : HI_EARLY_ALLOC_MAGIC_MASK);
2449 : 8 : ealloc_value |= ((ath10k_bus_get_num_banks(ar) <<
2450 : 8 : HI_EARLY_ALLOC_IRAM_BANKS_SHIFT) &
2451 : : HI_EARLY_ALLOC_IRAM_BANKS_MASK);
2452 : :
2453 : 8 : ret = ath10k_pci_diag_write32(ar, ealloc_targ_addr, ealloc_value);
2454 [ - + ]: 8 : if (ret != 0) {
2455 : 0 : ath10k_err(ar, "Failed to set early alloc val: %d\n", ret);
2456 : 0 : return ret;
2457 : : }
2458 : :
2459 : : /* Tell Target to proceed with initialization */
2460 : 8 : flag2_targ_addr = host_interest_item_address(HI_ITEM(hi_option_flag2));
2461 : :
2462 : 8 : ret = ath10k_pci_diag_read32(ar, flag2_targ_addr, &flag2_value);
2463 [ - + ]: 8 : if (ret != 0) {
2464 : 0 : ath10k_err(ar, "Failed to get option val: %d\n", ret);
2465 : 0 : return ret;
2466 : : }
2467 : :
2468 : 8 : flag2_value |= HI_OPTION_EARLY_CFG_DONE;
2469 : :
2470 : 8 : ret = ath10k_pci_diag_write32(ar, flag2_targ_addr, flag2_value);
2471 [ + + ]: 8 : if (ret != 0) {
2472 : 1 : ath10k_err(ar, "Failed to set option val: %d\n", ret);
2473 : 1 : return ret;
2474 : : }
2475 : :
2476 : : return 0;
2477 : : }
2478 : :
2479 : 28 : static void ath10k_pci_override_ce_config(struct ath10k *ar)
2480 : : {
2481 : 28 : struct ce_attr *attr;
2482 : 28 : struct ce_pipe_config *config;
2483 : :
2484 : : /* For QCA6174 we're overriding the Copy Engine 5 configuration,
2485 : : * since it is currently used for other feature.
2486 : : */
2487 : :
2488 : : /* Override Host's Copy Engine 5 configuration */
2489 : 28 : attr = &host_ce_config_wlan[5];
2490 : 28 : attr->src_sz_max = 0;
2491 : 28 : attr->dest_nentries = 0;
2492 : :
2493 : : /* Override Target firmware's Copy Engine configuration */
2494 : 28 : config = &target_ce_config_wlan[5];
2495 : 28 : config->pipedir = __cpu_to_le32(PIPEDIR_OUT);
2496 : 28 : config->nbytes_max = __cpu_to_le32(2048);
2497 : :
2498 : : /* Map from service/endpoint to Copy Engine */
2499 : 28 : target_service_to_ce_map_wlan[15].pipenum = __cpu_to_le32(1);
2500 : 28 : }
2501 : :
2502 : 28 : int ath10k_pci_alloc_pipes(struct ath10k *ar)
2503 : : {
2504 : 28 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2505 : 28 : struct ath10k_pci_pipe *pipe;
2506 : 28 : struct ath10k_ce *ce = ath10k_ce_priv(ar);
2507 : 28 : int i, ret;
2508 : :
2509 [ + + ]: 252 : for (i = 0; i < CE_COUNT; i++) {
2510 : 224 : pipe = &ar_pci->pipe_info[i];
2511 : 224 : pipe->ce_hdl = &ce->ce_states[i];
2512 : 224 : pipe->pipe_num = i;
2513 : 224 : pipe->hif_ce_state = ar;
2514 : :
2515 : 224 : ret = ath10k_ce_alloc_pipe(ar, i, &host_ce_config_wlan[i]);
2516 [ - + ]: 224 : if (ret) {
2517 : 0 : ath10k_err(ar, "failed to allocate copy engine pipe %d: %d\n",
2518 : : i, ret);
2519 : 0 : return ret;
2520 : : }
2521 : :
2522 : : /* Last CE is Diagnostic Window */
2523 [ + + ]: 224 : if (i == CE_DIAG_PIPE) {
2524 : 28 : ar_pci->ce_diag = pipe->ce_hdl;
2525 : 28 : continue;
2526 : : }
2527 : :
2528 : 196 : pipe->buf_sz = (size_t)(host_ce_config_wlan[i].src_sz_max);
2529 : : }
2530 : :
2531 : : return 0;
2532 : : }
2533 : :
2534 : 3 : void ath10k_pci_free_pipes(struct ath10k *ar)
2535 : : {
2536 : 3 : int i;
2537 : :
2538 [ + + - - : 27 : for (i = 0; i < CE_COUNT; i++)
- - ]
2539 : 24 : ath10k_ce_free_pipe(ar, i);
2540 : 0 : }
2541 : :
2542 : 121 : int ath10k_pci_init_pipes(struct ath10k *ar)
2543 : : {
2544 : 121 : int i, ret;
2545 : :
2546 [ + + ]: 1089 : for (i = 0; i < CE_COUNT; i++) {
2547 : 968 : ret = ath10k_ce_init_pipe(ar, i, &host_ce_config_wlan[i]);
2548 [ - + ]: 968 : if (ret) {
2549 : 0 : ath10k_err(ar, "failed to initialize copy engine pipe %d: %d\n",
2550 : : i, ret);
2551 : 0 : return ret;
2552 : : }
2553 : : }
2554 : :
2555 : : return 0;
2556 : : }
2557 : :
2558 : 6 : static bool ath10k_pci_has_fw_crashed(struct ath10k *ar)
2559 : : {
2560 : 12 : return ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS) &
2561 : : FW_IND_EVENT_PENDING;
2562 : : }
2563 : :
2564 : 4 : static void ath10k_pci_fw_crashed_clear(struct ath10k *ar)
2565 : : {
2566 : 4 : u32 val;
2567 : :
2568 : 4 : val = ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS);
2569 : 4 : val &= ~FW_IND_EVENT_PENDING;
2570 : 4 : ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS, val);
2571 : 4 : }
2572 : :
2573 : 0 : static bool ath10k_pci_has_device_gone(struct ath10k *ar)
2574 : : {
2575 : 0 : u32 val;
2576 : :
2577 : 0 : val = ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS);
2578 : 0 : return (val == 0xffffffff);
2579 : : }
2580 : :
2581 : : /* this function effectively clears target memory controller assert line */
2582 : 51 : static void ath10k_pci_warm_reset_si0(struct ath10k *ar)
2583 : : {
2584 : 51 : u32 val;
2585 : :
2586 : 51 : val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2587 : 51 : ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
2588 : 51 : val | SOC_RESET_CONTROL_SI0_RST_MASK);
2589 : 51 : val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2590 : :
2591 : 51 : msleep(10);
2592 : :
2593 : 51 : val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2594 : 51 : ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
2595 : 51 : val & ~SOC_RESET_CONTROL_SI0_RST_MASK);
2596 : 51 : val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2597 : :
2598 : 51 : msleep(10);
2599 : 51 : }
2600 : :
2601 : 102 : static void ath10k_pci_warm_reset_cpu(struct ath10k *ar)
2602 : : {
2603 : 102 : u32 val;
2604 : :
2605 : 102 : ath10k_pci_write32(ar, FW_INDICATOR_ADDRESS, 0);
2606 : :
2607 : 102 : val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2608 : 102 : ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
2609 : : val | SOC_RESET_CONTROL_CPU_WARM_RST_MASK);
2610 : 102 : }
2611 : :
2612 : 51 : static void ath10k_pci_warm_reset_ce(struct ath10k *ar)
2613 : : {
2614 : 51 : u32 val;
2615 : :
2616 : 51 : val = ath10k_pci_soc_read32(ar, SOC_RESET_CONTROL_ADDRESS);
2617 : :
2618 : 51 : ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
2619 : 51 : val | SOC_RESET_CONTROL_CE_RST_MASK);
2620 : 51 : msleep(10);
2621 : 51 : ath10k_pci_soc_write32(ar, SOC_RESET_CONTROL_ADDRESS,
2622 : 51 : val & ~SOC_RESET_CONTROL_CE_RST_MASK);
2623 : 51 : }
2624 : :
2625 : 51 : static void ath10k_pci_warm_reset_clear_lf(struct ath10k *ar)
2626 : : {
2627 : 51 : u32 val;
2628 : :
2629 : 51 : val = ath10k_pci_soc_read32(ar, SOC_LF_TIMER_CONTROL0_ADDRESS);
2630 : 51 : ath10k_pci_soc_write32(ar, SOC_LF_TIMER_CONTROL0_ADDRESS,
2631 : : val & ~SOC_LF_TIMER_CONTROL0_ENABLE_MASK);
2632 : 51 : }
2633 : :
2634 : 51 : static int ath10k_pci_warm_reset(struct ath10k *ar)
2635 : : {
2636 : 51 : int ret;
2637 : :
2638 [ + - ]: 51 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot warm reset\n");
2639 : :
2640 : 51 : spin_lock_bh(&ar->data_lock);
2641 : 51 : ar->stats.fw_warm_reset_counter++;
2642 : 51 : spin_unlock_bh(&ar->data_lock);
2643 : :
2644 : 51 : ath10k_pci_irq_disable(ar);
2645 : :
2646 : : /* Make sure the target CPU is not doing anything dangerous, e.g. if it
2647 : : * were to access copy engine while host performs copy engine reset
2648 : : * then it is possible for the device to confuse pci-e controller to
2649 : : * the point of bringing host system to a complete stop (i.e. hang).
2650 : : */
2651 : 51 : ath10k_pci_warm_reset_si0(ar);
2652 : 51 : ath10k_pci_warm_reset_cpu(ar);
2653 : 51 : ath10k_pci_init_pipes(ar);
2654 : 51 : ath10k_pci_wait_for_target_init(ar);
2655 : :
2656 : 51 : ath10k_pci_warm_reset_clear_lf(ar);
2657 : 51 : ath10k_pci_warm_reset_ce(ar);
2658 : 51 : ath10k_pci_warm_reset_cpu(ar);
2659 : 51 : ath10k_pci_init_pipes(ar);
2660 : :
2661 : 51 : ret = ath10k_pci_wait_for_target_init(ar);
2662 [ + + ]: 51 : if (ret) {
2663 : 6 : ath10k_warn(ar, "failed to wait for target init: %d\n", ret);
2664 : 6 : return ret;
2665 : : }
2666 : :
2667 [ + - ]: 45 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot warm reset complete\n");
2668 : :
2669 : : return 0;
2670 : : }
2671 : :
2672 : 0 : static int ath10k_pci_qca99x0_soft_chip_reset(struct ath10k *ar)
2673 : : {
2674 : 0 : ath10k_pci_irq_disable(ar);
2675 : 0 : return ath10k_pci_qca99x0_chip_reset(ar);
2676 : : }
2677 : :
2678 : 0 : static int ath10k_pci_safe_chip_reset(struct ath10k *ar)
2679 : : {
2680 [ # # ]: 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2681 : :
2682 [ # # ]: 0 : if (!ar_pci->pci_soft_reset)
2683 : : return -ENOTSUPP;
2684 : :
2685 : 0 : return ar_pci->pci_soft_reset(ar);
2686 : : }
2687 : :
2688 : 0 : static int ath10k_pci_qca988x_chip_reset(struct ath10k *ar)
2689 : : {
2690 : 0 : int i, ret;
2691 : 0 : u32 val;
2692 : :
2693 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot 988x chip reset\n");
2694 : :
2695 : : /* Some hardware revisions (e.g. CUS223v2) has issues with cold reset.
2696 : : * It is thus preferred to use warm reset which is safer but may not be
2697 : : * able to recover the device from all possible fail scenarios.
2698 : : *
2699 : : * Warm reset doesn't always work on first try so attempt it a few
2700 : : * times before giving up.
2701 : : */
2702 [ # # ]: 0 : for (i = 0; i < ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS; i++) {
2703 : 0 : ret = ath10k_pci_warm_reset(ar);
2704 [ # # ]: 0 : if (ret) {
2705 : 0 : ath10k_warn(ar, "failed to warm reset attempt %d of %d: %d\n",
2706 : : i + 1, ATH10K_PCI_NUM_WARM_RESET_ATTEMPTS,
2707 : : ret);
2708 : 0 : continue;
2709 : : }
2710 : :
2711 : : /* FIXME: Sometimes copy engine doesn't recover after warm
2712 : : * reset. In most cases this needs cold reset. In some of these
2713 : : * cases the device is in such a state that a cold reset may
2714 : : * lock up the host.
2715 : : *
2716 : : * Reading any host interest register via copy engine is
2717 : : * sufficient to verify if device is capable of booting
2718 : : * firmware blob.
2719 : : */
2720 : 0 : ret = ath10k_pci_init_pipes(ar);
2721 [ # # ]: 0 : if (ret) {
2722 : 0 : ath10k_warn(ar, "failed to init copy engine: %d\n",
2723 : : ret);
2724 : 0 : continue;
2725 : : }
2726 : :
2727 : 0 : ret = ath10k_pci_diag_read32(ar, QCA988X_HOST_INTEREST_ADDRESS,
2728 : : &val);
2729 [ # # ]: 0 : if (ret) {
2730 : 0 : ath10k_warn(ar, "failed to poke copy engine: %d\n",
2731 : : ret);
2732 : 0 : continue;
2733 : : }
2734 : :
2735 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot chip reset complete (warm)\n");
2736 : : return 0;
2737 : : }
2738 : :
2739 [ # # ]: 0 : if (ath10k_pci_reset_mode == ATH10K_PCI_RESET_WARM_ONLY) {
2740 : 0 : ath10k_warn(ar, "refusing cold reset as requested\n");
2741 : 0 : return -EPERM;
2742 : : }
2743 : :
2744 : 0 : ret = ath10k_pci_cold_reset(ar);
2745 [ # # ]: 0 : if (ret) {
2746 : 0 : ath10k_warn(ar, "failed to cold reset: %d\n", ret);
2747 : 0 : return ret;
2748 : : }
2749 : :
2750 : 0 : ret = ath10k_pci_wait_for_target_init(ar);
2751 [ # # ]: 0 : if (ret) {
2752 : 0 : ath10k_warn(ar, "failed to wait for target after cold reset: %d\n",
2753 : : ret);
2754 : 0 : return ret;
2755 : : }
2756 : :
2757 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca988x chip reset complete (cold)\n");
2758 : :
2759 : : return 0;
2760 : : }
2761 : :
2762 : 53 : static int ath10k_pci_qca6174_chip_reset(struct ath10k *ar)
2763 : : {
2764 : 53 : int ret;
2765 : :
2766 [ + - ]: 53 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca6174 chip reset\n");
2767 : :
2768 : : /* FIXME: QCA6174 requires cold + warm reset to work. */
2769 : :
2770 : 53 : ret = ath10k_pci_cold_reset(ar);
2771 [ - + ]: 53 : if (ret) {
2772 : 0 : ath10k_warn(ar, "failed to cold reset: %d\n", ret);
2773 : 0 : return ret;
2774 : : }
2775 : :
2776 : 53 : ret = ath10k_pci_wait_for_target_init(ar);
2777 [ + + ]: 53 : if (ret) {
2778 : 2 : ath10k_warn(ar, "failed to wait for target after cold reset: %d\n",
2779 : : ret);
2780 : 2 : return ret;
2781 : : }
2782 : :
2783 : 51 : ret = ath10k_pci_warm_reset(ar);
2784 [ + + ]: 51 : if (ret) {
2785 : 6 : ath10k_warn(ar, "failed to warm reset: %d\n", ret);
2786 : 6 : return ret;
2787 : : }
2788 : :
2789 [ + - ]: 45 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca6174 chip reset complete (cold)\n");
2790 : :
2791 : : return 0;
2792 : : }
2793 : :
2794 : 0 : static int ath10k_pci_qca99x0_chip_reset(struct ath10k *ar)
2795 : : {
2796 : 0 : int ret;
2797 : :
2798 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca99x0 chip reset\n");
2799 : :
2800 : 0 : ret = ath10k_pci_cold_reset(ar);
2801 [ # # ]: 0 : if (ret) {
2802 : 0 : ath10k_warn(ar, "failed to cold reset: %d\n", ret);
2803 : 0 : return ret;
2804 : : }
2805 : :
2806 : 0 : ret = ath10k_pci_wait_for_target_init(ar);
2807 [ # # ]: 0 : if (ret) {
2808 : 0 : ath10k_warn(ar, "failed to wait for target after cold reset: %d\n",
2809 : : ret);
2810 : 0 : return ret;
2811 : : }
2812 : :
2813 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot qca99x0 chip reset complete (cold)\n");
2814 : :
2815 : : return 0;
2816 : : }
2817 : :
2818 : 53 : static int ath10k_pci_chip_reset(struct ath10k *ar)
2819 : : {
2820 : 53 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2821 : :
2822 [ - + + - : 53 : if (WARN_ON(!ar_pci->pci_hard_reset))
- + + - ]
2823 : : return -ENOTSUPP;
2824 : :
2825 : 53 : return ar_pci->pci_hard_reset(ar);
2826 : : }
2827 : :
2828 : 25 : static int ath10k_pci_hif_power_up(struct ath10k *ar,
2829 : : enum ath10k_firmware_mode fw_mode)
2830 : : {
2831 [ + - ]: 25 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2832 : 25 : int ret;
2833 : :
2834 [ + - ]: 25 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif power up\n");
2835 : :
2836 : 25 : pcie_capability_read_word(ar_pci->pdev, PCI_EXP_LNKCTL,
2837 : : &ar_pci->link_ctl);
2838 : 25 : pcie_capability_write_word(ar_pci->pdev, PCI_EXP_LNKCTL,
2839 : 25 : ar_pci->link_ctl & ~PCI_EXP_LNKCTL_ASPMC);
2840 : :
2841 : : /*
2842 : : * Bring the target up cleanly.
2843 : : *
2844 : : * The target may be in an undefined state with an AUX-powered Target
2845 : : * and a Host in WoW mode. If the Host crashes, loses power, or is
2846 : : * restarted (without unloading the driver) then the Target is left
2847 : : * (aux) powered and running. On a subsequent driver load, the Target
2848 : : * is in an unexpected state. We try to catch that here in order to
2849 : : * reset the Target and retry the probe.
2850 : : */
2851 [ - + ]: 25 : ret = ath10k_pci_chip_reset(ar);
2852 [ + + ]: 25 : if (ret) {
2853 [ + + ]: 6 : if (ath10k_pci_has_fw_crashed(ar)) {
2854 : 4 : ath10k_warn(ar, "firmware crashed during chip reset\n");
2855 : 4 : ath10k_pci_fw_crashed_clear(ar);
2856 : 4 : ath10k_pci_fw_crashed_dump(ar);
2857 : : }
2858 : :
2859 : 6 : ath10k_err(ar, "failed to reset chip: %d\n", ret);
2860 : 6 : goto err_sleep;
2861 : : }
2862 : :
2863 : 19 : ret = ath10k_pci_init_pipes(ar);
2864 [ - + ]: 19 : if (ret) {
2865 : 0 : ath10k_err(ar, "failed to initialize CE: %d\n", ret);
2866 : 0 : goto err_sleep;
2867 : : }
2868 : :
2869 : 19 : ret = ath10k_pci_init_config(ar);
2870 [ + + ]: 19 : if (ret) {
2871 : 12 : ath10k_err(ar, "failed to setup init config: %d\n", ret);
2872 : 12 : goto err_ce;
2873 : : }
2874 : :
2875 : 7 : ret = ath10k_pci_wake_target_cpu(ar);
2876 [ - + ]: 7 : if (ret) {
2877 : 0 : ath10k_err(ar, "could not wake up target CPU: %d\n", ret);
2878 : 0 : goto err_ce;
2879 : : }
2880 : :
2881 : : return 0;
2882 : :
2883 : 12 : err_ce:
2884 : 12 : ath10k_pci_ce_deinit(ar);
2885 : :
2886 : : err_sleep:
2887 : : return ret;
2888 : : }
2889 : :
2890 : 7 : void ath10k_pci_hif_power_down(struct ath10k *ar)
2891 : : {
2892 [ + - ]: 7 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot hif power down\n");
2893 : :
2894 : : /* Currently hif_power_up performs effectively a reset and hif_stop
2895 : : * resets the chip as well so there's no point in resetting here.
2896 : : */
2897 : 7 : }
2898 : :
2899 : 0 : static int ath10k_pci_hif_suspend(struct ath10k *ar)
2900 : : {
2901 : : /* Nothing to do; the important stuff is in the driver suspend. */
2902 : 0 : return 0;
2903 : : }
2904 : :
2905 : 0 : static int ath10k_pci_suspend(struct ath10k *ar)
2906 : : {
2907 : : /* The grace timer can still be counting down and ar->ps_awake be true.
2908 : : * It is known that the device may be asleep after resuming regardless
2909 : : * of the SoC powersave state before suspending. Hence make sure the
2910 : : * device is asleep before proceeding.
2911 : : */
2912 : 0 : ath10k_pci_sleep_sync(ar);
2913 : :
2914 : 0 : return 0;
2915 : : }
2916 : :
2917 : 0 : static int ath10k_pci_hif_resume(struct ath10k *ar)
2918 : : {
2919 : : /* Nothing to do; the important stuff is in the driver resume. */
2920 : 0 : return 0;
2921 : : }
2922 : :
2923 : 0 : static int ath10k_pci_resume(struct ath10k *ar)
2924 : : {
2925 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
2926 : 0 : struct pci_dev *pdev = ar_pci->pdev;
2927 : 0 : u32 val;
2928 : 0 : int ret = 0;
2929 : :
2930 : 0 : ret = ath10k_pci_force_wake(ar);
2931 [ # # ]: 0 : if (ret) {
2932 : 0 : ath10k_err(ar, "failed to wake up target: %d\n", ret);
2933 : 0 : return ret;
2934 : : }
2935 : :
2936 : : /* Suspend/Resume resets the PCI configuration space, so we have to
2937 : : * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
2938 : : * from interfering with C3 CPU state. pci_restore_state won't help
2939 : : * here since it only restores the first 64 bytes pci config header.
2940 : : */
2941 : 0 : pci_read_config_dword(pdev, 0x40, &val);
2942 [ # # ]: 0 : if ((val & 0x0000ff00) != 0)
2943 : 0 : pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
2944 : :
2945 : : return ret;
2946 : : }
2947 : :
2948 : 0 : static bool ath10k_pci_validate_cal(void *data, size_t size)
2949 : : {
2950 : 0 : __le16 *cal_words = data;
2951 : 0 : u16 checksum = 0;
2952 : 0 : size_t i;
2953 : :
2954 : 0 : if (size % 2 != 0)
2955 : : return false;
2956 : :
2957 [ # # ]: 0 : for (i = 0; i < size / 2; i++)
2958 : 0 : checksum ^= le16_to_cpu(cal_words[i]);
2959 : :
2960 : 0 : return checksum == 0xffff;
2961 : : }
2962 : :
2963 : 0 : static void ath10k_pci_enable_eeprom(struct ath10k *ar)
2964 : : {
2965 : : /* Enable SI clock */
2966 : 0 : ath10k_pci_soc_write32(ar, CLOCK_CONTROL_OFFSET, 0x0);
2967 : :
2968 : : /* Configure GPIOs for I2C operation */
2969 : 0 : ath10k_pci_write32(ar,
2970 : : GPIO_BASE_ADDRESS + GPIO_PIN0_OFFSET +
2971 : : 4 * QCA9887_1_0_I2C_SDA_GPIO_PIN,
2972 : : SM(QCA9887_1_0_I2C_SDA_PIN_CONFIG,
2973 : : GPIO_PIN0_CONFIG) |
2974 : : SM(1, GPIO_PIN0_PAD_PULL));
2975 : :
2976 : 0 : ath10k_pci_write32(ar,
2977 : : GPIO_BASE_ADDRESS + GPIO_PIN0_OFFSET +
2978 : : 4 * QCA9887_1_0_SI_CLK_GPIO_PIN,
2979 : : SM(QCA9887_1_0_SI_CLK_PIN_CONFIG, GPIO_PIN0_CONFIG) |
2980 : : SM(1, GPIO_PIN0_PAD_PULL));
2981 : :
2982 : 0 : ath10k_pci_write32(ar,
2983 : : GPIO_BASE_ADDRESS +
2984 : : QCA9887_1_0_GPIO_ENABLE_W1TS_LOW_ADDRESS,
2985 : : 1u << QCA9887_1_0_SI_CLK_GPIO_PIN);
2986 : :
2987 : : /* In Swift ASIC - EEPROM clock will be (110MHz/512) = 214KHz */
2988 : 0 : ath10k_pci_write32(ar,
2989 : : SI_BASE_ADDRESS + SI_CONFIG_OFFSET,
2990 : : SM(1, SI_CONFIG_ERR_INT) |
2991 : : SM(1, SI_CONFIG_BIDIR_OD_DATA) |
2992 : : SM(1, SI_CONFIG_I2C) |
2993 : : SM(1, SI_CONFIG_POS_SAMPLE) |
2994 : : SM(1, SI_CONFIG_INACTIVE_DATA) |
2995 : : SM(1, SI_CONFIG_INACTIVE_CLK) |
2996 : : SM(8, SI_CONFIG_DIVIDER));
2997 : 0 : }
2998 : :
2999 : 0 : static int ath10k_pci_read_eeprom(struct ath10k *ar, u16 addr, u8 *out)
3000 : : {
3001 : 0 : u32 reg;
3002 : 0 : int wait_limit;
3003 : :
3004 : : /* set device select byte and for the read operation */
3005 : 0 : reg = QCA9887_EEPROM_SELECT_READ |
3006 : 0 : SM(addr, QCA9887_EEPROM_ADDR_LO) |
3007 : 0 : SM(addr >> 8, QCA9887_EEPROM_ADDR_HI);
3008 : 0 : ath10k_pci_write32(ar, SI_BASE_ADDRESS + SI_TX_DATA0_OFFSET, reg);
3009 : :
3010 : : /* write transmit data, transfer length, and START bit */
3011 : 0 : ath10k_pci_write32(ar, SI_BASE_ADDRESS + SI_CS_OFFSET,
3012 : : SM(1, SI_CS_START) | SM(1, SI_CS_RX_CNT) |
3013 : : SM(4, SI_CS_TX_CNT));
3014 : :
3015 : : /* wait max 1 sec */
3016 : 0 : wait_limit = 100000;
3017 : :
3018 : : /* wait for SI_CS_DONE_INT */
3019 : 0 : do {
3020 : 0 : reg = ath10k_pci_read32(ar, SI_BASE_ADDRESS + SI_CS_OFFSET);
3021 [ # # ]: 0 : if (MS(reg, SI_CS_DONE_INT))
3022 : : break;
3023 : :
3024 : 0 : wait_limit--;
3025 : 0 : udelay(10);
3026 [ # # ]: 0 : } while (wait_limit > 0);
3027 : :
3028 [ # # ]: 0 : if (!MS(reg, SI_CS_DONE_INT)) {
3029 : 0 : ath10k_err(ar, "timeout while reading device EEPROM at %04x\n",
3030 : : addr);
3031 : 0 : return -ETIMEDOUT;
3032 : : }
3033 : :
3034 : : /* clear SI_CS_DONE_INT */
3035 : 0 : ath10k_pci_write32(ar, SI_BASE_ADDRESS + SI_CS_OFFSET, reg);
3036 : :
3037 [ # # ]: 0 : if (MS(reg, SI_CS_DONE_ERR)) {
3038 : 0 : ath10k_err(ar, "failed to read device EEPROM at %04x\n", addr);
3039 : 0 : return -EIO;
3040 : : }
3041 : :
3042 : : /* extract receive data */
3043 : 0 : reg = ath10k_pci_read32(ar, SI_BASE_ADDRESS + SI_RX_DATA0_OFFSET);
3044 : 0 : *out = reg;
3045 : :
3046 : 0 : return 0;
3047 : : }
3048 : :
3049 : 0 : static int ath10k_pci_hif_fetch_cal_eeprom(struct ath10k *ar, void **data,
3050 : : size_t *data_len)
3051 : : {
3052 : 0 : u8 *caldata = NULL;
3053 : 0 : size_t calsize, i;
3054 : 0 : int ret;
3055 : :
3056 [ # # ]: 0 : if (!QCA_REV_9887(ar))
3057 : : return -EOPNOTSUPP;
3058 : :
3059 : 0 : calsize = ar->hw_params.cal_data_len;
3060 [ # # ]: 0 : caldata = kmalloc(calsize, GFP_KERNEL);
3061 [ # # ]: 0 : if (!caldata)
3062 : : return -ENOMEM;
3063 : :
3064 : 0 : ath10k_pci_enable_eeprom(ar);
3065 : :
3066 [ # # ]: 0 : for (i = 0; i < calsize; i++) {
3067 : 0 : ret = ath10k_pci_read_eeprom(ar, i, &caldata[i]);
3068 [ # # ]: 0 : if (ret)
3069 : 0 : goto err_free;
3070 : : }
3071 : :
3072 [ # # # # ]: 0 : if (!ath10k_pci_validate_cal(caldata, calsize))
3073 : 0 : goto err_free;
3074 : :
3075 : 0 : *data = caldata;
3076 : 0 : *data_len = calsize;
3077 : :
3078 : 0 : return 0;
3079 : :
3080 : 0 : err_free:
3081 : 0 : kfree(caldata);
3082 : :
3083 : 0 : return -EINVAL;
3084 : : }
3085 : :
3086 : : static const struct ath10k_hif_ops ath10k_pci_hif_ops = {
3087 : : .tx_sg = ath10k_pci_hif_tx_sg,
3088 : : .diag_read = ath10k_pci_hif_diag_read,
3089 : : .diag_write = ath10k_pci_diag_write_mem,
3090 : : .exchange_bmi_msg = ath10k_pci_hif_exchange_bmi_msg,
3091 : : .start = ath10k_pci_hif_start,
3092 : : .stop = ath10k_pci_hif_stop,
3093 : : .map_service_to_pipe = ath10k_pci_hif_map_service_to_pipe,
3094 : : .get_default_pipe = ath10k_pci_hif_get_default_pipe,
3095 : : .send_complete_check = ath10k_pci_hif_send_complete_check,
3096 : : .get_free_queue_number = ath10k_pci_hif_get_free_queue_number,
3097 : : .power_up = ath10k_pci_hif_power_up,
3098 : : .power_down = ath10k_pci_hif_power_down,
3099 : : .read32 = ath10k_pci_read32,
3100 : : .write32 = ath10k_pci_write32,
3101 : : .suspend = ath10k_pci_hif_suspend,
3102 : : .resume = ath10k_pci_hif_resume,
3103 : : .fetch_cal_eeprom = ath10k_pci_hif_fetch_cal_eeprom,
3104 : : };
3105 : :
3106 : : /*
3107 : : * Top-level interrupt handler for all PCI interrupts from a Target.
3108 : : * When a block of MSI interrupts is allocated, this top-level handler
3109 : : * is not used; instead, we directly call the correct sub-handler.
3110 : : */
3111 : 0 : static irqreturn_t ath10k_pci_interrupt_handler(int irq, void *arg)
3112 : : {
3113 : 0 : struct ath10k *ar = arg;
3114 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3115 : 0 : int ret;
3116 : :
3117 [ # # ]: 0 : if (ath10k_pci_has_device_gone(ar))
3118 : : return IRQ_NONE;
3119 : :
3120 : 0 : ret = ath10k_pci_force_wake(ar);
3121 [ # # ]: 0 : if (ret) {
3122 : 0 : ath10k_warn(ar, "failed to wake device up on irq: %d\n", ret);
3123 : 0 : return IRQ_NONE;
3124 : : }
3125 : :
3126 [ # # # # ]: 0 : if ((ar_pci->oper_irq_mode == ATH10K_PCI_IRQ_LEGACY) &&
3127 : 0 : !ath10k_pci_irq_pending(ar))
3128 : : return IRQ_NONE;
3129 : :
3130 : 0 : ath10k_pci_disable_and_clear_legacy_irq(ar);
3131 : 0 : ath10k_pci_irq_msi_fw_mask(ar);
3132 : 0 : napi_schedule(&ar->napi);
3133 : :
3134 : 0 : return IRQ_HANDLED;
3135 : : }
3136 : :
3137 : 0 : static int ath10k_pci_napi_poll(struct napi_struct *ctx, int budget)
3138 : : {
3139 : 0 : struct ath10k *ar = container_of(ctx, struct ath10k, napi);
3140 : 0 : int done = 0;
3141 : :
3142 [ # # ]: 0 : if (ath10k_pci_has_fw_crashed(ar)) {
3143 : 0 : ath10k_pci_fw_crashed_clear(ar);
3144 : 0 : ath10k_pci_fw_crashed_dump(ar);
3145 : 0 : napi_complete(ctx);
3146 : 0 : return done;
3147 : : }
3148 : :
3149 : 0 : ath10k_ce_per_engine_service_any(ar);
3150 : :
3151 : 0 : done = ath10k_htt_txrx_compl_task(ar, budget);
3152 : :
3153 [ # # ]: 0 : if (done < budget) {
3154 : 0 : napi_complete_done(ctx, done);
3155 : : /* In case of MSI, it is possible that interrupts are received
3156 : : * while NAPI poll is inprogress. So pending interrupts that are
3157 : : * received after processing all copy engine pipes by NAPI poll
3158 : : * will not be handled again. This is causing failure to
3159 : : * complete boot sequence in x86 platform. So before enabling
3160 : : * interrupts safer to check for pending interrupts for
3161 : : * immediate servicing.
3162 : : */
3163 [ # # # # ]: 0 : if (ath10k_ce_interrupt_summary(ar)) {
3164 : 0 : napi_reschedule(ctx);
3165 : 0 : goto out;
3166 : : }
3167 : 0 : ath10k_pci_enable_legacy_irq(ar);
3168 : 0 : ath10k_pci_irq_msi_fw_unmask(ar);
3169 : : }
3170 : :
3171 : 0 : out:
3172 : : return done;
3173 : : }
3174 : :
3175 : 28 : static int ath10k_pci_request_irq_msi(struct ath10k *ar)
3176 : : {
3177 : 28 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3178 : 28 : int ret;
3179 : :
3180 : 28 : ret = request_irq(ar_pci->pdev->irq,
3181 : : ath10k_pci_interrupt_handler,
3182 : : IRQF_SHARED, "ath10k_pci", ar);
3183 [ - + ]: 28 : if (ret) {
3184 : 0 : ath10k_warn(ar, "failed to request MSI irq %d: %d\n",
3185 : 0 : ar_pci->pdev->irq, ret);
3186 : 0 : return ret;
3187 : : }
3188 : :
3189 : : return 0;
3190 : : }
3191 : :
3192 : 0 : static int ath10k_pci_request_irq_legacy(struct ath10k *ar)
3193 : : {
3194 : 0 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3195 : 0 : int ret;
3196 : :
3197 : 0 : ret = request_irq(ar_pci->pdev->irq,
3198 : : ath10k_pci_interrupt_handler,
3199 : : IRQF_SHARED, "ath10k_pci", ar);
3200 [ # # ]: 0 : if (ret) {
3201 : 0 : ath10k_warn(ar, "failed to request legacy irq %d: %d\n",
3202 : 0 : ar_pci->pdev->irq, ret);
3203 : 0 : return ret;
3204 : : }
3205 : :
3206 : : return 0;
3207 : : }
3208 : :
3209 : 28 : static int ath10k_pci_request_irq(struct ath10k *ar)
3210 : : {
3211 [ - + - ]: 28 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3212 : :
3213 [ - + - ]: 28 : switch (ar_pci->oper_irq_mode) {
3214 : 0 : case ATH10K_PCI_IRQ_LEGACY:
3215 : 0 : return ath10k_pci_request_irq_legacy(ar);
3216 : 28 : case ATH10K_PCI_IRQ_MSI:
3217 : 28 : return ath10k_pci_request_irq_msi(ar);
3218 : : default:
3219 : : return -EINVAL;
3220 : : }
3221 : : }
3222 : :
3223 : 3 : static void ath10k_pci_free_irq(struct ath10k *ar)
3224 : : {
3225 : 3 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3226 : :
3227 : 3 : free_irq(ar_pci->pdev->irq, ar);
3228 : : }
3229 : :
3230 : 28 : void ath10k_pci_init_napi(struct ath10k *ar)
3231 : : {
3232 : 0 : netif_napi_add(&ar->napi_dev, &ar->napi, ath10k_pci_napi_poll,
3233 : : ATH10K_NAPI_BUDGET);
3234 : 0 : }
3235 : :
3236 : 28 : static int ath10k_pci_init_irq(struct ath10k *ar)
3237 : : {
3238 : 28 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3239 : 28 : int ret;
3240 : :
3241 : 28 : ath10k_pci_init_napi(ar);
3242 : :
3243 [ - + ]: 28 : if (ath10k_pci_irq_mode != ATH10K_PCI_IRQ_AUTO)
3244 : 0 : ath10k_info(ar, "limiting irq mode to: %d\n",
3245 : : ath10k_pci_irq_mode);
3246 : :
3247 : : /* Try MSI */
3248 [ + - ]: 28 : if (ath10k_pci_irq_mode != ATH10K_PCI_IRQ_LEGACY) {
3249 : 28 : ar_pci->oper_irq_mode = ATH10K_PCI_IRQ_MSI;
3250 : 28 : ret = pci_enable_msi(ar_pci->pdev);
3251 [ - + ]: 28 : if (ret == 0)
3252 : : return 0;
3253 : :
3254 : : /* fall-through */
3255 : : }
3256 : :
3257 : : /* Try legacy irq
3258 : : *
3259 : : * A potential race occurs here: The CORE_BASE write
3260 : : * depends on target correctly decoding AXI address but
3261 : : * host won't know when target writes BAR to CORE_CTRL.
3262 : : * This write might get lost if target has NOT written BAR.
3263 : : * For now, fix the race by repeating the write in below
3264 : : * synchronization checking.
3265 : : */
3266 : 0 : ar_pci->oper_irq_mode = ATH10K_PCI_IRQ_LEGACY;
3267 : :
3268 : 0 : ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
3269 : 0 : PCIE_INTR_FIRMWARE_MASK | PCIE_INTR_CE_MASK_ALL);
3270 : :
3271 : 0 : return 0;
3272 : : }
3273 : :
3274 : 0 : static void ath10k_pci_deinit_irq_legacy(struct ath10k *ar)
3275 : : {
3276 : 0 : ath10k_pci_write32(ar, SOC_CORE_BASE_ADDRESS + PCIE_INTR_ENABLE_ADDRESS,
3277 : : 0);
3278 : 0 : }
3279 : :
3280 : 3 : static int ath10k_pci_deinit_irq(struct ath10k *ar)
3281 : : {
3282 [ - + ]: 3 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3283 : :
3284 [ - + ]: 3 : switch (ar_pci->oper_irq_mode) {
3285 : : case ATH10K_PCI_IRQ_LEGACY:
3286 : 0 : ath10k_pci_deinit_irq_legacy(ar);
3287 : : break;
3288 : 3 : default:
3289 : 3 : pci_disable_msi(ar_pci->pdev);
3290 : 3 : break;
3291 : : }
3292 : :
3293 : 3 : return 0;
3294 : : }
3295 : :
3296 : 155 : int ath10k_pci_wait_for_target_init(struct ath10k *ar)
3297 : : {
3298 [ + - ]: 155 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3299 : 155 : unsigned long timeout;
3300 : 155 : u32 val;
3301 : :
3302 [ + - ]: 155 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot waiting target to initialise\n");
3303 : :
3304 : 155 : timeout = jiffies + msecs_to_jiffies(ATH10K_PCI_TARGET_WAIT);
3305 : :
3306 : 157 : do {
3307 : 157 : val = ath10k_pci_read32(ar, FW_INDICATOR_ADDRESS);
3308 : :
3309 [ + - ]: 157 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot target indicator %x\n",
3310 : : val);
3311 : :
3312 : : /* target should never return this */
3313 [ + + ]: 157 : if (val == 0xffffffff)
3314 : 1 : continue;
3315 : :
3316 : : /* the device has crashed so don't bother trying anymore */
3317 [ + + ]: 156 : if (val & FW_IND_EVENT_PENDING)
3318 : : break;
3319 : :
3320 [ + + ]: 148 : if (val & FW_IND_INITIALIZED)
3321 : : break;
3322 : :
3323 [ - + ]: 1 : if (ar_pci->oper_irq_mode == ATH10K_PCI_IRQ_LEGACY)
3324 : : /* Fix potential race by repeating CORE_BASE writes */
3325 : 0 : ath10k_pci_enable_legacy_irq(ar);
3326 : :
3327 [ + + ]: 11 : mdelay(10);
3328 [ + - ]: 2 : } while (time_before(jiffies, timeout));
3329 : :
3330 : 155 : ath10k_pci_disable_and_clear_legacy_irq(ar);
3331 : 155 : ath10k_pci_irq_msi_fw_mask(ar);
3332 : :
3333 [ - + ]: 155 : if (val == 0xffffffff) {
3334 : 0 : ath10k_err(ar, "failed to read device register, device is gone\n");
3335 : 0 : return -EIO;
3336 : : }
3337 : :
3338 [ + + ]: 155 : if (val & FW_IND_EVENT_PENDING) {
3339 : 8 : ath10k_warn(ar, "device has crashed during init\n");
3340 : 8 : return -ECOMM;
3341 : : }
3342 : :
3343 [ - + ]: 147 : if (!(val & FW_IND_INITIALIZED)) {
3344 : 0 : ath10k_err(ar, "failed to receive initialized event from target: %08x\n",
3345 : : val);
3346 : 0 : return -ETIMEDOUT;
3347 : : }
3348 : :
3349 [ + - ]: 147 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot target initialised\n");
3350 : : return 0;
3351 : : }
3352 : :
3353 : 53 : static int ath10k_pci_cold_reset(struct ath10k *ar)
3354 : : {
3355 : 53 : u32 val;
3356 : :
3357 [ + - ]: 53 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cold reset\n");
3358 : :
3359 : 53 : spin_lock_bh(&ar->data_lock);
3360 : :
3361 : 53 : ar->stats.fw_cold_reset_counter++;
3362 : :
3363 : 53 : spin_unlock_bh(&ar->data_lock);
3364 : :
3365 : : /* Put Target, including PCIe, into RESET. */
3366 : 53 : val = ath10k_pci_reg_read32(ar, SOC_GLOBAL_RESET_ADDRESS);
3367 : 53 : val |= 1;
3368 : 53 : ath10k_pci_reg_write32(ar, SOC_GLOBAL_RESET_ADDRESS, val);
3369 : :
3370 : : /* After writing into SOC_GLOBAL_RESET to put device into
3371 : : * reset and pulling out of reset pcie may not be stable
3372 : : * for any immediate pcie register access and cause bus error,
3373 : : * add delay before any pcie access request to fix this issue.
3374 : : */
3375 : 53 : msleep(20);
3376 : :
3377 : : /* Pull Target, including PCIe, out of RESET. */
3378 : 53 : val &= ~1;
3379 : 53 : ath10k_pci_reg_write32(ar, SOC_GLOBAL_RESET_ADDRESS, val);
3380 : :
3381 : 53 : msleep(20);
3382 : :
3383 [ + - ]: 53 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cold reset complete\n");
3384 : :
3385 : 53 : return 0;
3386 : : }
3387 : :
3388 : 28 : static int ath10k_pci_claim(struct ath10k *ar)
3389 : : {
3390 : 28 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3391 : 28 : struct pci_dev *pdev = ar_pci->pdev;
3392 : 28 : int ret;
3393 : :
3394 : 28 : pci_set_drvdata(pdev, ar);
3395 : :
3396 : 28 : ret = pci_enable_device(pdev);
3397 [ - + ]: 28 : if (ret) {
3398 : 0 : ath10k_err(ar, "failed to enable pci device: %d\n", ret);
3399 : 0 : return ret;
3400 : : }
3401 : :
3402 : 28 : ret = pci_request_region(pdev, BAR_NUM, "ath");
3403 [ - + ]: 28 : if (ret) {
3404 : 0 : ath10k_err(ar, "failed to request region BAR%d: %d\n", BAR_NUM,
3405 : : ret);
3406 : 0 : goto err_device;
3407 : : }
3408 : :
3409 : : /* Target expects 32 bit DMA. Enforce it. */
3410 : 28 : ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
3411 [ - + ]: 28 : if (ret) {
3412 : 0 : ath10k_err(ar, "failed to set dma mask to 32-bit: %d\n", ret);
3413 : 0 : goto err_region;
3414 : : }
3415 : :
3416 : 28 : ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
3417 [ - + ]: 28 : if (ret) {
3418 : 0 : ath10k_err(ar, "failed to set consistent dma mask to 32-bit: %d\n",
3419 : : ret);
3420 : 0 : goto err_region;
3421 : : }
3422 : :
3423 : 28 : pci_set_master(pdev);
3424 : :
3425 : : /* Arrange for access to Target SoC registers. */
3426 [ - + - - ]: 28 : ar_pci->mem_len = pci_resource_len(pdev, BAR_NUM);
3427 : 28 : ar_pci->mem = pci_iomap(pdev, BAR_NUM, 0);
3428 [ - + ]: 28 : if (!ar_pci->mem) {
3429 : 0 : ath10k_err(ar, "failed to iomap BAR%d\n", BAR_NUM);
3430 : 0 : ret = -EIO;
3431 : 0 : goto err_master;
3432 : : }
3433 : :
3434 [ + - ]: 28 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot pci_mem 0x%pK\n", ar_pci->mem);
3435 : : return 0;
3436 : :
3437 : : err_master:
3438 : 0 : pci_clear_master(pdev);
3439 : :
3440 : 0 : err_region:
3441 : 0 : pci_release_region(pdev, BAR_NUM);
3442 : :
3443 : 0 : err_device:
3444 : 0 : pci_disable_device(pdev);
3445 : :
3446 : 0 : return ret;
3447 : : }
3448 : :
3449 : 3 : static void ath10k_pci_release(struct ath10k *ar)
3450 : : {
3451 : 3 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3452 : 3 : struct pci_dev *pdev = ar_pci->pdev;
3453 : :
3454 : 3 : pci_iounmap(pdev, ar_pci->mem);
3455 : 3 : pci_release_region(pdev, BAR_NUM);
3456 : 3 : pci_clear_master(pdev);
3457 : 3 : pci_disable_device(pdev);
3458 : 3 : }
3459 : :
3460 : 25 : static bool ath10k_pci_chip_is_supported(u32 dev_id, u32 chip_id)
3461 : : {
3462 : 25 : const struct ath10k_pci_supp_chip *supp_chip;
3463 : 25 : int i;
3464 : 25 : u32 rev_id = MS(chip_id, SOC_CHIP_ID_REV);
3465 : :
3466 [ - - + - ]: 200 : for (i = 0; i < ARRAY_SIZE(ath10k_pci_supp_chips); i++) {
3467 : 200 : supp_chip = &ath10k_pci_supp_chips[i];
3468 : :
3469 [ - - + + ]: 200 : if (supp_chip->dev_id == dev_id &&
3470 [ - - - + ]: 25 : supp_chip->rev_id == rev_id)
3471 : : return true;
3472 : : }
3473 : :
3474 : : return false;
3475 : : }
3476 : :
3477 : 28 : int ath10k_pci_setup_resource(struct ath10k *ar)
3478 : : {
3479 : 28 : struct ath10k_pci *ar_pci = ath10k_pci_priv(ar);
3480 : 28 : struct ath10k_ce *ce = ath10k_ce_priv(ar);
3481 : 28 : int ret;
3482 : :
3483 : 28 : spin_lock_init(&ce->ce_lock);
3484 : 28 : spin_lock_init(&ar_pci->ps_lock);
3485 : 28 : mutex_init(&ar_pci->ce_diag_mutex);
3486 : :
3487 : 28 : INIT_WORK(&ar_pci->dump_work, ath10k_pci_fw_dump_work);
3488 : :
3489 : 28 : timer_setup(&ar_pci->rx_post_retry, ath10k_pci_rx_replenish_retry, 0);
3490 : :
3491 [ - + - - ]: 28 : if (QCA_REV_6174(ar) || QCA_REV_9377(ar))
3492 : 28 : ath10k_pci_override_ce_config(ar);
3493 : :
3494 : 28 : ret = ath10k_pci_alloc_pipes(ar);
3495 [ - + ]: 28 : if (ret) {
3496 : 0 : ath10k_err(ar, "failed to allocate copy engine pipes: %d\n",
3497 : : ret);
3498 : 0 : return ret;
3499 : : }
3500 : :
3501 : : return 0;
3502 : : }
3503 : :
3504 : 0 : void ath10k_pci_release_resource(struct ath10k *ar)
3505 : : {
3506 : 0 : ath10k_pci_rx_retry_sync(ar);
3507 : 0 : netif_napi_del(&ar->napi);
3508 : 0 : ath10k_pci_ce_deinit(ar);
3509 : : ath10k_pci_free_pipes(ar);
3510 : 0 : }
3511 : :
3512 : : static const struct ath10k_bus_ops ath10k_pci_bus_ops = {
3513 : : .read32 = ath10k_bus_pci_read32,
3514 : : .write32 = ath10k_bus_pci_write32,
3515 : : .get_num_banks = ath10k_pci_get_num_banks,
3516 : : };
3517 : :
3518 : 28 : static int ath10k_pci_probe(struct pci_dev *pdev,
3519 : : const struct pci_device_id *pci_dev)
3520 : : {
3521 : 28 : int ret = 0;
3522 : 28 : struct ath10k *ar;
3523 : 28 : struct ath10k_pci *ar_pci;
3524 : 28 : enum ath10k_hw_rev hw_rev;
3525 : 28 : struct ath10k_bus_params bus_params = {};
3526 : 28 : bool pci_ps, is_qca988x = false;
3527 : 28 : int (*pci_soft_reset)(struct ath10k *ar);
3528 : 28 : int (*pci_hard_reset)(struct ath10k *ar);
3529 : 28 : u32 (*targ_cpu_to_ce_addr)(struct ath10k *ar, u32 addr);
3530 : :
3531 [ - + - - : 28 : switch (pci_dev->device) {
- - - - ]
3532 : : case QCA988X_2_0_DEVICE_ID_UBNT:
3533 : : case QCA988X_2_0_DEVICE_ID:
3534 : : hw_rev = ATH10K_HW_QCA988X;
3535 : : pci_ps = false;
3536 : : is_qca988x = true;
3537 : : pci_soft_reset = ath10k_pci_warm_reset;
3538 : : pci_hard_reset = ath10k_pci_qca988x_chip_reset;
3539 : : targ_cpu_to_ce_addr = ath10k_pci_qca988x_targ_cpu_to_ce_addr;
3540 : : break;
3541 : 0 : case QCA9887_1_0_DEVICE_ID:
3542 : 0 : hw_rev = ATH10K_HW_QCA9887;
3543 : 0 : pci_ps = false;
3544 : 0 : pci_soft_reset = ath10k_pci_warm_reset;
3545 : 0 : pci_hard_reset = ath10k_pci_qca988x_chip_reset;
3546 : 0 : targ_cpu_to_ce_addr = ath10k_pci_qca988x_targ_cpu_to_ce_addr;
3547 : 0 : break;
3548 : 28 : case QCA6164_2_1_DEVICE_ID:
3549 : : case QCA6174_2_1_DEVICE_ID:
3550 : 28 : hw_rev = ATH10K_HW_QCA6174;
3551 : 28 : pci_ps = true;
3552 : 28 : pci_soft_reset = ath10k_pci_warm_reset;
3553 : 28 : pci_hard_reset = ath10k_pci_qca6174_chip_reset;
3554 : 28 : targ_cpu_to_ce_addr = ath10k_pci_qca6174_targ_cpu_to_ce_addr;
3555 : 28 : break;
3556 : 0 : case QCA99X0_2_0_DEVICE_ID:
3557 : 0 : hw_rev = ATH10K_HW_QCA99X0;
3558 : 0 : pci_ps = false;
3559 : 0 : pci_soft_reset = ath10k_pci_qca99x0_soft_chip_reset;
3560 : 0 : pci_hard_reset = ath10k_pci_qca99x0_chip_reset;
3561 : 0 : targ_cpu_to_ce_addr = ath10k_pci_qca99x0_targ_cpu_to_ce_addr;
3562 : 0 : break;
3563 : 0 : case QCA9984_1_0_DEVICE_ID:
3564 : 0 : hw_rev = ATH10K_HW_QCA9984;
3565 : 0 : pci_ps = false;
3566 : 0 : pci_soft_reset = ath10k_pci_qca99x0_soft_chip_reset;
3567 : 0 : pci_hard_reset = ath10k_pci_qca99x0_chip_reset;
3568 : 0 : targ_cpu_to_ce_addr = ath10k_pci_qca99x0_targ_cpu_to_ce_addr;
3569 : 0 : break;
3570 : 0 : case QCA9888_2_0_DEVICE_ID:
3571 : 0 : hw_rev = ATH10K_HW_QCA9888;
3572 : 0 : pci_ps = false;
3573 : 0 : pci_soft_reset = ath10k_pci_qca99x0_soft_chip_reset;
3574 : 0 : pci_hard_reset = ath10k_pci_qca99x0_chip_reset;
3575 : 0 : targ_cpu_to_ce_addr = ath10k_pci_qca99x0_targ_cpu_to_ce_addr;
3576 : 0 : break;
3577 : 0 : case QCA9377_1_0_DEVICE_ID:
3578 : 0 : hw_rev = ATH10K_HW_QCA9377;
3579 : 0 : pci_ps = true;
3580 : 0 : pci_soft_reset = ath10k_pci_warm_reset;
3581 : 0 : pci_hard_reset = ath10k_pci_qca6174_chip_reset;
3582 : 0 : targ_cpu_to_ce_addr = ath10k_pci_qca6174_targ_cpu_to_ce_addr;
3583 : 0 : break;
3584 : : default:
3585 : 0 : WARN_ON(1);
3586 : 0 : return -ENOTSUPP;
3587 : : }
3588 : :
3589 : 28 : ar = ath10k_core_create(sizeof(*ar_pci), &pdev->dev, ATH10K_BUS_PCI,
3590 : : hw_rev, &ath10k_pci_hif_ops);
3591 [ - + ]: 28 : if (!ar) {
3592 : 0 : dev_err(&pdev->dev, "failed to allocate core\n");
3593 : 0 : return -ENOMEM;
3594 : : }
3595 : :
3596 [ + - ]: 28 : ath10k_dbg(ar, ATH10K_DBG_BOOT, "pci probe %04x:%04x %04x:%04x\n",
3597 : : pdev->vendor, pdev->device,
3598 : : pdev->subsystem_vendor, pdev->subsystem_device);
3599 : :
3600 : 28 : ar_pci = ath10k_pci_priv(ar);
3601 : 28 : ar_pci->pdev = pdev;
3602 : 28 : ar_pci->dev = &pdev->dev;
3603 : 28 : ar_pci->ar = ar;
3604 : 28 : ar->dev_id = pci_dev->device;
3605 : 28 : ar_pci->pci_ps = pci_ps;
3606 : 28 : ar_pci->ce.bus_ops = &ath10k_pci_bus_ops;
3607 : 28 : ar_pci->pci_soft_reset = pci_soft_reset;
3608 : 28 : ar_pci->pci_hard_reset = pci_hard_reset;
3609 : 28 : ar_pci->targ_cpu_to_ce_addr = targ_cpu_to_ce_addr;
3610 : 28 : ar->ce_priv = &ar_pci->ce;
3611 : :
3612 : 28 : ar->id.vendor = pdev->vendor;
3613 : 28 : ar->id.device = pdev->device;
3614 : 28 : ar->id.subsystem_vendor = pdev->subsystem_vendor;
3615 : 28 : ar->id.subsystem_device = pdev->subsystem_device;
3616 : :
3617 : 28 : timer_setup(&ar_pci->ps_timer, ath10k_pci_ps_timer, 0);
3618 : :
3619 : 28 : ret = ath10k_pci_setup_resource(ar);
3620 [ - + ]: 28 : if (ret) {
3621 : 0 : ath10k_err(ar, "failed to setup resource: %d\n", ret);
3622 : 0 : goto err_core_destroy;
3623 : : }
3624 : :
3625 : 28 : ret = ath10k_pci_claim(ar);
3626 [ - + ]: 28 : if (ret) {
3627 : 0 : ath10k_err(ar, "failed to claim device: %d\n", ret);
3628 : 0 : goto err_free_pipes;
3629 : : }
3630 : :
3631 : 28 : ret = ath10k_pci_force_wake(ar);
3632 [ - + ]: 28 : if (ret) {
3633 : 0 : ath10k_warn(ar, "failed to wake up device : %d\n", ret);
3634 : 0 : goto err_sleep;
3635 : : }
3636 : :
3637 : : ath10k_pci_ce_deinit(ar);
3638 : 28 : ath10k_pci_irq_disable(ar);
3639 : :
3640 : 28 : ret = ath10k_pci_init_irq(ar);
3641 [ - + ]: 28 : if (ret) {
3642 : 0 : ath10k_err(ar, "failed to init irqs: %d\n", ret);
3643 : 0 : goto err_sleep;
3644 : : }
3645 : :
3646 : 28 : ath10k_info(ar, "pci irq %s oper_irq_mode %d irq_mode %d reset_mode %d\n",
3647 [ + - ]: 28 : ath10k_pci_get_irq_method(ar), ar_pci->oper_irq_mode,
3648 : : ath10k_pci_irq_mode, ath10k_pci_reset_mode);
3649 : :
3650 : 28 : ret = ath10k_pci_request_irq(ar);
3651 [ - + ]: 28 : if (ret) {
3652 : 0 : ath10k_warn(ar, "failed to request irqs: %d\n", ret);
3653 : 0 : goto err_deinit_irq;
3654 : : }
3655 : :
3656 : 28 : bus_params.dev_type = ATH10K_DEV_TYPE_LL;
3657 : 28 : bus_params.link_can_suspend = true;
3658 : : /* Read CHIP_ID before reset to catch QCA9880-AR1A v1 devices that
3659 : : * fall off the bus during chip_reset. These chips have the same pci
3660 : : * device id as the QCA9880 BR4A or 2R4E. So that's why the check.
3661 : : */
3662 [ - + ]: 28 : if (is_qca988x) {
3663 : 0 : bus_params.chip_id =
3664 : 0 : ath10k_pci_soc_read32(ar, SOC_CHIP_ID_ADDRESS);
3665 [ # # ]: 0 : if (bus_params.chip_id != 0xffffffff) {
3666 [ # # ]: 0 : if (!ath10k_pci_chip_is_supported(pdev->device,
3667 : : bus_params.chip_id))
3668 : 0 : goto err_unsupported;
3669 : : }
3670 : : }
3671 : :
3672 [ - + ]: 28 : ret = ath10k_pci_chip_reset(ar);
3673 [ + + ]: 28 : if (ret) {
3674 : 2 : ath10k_err(ar, "failed to reset chip: %d\n", ret);
3675 : 2 : goto err_free_irq;
3676 : : }
3677 : :
3678 : 26 : bus_params.chip_id = ath10k_pci_soc_read32(ar, SOC_CHIP_ID_ADDRESS);
3679 [ + + ]: 26 : if (bus_params.chip_id == 0xffffffff)
3680 : 1 : goto err_unsupported;
3681 : :
3682 [ - + ]: 50 : if (!ath10k_pci_chip_is_supported(pdev->device, bus_params.chip_id))
3683 : 0 : goto err_free_irq;
3684 : :
3685 : 25 : ret = ath10k_core_register(ar, &bus_params);
3686 [ - + ]: 25 : if (ret) {
3687 : 0 : ath10k_err(ar, "failed to register driver core: %d\n", ret);
3688 : 0 : goto err_free_irq;
3689 : : }
3690 : :
3691 : : return 0;
3692 : :
3693 : 1 : err_unsupported:
3694 : 1 : ath10k_err(ar, "device %04x with chip_id %08x isn't supported\n",
3695 : 1 : pdev->device, bus_params.chip_id);
3696 : :
3697 : 3 : err_free_irq:
3698 : 3 : ath10k_pci_free_irq(ar);
3699 : 3 : ath10k_pci_rx_retry_sync(ar);
3700 : :
3701 : 3 : err_deinit_irq:
3702 : 3 : ath10k_pci_deinit_irq(ar);
3703 : :
3704 : 3 : err_sleep:
3705 : 3 : ath10k_pci_sleep_sync(ar);
3706 : 3 : ath10k_pci_release(ar);
3707 : :
3708 : 3 : err_free_pipes:
3709 : 3 : ath10k_pci_free_pipes(ar);
3710 : :
3711 : 3 : err_core_destroy:
3712 : 3 : ath10k_core_destroy(ar);
3713 : :
3714 : 3 : return ret;
3715 : : }
3716 : :
3717 : 0 : static void ath10k_pci_remove(struct pci_dev *pdev)
3718 : : {
3719 [ # # ]: 0 : struct ath10k *ar = pci_get_drvdata(pdev);
3720 : 0 : struct ath10k_pci *ar_pci;
3721 : :
3722 [ # # ]: 0 : ath10k_dbg(ar, ATH10K_DBG_PCI, "pci remove\n");
3723 : :
3724 [ # # ]: 0 : if (!ar)
3725 : : return;
3726 : :
3727 [ # # ]: 0 : ar_pci = ath10k_pci_priv(ar);
3728 : :
3729 [ # # ]: 0 : if (!ar_pci)
3730 : : return;
3731 : :
3732 : 0 : ath10k_core_unregister(ar);
3733 : 0 : ath10k_pci_free_irq(ar);
3734 : 0 : ath10k_pci_deinit_irq(ar);
3735 : 0 : ath10k_pci_release_resource(ar);
3736 : 0 : ath10k_pci_sleep_sync(ar);
3737 : 0 : ath10k_pci_release(ar);
3738 : 0 : ath10k_core_destroy(ar);
3739 : : }
3740 : :
3741 : : MODULE_DEVICE_TABLE(pci, ath10k_pci_id_table);
3742 : :
3743 : 0 : static __maybe_unused int ath10k_pci_pm_suspend(struct device *dev)
3744 : : {
3745 : 0 : struct ath10k *ar = dev_get_drvdata(dev);
3746 : 0 : int ret;
3747 : :
3748 : 0 : ret = ath10k_pci_suspend(ar);
3749 : 0 : if (ret)
3750 : : ath10k_warn(ar, "failed to suspend hif: %d\n", ret);
3751 : :
3752 : 0 : return ret;
3753 : : }
3754 : :
3755 : 0 : static __maybe_unused int ath10k_pci_pm_resume(struct device *dev)
3756 : : {
3757 : 0 : struct ath10k *ar = dev_get_drvdata(dev);
3758 : 0 : int ret;
3759 : :
3760 : 0 : ret = ath10k_pci_resume(ar);
3761 [ # # ]: 0 : if (ret)
3762 : 0 : ath10k_warn(ar, "failed to resume hif: %d\n", ret);
3763 : :
3764 : 0 : return ret;
3765 : : }
3766 : :
3767 : : static SIMPLE_DEV_PM_OPS(ath10k_pci_pm_ops,
3768 : : ath10k_pci_pm_suspend,
3769 : : ath10k_pci_pm_resume);
3770 : :
3771 : : static struct pci_driver ath10k_pci_driver = {
3772 : : .name = "ath10k_pci",
3773 : : .id_table = ath10k_pci_id_table,
3774 : : .probe = ath10k_pci_probe,
3775 : : .remove = ath10k_pci_remove,
3776 : : #ifdef CONFIG_PM
3777 : : .driver.pm = &ath10k_pci_pm_ops,
3778 : : #endif
3779 : : };
3780 : :
3781 : 28 : static int __init ath10k_pci_init(void)
3782 : : {
3783 : 28 : int ret;
3784 : :
3785 : 28 : ret = pci_register_driver(&ath10k_pci_driver);
3786 [ - + ]: 28 : if (ret)
3787 : 0 : printk(KERN_ERR "failed to register ath10k pci driver: %d\n",
3788 : : ret);
3789 : :
3790 : 28 : ret = ath10k_ahb_init();
3791 : 28 : if (ret)
3792 : : printk(KERN_ERR "ahb init failed: %d\n", ret);
3793 : :
3794 : 28 : return ret;
3795 : : }
3796 : : module_init(ath10k_pci_init);
3797 : :
3798 : 0 : static void __exit ath10k_pci_exit(void)
3799 : : {
3800 : 0 : pci_unregister_driver(&ath10k_pci_driver);
3801 : 0 : ath10k_ahb_exit();
3802 : 0 : }
3803 : :
3804 : : module_exit(ath10k_pci_exit);
3805 : :
3806 : : MODULE_AUTHOR("Qualcomm Atheros");
3807 : : MODULE_DESCRIPTION("Driver support for Qualcomm Atheros 802.11ac WLAN PCIe/AHB devices");
3808 : : MODULE_LICENSE("Dual BSD/GPL");
3809 : :
3810 : : /* QCA988x 2.0 firmware files */
3811 : : MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API2_FILE);
3812 : : MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API3_FILE);
3813 : : MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API4_FILE);
3814 : : MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_FW_API5_FILE);
3815 : : MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" QCA988X_HW_2_0_BOARD_DATA_FILE);
3816 : : MODULE_FIRMWARE(QCA988X_HW_2_0_FW_DIR "/" ATH10K_BOARD_API2_FILE);
3817 : :
3818 : : /* QCA9887 1.0 firmware files */
3819 : : MODULE_FIRMWARE(QCA9887_HW_1_0_FW_DIR "/" ATH10K_FW_API5_FILE);
3820 : : MODULE_FIRMWARE(QCA9887_HW_1_0_FW_DIR "/" QCA9887_HW_1_0_BOARD_DATA_FILE);
3821 : : MODULE_FIRMWARE(QCA9887_HW_1_0_FW_DIR "/" ATH10K_BOARD_API2_FILE);
3822 : :
3823 : : /* QCA6174 2.1 firmware files */
3824 : : MODULE_FIRMWARE(QCA6174_HW_2_1_FW_DIR "/" ATH10K_FW_API4_FILE);
3825 : : MODULE_FIRMWARE(QCA6174_HW_2_1_FW_DIR "/" ATH10K_FW_API5_FILE);
3826 : : MODULE_FIRMWARE(QCA6174_HW_2_1_FW_DIR "/" QCA6174_HW_2_1_BOARD_DATA_FILE);
3827 : : MODULE_FIRMWARE(QCA6174_HW_2_1_FW_DIR "/" ATH10K_BOARD_API2_FILE);
3828 : :
3829 : : /* QCA6174 3.1 firmware files */
3830 : : MODULE_FIRMWARE(QCA6174_HW_3_0_FW_DIR "/" ATH10K_FW_API4_FILE);
3831 : : MODULE_FIRMWARE(QCA6174_HW_3_0_FW_DIR "/" ATH10K_FW_API5_FILE);
3832 : : MODULE_FIRMWARE(QCA6174_HW_3_0_FW_DIR "/" ATH10K_FW_API6_FILE);
3833 : : MODULE_FIRMWARE(QCA6174_HW_3_0_FW_DIR "/" QCA6174_HW_3_0_BOARD_DATA_FILE);
3834 : : MODULE_FIRMWARE(QCA6174_HW_3_0_FW_DIR "/" ATH10K_BOARD_API2_FILE);
3835 : :
3836 : : /* QCA9377 1.0 firmware files */
3837 : : MODULE_FIRMWARE(QCA9377_HW_1_0_FW_DIR "/" ATH10K_FW_API6_FILE);
3838 : : MODULE_FIRMWARE(QCA9377_HW_1_0_FW_DIR "/" ATH10K_FW_API5_FILE);
3839 : : MODULE_FIRMWARE(QCA9377_HW_1_0_FW_DIR "/" QCA9377_HW_1_0_BOARD_DATA_FILE);
|
