1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
4 * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
5 */
6
7 #include <linux/elf.h>
8
9 #include "qmi.h"
10 #include "core.h"
11 #include "debug.h"
12 #include "hif.h"
13 #include <linux/of.h>
14 #include <linux/of_address.h>
15 #include <linux/ioport.h>
16 #include <linux/firmware.h>
17 #include <linux/of_irq.h>
18
19 #define SLEEP_CLOCK_SELECT_INTERNAL_BIT 0x02
20 #define HOST_CSTATE_BIT 0x04
21 #define PLATFORM_CAP_PCIE_GLOBAL_RESET 0x08
22 #define PLATFORM_CAP_PCIE_PME_D3COLD 0x10
23
24 #define FW_BUILD_ID_MASK "QC_IMAGE_VERSION_STRING="
25
26 bool ath11k_cold_boot_cal = 1;
27 EXPORT_SYMBOL(ath11k_cold_boot_cal);
28 module_param_named(cold_boot_cal, ath11k_cold_boot_cal, bool, 0644);
29 MODULE_PARM_DESC(cold_boot_cal,
30 "Decrease the channel switch time but increase the driver load time (Default: true)");
31
32 static const struct qmi_elem_info qmi_wlanfw_host_cap_req_msg_v01_ei[] = {
33 {
34 .data_type = QMI_OPT_FLAG,
35 .elem_len = 1,
36 .elem_size = sizeof(u8),
37 .array_type = NO_ARRAY,
38 .tlv_type = 0x10,
39 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
40 num_clients_valid),
41 },
42 {
43 .data_type = QMI_UNSIGNED_4_BYTE,
44 .elem_len = 1,
45 .elem_size = sizeof(u32),
46 .array_type = NO_ARRAY,
47 .tlv_type = 0x10,
48 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
49 num_clients),
50 },
51 {
52 .data_type = QMI_OPT_FLAG,
53 .elem_len = 1,
54 .elem_size = sizeof(u8),
55 .array_type = NO_ARRAY,
56 .tlv_type = 0x11,
57 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
58 wake_msi_valid),
59 },
60 {
61 .data_type = QMI_UNSIGNED_4_BYTE,
62 .elem_len = 1,
63 .elem_size = sizeof(u32),
64 .array_type = NO_ARRAY,
65 .tlv_type = 0x11,
66 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
67 wake_msi),
68 },
69 {
70 .data_type = QMI_OPT_FLAG,
71 .elem_len = 1,
72 .elem_size = sizeof(u8),
73 .array_type = NO_ARRAY,
74 .tlv_type = 0x12,
75 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
76 gpios_valid),
77 },
78 {
79 .data_type = QMI_DATA_LEN,
80 .elem_len = 1,
81 .elem_size = sizeof(u8),
82 .array_type = NO_ARRAY,
83 .tlv_type = 0x12,
84 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
85 gpios_len),
86 },
87 {
88 .data_type = QMI_UNSIGNED_4_BYTE,
89 .elem_len = QMI_WLFW_MAX_NUM_GPIO_V01,
90 .elem_size = sizeof(u32),
91 .array_type = VAR_LEN_ARRAY,
92 .tlv_type = 0x12,
93 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
94 gpios),
95 },
96 {
97 .data_type = QMI_OPT_FLAG,
98 .elem_len = 1,
99 .elem_size = sizeof(u8),
100 .array_type = NO_ARRAY,
101 .tlv_type = 0x13,
102 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
103 nm_modem_valid),
104 },
105 {
106 .data_type = QMI_UNSIGNED_1_BYTE,
107 .elem_len = 1,
108 .elem_size = sizeof(u8),
109 .array_type = NO_ARRAY,
110 .tlv_type = 0x13,
111 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
112 nm_modem),
113 },
114 {
115 .data_type = QMI_OPT_FLAG,
116 .elem_len = 1,
117 .elem_size = sizeof(u8),
118 .array_type = NO_ARRAY,
119 .tlv_type = 0x14,
120 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
121 bdf_support_valid),
122 },
123 {
124 .data_type = QMI_UNSIGNED_1_BYTE,
125 .elem_len = 1,
126 .elem_size = sizeof(u8),
127 .array_type = NO_ARRAY,
128 .tlv_type = 0x14,
129 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
130 bdf_support),
131 },
132 {
133 .data_type = QMI_OPT_FLAG,
134 .elem_len = 1,
135 .elem_size = sizeof(u8),
136 .array_type = NO_ARRAY,
137 .tlv_type = 0x15,
138 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
139 bdf_cache_support_valid),
140 },
141 {
142 .data_type = QMI_UNSIGNED_1_BYTE,
143 .elem_len = 1,
144 .elem_size = sizeof(u8),
145 .array_type = NO_ARRAY,
146 .tlv_type = 0x15,
147 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
148 bdf_cache_support),
149 },
150 {
151 .data_type = QMI_OPT_FLAG,
152 .elem_len = 1,
153 .elem_size = sizeof(u8),
154 .array_type = NO_ARRAY,
155 .tlv_type = 0x16,
156 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
157 m3_support_valid),
158 },
159 {
160 .data_type = QMI_UNSIGNED_1_BYTE,
161 .elem_len = 1,
162 .elem_size = sizeof(u8),
163 .array_type = NO_ARRAY,
164 .tlv_type = 0x16,
165 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
166 m3_support),
167 },
168 {
169 .data_type = QMI_OPT_FLAG,
170 .elem_len = 1,
171 .elem_size = sizeof(u8),
172 .array_type = NO_ARRAY,
173 .tlv_type = 0x17,
174 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
175 m3_cache_support_valid),
176 },
177 {
178 .data_type = QMI_UNSIGNED_1_BYTE,
179 .elem_len = 1,
180 .elem_size = sizeof(u8),
181 .array_type = NO_ARRAY,
182 .tlv_type = 0x17,
183 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
184 m3_cache_support),
185 },
186 {
187 .data_type = QMI_OPT_FLAG,
188 .elem_len = 1,
189 .elem_size = sizeof(u8),
190 .array_type = NO_ARRAY,
191 .tlv_type = 0x18,
192 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
193 cal_filesys_support_valid),
194 },
195 {
196 .data_type = QMI_UNSIGNED_1_BYTE,
197 .elem_len = 1,
198 .elem_size = sizeof(u8),
199 .array_type = NO_ARRAY,
200 .tlv_type = 0x18,
201 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
202 cal_filesys_support),
203 },
204 {
205 .data_type = QMI_OPT_FLAG,
206 .elem_len = 1,
207 .elem_size = sizeof(u8),
208 .array_type = NO_ARRAY,
209 .tlv_type = 0x19,
210 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
211 cal_cache_support_valid),
212 },
213 {
214 .data_type = QMI_UNSIGNED_1_BYTE,
215 .elem_len = 1,
216 .elem_size = sizeof(u8),
217 .array_type = NO_ARRAY,
218 .tlv_type = 0x19,
219 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
220 cal_cache_support),
221 },
222 {
223 .data_type = QMI_OPT_FLAG,
224 .elem_len = 1,
225 .elem_size = sizeof(u8),
226 .array_type = NO_ARRAY,
227 .tlv_type = 0x1A,
228 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
229 cal_done_valid),
230 },
231 {
232 .data_type = QMI_UNSIGNED_1_BYTE,
233 .elem_len = 1,
234 .elem_size = sizeof(u8),
235 .array_type = NO_ARRAY,
236 .tlv_type = 0x1A,
237 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
238 cal_done),
239 },
240 {
241 .data_type = QMI_OPT_FLAG,
242 .elem_len = 1,
243 .elem_size = sizeof(u8),
244 .array_type = NO_ARRAY,
245 .tlv_type = 0x1B,
246 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
247 mem_bucket_valid),
248 },
249 {
250 .data_type = QMI_UNSIGNED_4_BYTE,
251 .elem_len = 1,
252 .elem_size = sizeof(u32),
253 .array_type = NO_ARRAY,
254 .tlv_type = 0x1B,
255 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
256 mem_bucket),
257 },
258 {
259 .data_type = QMI_OPT_FLAG,
260 .elem_len = 1,
261 .elem_size = sizeof(u8),
262 .array_type = NO_ARRAY,
263 .tlv_type = 0x1C,
264 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
265 mem_cfg_mode_valid),
266 },
267 {
268 .data_type = QMI_UNSIGNED_1_BYTE,
269 .elem_len = 1,
270 .elem_size = sizeof(u8),
271 .array_type = NO_ARRAY,
272 .tlv_type = 0x1C,
273 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
274 mem_cfg_mode),
275 },
276 {
277 .data_type = QMI_EOTI,
278 .array_type = NO_ARRAY,
279 .tlv_type = QMI_COMMON_TLV_TYPE,
280 },
281 };
282
283 static const struct qmi_elem_info qmi_wlanfw_host_cap_resp_msg_v01_ei[] = {
284 {
285 .data_type = QMI_STRUCT,
286 .elem_len = 1,
287 .elem_size = sizeof(struct qmi_response_type_v01),
288 .array_type = NO_ARRAY,
289 .tlv_type = 0x02,
290 .offset = offsetof(struct qmi_wlanfw_host_cap_resp_msg_v01, resp),
291 .ei_array = qmi_response_type_v01_ei,
292 },
293 {
294 .data_type = QMI_EOTI,
295 .array_type = NO_ARRAY,
296 .tlv_type = QMI_COMMON_TLV_TYPE,
297 },
298 };
299
300 static const struct qmi_elem_info qmi_wlanfw_ind_register_req_msg_v01_ei[] = {
301 {
302 .data_type = QMI_OPT_FLAG,
303 .elem_len = 1,
304 .elem_size = sizeof(u8),
305 .array_type = NO_ARRAY,
306 .tlv_type = 0x10,
307 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
308 fw_ready_enable_valid),
309 },
310 {
311 .data_type = QMI_UNSIGNED_1_BYTE,
312 .elem_len = 1,
313 .elem_size = sizeof(u8),
314 .array_type = NO_ARRAY,
315 .tlv_type = 0x10,
316 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
317 fw_ready_enable),
318 },
319 {
320 .data_type = QMI_OPT_FLAG,
321 .elem_len = 1,
322 .elem_size = sizeof(u8),
323 .array_type = NO_ARRAY,
324 .tlv_type = 0x11,
325 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
326 initiate_cal_download_enable_valid),
327 },
328 {
329 .data_type = QMI_UNSIGNED_1_BYTE,
330 .elem_len = 1,
331 .elem_size = sizeof(u8),
332 .array_type = NO_ARRAY,
333 .tlv_type = 0x11,
334 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
335 initiate_cal_download_enable),
336 },
337 {
338 .data_type = QMI_OPT_FLAG,
339 .elem_len = 1,
340 .elem_size = sizeof(u8),
341 .array_type = NO_ARRAY,
342 .tlv_type = 0x12,
343 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
344 initiate_cal_update_enable_valid),
345 },
346 {
347 .data_type = QMI_UNSIGNED_1_BYTE,
348 .elem_len = 1,
349 .elem_size = sizeof(u8),
350 .array_type = NO_ARRAY,
351 .tlv_type = 0x12,
352 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
353 initiate_cal_update_enable),
354 },
355 {
356 .data_type = QMI_OPT_FLAG,
357 .elem_len = 1,
358 .elem_size = sizeof(u8),
359 .array_type = NO_ARRAY,
360 .tlv_type = 0x13,
361 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
362 msa_ready_enable_valid),
363 },
364 {
365 .data_type = QMI_UNSIGNED_1_BYTE,
366 .elem_len = 1,
367 .elem_size = sizeof(u8),
368 .array_type = NO_ARRAY,
369 .tlv_type = 0x13,
370 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
371 msa_ready_enable),
372 },
373 {
374 .data_type = QMI_OPT_FLAG,
375 .elem_len = 1,
376 .elem_size = sizeof(u8),
377 .array_type = NO_ARRAY,
378 .tlv_type = 0x14,
379 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
380 pin_connect_result_enable_valid),
381 },
382 {
383 .data_type = QMI_UNSIGNED_1_BYTE,
384 .elem_len = 1,
385 .elem_size = sizeof(u8),
386 .array_type = NO_ARRAY,
387 .tlv_type = 0x14,
388 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
389 pin_connect_result_enable),
390 },
391 {
392 .data_type = QMI_OPT_FLAG,
393 .elem_len = 1,
394 .elem_size = sizeof(u8),
395 .array_type = NO_ARRAY,
396 .tlv_type = 0x15,
397 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
398 client_id_valid),
399 },
400 {
401 .data_type = QMI_UNSIGNED_4_BYTE,
402 .elem_len = 1,
403 .elem_size = sizeof(u32),
404 .array_type = NO_ARRAY,
405 .tlv_type = 0x15,
406 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
407 client_id),
408 },
409 {
410 .data_type = QMI_OPT_FLAG,
411 .elem_len = 1,
412 .elem_size = sizeof(u8),
413 .array_type = NO_ARRAY,
414 .tlv_type = 0x16,
415 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
416 request_mem_enable_valid),
417 },
418 {
419 .data_type = QMI_UNSIGNED_1_BYTE,
420 .elem_len = 1,
421 .elem_size = sizeof(u8),
422 .array_type = NO_ARRAY,
423 .tlv_type = 0x16,
424 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
425 request_mem_enable),
426 },
427 {
428 .data_type = QMI_OPT_FLAG,
429 .elem_len = 1,
430 .elem_size = sizeof(u8),
431 .array_type = NO_ARRAY,
432 .tlv_type = 0x17,
433 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
434 fw_mem_ready_enable_valid),
435 },
436 {
437 .data_type = QMI_UNSIGNED_1_BYTE,
438 .elem_len = 1,
439 .elem_size = sizeof(u8),
440 .array_type = NO_ARRAY,
441 .tlv_type = 0x17,
442 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
443 fw_mem_ready_enable),
444 },
445 {
446 .data_type = QMI_OPT_FLAG,
447 .elem_len = 1,
448 .elem_size = sizeof(u8),
449 .array_type = NO_ARRAY,
450 .tlv_type = 0x18,
451 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
452 fw_init_done_enable_valid),
453 },
454 {
455 .data_type = QMI_UNSIGNED_1_BYTE,
456 .elem_len = 1,
457 .elem_size = sizeof(u8),
458 .array_type = NO_ARRAY,
459 .tlv_type = 0x18,
460 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
461 fw_init_done_enable),
462 },
463
464 {
465 .data_type = QMI_OPT_FLAG,
466 .elem_len = 1,
467 .elem_size = sizeof(u8),
468 .array_type = NO_ARRAY,
469 .tlv_type = 0x19,
470 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
471 rejuvenate_enable_valid),
472 },
473 {
474 .data_type = QMI_UNSIGNED_1_BYTE,
475 .elem_len = 1,
476 .elem_size = sizeof(u8),
477 .array_type = NO_ARRAY,
478 .tlv_type = 0x19,
479 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
480 rejuvenate_enable),
481 },
482 {
483 .data_type = QMI_OPT_FLAG,
484 .elem_len = 1,
485 .elem_size = sizeof(u8),
486 .array_type = NO_ARRAY,
487 .tlv_type = 0x1A,
488 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
489 xo_cal_enable_valid),
490 },
491 {
492 .data_type = QMI_UNSIGNED_1_BYTE,
493 .elem_len = 1,
494 .elem_size = sizeof(u8),
495 .array_type = NO_ARRAY,
496 .tlv_type = 0x1A,
497 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
498 xo_cal_enable),
499 },
500 {
501 .data_type = QMI_OPT_FLAG,
502 .elem_len = 1,
503 .elem_size = sizeof(u8),
504 .array_type = NO_ARRAY,
505 .tlv_type = 0x1B,
506 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
507 cal_done_enable_valid),
508 },
509 {
510 .data_type = QMI_UNSIGNED_1_BYTE,
511 .elem_len = 1,
512 .elem_size = sizeof(u8),
513 .array_type = NO_ARRAY,
514 .tlv_type = 0x1B,
515 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
516 cal_done_enable),
517 },
518 {
519 .data_type = QMI_EOTI,
520 .array_type = NO_ARRAY,
521 .tlv_type = QMI_COMMON_TLV_TYPE,
522 },
523 };
524
525 static const struct qmi_elem_info qmi_wlanfw_ind_register_resp_msg_v01_ei[] = {
526 {
527 .data_type = QMI_STRUCT,
528 .elem_len = 1,
529 .elem_size = sizeof(struct qmi_response_type_v01),
530 .array_type = NO_ARRAY,
531 .tlv_type = 0x02,
532 .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
533 resp),
534 .ei_array = qmi_response_type_v01_ei,
535 },
536 {
537 .data_type = QMI_OPT_FLAG,
538 .elem_len = 1,
539 .elem_size = sizeof(u8),
540 .array_type = NO_ARRAY,
541 .tlv_type = 0x10,
542 .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
543 fw_status_valid),
544 },
545 {
546 .data_type = QMI_UNSIGNED_8_BYTE,
547 .elem_len = 1,
548 .elem_size = sizeof(u64),
549 .array_type = NO_ARRAY,
550 .tlv_type = 0x10,
551 .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
552 fw_status),
553 },
554 {
555 .data_type = QMI_EOTI,
556 .array_type = NO_ARRAY,
557 .tlv_type = QMI_COMMON_TLV_TYPE,
558 },
559 };
560
561 static const struct qmi_elem_info qmi_wlanfw_mem_cfg_s_v01_ei[] = {
562 {
563 .data_type = QMI_UNSIGNED_8_BYTE,
564 .elem_len = 1,
565 .elem_size = sizeof(u64),
566 .array_type = NO_ARRAY,
567 .tlv_type = 0,
568 .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, offset),
569 },
570 {
571 .data_type = QMI_UNSIGNED_4_BYTE,
572 .elem_len = 1,
573 .elem_size = sizeof(u32),
574 .array_type = NO_ARRAY,
575 .tlv_type = 0,
576 .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, size),
577 },
578 {
579 .data_type = QMI_UNSIGNED_1_BYTE,
580 .elem_len = 1,
581 .elem_size = sizeof(u8),
582 .array_type = NO_ARRAY,
583 .tlv_type = 0,
584 .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, secure_flag),
585 },
586 {
587 .data_type = QMI_EOTI,
588 .array_type = NO_ARRAY,
589 .tlv_type = QMI_COMMON_TLV_TYPE,
590 },
591 };
592
593 static const struct qmi_elem_info qmi_wlanfw_mem_seg_s_v01_ei[] = {
594 {
595 .data_type = QMI_UNSIGNED_4_BYTE,
596 .elem_len = 1,
597 .elem_size = sizeof(u32),
598 .array_type = NO_ARRAY,
599 .tlv_type = 0,
600 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01,
601 size),
602 },
603 {
604 .data_type = QMI_SIGNED_4_BYTE_ENUM,
605 .elem_len = 1,
606 .elem_size = sizeof(enum qmi_wlanfw_mem_type_enum_v01),
607 .array_type = NO_ARRAY,
608 .tlv_type = 0,
609 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01, type),
610 },
611 {
612 .data_type = QMI_DATA_LEN,
613 .elem_len = 1,
614 .elem_size = sizeof(u8),
615 .array_type = NO_ARRAY,
616 .tlv_type = 0,
617 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg_len),
618 },
619 {
620 .data_type = QMI_STRUCT,
621 .elem_len = QMI_WLANFW_MAX_NUM_MEM_CFG_V01,
622 .elem_size = sizeof(struct qmi_wlanfw_mem_cfg_s_v01),
623 .array_type = VAR_LEN_ARRAY,
624 .tlv_type = 0,
625 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg),
626 .ei_array = qmi_wlanfw_mem_cfg_s_v01_ei,
627 },
628 {
629 .data_type = QMI_EOTI,
630 .array_type = NO_ARRAY,
631 .tlv_type = QMI_COMMON_TLV_TYPE,
632 },
633 };
634
635 static const struct qmi_elem_info qmi_wlanfw_request_mem_ind_msg_v01_ei[] = {
636 {
637 .data_type = QMI_DATA_LEN,
638 .elem_len = 1,
639 .elem_size = sizeof(u8),
640 .array_type = NO_ARRAY,
641 .tlv_type = 0x01,
642 .offset = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
643 mem_seg_len),
644 },
645 {
646 .data_type = QMI_STRUCT,
647 .elem_len = ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
648 .elem_size = sizeof(struct qmi_wlanfw_mem_seg_s_v01),
649 .array_type = VAR_LEN_ARRAY,
650 .tlv_type = 0x01,
651 .offset = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
652 mem_seg),
653 .ei_array = qmi_wlanfw_mem_seg_s_v01_ei,
654 },
655 {
656 .data_type = QMI_EOTI,
657 .array_type = NO_ARRAY,
658 .tlv_type = QMI_COMMON_TLV_TYPE,
659 },
660 };
661
662 static const struct qmi_elem_info qmi_wlanfw_mem_seg_resp_s_v01_ei[] = {
663 {
664 .data_type = QMI_UNSIGNED_8_BYTE,
665 .elem_len = 1,
666 .elem_size = sizeof(u64),
667 .array_type = NO_ARRAY,
668 .tlv_type = 0,
669 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, addr),
670 },
671 {
672 .data_type = QMI_UNSIGNED_4_BYTE,
673 .elem_len = 1,
674 .elem_size = sizeof(u32),
675 .array_type = NO_ARRAY,
676 .tlv_type = 0,
677 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, size),
678 },
679 {
680 .data_type = QMI_SIGNED_4_BYTE_ENUM,
681 .elem_len = 1,
682 .elem_size = sizeof(enum qmi_wlanfw_mem_type_enum_v01),
683 .array_type = NO_ARRAY,
684 .tlv_type = 0,
685 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, type),
686 },
687 {
688 .data_type = QMI_UNSIGNED_1_BYTE,
689 .elem_len = 1,
690 .elem_size = sizeof(u8),
691 .array_type = NO_ARRAY,
692 .tlv_type = 0,
693 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, restore),
694 },
695 {
696 .data_type = QMI_EOTI,
697 .array_type = NO_ARRAY,
698 .tlv_type = QMI_COMMON_TLV_TYPE,
699 },
700 };
701
702 static const struct qmi_elem_info qmi_wlanfw_respond_mem_req_msg_v01_ei[] = {
703 {
704 .data_type = QMI_DATA_LEN,
705 .elem_len = 1,
706 .elem_size = sizeof(u8),
707 .array_type = NO_ARRAY,
708 .tlv_type = 0x01,
709 .offset = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
710 mem_seg_len),
711 },
712 {
713 .data_type = QMI_STRUCT,
714 .elem_len = ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
715 .elem_size = sizeof(struct qmi_wlanfw_mem_seg_resp_s_v01),
716 .array_type = VAR_LEN_ARRAY,
717 .tlv_type = 0x01,
718 .offset = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
719 mem_seg),
720 .ei_array = qmi_wlanfw_mem_seg_resp_s_v01_ei,
721 },
722 {
723 .data_type = QMI_EOTI,
724 .array_type = NO_ARRAY,
725 .tlv_type = QMI_COMMON_TLV_TYPE,
726 },
727 };
728
729 static const struct qmi_elem_info qmi_wlanfw_respond_mem_resp_msg_v01_ei[] = {
730 {
731 .data_type = QMI_STRUCT,
732 .elem_len = 1,
733 .elem_size = sizeof(struct qmi_response_type_v01),
734 .array_type = NO_ARRAY,
735 .tlv_type = 0x02,
736 .offset = offsetof(struct qmi_wlanfw_respond_mem_resp_msg_v01,
737 resp),
738 .ei_array = qmi_response_type_v01_ei,
739 },
740 {
741 .data_type = QMI_EOTI,
742 .array_type = NO_ARRAY,
743 .tlv_type = QMI_COMMON_TLV_TYPE,
744 },
745 };
746
747 static const struct qmi_elem_info qmi_wlanfw_cap_req_msg_v01_ei[] = {
748 {
749 .data_type = QMI_EOTI,
750 .array_type = NO_ARRAY,
751 .tlv_type = QMI_COMMON_TLV_TYPE,
752 },
753 };
754
755 static const struct qmi_elem_info qmi_wlanfw_device_info_req_msg_v01_ei[] = {
756 {
757 .data_type = QMI_EOTI,
758 .array_type = NO_ARRAY,
759 .tlv_type = QMI_COMMON_TLV_TYPE,
760 },
761 };
762
763 static const struct qmi_elem_info qmi_wlfw_device_info_resp_msg_v01_ei[] = {
764 {
765 .data_type = QMI_STRUCT,
766 .elem_len = 1,
767 .elem_size = sizeof(struct qmi_response_type_v01),
768 .array_type = NO_ARRAY,
769 .tlv_type = 0x02,
770 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
771 resp),
772 .ei_array = qmi_response_type_v01_ei,
773 },
774 {
775 .data_type = QMI_OPT_FLAG,
776 .elem_len = 1,
777 .elem_size = sizeof(u8),
778 .array_type = NO_ARRAY,
779 .tlv_type = 0x10,
780 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
781 bar_addr_valid),
782 },
783 {
784 .data_type = QMI_UNSIGNED_8_BYTE,
785 .elem_len = 1,
786 .elem_size = sizeof(u64),
787 .array_type = NO_ARRAY,
788 .tlv_type = 0x10,
789 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
790 bar_addr),
791 },
792 {
793 .data_type = QMI_OPT_FLAG,
794 .elem_len = 1,
795 .elem_size = sizeof(u8),
796 .array_type = NO_ARRAY,
797 .tlv_type = 0x11,
798 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
799 bar_size_valid),
800 },
801 {
802 .data_type = QMI_UNSIGNED_4_BYTE,
803 .elem_len = 1,
804 .elem_size = sizeof(u32),
805 .array_type = NO_ARRAY,
806 .tlv_type = 0x11,
807 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
808 bar_size),
809 },
810 {
811 .data_type = QMI_EOTI,
812 .array_type = NO_ARRAY,
813 .tlv_type = QMI_COMMON_TLV_TYPE,
814 },
815 };
816
817 static const struct qmi_elem_info qmi_wlanfw_rf_chip_info_s_v01_ei[] = {
818 {
819 .data_type = QMI_UNSIGNED_4_BYTE,
820 .elem_len = 1,
821 .elem_size = sizeof(u32),
822 .array_type = NO_ARRAY,
823 .tlv_type = 0,
824 .offset = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
825 chip_id),
826 },
827 {
828 .data_type = QMI_UNSIGNED_4_BYTE,
829 .elem_len = 1,
830 .elem_size = sizeof(u32),
831 .array_type = NO_ARRAY,
832 .tlv_type = 0,
833 .offset = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
834 chip_family),
835 },
836 {
837 .data_type = QMI_EOTI,
838 .array_type = NO_ARRAY,
839 .tlv_type = QMI_COMMON_TLV_TYPE,
840 },
841 };
842
843 static const struct qmi_elem_info qmi_wlanfw_rf_board_info_s_v01_ei[] = {
844 {
845 .data_type = QMI_UNSIGNED_4_BYTE,
846 .elem_len = 1,
847 .elem_size = sizeof(u32),
848 .array_type = NO_ARRAY,
849 .tlv_type = 0,
850 .offset = offsetof(struct qmi_wlanfw_rf_board_info_s_v01,
851 board_id),
852 },
853 {
854 .data_type = QMI_EOTI,
855 .array_type = NO_ARRAY,
856 .tlv_type = QMI_COMMON_TLV_TYPE,
857 },
858 };
859
860 static const struct qmi_elem_info qmi_wlanfw_soc_info_s_v01_ei[] = {
861 {
862 .data_type = QMI_UNSIGNED_4_BYTE,
863 .elem_len = 1,
864 .elem_size = sizeof(u32),
865 .array_type = NO_ARRAY,
866 .tlv_type = 0,
867 .offset = offsetof(struct qmi_wlanfw_soc_info_s_v01, soc_id),
868 },
869 {
870 .data_type = QMI_EOTI,
871 .array_type = NO_ARRAY,
872 .tlv_type = QMI_COMMON_TLV_TYPE,
873 },
874 };
875
876 static const struct qmi_elem_info qmi_wlanfw_fw_version_info_s_v01_ei[] = {
877 {
878 .data_type = QMI_UNSIGNED_4_BYTE,
879 .elem_len = 1,
880 .elem_size = sizeof(u32),
881 .array_type = NO_ARRAY,
882 .tlv_type = 0,
883 .offset = offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
884 fw_version),
885 },
886 {
887 .data_type = QMI_STRING,
888 .elem_len = ATH11K_QMI_WLANFW_MAX_TIMESTAMP_LEN_V01 + 1,
889 .elem_size = sizeof(char),
890 .array_type = NO_ARRAY,
891 .tlv_type = 0,
892 .offset = offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
893 fw_build_timestamp),
894 },
895 {
896 .data_type = QMI_EOTI,
897 .array_type = NO_ARRAY,
898 .tlv_type = QMI_COMMON_TLV_TYPE,
899 },
900 };
901
902 static const struct qmi_elem_info qmi_wlanfw_cap_resp_msg_v01_ei[] = {
903 {
904 .data_type = QMI_STRUCT,
905 .elem_len = 1,
906 .elem_size = sizeof(struct qmi_response_type_v01),
907 .array_type = NO_ARRAY,
908 .tlv_type = 0x02,
909 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01, resp),
910 .ei_array = qmi_response_type_v01_ei,
911 },
912 {
913 .data_type = QMI_OPT_FLAG,
914 .elem_len = 1,
915 .elem_size = sizeof(u8),
916 .array_type = NO_ARRAY,
917 .tlv_type = 0x10,
918 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
919 chip_info_valid),
920 },
921 {
922 .data_type = QMI_STRUCT,
923 .elem_len = 1,
924 .elem_size = sizeof(struct qmi_wlanfw_rf_chip_info_s_v01),
925 .array_type = NO_ARRAY,
926 .tlv_type = 0x10,
927 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
928 chip_info),
929 .ei_array = qmi_wlanfw_rf_chip_info_s_v01_ei,
930 },
931 {
932 .data_type = QMI_OPT_FLAG,
933 .elem_len = 1,
934 .elem_size = sizeof(u8),
935 .array_type = NO_ARRAY,
936 .tlv_type = 0x11,
937 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
938 board_info_valid),
939 },
940 {
941 .data_type = QMI_STRUCT,
942 .elem_len = 1,
943 .elem_size = sizeof(struct qmi_wlanfw_rf_board_info_s_v01),
944 .array_type = NO_ARRAY,
945 .tlv_type = 0x11,
946 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
947 board_info),
948 .ei_array = qmi_wlanfw_rf_board_info_s_v01_ei,
949 },
950 {
951 .data_type = QMI_OPT_FLAG,
952 .elem_len = 1,
953 .elem_size = sizeof(u8),
954 .array_type = NO_ARRAY,
955 .tlv_type = 0x12,
956 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
957 soc_info_valid),
958 },
959 {
960 .data_type = QMI_STRUCT,
961 .elem_len = 1,
962 .elem_size = sizeof(struct qmi_wlanfw_soc_info_s_v01),
963 .array_type = NO_ARRAY,
964 .tlv_type = 0x12,
965 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
966 soc_info),
967 .ei_array = qmi_wlanfw_soc_info_s_v01_ei,
968 },
969 {
970 .data_type = QMI_OPT_FLAG,
971 .elem_len = 1,
972 .elem_size = sizeof(u8),
973 .array_type = NO_ARRAY,
974 .tlv_type = 0x13,
975 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
976 fw_version_info_valid),
977 },
978 {
979 .data_type = QMI_STRUCT,
980 .elem_len = 1,
981 .elem_size = sizeof(struct qmi_wlanfw_fw_version_info_s_v01),
982 .array_type = NO_ARRAY,
983 .tlv_type = 0x13,
984 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
985 fw_version_info),
986 .ei_array = qmi_wlanfw_fw_version_info_s_v01_ei,
987 },
988 {
989 .data_type = QMI_OPT_FLAG,
990 .elem_len = 1,
991 .elem_size = sizeof(u8),
992 .array_type = NO_ARRAY,
993 .tlv_type = 0x14,
994 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
995 fw_build_id_valid),
996 },
997 {
998 .data_type = QMI_STRING,
999 .elem_len = ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 + 1,
1000 .elem_size = sizeof(char),
1001 .array_type = NO_ARRAY,
1002 .tlv_type = 0x14,
1003 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1004 fw_build_id),
1005 },
1006 {
1007 .data_type = QMI_OPT_FLAG,
1008 .elem_len = 1,
1009 .elem_size = sizeof(u8),
1010 .array_type = NO_ARRAY,
1011 .tlv_type = 0x15,
1012 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1013 num_macs_valid),
1014 },
1015 {
1016 .data_type = QMI_UNSIGNED_1_BYTE,
1017 .elem_len = 1,
1018 .elem_size = sizeof(u8),
1019 .array_type = NO_ARRAY,
1020 .tlv_type = 0x15,
1021 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1022 num_macs),
1023 },
1024 {
1025 .data_type = QMI_OPT_FLAG,
1026 .elem_len = 1,
1027 .elem_size = sizeof(u8),
1028 .array_type = NO_ARRAY,
1029 .tlv_type = 0x16,
1030 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1031 voltage_mv_valid),
1032 },
1033 {
1034 .data_type = QMI_UNSIGNED_4_BYTE,
1035 .elem_len = 1,
1036 .elem_size = sizeof(u32),
1037 .array_type = NO_ARRAY,
1038 .tlv_type = 0x16,
1039 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1040 voltage_mv),
1041 },
1042 {
1043 .data_type = QMI_OPT_FLAG,
1044 .elem_len = 1,
1045 .elem_size = sizeof(u8),
1046 .array_type = NO_ARRAY,
1047 .tlv_type = 0x17,
1048 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1049 time_freq_hz_valid),
1050 },
1051 {
1052 .data_type = QMI_UNSIGNED_4_BYTE,
1053 .elem_len = 1,
1054 .elem_size = sizeof(u32),
1055 .array_type = NO_ARRAY,
1056 .tlv_type = 0x17,
1057 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1058 time_freq_hz),
1059 },
1060 {
1061 .data_type = QMI_OPT_FLAG,
1062 .elem_len = 1,
1063 .elem_size = sizeof(u8),
1064 .array_type = NO_ARRAY,
1065 .tlv_type = 0x18,
1066 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1067 otp_version_valid),
1068 },
1069 {
1070 .data_type = QMI_UNSIGNED_4_BYTE,
1071 .elem_len = 1,
1072 .elem_size = sizeof(u32),
1073 .array_type = NO_ARRAY,
1074 .tlv_type = 0x18,
1075 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1076 otp_version),
1077 },
1078 {
1079 .data_type = QMI_OPT_FLAG,
1080 .elem_len = 1,
1081 .elem_size = sizeof(u8),
1082 .array_type = NO_ARRAY,
1083 .tlv_type = 0x19,
1084 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1085 eeprom_read_timeout_valid),
1086 },
1087 {
1088 .data_type = QMI_UNSIGNED_4_BYTE,
1089 .elem_len = 1,
1090 .elem_size = sizeof(u32),
1091 .array_type = NO_ARRAY,
1092 .tlv_type = 0x19,
1093 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1094 eeprom_read_timeout),
1095 },
1096 {
1097 .data_type = QMI_EOTI,
1098 .array_type = NO_ARRAY,
1099 .tlv_type = QMI_COMMON_TLV_TYPE,
1100 },
1101 };
1102
1103 static const struct qmi_elem_info qmi_wlanfw_bdf_download_req_msg_v01_ei[] = {
1104 {
1105 .data_type = QMI_UNSIGNED_1_BYTE,
1106 .elem_len = 1,
1107 .elem_size = sizeof(u8),
1108 .array_type = NO_ARRAY,
1109 .tlv_type = 0x01,
1110 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1111 valid),
1112 },
1113 {
1114 .data_type = QMI_OPT_FLAG,
1115 .elem_len = 1,
1116 .elem_size = sizeof(u8),
1117 .array_type = NO_ARRAY,
1118 .tlv_type = 0x10,
1119 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1120 file_id_valid),
1121 },
1122 {
1123 .data_type = QMI_SIGNED_4_BYTE_ENUM,
1124 .elem_len = 1,
1125 .elem_size = sizeof(enum qmi_wlanfw_cal_temp_id_enum_v01),
1126 .array_type = NO_ARRAY,
1127 .tlv_type = 0x10,
1128 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1129 file_id),
1130 },
1131 {
1132 .data_type = QMI_OPT_FLAG,
1133 .elem_len = 1,
1134 .elem_size = sizeof(u8),
1135 .array_type = NO_ARRAY,
1136 .tlv_type = 0x11,
1137 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1138 total_size_valid),
1139 },
1140 {
1141 .data_type = QMI_UNSIGNED_4_BYTE,
1142 .elem_len = 1,
1143 .elem_size = sizeof(u32),
1144 .array_type = NO_ARRAY,
1145 .tlv_type = 0x11,
1146 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1147 total_size),
1148 },
1149 {
1150 .data_type = QMI_OPT_FLAG,
1151 .elem_len = 1,
1152 .elem_size = sizeof(u8),
1153 .array_type = NO_ARRAY,
1154 .tlv_type = 0x12,
1155 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1156 seg_id_valid),
1157 },
1158 {
1159 .data_type = QMI_UNSIGNED_4_BYTE,
1160 .elem_len = 1,
1161 .elem_size = sizeof(u32),
1162 .array_type = NO_ARRAY,
1163 .tlv_type = 0x12,
1164 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1165 seg_id),
1166 },
1167 {
1168 .data_type = QMI_OPT_FLAG,
1169 .elem_len = 1,
1170 .elem_size = sizeof(u8),
1171 .array_type = NO_ARRAY,
1172 .tlv_type = 0x13,
1173 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1174 data_valid),
1175 },
1176 {
1177 .data_type = QMI_DATA_LEN,
1178 .elem_len = 1,
1179 .elem_size = sizeof(u16),
1180 .array_type = NO_ARRAY,
1181 .tlv_type = 0x13,
1182 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1183 data_len),
1184 },
1185 {
1186 .data_type = QMI_UNSIGNED_1_BYTE,
1187 .elem_len = QMI_WLANFW_MAX_DATA_SIZE_V01,
1188 .elem_size = sizeof(u8),
1189 .array_type = VAR_LEN_ARRAY,
1190 .tlv_type = 0x13,
1191 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1192 data),
1193 },
1194 {
1195 .data_type = QMI_OPT_FLAG,
1196 .elem_len = 1,
1197 .elem_size = sizeof(u8),
1198 .array_type = NO_ARRAY,
1199 .tlv_type = 0x14,
1200 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1201 end_valid),
1202 },
1203 {
1204 .data_type = QMI_UNSIGNED_1_BYTE,
1205 .elem_len = 1,
1206 .elem_size = sizeof(u8),
1207 .array_type = NO_ARRAY,
1208 .tlv_type = 0x14,
1209 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1210 end),
1211 },
1212 {
1213 .data_type = QMI_OPT_FLAG,
1214 .elem_len = 1,
1215 .elem_size = sizeof(u8),
1216 .array_type = NO_ARRAY,
1217 .tlv_type = 0x15,
1218 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1219 bdf_type_valid),
1220 },
1221 {
1222 .data_type = QMI_UNSIGNED_1_BYTE,
1223 .elem_len = 1,
1224 .elem_size = sizeof(u8),
1225 .array_type = NO_ARRAY,
1226 .tlv_type = 0x15,
1227 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1228 bdf_type),
1229 },
1230
1231 {
1232 .data_type = QMI_EOTI,
1233 .array_type = NO_ARRAY,
1234 .tlv_type = QMI_COMMON_TLV_TYPE,
1235 },
1236 };
1237
1238 static const struct qmi_elem_info qmi_wlanfw_bdf_download_resp_msg_v01_ei[] = {
1239 {
1240 .data_type = QMI_STRUCT,
1241 .elem_len = 1,
1242 .elem_size = sizeof(struct qmi_response_type_v01),
1243 .array_type = NO_ARRAY,
1244 .tlv_type = 0x02,
1245 .offset = offsetof(struct qmi_wlanfw_bdf_download_resp_msg_v01,
1246 resp),
1247 .ei_array = qmi_response_type_v01_ei,
1248 },
1249 {
1250 .data_type = QMI_EOTI,
1251 .array_type = NO_ARRAY,
1252 .tlv_type = QMI_COMMON_TLV_TYPE,
1253 },
1254 };
1255
1256 static const struct qmi_elem_info qmi_wlanfw_m3_info_req_msg_v01_ei[] = {
1257 {
1258 .data_type = QMI_UNSIGNED_8_BYTE,
1259 .elem_len = 1,
1260 .elem_size = sizeof(u64),
1261 .array_type = NO_ARRAY,
1262 .tlv_type = 0x01,
1263 .offset = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, addr),
1264 },
1265 {
1266 .data_type = QMI_UNSIGNED_4_BYTE,
1267 .elem_len = 1,
1268 .elem_size = sizeof(u32),
1269 .array_type = NO_ARRAY,
1270 .tlv_type = 0x02,
1271 .offset = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, size),
1272 },
1273 {
1274 .data_type = QMI_EOTI,
1275 .array_type = NO_ARRAY,
1276 .tlv_type = QMI_COMMON_TLV_TYPE,
1277 },
1278 };
1279
1280 static const struct qmi_elem_info qmi_wlanfw_m3_info_resp_msg_v01_ei[] = {
1281 {
1282 .data_type = QMI_STRUCT,
1283 .elem_len = 1,
1284 .elem_size = sizeof(struct qmi_response_type_v01),
1285 .array_type = NO_ARRAY,
1286 .tlv_type = 0x02,
1287 .offset = offsetof(struct qmi_wlanfw_m3_info_resp_msg_v01, resp),
1288 .ei_array = qmi_response_type_v01_ei,
1289 },
1290 {
1291 .data_type = QMI_EOTI,
1292 .array_type = NO_ARRAY,
1293 .tlv_type = QMI_COMMON_TLV_TYPE,
1294 },
1295 };
1296
1297 static const struct qmi_elem_info qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei[] = {
1298 {
1299 .data_type = QMI_UNSIGNED_4_BYTE,
1300 .elem_len = 1,
1301 .elem_size = sizeof(u32),
1302 .array_type = NO_ARRAY,
1303 .tlv_type = 0,
1304 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1305 pipe_num),
1306 },
1307 {
1308 .data_type = QMI_SIGNED_4_BYTE_ENUM,
1309 .elem_len = 1,
1310 .elem_size = sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1311 .array_type = NO_ARRAY,
1312 .tlv_type = 0,
1313 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1314 pipe_dir),
1315 },
1316 {
1317 .data_type = QMI_UNSIGNED_4_BYTE,
1318 .elem_len = 1,
1319 .elem_size = sizeof(u32),
1320 .array_type = NO_ARRAY,
1321 .tlv_type = 0,
1322 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1323 nentries),
1324 },
1325 {
1326 .data_type = QMI_UNSIGNED_4_BYTE,
1327 .elem_len = 1,
1328 .elem_size = sizeof(u32),
1329 .array_type = NO_ARRAY,
1330 .tlv_type = 0,
1331 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1332 nbytes_max),
1333 },
1334 {
1335 .data_type = QMI_UNSIGNED_4_BYTE,
1336 .elem_len = 1,
1337 .elem_size = sizeof(u32),
1338 .array_type = NO_ARRAY,
1339 .tlv_type = 0,
1340 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1341 flags),
1342 },
1343 {
1344 .data_type = QMI_EOTI,
1345 .array_type = NO_ARRAY,
1346 .tlv_type = QMI_COMMON_TLV_TYPE,
1347 },
1348 };
1349
1350 static const struct qmi_elem_info qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei[] = {
1351 {
1352 .data_type = QMI_UNSIGNED_4_BYTE,
1353 .elem_len = 1,
1354 .elem_size = sizeof(u32),
1355 .array_type = NO_ARRAY,
1356 .tlv_type = 0,
1357 .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1358 service_id),
1359 },
1360 {
1361 .data_type = QMI_SIGNED_4_BYTE_ENUM,
1362 .elem_len = 1,
1363 .elem_size = sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1364 .array_type = NO_ARRAY,
1365 .tlv_type = 0,
1366 .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1367 pipe_dir),
1368 },
1369 {
1370 .data_type = QMI_UNSIGNED_4_BYTE,
1371 .elem_len = 1,
1372 .elem_size = sizeof(u32),
1373 .array_type = NO_ARRAY,
1374 .tlv_type = 0,
1375 .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1376 pipe_num),
1377 },
1378 {
1379 .data_type = QMI_EOTI,
1380 .array_type = NO_ARRAY,
1381 .tlv_type = QMI_COMMON_TLV_TYPE,
1382 },
1383 };
1384
1385 static const struct qmi_elem_info qmi_wlanfw_shadow_reg_cfg_s_v01_ei[] = {
1386 {
1387 .data_type = QMI_UNSIGNED_2_BYTE,
1388 .elem_len = 1,
1389 .elem_size = sizeof(u16),
1390 .array_type = NO_ARRAY,
1391 .tlv_type = 0,
1392 .offset = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01, id),
1393 },
1394 {
1395 .data_type = QMI_UNSIGNED_2_BYTE,
1396 .elem_len = 1,
1397 .elem_size = sizeof(u16),
1398 .array_type = NO_ARRAY,
1399 .tlv_type = 0,
1400 .offset = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01,
1401 offset),
1402 },
1403 {
1404 .data_type = QMI_EOTI,
1405 .array_type = QMI_COMMON_TLV_TYPE,
1406 },
1407 };
1408
1409 static const struct qmi_elem_info qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei[] = {
1410 {
1411 .data_type = QMI_UNSIGNED_4_BYTE,
1412 .elem_len = 1,
1413 .elem_size = sizeof(u32),
1414 .array_type = NO_ARRAY,
1415 .tlv_type = 0,
1416 .offset = offsetof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01,
1417 addr),
1418 },
1419 {
1420 .data_type = QMI_EOTI,
1421 .array_type = NO_ARRAY,
1422 .tlv_type = QMI_COMMON_TLV_TYPE,
1423 },
1424 };
1425
1426 static const struct qmi_elem_info qmi_wlanfw_wlan_mode_req_msg_v01_ei[] = {
1427 {
1428 .data_type = QMI_UNSIGNED_4_BYTE,
1429 .elem_len = 1,
1430 .elem_size = sizeof(u32),
1431 .array_type = NO_ARRAY,
1432 .tlv_type = 0x01,
1433 .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1434 mode),
1435 },
1436 {
1437 .data_type = QMI_OPT_FLAG,
1438 .elem_len = 1,
1439 .elem_size = sizeof(u8),
1440 .array_type = NO_ARRAY,
1441 .tlv_type = 0x10,
1442 .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1443 hw_debug_valid),
1444 },
1445 {
1446 .data_type = QMI_UNSIGNED_1_BYTE,
1447 .elem_len = 1,
1448 .elem_size = sizeof(u8),
1449 .array_type = NO_ARRAY,
1450 .tlv_type = 0x10,
1451 .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1452 hw_debug),
1453 },
1454 {
1455 .data_type = QMI_EOTI,
1456 .array_type = NO_ARRAY,
1457 .tlv_type = QMI_COMMON_TLV_TYPE,
1458 },
1459 };
1460
1461 static const struct qmi_elem_info qmi_wlanfw_wlan_mode_resp_msg_v01_ei[] = {
1462 {
1463 .data_type = QMI_STRUCT,
1464 .elem_len = 1,
1465 .elem_size = sizeof(struct qmi_response_type_v01),
1466 .array_type = NO_ARRAY,
1467 .tlv_type = 0x02,
1468 .offset = offsetof(struct qmi_wlanfw_wlan_mode_resp_msg_v01,
1469 resp),
1470 .ei_array = qmi_response_type_v01_ei,
1471 },
1472 {
1473 .data_type = QMI_EOTI,
1474 .array_type = NO_ARRAY,
1475 .tlv_type = QMI_COMMON_TLV_TYPE,
1476 },
1477 };
1478
1479 static const struct qmi_elem_info qmi_wlanfw_wlan_cfg_req_msg_v01_ei[] = {
1480 {
1481 .data_type = QMI_OPT_FLAG,
1482 .elem_len = 1,
1483 .elem_size = sizeof(u8),
1484 .array_type = NO_ARRAY,
1485 .tlv_type = 0x10,
1486 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1487 host_version_valid),
1488 },
1489 {
1490 .data_type = QMI_STRING,
1491 .elem_len = QMI_WLANFW_MAX_STR_LEN_V01 + 1,
1492 .elem_size = sizeof(char),
1493 .array_type = NO_ARRAY,
1494 .tlv_type = 0x10,
1495 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1496 host_version),
1497 },
1498 {
1499 .data_type = QMI_OPT_FLAG,
1500 .elem_len = 1,
1501 .elem_size = sizeof(u8),
1502 .array_type = NO_ARRAY,
1503 .tlv_type = 0x11,
1504 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1505 tgt_cfg_valid),
1506 },
1507 {
1508 .data_type = QMI_DATA_LEN,
1509 .elem_len = 1,
1510 .elem_size = sizeof(u8),
1511 .array_type = NO_ARRAY,
1512 .tlv_type = 0x11,
1513 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1514 tgt_cfg_len),
1515 },
1516 {
1517 .data_type = QMI_STRUCT,
1518 .elem_len = QMI_WLANFW_MAX_NUM_CE_V01,
1519 .elem_size = sizeof(
1520 struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01),
1521 .array_type = VAR_LEN_ARRAY,
1522 .tlv_type = 0x11,
1523 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1524 tgt_cfg),
1525 .ei_array = qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei,
1526 },
1527 {
1528 .data_type = QMI_OPT_FLAG,
1529 .elem_len = 1,
1530 .elem_size = sizeof(u8),
1531 .array_type = NO_ARRAY,
1532 .tlv_type = 0x12,
1533 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1534 svc_cfg_valid),
1535 },
1536 {
1537 .data_type = QMI_DATA_LEN,
1538 .elem_len = 1,
1539 .elem_size = sizeof(u8),
1540 .array_type = NO_ARRAY,
1541 .tlv_type = 0x12,
1542 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1543 svc_cfg_len),
1544 },
1545 {
1546 .data_type = QMI_STRUCT,
1547 .elem_len = QMI_WLANFW_MAX_NUM_SVC_V01,
1548 .elem_size = sizeof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01),
1549 .array_type = VAR_LEN_ARRAY,
1550 .tlv_type = 0x12,
1551 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1552 svc_cfg),
1553 .ei_array = qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei,
1554 },
1555 {
1556 .data_type = QMI_OPT_FLAG,
1557 .elem_len = 1,
1558 .elem_size = sizeof(u8),
1559 .array_type = NO_ARRAY,
1560 .tlv_type = 0x13,
1561 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1562 shadow_reg_valid),
1563 },
1564 {
1565 .data_type = QMI_DATA_LEN,
1566 .elem_len = 1,
1567 .elem_size = sizeof(u8),
1568 .array_type = NO_ARRAY,
1569 .tlv_type = 0x13,
1570 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1571 shadow_reg_len),
1572 },
1573 {
1574 .data_type = QMI_STRUCT,
1575 .elem_len = QMI_WLANFW_MAX_NUM_SHADOW_REG_V01,
1576 .elem_size = sizeof(struct qmi_wlanfw_shadow_reg_cfg_s_v01),
1577 .array_type = VAR_LEN_ARRAY,
1578 .tlv_type = 0x13,
1579 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1580 shadow_reg),
1581 .ei_array = qmi_wlanfw_shadow_reg_cfg_s_v01_ei,
1582 },
1583 {
1584 .data_type = QMI_OPT_FLAG,
1585 .elem_len = 1,
1586 .elem_size = sizeof(u8),
1587 .array_type = NO_ARRAY,
1588 .tlv_type = 0x14,
1589 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1590 shadow_reg_v2_valid),
1591 },
1592 {
1593 .data_type = QMI_DATA_LEN,
1594 .elem_len = 1,
1595 .elem_size = sizeof(u8),
1596 .array_type = NO_ARRAY,
1597 .tlv_type = 0x14,
1598 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1599 shadow_reg_v2_len),
1600 },
1601 {
1602 .data_type = QMI_STRUCT,
1603 .elem_len = QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01,
1604 .elem_size = sizeof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01),
1605 .array_type = VAR_LEN_ARRAY,
1606 .tlv_type = 0x14,
1607 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1608 shadow_reg_v2),
1609 .ei_array = qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei,
1610 },
1611 {
1612 .data_type = QMI_EOTI,
1613 .array_type = NO_ARRAY,
1614 .tlv_type = QMI_COMMON_TLV_TYPE,
1615 },
1616 };
1617
1618 static const struct qmi_elem_info qmi_wlanfw_wlan_cfg_resp_msg_v01_ei[] = {
1619 {
1620 .data_type = QMI_STRUCT,
1621 .elem_len = 1,
1622 .elem_size = sizeof(struct qmi_response_type_v01),
1623 .array_type = NO_ARRAY,
1624 .tlv_type = 0x02,
1625 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_resp_msg_v01, resp),
1626 .ei_array = qmi_response_type_v01_ei,
1627 },
1628 {
1629 .data_type = QMI_EOTI,
1630 .array_type = NO_ARRAY,
1631 .tlv_type = QMI_COMMON_TLV_TYPE,
1632 },
1633 };
1634
1635 static const struct qmi_elem_info qmi_wlanfw_mem_ready_ind_msg_v01_ei[] = {
1636 {
1637 .data_type = QMI_EOTI,
1638 .array_type = NO_ARRAY,
1639 },
1640 };
1641
1642 static const struct qmi_elem_info qmi_wlanfw_fw_ready_ind_msg_v01_ei[] = {
1643 {
1644 .data_type = QMI_EOTI,
1645 .array_type = NO_ARRAY,
1646 },
1647 };
1648
1649 static const struct qmi_elem_info qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei[] = {
1650 {
1651 .data_type = QMI_EOTI,
1652 .array_type = NO_ARRAY,
1653 },
1654 };
1655
1656 static const struct qmi_elem_info qmi_wlanfw_wlan_ini_req_msg_v01_ei[] = {
1657 {
1658 .data_type = QMI_OPT_FLAG,
1659 .elem_len = 1,
1660 .elem_size = sizeof(u8),
1661 .array_type = NO_ARRAY,
1662 .tlv_type = 0x10,
1663 .offset = offsetof(struct qmi_wlanfw_wlan_ini_req_msg_v01,
1664 enablefwlog_valid),
1665 },
1666 {
1667 .data_type = QMI_UNSIGNED_1_BYTE,
1668 .elem_len = 1,
1669 .elem_size = sizeof(u8),
1670 .array_type = NO_ARRAY,
1671 .tlv_type = 0x10,
1672 .offset = offsetof(struct qmi_wlanfw_wlan_ini_req_msg_v01,
1673 enablefwlog),
1674 },
1675 {
1676 .data_type = QMI_EOTI,
1677 .array_type = NO_ARRAY,
1678 .tlv_type = QMI_COMMON_TLV_TYPE,
1679 },
1680 };
1681
1682 static const struct qmi_elem_info qmi_wlanfw_wlan_ini_resp_msg_v01_ei[] = {
1683 {
1684 .data_type = QMI_STRUCT,
1685 .elem_len = 1,
1686 .elem_size = sizeof(struct qmi_response_type_v01),
1687 .array_type = NO_ARRAY,
1688 .tlv_type = 0x02,
1689 .offset = offsetof(struct qmi_wlanfw_wlan_ini_resp_msg_v01,
1690 resp),
1691 .ei_array = qmi_response_type_v01_ei,
1692 },
1693 {
1694 .data_type = QMI_EOTI,
1695 .array_type = NO_ARRAY,
1696 .tlv_type = QMI_COMMON_TLV_TYPE,
1697 },
1698 };
1699
1700 static const struct qmi_elem_info qmi_wlfw_fw_init_done_ind_msg_v01_ei[] = {
1701 {
1702 .data_type = QMI_EOTI,
1703 .array_type = NO_ARRAY,
1704 },
1705 };
1706
ath11k_qmi_host_cap_send(struct ath11k_base * ab)1707 static int ath11k_qmi_host_cap_send(struct ath11k_base *ab)
1708 {
1709 struct qmi_wlanfw_host_cap_req_msg_v01 req;
1710 struct qmi_wlanfw_host_cap_resp_msg_v01 resp;
1711 struct qmi_txn txn;
1712 int ret = 0;
1713
1714 memset(&req, 0, sizeof(req));
1715 memset(&resp, 0, sizeof(resp));
1716
1717 req.num_clients_valid = 1;
1718 req.num_clients = 1;
1719 req.mem_cfg_mode = ab->qmi.target_mem_mode;
1720 req.mem_cfg_mode_valid = 1;
1721 req.bdf_support_valid = 1;
1722 req.bdf_support = 1;
1723
1724 if (ab->hw_params.m3_fw_support) {
1725 req.m3_support_valid = 1;
1726 req.m3_support = 1;
1727 req.m3_cache_support_valid = 1;
1728 req.m3_cache_support = 1;
1729 } else {
1730 req.m3_support_valid = 0;
1731 req.m3_support = 0;
1732 req.m3_cache_support_valid = 0;
1733 req.m3_cache_support = 0;
1734 }
1735
1736 req.cal_done_valid = 1;
1737 req.cal_done = ab->qmi.cal_done;
1738
1739 if (ab->hw_params.internal_sleep_clock) {
1740 req.nm_modem_valid = 1;
1741
1742 /* Notify firmware that this is non-qualcomm platform. */
1743 req.nm_modem |= HOST_CSTATE_BIT;
1744
1745 /* Notify firmware about the sleep clock selection,
1746 * nm_modem_bit[1] is used for this purpose. Host driver on
1747 * non-qualcomm platforms should select internal sleep
1748 * clock.
1749 */
1750 req.nm_modem |= SLEEP_CLOCK_SELECT_INTERNAL_BIT;
1751 }
1752
1753 if (ab->hw_params.global_reset)
1754 req.nm_modem |= PLATFORM_CAP_PCIE_GLOBAL_RESET;
1755
1756 req.nm_modem |= PLATFORM_CAP_PCIE_PME_D3COLD;
1757
1758 ath11k_dbg(ab, ATH11K_DBG_QMI, "host cap request\n");
1759
1760 ret = qmi_txn_init(&ab->qmi.handle, &txn,
1761 qmi_wlanfw_host_cap_resp_msg_v01_ei, &resp);
1762 if (ret < 0)
1763 goto out;
1764
1765 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1766 QMI_WLANFW_HOST_CAP_REQ_V01,
1767 QMI_WLANFW_HOST_CAP_REQ_MSG_V01_MAX_LEN,
1768 qmi_wlanfw_host_cap_req_msg_v01_ei, &req);
1769 if (ret < 0) {
1770 qmi_txn_cancel(&txn);
1771 ath11k_warn(ab, "failed to send host capability request: %d\n", ret);
1772 goto out;
1773 }
1774
1775 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1776 if (ret < 0)
1777 goto out;
1778
1779 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1780 ath11k_warn(ab, "host capability request failed: %d %d\n",
1781 resp.resp.result, resp.resp.error);
1782 ret = -EINVAL;
1783 goto out;
1784 }
1785
1786 out:
1787 return ret;
1788 }
1789
ath11k_qmi_fw_ind_register_send(struct ath11k_base * ab)1790 static int ath11k_qmi_fw_ind_register_send(struct ath11k_base *ab)
1791 {
1792 struct qmi_wlanfw_ind_register_req_msg_v01 *req;
1793 struct qmi_wlanfw_ind_register_resp_msg_v01 *resp;
1794 struct qmi_handle *handle = &ab->qmi.handle;
1795 struct qmi_txn txn;
1796 int ret;
1797
1798 req = kzalloc(sizeof(*req), GFP_KERNEL);
1799 if (!req)
1800 return -ENOMEM;
1801
1802 resp = kzalloc(sizeof(*resp), GFP_KERNEL);
1803 if (!resp) {
1804 ret = -ENOMEM;
1805 goto resp_out;
1806 }
1807
1808 req->client_id_valid = 1;
1809 req->client_id = QMI_WLANFW_CLIENT_ID;
1810 req->fw_ready_enable_valid = 1;
1811 req->fw_ready_enable = 1;
1812 req->cal_done_enable_valid = 1;
1813 req->cal_done_enable = 1;
1814 req->fw_init_done_enable_valid = 1;
1815 req->fw_init_done_enable = 1;
1816
1817 req->pin_connect_result_enable_valid = 0;
1818 req->pin_connect_result_enable = 0;
1819
1820 /* WCN6750 doesn't request for DDR memory via QMI,
1821 * instead it uses a fixed 12MB reserved memory
1822 * region in DDR.
1823 */
1824 if (!ab->hw_params.fixed_fw_mem) {
1825 req->request_mem_enable_valid = 1;
1826 req->request_mem_enable = 1;
1827 req->fw_mem_ready_enable_valid = 1;
1828 req->fw_mem_ready_enable = 1;
1829 }
1830
1831 ret = qmi_txn_init(handle, &txn,
1832 qmi_wlanfw_ind_register_resp_msg_v01_ei, resp);
1833 if (ret < 0)
1834 goto out;
1835
1836 ath11k_dbg(ab, ATH11K_DBG_QMI, "indication register request\n");
1837
1838 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1839 QMI_WLANFW_IND_REGISTER_REQ_V01,
1840 QMI_WLANFW_IND_REGISTER_REQ_MSG_V01_MAX_LEN,
1841 qmi_wlanfw_ind_register_req_msg_v01_ei, req);
1842 if (ret < 0) {
1843 qmi_txn_cancel(&txn);
1844 ath11k_warn(ab, "failed to send indication register request: %d\n",
1845 ret);
1846 goto out;
1847 }
1848
1849 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1850 if (ret < 0) {
1851 ath11k_warn(ab, "failed to register fw indication: %d\n", ret);
1852 goto out;
1853 }
1854
1855 if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
1856 ath11k_warn(ab, "firmware indication register request failed: %d %d\n",
1857 resp->resp.result, resp->resp.error);
1858 ret = -EINVAL;
1859 goto out;
1860 }
1861
1862 out:
1863 kfree(resp);
1864 resp_out:
1865 kfree(req);
1866 return ret;
1867 }
1868
ath11k_qmi_respond_fw_mem_request(struct ath11k_base * ab)1869 static int ath11k_qmi_respond_fw_mem_request(struct ath11k_base *ab)
1870 {
1871 struct qmi_wlanfw_respond_mem_req_msg_v01 *req;
1872 struct qmi_wlanfw_respond_mem_resp_msg_v01 resp;
1873 struct qmi_txn txn;
1874 int ret = 0, i;
1875 bool delayed;
1876
1877 req = kzalloc(sizeof(*req), GFP_KERNEL);
1878 if (!req)
1879 return -ENOMEM;
1880
1881 memset(&resp, 0, sizeof(resp));
1882
1883 /* For QCA6390 by default FW requests a block of ~4M contiguous
1884 * DMA memory, it's hard to allocate from OS. So host returns
1885 * failure to FW and FW will then request multiple blocks of small
1886 * chunk size memory.
1887 */
1888 if (!(ab->hw_params.fixed_mem_region ||
1889 test_bit(ATH11K_FLAG_FIXED_MEM_RGN, &ab->dev_flags)) &&
1890 ab->qmi.target_mem_delayed) {
1891 delayed = true;
1892 ath11k_dbg(ab, ATH11K_DBG_QMI, "delays mem_request %d\n",
1893 ab->qmi.mem_seg_count);
1894 memset(req, 0, sizeof(*req));
1895 } else {
1896 delayed = false;
1897 req->mem_seg_len = ab->qmi.mem_seg_count;
1898
1899 for (i = 0; i < req->mem_seg_len ; i++) {
1900 req->mem_seg[i].addr = ab->qmi.target_mem[i].paddr;
1901 req->mem_seg[i].size = ab->qmi.target_mem[i].size;
1902 req->mem_seg[i].type = ab->qmi.target_mem[i].type;
1903 ath11k_dbg(ab, ATH11K_DBG_QMI,
1904 "req mem_seg[%d] %pad %u %u\n", i,
1905 &ab->qmi.target_mem[i].paddr,
1906 ab->qmi.target_mem[i].size,
1907 ab->qmi.target_mem[i].type);
1908 }
1909 }
1910
1911 ret = qmi_txn_init(&ab->qmi.handle, &txn,
1912 qmi_wlanfw_respond_mem_resp_msg_v01_ei, &resp);
1913 if (ret < 0)
1914 goto out;
1915
1916 ath11k_dbg(ab, ATH11K_DBG_QMI, "respond memory request delayed %i\n",
1917 delayed);
1918
1919 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1920 QMI_WLANFW_RESPOND_MEM_REQ_V01,
1921 QMI_WLANFW_RESPOND_MEM_REQ_MSG_V01_MAX_LEN,
1922 qmi_wlanfw_respond_mem_req_msg_v01_ei, req);
1923 if (ret < 0) {
1924 qmi_txn_cancel(&txn);
1925 ath11k_warn(ab, "failed to respond qmi memory request: %d\n",
1926 ret);
1927 goto out;
1928 }
1929
1930 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1931 if (ret < 0) {
1932 ath11k_warn(ab, "failed to wait qmi memory request: %d\n", ret);
1933 goto out;
1934 }
1935
1936 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1937 /* the error response is expected when
1938 * target_mem_delayed is true.
1939 */
1940 if (delayed && resp.resp.error == 0)
1941 goto out;
1942
1943 ath11k_warn(ab, "qmi respond memory request failed: %d %d\n",
1944 resp.resp.result, resp.resp.error);
1945 ret = -EINVAL;
1946 goto out;
1947 }
1948 out:
1949 kfree(req);
1950 return ret;
1951 }
1952
ath11k_qmi_free_target_mem_chunk(struct ath11k_base * ab)1953 static void ath11k_qmi_free_target_mem_chunk(struct ath11k_base *ab)
1954 {
1955 int i;
1956
1957 for (i = 0; i < ab->qmi.mem_seg_count; i++) {
1958 if ((ab->hw_params.fixed_mem_region ||
1959 test_bit(ATH11K_FLAG_FIXED_MEM_RGN, &ab->dev_flags)) &&
1960 ab->qmi.target_mem[i].iaddr)
1961 iounmap(ab->qmi.target_mem[i].iaddr);
1962
1963 if (!ab->qmi.target_mem[i].vaddr)
1964 continue;
1965
1966 dma_free_coherent(ab->dev,
1967 ab->qmi.target_mem[i].prev_size,
1968 ab->qmi.target_mem[i].vaddr,
1969 ab->qmi.target_mem[i].paddr);
1970 ab->qmi.target_mem[i].vaddr = NULL;
1971 }
1972 }
1973
ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base * ab)1974 static int ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base *ab)
1975 {
1976 int i;
1977 struct target_mem_chunk *chunk;
1978
1979 ab->qmi.target_mem_delayed = false;
1980
1981 for (i = 0; i < ab->qmi.mem_seg_count; i++) {
1982 chunk = &ab->qmi.target_mem[i];
1983
1984 /* Firmware reloads in coldboot/firmware recovery.
1985 * in such case, no need to allocate memory for FW again.
1986 */
1987 if (chunk->vaddr) {
1988 if (chunk->prev_type == chunk->type &&
1989 chunk->prev_size == chunk->size)
1990 continue;
1991
1992 if (ab->qmi.mem_seg_count <= ATH11K_QMI_FW_MEM_REQ_SEGMENT_CNT) {
1993 ath11k_dbg(ab, ATH11K_DBG_QMI,
1994 "size/type mismatch (current %d %u) (prev %d %u), try later with small size\n",
1995 chunk->size, chunk->type,
1996 chunk->prev_size, chunk->prev_type);
1997 ab->qmi.target_mem_delayed = true;
1998 return 0;
1999 }
2000
2001 /* cannot reuse the existing chunk */
2002 dma_free_coherent(ab->dev, chunk->prev_size,
2003 chunk->vaddr, chunk->paddr);
2004 chunk->vaddr = NULL;
2005 }
2006
2007 chunk->vaddr = dma_alloc_coherent(ab->dev,
2008 chunk->size,
2009 &chunk->paddr,
2010 GFP_KERNEL | __GFP_NOWARN);
2011 if (!chunk->vaddr) {
2012 if (ab->qmi.mem_seg_count <= ATH11K_QMI_FW_MEM_REQ_SEGMENT_CNT) {
2013 ath11k_dbg(ab, ATH11K_DBG_QMI,
2014 "dma allocation failed (%d B type %u), will try later with small size\n",
2015 chunk->size,
2016 chunk->type);
2017 ath11k_qmi_free_target_mem_chunk(ab);
2018 ab->qmi.target_mem_delayed = true;
2019 return 0;
2020 }
2021
2022 ath11k_err(ab, "failed to allocate dma memory for qmi (%d B type %u)\n",
2023 chunk->size,
2024 chunk->type);
2025 return -EINVAL;
2026 }
2027 chunk->prev_type = chunk->type;
2028 chunk->prev_size = chunk->size;
2029 }
2030
2031 return 0;
2032 }
2033
ath11k_qmi_assign_target_mem_chunk(struct ath11k_base * ab)2034 static int ath11k_qmi_assign_target_mem_chunk(struct ath11k_base *ab)
2035 {
2036 struct device *dev = ab->dev;
2037 struct device_node *hremote_node = NULL;
2038 struct resource res;
2039 u32 host_ddr_sz;
2040 int i, idx, ret;
2041
2042 for (i = 0, idx = 0; i < ab->qmi.mem_seg_count; i++) {
2043 switch (ab->qmi.target_mem[i].type) {
2044 case HOST_DDR_REGION_TYPE:
2045 hremote_node = of_parse_phandle(dev->of_node, "memory-region", 0);
2046 if (!hremote_node) {
2047 ath11k_dbg(ab, ATH11K_DBG_QMI,
2048 "fail to get hremote_node\n");
2049 return -ENODEV;
2050 }
2051
2052 ret = of_address_to_resource(hremote_node, 0, &res);
2053 of_node_put(hremote_node);
2054 if (ret) {
2055 ath11k_dbg(ab, ATH11K_DBG_QMI,
2056 "fail to get reg from hremote\n");
2057 return ret;
2058 }
2059
2060 if (res.end - res.start + 1 < ab->qmi.target_mem[i].size) {
2061 ath11k_dbg(ab, ATH11K_DBG_QMI,
2062 "fail to assign memory of sz\n");
2063 return -EINVAL;
2064 }
2065
2066 ab->qmi.target_mem[idx].paddr = res.start;
2067 ab->qmi.target_mem[idx].iaddr =
2068 ioremap(ab->qmi.target_mem[idx].paddr,
2069 ab->qmi.target_mem[i].size);
2070 if (!ab->qmi.target_mem[idx].iaddr)
2071 return -EIO;
2072
2073 ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
2074 host_ddr_sz = ab->qmi.target_mem[i].size;
2075 ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
2076 idx++;
2077 break;
2078 case BDF_MEM_REGION_TYPE:
2079 ab->qmi.target_mem[idx].paddr = ab->hw_params.bdf_addr;
2080 ab->qmi.target_mem[idx].vaddr = NULL;
2081 ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
2082 ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
2083 idx++;
2084 break;
2085 case CALDB_MEM_REGION_TYPE:
2086 if (ab->qmi.target_mem[i].size > ATH11K_QMI_CALDB_SIZE) {
2087 ath11k_warn(ab, "qmi mem size is low to load caldata\n");
2088 return -EINVAL;
2089 }
2090
2091 if (ath11k_core_coldboot_cal_support(ab)) {
2092 if (hremote_node) {
2093 ab->qmi.target_mem[idx].paddr =
2094 res.start + host_ddr_sz;
2095 ab->qmi.target_mem[idx].iaddr =
2096 ioremap(ab->qmi.target_mem[idx].paddr,
2097 ab->qmi.target_mem[i].size);
2098 if (!ab->qmi.target_mem[idx].iaddr)
2099 return -EIO;
2100 } else {
2101 ab->qmi.target_mem[idx].paddr =
2102 ATH11K_QMI_CALDB_ADDRESS;
2103 }
2104 } else {
2105 ab->qmi.target_mem[idx].paddr = 0;
2106 ab->qmi.target_mem[idx].vaddr = NULL;
2107 }
2108 ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
2109 ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
2110 idx++;
2111 break;
2112 default:
2113 ath11k_warn(ab, "qmi ignore invalid mem req type %d\n",
2114 ab->qmi.target_mem[i].type);
2115 break;
2116 }
2117 }
2118 ab->qmi.mem_seg_count = idx;
2119
2120 return 0;
2121 }
2122
ath11k_qmi_request_device_info(struct ath11k_base * ab)2123 static int ath11k_qmi_request_device_info(struct ath11k_base *ab)
2124 {
2125 struct qmi_wlanfw_device_info_req_msg_v01 req = {};
2126 struct qmi_wlanfw_device_info_resp_msg_v01 resp = {};
2127 struct qmi_txn txn;
2128 void __iomem *bar_addr_va;
2129 int ret;
2130
2131 /* device info message req is only sent for hybrid bus devices */
2132 if (!ab->hw_params.hybrid_bus_type)
2133 return 0;
2134
2135 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2136 qmi_wlfw_device_info_resp_msg_v01_ei, &resp);
2137 if (ret < 0)
2138 goto out;
2139
2140 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2141 QMI_WLANFW_DEVICE_INFO_REQ_V01,
2142 QMI_WLANFW_DEVICE_INFO_REQ_MSG_V01_MAX_LEN,
2143 qmi_wlanfw_device_info_req_msg_v01_ei, &req);
2144 if (ret < 0) {
2145 qmi_txn_cancel(&txn);
2146 ath11k_warn(ab, "failed to send qmi target device info request: %d\n",
2147 ret);
2148 goto out;
2149 }
2150
2151 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2152 if (ret < 0) {
2153 ath11k_warn(ab, "failed to wait qmi target device info request: %d\n",
2154 ret);
2155 goto out;
2156 }
2157
2158 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2159 ath11k_warn(ab, "qmi device info request failed: %d %d\n",
2160 resp.resp.result, resp.resp.error);
2161 ret = -EINVAL;
2162 goto out;
2163 }
2164
2165 if (!resp.bar_addr_valid || !resp.bar_size_valid) {
2166 ath11k_warn(ab, "qmi device info response invalid: %d %d\n",
2167 resp.resp.result, resp.resp.error);
2168 ret = -EINVAL;
2169 goto out;
2170 }
2171
2172 if (!resp.bar_addr ||
2173 resp.bar_size != ATH11K_QMI_DEVICE_BAR_SIZE) {
2174 ath11k_warn(ab, "qmi device info invalid address and size: %llu %u\n",
2175 resp.bar_addr, resp.bar_size);
2176 ret = -EINVAL;
2177 goto out;
2178 }
2179
2180 bar_addr_va = devm_ioremap(ab->dev, resp.bar_addr, resp.bar_size);
2181
2182 if (!bar_addr_va) {
2183 ath11k_warn(ab, "qmi device info ioremap failed\n");
2184 ab->mem_len = 0;
2185 ret = -EIO;
2186 goto out;
2187 }
2188
2189 ab->mem = bar_addr_va;
2190 ab->mem_len = resp.bar_size;
2191
2192 if (!ab->hw_params.ce_remap)
2193 ab->mem_ce = ab->mem;
2194
2195 return 0;
2196 out:
2197 return ret;
2198 }
2199
ath11k_qmi_request_target_cap(struct ath11k_base * ab)2200 static int ath11k_qmi_request_target_cap(struct ath11k_base *ab)
2201 {
2202 struct qmi_wlanfw_cap_req_msg_v01 req;
2203 struct qmi_wlanfw_cap_resp_msg_v01 resp;
2204 struct qmi_txn txn;
2205 int ret = 0;
2206 int r;
2207 char *fw_build_id;
2208 int fw_build_id_mask_len;
2209
2210 memset(&req, 0, sizeof(req));
2211 memset(&resp, 0, sizeof(resp));
2212
2213 ret = qmi_txn_init(&ab->qmi.handle, &txn, qmi_wlanfw_cap_resp_msg_v01_ei,
2214 &resp);
2215 if (ret < 0)
2216 goto out;
2217
2218 ath11k_dbg(ab, ATH11K_DBG_QMI, "target cap request\n");
2219
2220 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2221 QMI_WLANFW_CAP_REQ_V01,
2222 QMI_WLANFW_CAP_REQ_MSG_V01_MAX_LEN,
2223 qmi_wlanfw_cap_req_msg_v01_ei, &req);
2224 if (ret < 0) {
2225 qmi_txn_cancel(&txn);
2226 ath11k_warn(ab, "failed to send qmi cap request: %d\n",
2227 ret);
2228 goto out;
2229 }
2230
2231 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2232 if (ret < 0) {
2233 ath11k_warn(ab, "failed to wait qmi cap request: %d\n", ret);
2234 goto out;
2235 }
2236
2237 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2238 ath11k_warn(ab, "qmi cap request failed: %d %d\n",
2239 resp.resp.result, resp.resp.error);
2240 ret = -EINVAL;
2241 goto out;
2242 }
2243
2244 if (resp.chip_info_valid) {
2245 ab->qmi.target.chip_id = resp.chip_info.chip_id;
2246 ab->qmi.target.chip_family = resp.chip_info.chip_family;
2247 }
2248
2249 if (resp.board_info_valid)
2250 ab->qmi.target.board_id = resp.board_info.board_id;
2251 else
2252 ab->qmi.target.board_id = 0xFF;
2253
2254 if (resp.soc_info_valid)
2255 ab->qmi.target.soc_id = resp.soc_info.soc_id;
2256
2257 if (resp.fw_version_info_valid) {
2258 ab->qmi.target.fw_version = resp.fw_version_info.fw_version;
2259 strscpy(ab->qmi.target.fw_build_timestamp,
2260 resp.fw_version_info.fw_build_timestamp,
2261 sizeof(ab->qmi.target.fw_build_timestamp));
2262 }
2263
2264 if (resp.fw_build_id_valid)
2265 strscpy(ab->qmi.target.fw_build_id, resp.fw_build_id,
2266 sizeof(ab->qmi.target.fw_build_id));
2267
2268 if (resp.eeprom_read_timeout_valid) {
2269 ab->qmi.target.eeprom_caldata =
2270 resp.eeprom_read_timeout;
2271 ath11k_dbg(ab, ATH11K_DBG_QMI, "cal data supported from eeprom\n");
2272 }
2273
2274 fw_build_id = ab->qmi.target.fw_build_id;
2275 fw_build_id_mask_len = strlen(FW_BUILD_ID_MASK);
2276 if (!strncmp(fw_build_id, FW_BUILD_ID_MASK, fw_build_id_mask_len))
2277 fw_build_id = fw_build_id + fw_build_id_mask_len;
2278
2279 ath11k_info(ab, "chip_id 0x%x chip_family 0x%x board_id 0x%x soc_id 0x%x\n",
2280 ab->qmi.target.chip_id, ab->qmi.target.chip_family,
2281 ab->qmi.target.board_id, ab->qmi.target.soc_id);
2282
2283 ath11k_info(ab, "fw_version 0x%x fw_build_timestamp %s fw_build_id %s",
2284 ab->qmi.target.fw_version,
2285 ab->qmi.target.fw_build_timestamp,
2286 fw_build_id);
2287
2288 r = ath11k_core_check_smbios(ab);
2289 if (r)
2290 ath11k_dbg(ab, ATH11K_DBG_QMI, "SMBIOS bdf variant name not set.\n");
2291
2292 r = ath11k_core_check_dt(ab);
2293 if (r)
2294 ath11k_dbg(ab, ATH11K_DBG_QMI, "DT bdf variant name not set.\n");
2295
2296 out:
2297 return ret;
2298 }
2299
ath11k_qmi_load_file_target_mem(struct ath11k_base * ab,const u8 * data,u32 len,u8 type)2300 static int ath11k_qmi_load_file_target_mem(struct ath11k_base *ab,
2301 const u8 *data, u32 len, u8 type)
2302 {
2303 struct qmi_wlanfw_bdf_download_req_msg_v01 *req;
2304 struct qmi_wlanfw_bdf_download_resp_msg_v01 resp;
2305 struct qmi_txn txn;
2306 const u8 *temp = data;
2307 void __iomem *bdf_addr = NULL;
2308 int ret = 0;
2309 u32 remaining = len;
2310
2311 req = kzalloc(sizeof(*req), GFP_KERNEL);
2312 if (!req)
2313 return -ENOMEM;
2314
2315 memset(&resp, 0, sizeof(resp));
2316
2317 if (ab->hw_params.fixed_bdf_addr) {
2318 bdf_addr = ioremap(ab->hw_params.bdf_addr, ab->hw_params.fw.board_size);
2319 if (!bdf_addr) {
2320 ath11k_warn(ab, "qmi ioremap error for bdf_addr\n");
2321 ret = -EIO;
2322 goto err_free_req;
2323 }
2324 }
2325
2326 while (remaining) {
2327 req->valid = 1;
2328 req->file_id_valid = 1;
2329 req->file_id = ab->qmi.target.board_id;
2330 req->total_size_valid = 1;
2331 req->total_size = remaining;
2332 req->seg_id_valid = 1;
2333 req->data_valid = 1;
2334 req->bdf_type = type;
2335 req->bdf_type_valid = 1;
2336 req->end_valid = 1;
2337 req->end = 0;
2338
2339 if (remaining > QMI_WLANFW_MAX_DATA_SIZE_V01) {
2340 req->data_len = QMI_WLANFW_MAX_DATA_SIZE_V01;
2341 } else {
2342 req->data_len = remaining;
2343 req->end = 1;
2344 }
2345
2346 if (ab->hw_params.fixed_bdf_addr ||
2347 type == ATH11K_QMI_FILE_TYPE_EEPROM) {
2348 req->data_valid = 0;
2349 req->end = 1;
2350 req->data_len = ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE;
2351 } else {
2352 memcpy(req->data, temp, req->data_len);
2353 }
2354
2355 if (ab->hw_params.fixed_bdf_addr) {
2356 if (type == ATH11K_QMI_FILE_TYPE_CALDATA)
2357 bdf_addr += ab->hw_params.fw.cal_offset;
2358
2359 memcpy_toio(bdf_addr, temp, len);
2360 }
2361
2362 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2363 qmi_wlanfw_bdf_download_resp_msg_v01_ei,
2364 &resp);
2365 if (ret < 0)
2366 goto err_iounmap;
2367
2368 ath11k_dbg(ab, ATH11K_DBG_QMI, "bdf download req fixed addr type %d\n",
2369 type);
2370
2371 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2372 QMI_WLANFW_BDF_DOWNLOAD_REQ_V01,
2373 QMI_WLANFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_LEN,
2374 qmi_wlanfw_bdf_download_req_msg_v01_ei, req);
2375 if (ret < 0) {
2376 qmi_txn_cancel(&txn);
2377 goto err_iounmap;
2378 }
2379
2380 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2381 if (ret < 0) {
2382 ath11k_warn(ab, "failed to wait board file download request: %d\n",
2383 ret);
2384 goto err_iounmap;
2385 }
2386
2387 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2388 ath11k_warn(ab, "board file download request failed: %d %d\n",
2389 resp.resp.result, resp.resp.error);
2390 ret = -EINVAL;
2391 goto err_iounmap;
2392 }
2393
2394 if (ab->hw_params.fixed_bdf_addr ||
2395 type == ATH11K_QMI_FILE_TYPE_EEPROM) {
2396 remaining = 0;
2397 } else {
2398 remaining -= req->data_len;
2399 temp += req->data_len;
2400 req->seg_id++;
2401 ath11k_dbg(ab, ATH11K_DBG_QMI, "bdf download request remaining %i\n",
2402 remaining);
2403 }
2404 }
2405
2406 err_iounmap:
2407 if (ab->hw_params.fixed_bdf_addr)
2408 iounmap(bdf_addr);
2409
2410 err_free_req:
2411 kfree(req);
2412
2413 return ret;
2414 }
2415
ath11k_qmi_load_bdf_qmi(struct ath11k_base * ab,bool regdb)2416 static int ath11k_qmi_load_bdf_qmi(struct ath11k_base *ab,
2417 bool regdb)
2418 {
2419 struct device *dev = ab->dev;
2420 char filename[ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE];
2421 const struct firmware *fw_entry;
2422 struct ath11k_board_data bd;
2423 u32 fw_size, file_type;
2424 int ret = 0, bdf_type;
2425 const u8 *tmp;
2426
2427 memset(&bd, 0, sizeof(bd));
2428
2429 if (regdb) {
2430 ret = ath11k_core_fetch_regdb(ab, &bd);
2431 } else {
2432 ret = ath11k_core_fetch_bdf(ab, &bd);
2433 if (ret)
2434 ath11k_warn(ab, "qmi failed to fetch board file: %d\n", ret);
2435 }
2436
2437 if (ret)
2438 goto out;
2439
2440 if (regdb)
2441 bdf_type = ATH11K_QMI_BDF_TYPE_REGDB;
2442 else if (bd.len >= SELFMAG && memcmp(bd.data, ELFMAG, SELFMAG) == 0)
2443 bdf_type = ATH11K_QMI_BDF_TYPE_ELF;
2444 else
2445 bdf_type = ATH11K_QMI_BDF_TYPE_BIN;
2446
2447 ath11k_dbg(ab, ATH11K_DBG_QMI, "bdf_type %d\n", bdf_type);
2448
2449 fw_size = min_t(u32, ab->hw_params.fw.board_size, bd.len);
2450
2451 ret = ath11k_qmi_load_file_target_mem(ab, bd.data, fw_size, bdf_type);
2452 if (ret < 0) {
2453 ath11k_warn(ab, "qmi failed to load bdf file\n");
2454 goto out;
2455 }
2456
2457 /* QCA6390/WCN6855 does not support cal data, skip it */
2458 if (bdf_type == ATH11K_QMI_BDF_TYPE_ELF || bdf_type == ATH11K_QMI_BDF_TYPE_REGDB)
2459 goto out;
2460
2461 if (ab->qmi.target.eeprom_caldata) {
2462 file_type = ATH11K_QMI_FILE_TYPE_EEPROM;
2463 tmp = filename;
2464 fw_size = ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE;
2465 } else {
2466 file_type = ATH11K_QMI_FILE_TYPE_CALDATA;
2467
2468 /* cal-<bus>-<id>.bin */
2469 snprintf(filename, sizeof(filename), "cal-%s-%s.bin",
2470 ath11k_bus_str(ab->hif.bus), dev_name(dev));
2471 fw_entry = ath11k_core_firmware_request(ab, filename);
2472 if (!IS_ERR(fw_entry))
2473 goto success;
2474
2475 fw_entry = ath11k_core_firmware_request(ab, ATH11K_DEFAULT_CAL_FILE);
2476 if (IS_ERR(fw_entry)) {
2477 /* Caldata may not be present during first time calibration in
2478 * factory hence allow to boot without loading caldata in ftm mode
2479 */
2480 if (ath11k_ftm_mode) {
2481 ath11k_info(ab,
2482 "Booting without cal data file in factory test mode\n");
2483 return 0;
2484 }
2485 ret = PTR_ERR(fw_entry);
2486 ath11k_warn(ab,
2487 "qmi failed to load CAL data file:%s\n",
2488 filename);
2489 goto out;
2490 }
2491 success:
2492 fw_size = min_t(u32, ab->hw_params.fw.board_size, fw_entry->size);
2493 tmp = fw_entry->data;
2494 }
2495
2496 ret = ath11k_qmi_load_file_target_mem(ab, tmp, fw_size, file_type);
2497 if (ret < 0) {
2498 ath11k_warn(ab, "qmi failed to load caldata\n");
2499 goto out_qmi_cal;
2500 }
2501
2502 ath11k_dbg(ab, ATH11K_DBG_QMI, "caldata type: %u\n", file_type);
2503
2504 out_qmi_cal:
2505 if (!ab->qmi.target.eeprom_caldata)
2506 release_firmware(fw_entry);
2507 out:
2508 ath11k_core_free_bdf(ab, &bd);
2509 ath11k_dbg(ab, ATH11K_DBG_QMI, "BDF download sequence completed\n");
2510
2511 return ret;
2512 }
2513
ath11k_qmi_m3_load(struct ath11k_base * ab)2514 static int ath11k_qmi_m3_load(struct ath11k_base *ab)
2515 {
2516 struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2517 const struct firmware *fw = NULL;
2518 const void *m3_data;
2519 char path[100];
2520 size_t m3_len;
2521 int ret;
2522
2523 if (m3_mem->vaddr)
2524 /* m3 firmware buffer is already available in the DMA buffer */
2525 return 0;
2526
2527 if (ab->fw.m3_data && ab->fw.m3_len > 0) {
2528 /* firmware-N.bin had a m3 firmware file so use that */
2529 m3_data = ab->fw.m3_data;
2530 m3_len = ab->fw.m3_len;
2531 } else {
2532 /* No m3 file in firmware-N.bin so try to request old
2533 * separate m3.bin.
2534 */
2535 fw = ath11k_core_firmware_request(ab, ATH11K_M3_FILE);
2536 if (IS_ERR(fw)) {
2537 ret = PTR_ERR(fw);
2538 ath11k_core_create_firmware_path(ab, ATH11K_M3_FILE,
2539 path, sizeof(path));
2540 ath11k_err(ab, "failed to load %s: %d\n", path, ret);
2541 return ret;
2542 }
2543
2544 m3_data = fw->data;
2545 m3_len = fw->size;
2546 }
2547
2548 m3_mem->vaddr = dma_alloc_coherent(ab->dev,
2549 m3_len, &m3_mem->paddr,
2550 GFP_KERNEL);
2551 if (!m3_mem->vaddr) {
2552 ath11k_err(ab, "failed to allocate memory for M3 with size %zu\n",
2553 m3_len);
2554 ret = -ENOMEM;
2555 goto out;
2556 }
2557
2558 memcpy(m3_mem->vaddr, m3_data, m3_len);
2559 m3_mem->size = m3_len;
2560
2561 ret = 0;
2562
2563 out:
2564 release_firmware(fw);
2565
2566 return ret;
2567 }
2568
ath11k_qmi_m3_free(struct ath11k_base * ab)2569 static void ath11k_qmi_m3_free(struct ath11k_base *ab)
2570 {
2571 struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2572
2573 if (!ab->hw_params.m3_fw_support || !m3_mem->vaddr)
2574 return;
2575
2576 dma_free_coherent(ab->dev, m3_mem->size,
2577 m3_mem->vaddr, m3_mem->paddr);
2578 m3_mem->vaddr = NULL;
2579 m3_mem->size = 0;
2580 }
2581
ath11k_qmi_wlanfw_m3_info_send(struct ath11k_base * ab)2582 static int ath11k_qmi_wlanfw_m3_info_send(struct ath11k_base *ab)
2583 {
2584 struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2585 struct qmi_wlanfw_m3_info_req_msg_v01 req;
2586 struct qmi_wlanfw_m3_info_resp_msg_v01 resp;
2587 struct qmi_txn txn;
2588 int ret = 0;
2589
2590 memset(&req, 0, sizeof(req));
2591 memset(&resp, 0, sizeof(resp));
2592
2593 if (ab->hw_params.m3_fw_support) {
2594 ret = ath11k_qmi_m3_load(ab);
2595 if (ret) {
2596 ath11k_err(ab, "failed to load m3 firmware: %d", ret);
2597 return ret;
2598 }
2599
2600 req.addr = m3_mem->paddr;
2601 req.size = m3_mem->size;
2602 } else {
2603 req.addr = 0;
2604 req.size = 0;
2605 }
2606
2607 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2608 qmi_wlanfw_m3_info_resp_msg_v01_ei, &resp);
2609 if (ret < 0)
2610 goto out;
2611
2612 ath11k_dbg(ab, ATH11K_DBG_QMI, "m3 info req\n");
2613
2614 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2615 QMI_WLANFW_M3_INFO_REQ_V01,
2616 QMI_WLANFW_M3_INFO_REQ_MSG_V01_MAX_MSG_LEN,
2617 qmi_wlanfw_m3_info_req_msg_v01_ei, &req);
2618 if (ret < 0) {
2619 qmi_txn_cancel(&txn);
2620 ath11k_warn(ab, "failed to send m3 information request: %d\n",
2621 ret);
2622 goto out;
2623 }
2624
2625 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2626 if (ret < 0) {
2627 ath11k_warn(ab, "failed to wait m3 information request: %d\n", ret);
2628 goto out;
2629 }
2630
2631 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2632 ath11k_warn(ab, "m3 info request failed: %d %d\n",
2633 resp.resp.result, resp.resp.error);
2634 ret = -EINVAL;
2635 goto out;
2636 }
2637 out:
2638 return ret;
2639 }
2640
ath11k_qmi_wlanfw_mode_send(struct ath11k_base * ab,u32 mode)2641 static int ath11k_qmi_wlanfw_mode_send(struct ath11k_base *ab,
2642 u32 mode)
2643 {
2644 struct qmi_wlanfw_wlan_mode_req_msg_v01 req;
2645 struct qmi_wlanfw_wlan_mode_resp_msg_v01 resp;
2646 struct qmi_txn txn;
2647 int ret = 0;
2648
2649 memset(&req, 0, sizeof(req));
2650 memset(&resp, 0, sizeof(resp));
2651
2652 req.mode = mode;
2653 req.hw_debug_valid = 1;
2654 req.hw_debug = 0;
2655
2656 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2657 qmi_wlanfw_wlan_mode_resp_msg_v01_ei, &resp);
2658 if (ret < 0)
2659 goto out;
2660
2661 ath11k_dbg(ab, ATH11K_DBG_QMI, "wlan mode req mode %d\n", mode);
2662
2663 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2664 QMI_WLANFW_WLAN_MODE_REQ_V01,
2665 QMI_WLANFW_WLAN_MODE_REQ_MSG_V01_MAX_LEN,
2666 qmi_wlanfw_wlan_mode_req_msg_v01_ei, &req);
2667 if (ret < 0) {
2668 qmi_txn_cancel(&txn);
2669 ath11k_warn(ab, "failed to send wlan mode request (mode %d): %d\n",
2670 mode, ret);
2671 goto out;
2672 }
2673
2674 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2675 if (ret < 0) {
2676 if (mode == ATH11K_FIRMWARE_MODE_OFF && ret == -ENETRESET) {
2677 ath11k_warn(ab, "WLFW service is dis-connected\n");
2678 return 0;
2679 }
2680 ath11k_warn(ab, "failed to wait wlan mode request (mode %d): %d\n",
2681 mode, ret);
2682 goto out;
2683 }
2684
2685 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2686 ath11k_warn(ab, "wlan mode request failed (mode: %d): %d %d\n",
2687 mode, resp.resp.result, resp.resp.error);
2688 ret = -EINVAL;
2689 goto out;
2690 }
2691
2692 out:
2693 return ret;
2694 }
2695
ath11k_qmi_wlanfw_wlan_cfg_send(struct ath11k_base * ab)2696 static int ath11k_qmi_wlanfw_wlan_cfg_send(struct ath11k_base *ab)
2697 {
2698 struct qmi_wlanfw_wlan_cfg_req_msg_v01 *req;
2699 struct qmi_wlanfw_wlan_cfg_resp_msg_v01 resp;
2700 struct ce_pipe_config *ce_cfg;
2701 struct service_to_pipe *svc_cfg;
2702 struct qmi_txn txn;
2703 int ret = 0, pipe_num;
2704
2705 ce_cfg = (struct ce_pipe_config *)ab->qmi.ce_cfg.tgt_ce;
2706 svc_cfg = (struct service_to_pipe *)ab->qmi.ce_cfg.svc_to_ce_map;
2707
2708 req = kzalloc(sizeof(*req), GFP_KERNEL);
2709 if (!req)
2710 return -ENOMEM;
2711
2712 memset(&resp, 0, sizeof(resp));
2713
2714 req->host_version_valid = 1;
2715 strscpy(req->host_version, ATH11K_HOST_VERSION_STRING,
2716 sizeof(req->host_version));
2717
2718 req->tgt_cfg_valid = 1;
2719 /* This is number of CE configs */
2720 req->tgt_cfg_len = ab->qmi.ce_cfg.tgt_ce_len;
2721 for (pipe_num = 0; pipe_num < req->tgt_cfg_len ; pipe_num++) {
2722 req->tgt_cfg[pipe_num].pipe_num = ce_cfg[pipe_num].pipenum;
2723 req->tgt_cfg[pipe_num].pipe_dir = ce_cfg[pipe_num].pipedir;
2724 req->tgt_cfg[pipe_num].nentries = ce_cfg[pipe_num].nentries;
2725 req->tgt_cfg[pipe_num].nbytes_max = ce_cfg[pipe_num].nbytes_max;
2726 req->tgt_cfg[pipe_num].flags = ce_cfg[pipe_num].flags;
2727 }
2728
2729 req->svc_cfg_valid = 1;
2730 /* This is number of Service/CE configs */
2731 req->svc_cfg_len = ab->qmi.ce_cfg.svc_to_ce_map_len;
2732 for (pipe_num = 0; pipe_num < req->svc_cfg_len; pipe_num++) {
2733 req->svc_cfg[pipe_num].service_id = svc_cfg[pipe_num].service_id;
2734 req->svc_cfg[pipe_num].pipe_dir = svc_cfg[pipe_num].pipedir;
2735 req->svc_cfg[pipe_num].pipe_num = svc_cfg[pipe_num].pipenum;
2736 }
2737 req->shadow_reg_valid = 0;
2738
2739 /* set shadow v2 configuration */
2740 if (ab->hw_params.supports_shadow_regs) {
2741 req->shadow_reg_v2_valid = 1;
2742 req->shadow_reg_v2_len = min_t(u32,
2743 ab->qmi.ce_cfg.shadow_reg_v2_len,
2744 QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01);
2745 memcpy(&req->shadow_reg_v2, ab->qmi.ce_cfg.shadow_reg_v2,
2746 sizeof(u32) * req->shadow_reg_v2_len);
2747 } else {
2748 req->shadow_reg_v2_valid = 0;
2749 }
2750
2751 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2752 qmi_wlanfw_wlan_cfg_resp_msg_v01_ei, &resp);
2753 if (ret < 0)
2754 goto out;
2755
2756 ath11k_dbg(ab, ATH11K_DBG_QMI, "wlan cfg req\n");
2757
2758 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2759 QMI_WLANFW_WLAN_CFG_REQ_V01,
2760 QMI_WLANFW_WLAN_CFG_REQ_MSG_V01_MAX_LEN,
2761 qmi_wlanfw_wlan_cfg_req_msg_v01_ei, req);
2762 if (ret < 0) {
2763 qmi_txn_cancel(&txn);
2764 ath11k_warn(ab, "failed to send wlan config request: %d\n",
2765 ret);
2766 goto out;
2767 }
2768
2769 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2770 if (ret < 0) {
2771 ath11k_warn(ab, "failed to wait wlan config request: %d\n", ret);
2772 goto out;
2773 }
2774
2775 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2776 ath11k_warn(ab, "wlan config request failed: %d %d\n",
2777 resp.resp.result, resp.resp.error);
2778 ret = -EINVAL;
2779 goto out;
2780 }
2781
2782 out:
2783 kfree(req);
2784 return ret;
2785 }
2786
ath11k_qmi_wlanfw_wlan_ini_send(struct ath11k_base * ab,bool enable)2787 static int ath11k_qmi_wlanfw_wlan_ini_send(struct ath11k_base *ab, bool enable)
2788 {
2789 int ret;
2790 struct qmi_txn txn;
2791 struct qmi_wlanfw_wlan_ini_req_msg_v01 req = {};
2792 struct qmi_wlanfw_wlan_ini_resp_msg_v01 resp = {};
2793
2794 req.enablefwlog_valid = true;
2795 req.enablefwlog = enable ? 1 : 0;
2796
2797 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2798 qmi_wlanfw_wlan_ini_resp_msg_v01_ei, &resp);
2799 if (ret < 0)
2800 goto out;
2801
2802 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2803 QMI_WLANFW_WLAN_INI_REQ_V01,
2804 QMI_WLANFW_WLAN_INI_REQ_MSG_V01_MAX_LEN,
2805 qmi_wlanfw_wlan_ini_req_msg_v01_ei, &req);
2806 if (ret < 0) {
2807 ath11k_warn(ab, "qmi failed to send wlan ini request, err = %d\n",
2808 ret);
2809 qmi_txn_cancel(&txn);
2810 goto out;
2811 }
2812
2813 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2814 if (ret < 0) {
2815 ath11k_warn(ab, "qmi failed wlan ini request, err = %d\n", ret);
2816 goto out;
2817 }
2818
2819 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2820 ath11k_warn(ab, "qmi wlan ini request failed, result: %d, err: %d\n",
2821 resp.resp.result, resp.resp.error);
2822 ret = -EINVAL;
2823 }
2824
2825 out:
2826 return ret;
2827 }
2828
ath11k_qmi_firmware_stop(struct ath11k_base * ab)2829 void ath11k_qmi_firmware_stop(struct ath11k_base *ab)
2830 {
2831 int ret;
2832
2833 ath11k_dbg(ab, ATH11K_DBG_QMI, "firmware stop\n");
2834
2835 ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_OFF);
2836 if (ret < 0) {
2837 ath11k_warn(ab, "qmi failed to send wlan mode off: %d\n", ret);
2838 return;
2839 }
2840 }
2841
ath11k_qmi_firmware_start(struct ath11k_base * ab,u32 mode)2842 int ath11k_qmi_firmware_start(struct ath11k_base *ab,
2843 u32 mode)
2844 {
2845 int ret;
2846
2847 ath11k_dbg(ab, ATH11K_DBG_QMI, "firmware start\n");
2848
2849 if (ab->hw_params.fw_wmi_diag_event) {
2850 ret = ath11k_qmi_wlanfw_wlan_ini_send(ab, true);
2851 if (ret < 0) {
2852 ath11k_warn(ab, "qmi failed to send wlan fw ini:%d\n", ret);
2853 return ret;
2854 }
2855 }
2856
2857 ret = ath11k_qmi_wlanfw_wlan_cfg_send(ab);
2858 if (ret < 0) {
2859 ath11k_warn(ab, "qmi failed to send wlan cfg: %d\n", ret);
2860 return ret;
2861 }
2862
2863 ret = ath11k_qmi_wlanfw_mode_send(ab, mode);
2864 if (ret < 0) {
2865 ath11k_warn(ab, "qmi failed to send wlan fw mode: %d\n", ret);
2866 return ret;
2867 }
2868
2869 return 0;
2870 }
2871
ath11k_qmi_fwreset_from_cold_boot(struct ath11k_base * ab)2872 int ath11k_qmi_fwreset_from_cold_boot(struct ath11k_base *ab)
2873 {
2874 long time_left;
2875
2876 if (!ath11k_core_coldboot_cal_support(ab) ||
2877 ab->hw_params.cbcal_restart_fw == 0)
2878 return 0;
2879
2880 ath11k_dbg(ab, ATH11K_DBG_QMI, "wait for cold boot done\n");
2881
2882 time_left = wait_event_timeout(ab->qmi.cold_boot_waitq,
2883 (ab->qmi.cal_done == 1),
2884 ATH11K_COLD_BOOT_FW_RESET_DELAY);
2885
2886 if (time_left <= 0) {
2887 ath11k_warn(ab, "Coldboot Calibration timed out\n");
2888 return -ETIMEDOUT;
2889 }
2890
2891 /* reset the firmware */
2892 ath11k_hif_power_down(ab);
2893 ath11k_hif_power_up(ab);
2894 ath11k_dbg(ab, ATH11K_DBG_QMI, "exit wait for cold boot done\n");
2895 return 0;
2896 }
2897 EXPORT_SYMBOL(ath11k_qmi_fwreset_from_cold_boot);
2898
ath11k_qmi_process_coldboot_calibration(struct ath11k_base * ab)2899 static int ath11k_qmi_process_coldboot_calibration(struct ath11k_base *ab)
2900 {
2901 long time_left;
2902 int ret;
2903
2904 ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_COLD_BOOT);
2905 if (ret < 0) {
2906 ath11k_warn(ab, "qmi failed to send wlan fw mode: %d\n", ret);
2907 return ret;
2908 }
2909
2910 ath11k_dbg(ab, ATH11K_DBG_QMI, "Coldboot calibration wait started\n");
2911
2912 time_left = wait_event_timeout(ab->qmi.cold_boot_waitq,
2913 (ab->qmi.cal_done == 1),
2914 ATH11K_COLD_BOOT_FW_RESET_DELAY);
2915 if (time_left <= 0) {
2916 ath11k_warn(ab, "coldboot calibration timed out\n");
2917 return 0;
2918 }
2919
2920 ath11k_dbg(ab, ATH11K_DBG_QMI, "Coldboot calibration done\n");
2921
2922 return 0;
2923 }
2924
2925 static int
ath11k_qmi_driver_event_post(struct ath11k_qmi * qmi,enum ath11k_qmi_event_type type,void * data)2926 ath11k_qmi_driver_event_post(struct ath11k_qmi *qmi,
2927 enum ath11k_qmi_event_type type,
2928 void *data)
2929 {
2930 struct ath11k_qmi_driver_event *event;
2931
2932 event = kzalloc(sizeof(*event), GFP_ATOMIC);
2933 if (!event)
2934 return -ENOMEM;
2935
2936 event->type = type;
2937 event->data = data;
2938
2939 spin_lock(&qmi->event_lock);
2940 list_add_tail(&event->list, &qmi->event_list);
2941 spin_unlock(&qmi->event_lock);
2942
2943 queue_work(qmi->event_wq, &qmi->event_work);
2944
2945 return 0;
2946 }
2947
ath11k_qmi_event_mem_request(struct ath11k_qmi * qmi)2948 static int ath11k_qmi_event_mem_request(struct ath11k_qmi *qmi)
2949 {
2950 struct ath11k_base *ab = qmi->ab;
2951 int ret;
2952
2953 ret = ath11k_qmi_respond_fw_mem_request(ab);
2954 if (ret < 0) {
2955 ath11k_warn(ab, "qmi failed to respond fw mem req: %d\n", ret);
2956 return ret;
2957 }
2958
2959 return ret;
2960 }
2961
ath11k_qmi_event_load_bdf(struct ath11k_qmi * qmi)2962 static int ath11k_qmi_event_load_bdf(struct ath11k_qmi *qmi)
2963 {
2964 struct ath11k_base *ab = qmi->ab;
2965 int ret;
2966
2967 ret = ath11k_qmi_request_target_cap(ab);
2968 if (ret < 0) {
2969 ath11k_warn(ab, "failed to request qmi target capabilities: %d\n",
2970 ret);
2971 return ret;
2972 }
2973
2974 ret = ath11k_qmi_request_device_info(ab);
2975 if (ret < 0) {
2976 ath11k_warn(ab, "failed to request qmi device info: %d\n", ret);
2977 return ret;
2978 }
2979
2980 if (ab->hw_params.supports_regdb)
2981 ath11k_qmi_load_bdf_qmi(ab, true);
2982
2983 ret = ath11k_qmi_load_bdf_qmi(ab, false);
2984 if (ret < 0) {
2985 ath11k_warn(ab, "failed to load board data file: %d\n", ret);
2986 return ret;
2987 }
2988
2989 return 0;
2990 }
2991
ath11k_qmi_event_server_arrive(struct ath11k_qmi * qmi)2992 static int ath11k_qmi_event_server_arrive(struct ath11k_qmi *qmi)
2993 {
2994 struct ath11k_base *ab = qmi->ab;
2995 int ret;
2996
2997 ret = ath11k_qmi_fw_ind_register_send(ab);
2998 if (ret < 0) {
2999 ath11k_warn(ab, "failed to send qmi firmware indication: %d\n",
3000 ret);
3001 return ret;
3002 }
3003
3004 ret = ath11k_qmi_host_cap_send(ab);
3005 if (ret < 0) {
3006 ath11k_warn(ab, "failed to send qmi host cap: %d\n", ret);
3007 return ret;
3008 }
3009
3010 if (!ab->hw_params.fixed_fw_mem)
3011 return ret;
3012
3013 ret = ath11k_qmi_event_load_bdf(qmi);
3014 if (ret < 0) {
3015 ath11k_warn(ab, "qmi failed to download BDF:%d\n", ret);
3016 return ret;
3017 }
3018
3019 return ret;
3020 }
3021
ath11k_qmi_msg_mem_request_cb(struct qmi_handle * qmi_hdl,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * data)3022 static void ath11k_qmi_msg_mem_request_cb(struct qmi_handle *qmi_hdl,
3023 struct sockaddr_qrtr *sq,
3024 struct qmi_txn *txn,
3025 const void *data)
3026 {
3027 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3028 struct ath11k_base *ab = qmi->ab;
3029 const struct qmi_wlanfw_request_mem_ind_msg_v01 *msg = data;
3030 int i, ret;
3031
3032 ath11k_dbg(ab, ATH11K_DBG_QMI, "firmware request memory request\n");
3033
3034 if (msg->mem_seg_len == 0 ||
3035 msg->mem_seg_len > ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01)
3036 ath11k_warn(ab, "invalid memory segment length: %u\n",
3037 msg->mem_seg_len);
3038
3039 ab->qmi.mem_seg_count = msg->mem_seg_len;
3040
3041 for (i = 0; i < qmi->mem_seg_count ; i++) {
3042 ab->qmi.target_mem[i].type = msg->mem_seg[i].type;
3043 ab->qmi.target_mem[i].size = msg->mem_seg[i].size;
3044 ath11k_dbg(ab, ATH11K_DBG_QMI, "mem seg type %d size %d\n",
3045 msg->mem_seg[i].type, msg->mem_seg[i].size);
3046 }
3047
3048 if (ab->hw_params.fixed_mem_region ||
3049 test_bit(ATH11K_FLAG_FIXED_MEM_RGN, &ab->dev_flags)) {
3050 ret = ath11k_qmi_assign_target_mem_chunk(ab);
3051 if (ret) {
3052 ath11k_warn(ab, "failed to assign qmi target memory: %d\n",
3053 ret);
3054 return;
3055 }
3056 } else {
3057 ret = ath11k_qmi_alloc_target_mem_chunk(ab);
3058 if (ret) {
3059 ath11k_warn(ab, "failed to allocate qmi target memory: %d\n",
3060 ret);
3061 return;
3062 }
3063 }
3064
3065 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_REQUEST_MEM, NULL);
3066 }
3067
ath11k_qmi_msg_mem_ready_cb(struct qmi_handle * qmi_hdl,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * decoded)3068 static void ath11k_qmi_msg_mem_ready_cb(struct qmi_handle *qmi_hdl,
3069 struct sockaddr_qrtr *sq,
3070 struct qmi_txn *txn,
3071 const void *decoded)
3072 {
3073 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3074 struct ath11k_base *ab = qmi->ab;
3075
3076 ath11k_dbg(ab, ATH11K_DBG_QMI, "firmware memory ready indication\n");
3077 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_MEM_READY, NULL);
3078 }
3079
ath11k_qmi_msg_fw_ready_cb(struct qmi_handle * qmi_hdl,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * decoded)3080 static void ath11k_qmi_msg_fw_ready_cb(struct qmi_handle *qmi_hdl,
3081 struct sockaddr_qrtr *sq,
3082 struct qmi_txn *txn,
3083 const void *decoded)
3084 {
3085 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3086 struct ath11k_base *ab = qmi->ab;
3087
3088 ath11k_dbg(ab, ATH11K_DBG_QMI, "firmware ready\n");
3089
3090 if (!ab->qmi.cal_done) {
3091 ab->qmi.cal_done = 1;
3092 wake_up(&ab->qmi.cold_boot_waitq);
3093 }
3094
3095 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_READY, NULL);
3096 }
3097
ath11k_qmi_msg_cold_boot_cal_done_cb(struct qmi_handle * qmi_hdl,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * decoded)3098 static void ath11k_qmi_msg_cold_boot_cal_done_cb(struct qmi_handle *qmi_hdl,
3099 struct sockaddr_qrtr *sq,
3100 struct qmi_txn *txn,
3101 const void *decoded)
3102 {
3103 struct ath11k_qmi *qmi = container_of(qmi_hdl,
3104 struct ath11k_qmi, handle);
3105 struct ath11k_base *ab = qmi->ab;
3106
3107 ab->qmi.cal_done = 1;
3108 wake_up(&ab->qmi.cold_boot_waitq);
3109 ath11k_dbg(ab, ATH11K_DBG_QMI, "cold boot calibration done\n");
3110 }
3111
ath11k_qmi_msg_fw_init_done_cb(struct qmi_handle * qmi_hdl,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * decoded)3112 static void ath11k_qmi_msg_fw_init_done_cb(struct qmi_handle *qmi_hdl,
3113 struct sockaddr_qrtr *sq,
3114 struct qmi_txn *txn,
3115 const void *decoded)
3116 {
3117 struct ath11k_qmi *qmi = container_of(qmi_hdl,
3118 struct ath11k_qmi, handle);
3119 struct ath11k_base *ab = qmi->ab;
3120
3121 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_INIT_DONE, NULL);
3122 ath11k_dbg(ab, ATH11K_DBG_QMI, "firmware init done\n");
3123 }
3124
3125 static const struct qmi_msg_handler ath11k_qmi_msg_handlers[] = {
3126 {
3127 .type = QMI_INDICATION,
3128 .msg_id = QMI_WLFW_REQUEST_MEM_IND_V01,
3129 .ei = qmi_wlanfw_request_mem_ind_msg_v01_ei,
3130 .decoded_size = sizeof(struct qmi_wlanfw_request_mem_ind_msg_v01),
3131 .fn = ath11k_qmi_msg_mem_request_cb,
3132 },
3133 {
3134 .type = QMI_INDICATION,
3135 .msg_id = QMI_WLFW_FW_MEM_READY_IND_V01,
3136 .ei = qmi_wlanfw_mem_ready_ind_msg_v01_ei,
3137 .decoded_size = sizeof(struct qmi_wlanfw_fw_mem_ready_ind_msg_v01),
3138 .fn = ath11k_qmi_msg_mem_ready_cb,
3139 },
3140 {
3141 .type = QMI_INDICATION,
3142 .msg_id = QMI_WLFW_FW_READY_IND_V01,
3143 .ei = qmi_wlanfw_fw_ready_ind_msg_v01_ei,
3144 .decoded_size = sizeof(struct qmi_wlanfw_fw_ready_ind_msg_v01),
3145 .fn = ath11k_qmi_msg_fw_ready_cb,
3146 },
3147 {
3148 .type = QMI_INDICATION,
3149 .msg_id = QMI_WLFW_COLD_BOOT_CAL_DONE_IND_V01,
3150 .ei = qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei,
3151 .decoded_size =
3152 sizeof(struct qmi_wlanfw_fw_cold_cal_done_ind_msg_v01),
3153 .fn = ath11k_qmi_msg_cold_boot_cal_done_cb,
3154 },
3155 {
3156 .type = QMI_INDICATION,
3157 .msg_id = QMI_WLFW_FW_INIT_DONE_IND_V01,
3158 .ei = qmi_wlfw_fw_init_done_ind_msg_v01_ei,
3159 .decoded_size =
3160 sizeof(struct qmi_wlfw_fw_init_done_ind_msg_v01),
3161 .fn = ath11k_qmi_msg_fw_init_done_cb,
3162 },
3163
3164 /* end of list */
3165 {},
3166 };
3167
ath11k_qmi_ops_new_server(struct qmi_handle * qmi_hdl,struct qmi_service * service)3168 static int ath11k_qmi_ops_new_server(struct qmi_handle *qmi_hdl,
3169 struct qmi_service *service)
3170 {
3171 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3172 struct ath11k_base *ab = qmi->ab;
3173 struct sockaddr_qrtr *sq = &qmi->sq;
3174 int ret;
3175
3176 sq->sq_family = AF_QIPCRTR;
3177 sq->sq_node = service->node;
3178 sq->sq_port = service->port;
3179
3180 ret = kernel_connect(qmi_hdl->sock, (struct sockaddr *)sq,
3181 sizeof(*sq), 0);
3182 if (ret) {
3183 ath11k_warn(ab, "failed to connect to qmi remote service: %d\n", ret);
3184 return ret;
3185 }
3186
3187 ath11k_dbg(ab, ATH11K_DBG_QMI, "wifi fw qmi service connected\n");
3188 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_ARRIVE, NULL);
3189
3190 return ret;
3191 }
3192
ath11k_qmi_ops_del_server(struct qmi_handle * qmi_hdl,struct qmi_service * service)3193 static void ath11k_qmi_ops_del_server(struct qmi_handle *qmi_hdl,
3194 struct qmi_service *service)
3195 {
3196 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3197 struct ath11k_base *ab = qmi->ab;
3198
3199 ath11k_dbg(ab, ATH11K_DBG_QMI, "wifi fw del server\n");
3200 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_EXIT, NULL);
3201 }
3202
3203 static const struct qmi_ops ath11k_qmi_ops = {
3204 .new_server = ath11k_qmi_ops_new_server,
3205 .del_server = ath11k_qmi_ops_del_server,
3206 };
3207
ath11k_qmi_driver_event_work(struct work_struct * work)3208 static void ath11k_qmi_driver_event_work(struct work_struct *work)
3209 {
3210 struct ath11k_qmi *qmi = container_of(work, struct ath11k_qmi,
3211 event_work);
3212 struct ath11k_qmi_driver_event *event;
3213 struct ath11k_base *ab = qmi->ab;
3214 int ret;
3215
3216 spin_lock(&qmi->event_lock);
3217 while (!list_empty(&qmi->event_list)) {
3218 event = list_first_entry(&qmi->event_list,
3219 struct ath11k_qmi_driver_event, list);
3220 list_del(&event->list);
3221 spin_unlock(&qmi->event_lock);
3222
3223 if (test_bit(ATH11K_FLAG_UNREGISTERING, &ab->dev_flags)) {
3224 kfree(event);
3225 return;
3226 }
3227
3228 switch (event->type) {
3229 case ATH11K_QMI_EVENT_SERVER_ARRIVE:
3230 ret = ath11k_qmi_event_server_arrive(qmi);
3231 if (ret < 0)
3232 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3233 break;
3234 case ATH11K_QMI_EVENT_SERVER_EXIT:
3235 set_bit(ATH11K_FLAG_CRASH_FLUSH, &ab->dev_flags);
3236 set_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
3237
3238 if (!ab->is_reset)
3239 ath11k_core_pre_reconfigure_recovery(ab);
3240 break;
3241 case ATH11K_QMI_EVENT_REQUEST_MEM:
3242 ret = ath11k_qmi_event_mem_request(qmi);
3243 if (ret < 0)
3244 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3245 break;
3246 case ATH11K_QMI_EVENT_FW_MEM_READY:
3247 ret = ath11k_qmi_event_load_bdf(qmi);
3248 if (ret < 0) {
3249 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3250 break;
3251 }
3252
3253 ret = ath11k_qmi_wlanfw_m3_info_send(ab);
3254 if (ret < 0) {
3255 ath11k_warn(ab,
3256 "failed to send qmi m3 info req: %d\n", ret);
3257 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3258 }
3259
3260 break;
3261 case ATH11K_QMI_EVENT_FW_INIT_DONE:
3262 clear_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3263 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) {
3264 if (ab->is_reset)
3265 ath11k_hal_dump_srng_stats(ab);
3266 queue_work(ab->workqueue, &ab->restart_work);
3267 break;
3268 }
3269
3270 if (ab->qmi.cal_done == 0 &&
3271 ath11k_core_coldboot_cal_support(ab)) {
3272 ath11k_qmi_process_coldboot_calibration(ab);
3273 } else {
3274 clear_bit(ATH11K_FLAG_CRASH_FLUSH,
3275 &ab->dev_flags);
3276 clear_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
3277 ret = ath11k_core_qmi_firmware_ready(ab);
3278 if (ret) {
3279 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3280 break;
3281 }
3282 set_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags);
3283 }
3284
3285 break;
3286 case ATH11K_QMI_EVENT_FW_READY:
3287 /* For targets requiring a FW restart upon cold
3288 * boot completion, there is no need to process
3289 * FW ready; such targets will receive FW init
3290 * done message after FW restart.
3291 */
3292 if (ab->hw_params.cbcal_restart_fw)
3293 break;
3294
3295 clear_bit(ATH11K_FLAG_CRASH_FLUSH,
3296 &ab->dev_flags);
3297 clear_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
3298 ath11k_core_qmi_firmware_ready(ab);
3299 set_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags);
3300
3301 break;
3302 case ATH11K_QMI_EVENT_COLD_BOOT_CAL_DONE:
3303 break;
3304 default:
3305 ath11k_warn(ab, "invalid qmi event type: %d", event->type);
3306 break;
3307 }
3308 kfree(event);
3309 spin_lock(&qmi->event_lock);
3310 }
3311 spin_unlock(&qmi->event_lock);
3312 }
3313
ath11k_qmi_init_service(struct ath11k_base * ab)3314 int ath11k_qmi_init_service(struct ath11k_base *ab)
3315 {
3316 int ret;
3317
3318 memset(&ab->qmi.target, 0, sizeof(struct target_info));
3319 memset(&ab->qmi.target_mem, 0, sizeof(struct target_mem_chunk));
3320 ab->qmi.ab = ab;
3321
3322 ab->qmi.target_mem_mode = ab->hw_params.fw_mem_mode;
3323 ret = qmi_handle_init(&ab->qmi.handle, ATH11K_QMI_RESP_LEN_MAX,
3324 &ath11k_qmi_ops, ath11k_qmi_msg_handlers);
3325 if (ret < 0) {
3326 ath11k_warn(ab, "failed to initialize qmi handle: %d\n", ret);
3327 return ret;
3328 }
3329
3330 ab->qmi.event_wq = alloc_ordered_workqueue("ath11k_qmi_driver_event", 0);
3331 if (!ab->qmi.event_wq) {
3332 ath11k_err(ab, "failed to allocate workqueue\n");
3333 return -EFAULT;
3334 }
3335
3336 INIT_LIST_HEAD(&ab->qmi.event_list);
3337 spin_lock_init(&ab->qmi.event_lock);
3338 INIT_WORK(&ab->qmi.event_work, ath11k_qmi_driver_event_work);
3339
3340 ret = qmi_add_lookup(&ab->qmi.handle, ATH11K_QMI_WLFW_SERVICE_ID_V01,
3341 ATH11K_QMI_WLFW_SERVICE_VERS_V01,
3342 ab->qmi.service_ins_id);
3343 if (ret < 0) {
3344 ath11k_warn(ab, "failed to add qmi lookup: %d\n", ret);
3345 destroy_workqueue(ab->qmi.event_wq);
3346 return ret;
3347 }
3348
3349 return ret;
3350 }
3351
ath11k_qmi_deinit_service(struct ath11k_base * ab)3352 void ath11k_qmi_deinit_service(struct ath11k_base *ab)
3353 {
3354 qmi_handle_release(&ab->qmi.handle);
3355 cancel_work_sync(&ab->qmi.event_work);
3356 destroy_workqueue(ab->qmi.event_wq);
3357 ath11k_qmi_m3_free(ab);
3358 ath11k_qmi_free_target_mem_chunk(ab);
3359 }
3360 EXPORT_SYMBOL(ath11k_qmi_deinit_service);
3361
ath11k_qmi_free_resource(struct ath11k_base * ab)3362 void ath11k_qmi_free_resource(struct ath11k_base *ab)
3363 {
3364 ath11k_qmi_free_target_mem_chunk(ab);
3365 ath11k_qmi_m3_free(ab);
3366 }
3367