1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
4 */
5
6 #include <linux/elf.h>
7
8 #include "qmi.h"
9 #include "core.h"
10 #include "debug.h"
11 #include <linux/of.h>
12 #include <linux/firmware.h>
13
14 #define SLEEP_CLOCK_SELECT_INTERNAL_BIT 0x02
15 #define HOST_CSTATE_BIT 0x04
16
17 bool ath11k_cold_boot_cal = 1;
18 EXPORT_SYMBOL(ath11k_cold_boot_cal);
19 module_param_named(cold_boot_cal, ath11k_cold_boot_cal, bool, 0644);
20 MODULE_PARM_DESC(cold_boot_cal,
21 "Decrease the channel switch time but increase the driver load time (Default: true)");
22
23 static struct qmi_elem_info qmi_wlanfw_host_cap_req_msg_v01_ei[] = {
24 {
25 .data_type = QMI_OPT_FLAG,
26 .elem_len = 1,
27 .elem_size = sizeof(u8),
28 .array_type = NO_ARRAY,
29 .tlv_type = 0x10,
30 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
31 num_clients_valid),
32 },
33 {
34 .data_type = QMI_UNSIGNED_4_BYTE,
35 .elem_len = 1,
36 .elem_size = sizeof(u32),
37 .array_type = NO_ARRAY,
38 .tlv_type = 0x10,
39 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
40 num_clients),
41 },
42 {
43 .data_type = QMI_OPT_FLAG,
44 .elem_len = 1,
45 .elem_size = sizeof(u8),
46 .array_type = NO_ARRAY,
47 .tlv_type = 0x11,
48 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
49 wake_msi_valid),
50 },
51 {
52 .data_type = QMI_UNSIGNED_4_BYTE,
53 .elem_len = 1,
54 .elem_size = sizeof(u32),
55 .array_type = NO_ARRAY,
56 .tlv_type = 0x11,
57 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
58 wake_msi),
59 },
60 {
61 .data_type = QMI_OPT_FLAG,
62 .elem_len = 1,
63 .elem_size = sizeof(u8),
64 .array_type = NO_ARRAY,
65 .tlv_type = 0x12,
66 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
67 gpios_valid),
68 },
69 {
70 .data_type = QMI_DATA_LEN,
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_len),
77 },
78 {
79 .data_type = QMI_UNSIGNED_4_BYTE,
80 .elem_len = QMI_WLFW_MAX_NUM_GPIO_V01,
81 .elem_size = sizeof(u32),
82 .array_type = VAR_LEN_ARRAY,
83 .tlv_type = 0x12,
84 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
85 gpios),
86 },
87 {
88 .data_type = QMI_OPT_FLAG,
89 .elem_len = 1,
90 .elem_size = sizeof(u8),
91 .array_type = NO_ARRAY,
92 .tlv_type = 0x13,
93 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
94 nm_modem_valid),
95 },
96 {
97 .data_type = QMI_UNSIGNED_1_BYTE,
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),
104 },
105 {
106 .data_type = QMI_OPT_FLAG,
107 .elem_len = 1,
108 .elem_size = sizeof(u8),
109 .array_type = NO_ARRAY,
110 .tlv_type = 0x14,
111 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
112 bdf_support_valid),
113 },
114 {
115 .data_type = QMI_UNSIGNED_1_BYTE,
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),
122 },
123 {
124 .data_type = QMI_OPT_FLAG,
125 .elem_len = 1,
126 .elem_size = sizeof(u8),
127 .array_type = NO_ARRAY,
128 .tlv_type = 0x15,
129 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
130 bdf_cache_support_valid),
131 },
132 {
133 .data_type = QMI_UNSIGNED_1_BYTE,
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),
140 },
141 {
142 .data_type = QMI_OPT_FLAG,
143 .elem_len = 1,
144 .elem_size = sizeof(u8),
145 .array_type = NO_ARRAY,
146 .tlv_type = 0x16,
147 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
148 m3_support_valid),
149 },
150 {
151 .data_type = QMI_UNSIGNED_1_BYTE,
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),
158 },
159 {
160 .data_type = QMI_OPT_FLAG,
161 .elem_len = 1,
162 .elem_size = sizeof(u8),
163 .array_type = NO_ARRAY,
164 .tlv_type = 0x17,
165 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
166 m3_cache_support_valid),
167 },
168 {
169 .data_type = QMI_UNSIGNED_1_BYTE,
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),
176 },
177 {
178 .data_type = QMI_OPT_FLAG,
179 .elem_len = 1,
180 .elem_size = sizeof(u8),
181 .array_type = NO_ARRAY,
182 .tlv_type = 0x18,
183 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
184 cal_filesys_support_valid),
185 },
186 {
187 .data_type = QMI_UNSIGNED_1_BYTE,
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),
194 },
195 {
196 .data_type = QMI_OPT_FLAG,
197 .elem_len = 1,
198 .elem_size = sizeof(u8),
199 .array_type = NO_ARRAY,
200 .tlv_type = 0x19,
201 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
202 cal_cache_support_valid),
203 },
204 {
205 .data_type = QMI_UNSIGNED_1_BYTE,
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),
212 },
213 {
214 .data_type = QMI_OPT_FLAG,
215 .elem_len = 1,
216 .elem_size = sizeof(u8),
217 .array_type = NO_ARRAY,
218 .tlv_type = 0x1A,
219 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
220 cal_done_valid),
221 },
222 {
223 .data_type = QMI_UNSIGNED_1_BYTE,
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),
230 },
231 {
232 .data_type = QMI_OPT_FLAG,
233 .elem_len = 1,
234 .elem_size = sizeof(u8),
235 .array_type = NO_ARRAY,
236 .tlv_type = 0x1B,
237 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
238 mem_bucket_valid),
239 },
240 {
241 .data_type = QMI_UNSIGNED_4_BYTE,
242 .elem_len = 1,
243 .elem_size = sizeof(u32),
244 .array_type = NO_ARRAY,
245 .tlv_type = 0x1B,
246 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
247 mem_bucket),
248 },
249 {
250 .data_type = QMI_OPT_FLAG,
251 .elem_len = 1,
252 .elem_size = sizeof(u8),
253 .array_type = NO_ARRAY,
254 .tlv_type = 0x1C,
255 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
256 mem_cfg_mode_valid),
257 },
258 {
259 .data_type = QMI_UNSIGNED_1_BYTE,
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),
266 },
267 {
268 .data_type = QMI_EOTI,
269 .array_type = NO_ARRAY,
270 .tlv_type = QMI_COMMON_TLV_TYPE,
271 },
272 };
273
274 static struct qmi_elem_info qmi_wlanfw_host_cap_resp_msg_v01_ei[] = {
275 {
276 .data_type = QMI_STRUCT,
277 .elem_len = 1,
278 .elem_size = sizeof(struct qmi_response_type_v01),
279 .array_type = NO_ARRAY,
280 .tlv_type = 0x02,
281 .offset = offsetof(struct qmi_wlanfw_host_cap_resp_msg_v01, resp),
282 .ei_array = qmi_response_type_v01_ei,
283 },
284 {
285 .data_type = QMI_EOTI,
286 .array_type = NO_ARRAY,
287 .tlv_type = QMI_COMMON_TLV_TYPE,
288 },
289 };
290
291 static struct qmi_elem_info qmi_wlanfw_ind_register_req_msg_v01_ei[] = {
292 {
293 .data_type = QMI_OPT_FLAG,
294 .elem_len = 1,
295 .elem_size = sizeof(u8),
296 .array_type = NO_ARRAY,
297 .tlv_type = 0x10,
298 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
299 fw_ready_enable_valid),
300 },
301 {
302 .data_type = QMI_UNSIGNED_1_BYTE,
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),
309 },
310 {
311 .data_type = QMI_OPT_FLAG,
312 .elem_len = 1,
313 .elem_size = sizeof(u8),
314 .array_type = NO_ARRAY,
315 .tlv_type = 0x11,
316 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
317 initiate_cal_download_enable_valid),
318 },
319 {
320 .data_type = QMI_UNSIGNED_1_BYTE,
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),
327 },
328 {
329 .data_type = QMI_OPT_FLAG,
330 .elem_len = 1,
331 .elem_size = sizeof(u8),
332 .array_type = NO_ARRAY,
333 .tlv_type = 0x12,
334 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
335 initiate_cal_update_enable_valid),
336 },
337 {
338 .data_type = QMI_UNSIGNED_1_BYTE,
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),
345 },
346 {
347 .data_type = QMI_OPT_FLAG,
348 .elem_len = 1,
349 .elem_size = sizeof(u8),
350 .array_type = NO_ARRAY,
351 .tlv_type = 0x13,
352 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
353 msa_ready_enable_valid),
354 },
355 {
356 .data_type = QMI_UNSIGNED_1_BYTE,
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),
363 },
364 {
365 .data_type = QMI_OPT_FLAG,
366 .elem_len = 1,
367 .elem_size = sizeof(u8),
368 .array_type = NO_ARRAY,
369 .tlv_type = 0x14,
370 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
371 pin_connect_result_enable_valid),
372 },
373 {
374 .data_type = QMI_UNSIGNED_1_BYTE,
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),
381 },
382 {
383 .data_type = QMI_OPT_FLAG,
384 .elem_len = 1,
385 .elem_size = sizeof(u8),
386 .array_type = NO_ARRAY,
387 .tlv_type = 0x15,
388 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
389 client_id_valid),
390 },
391 {
392 .data_type = QMI_UNSIGNED_4_BYTE,
393 .elem_len = 1,
394 .elem_size = sizeof(u32),
395 .array_type = NO_ARRAY,
396 .tlv_type = 0x15,
397 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
398 client_id),
399 },
400 {
401 .data_type = QMI_OPT_FLAG,
402 .elem_len = 1,
403 .elem_size = sizeof(u8),
404 .array_type = NO_ARRAY,
405 .tlv_type = 0x16,
406 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
407 request_mem_enable_valid),
408 },
409 {
410 .data_type = QMI_UNSIGNED_1_BYTE,
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),
417 },
418 {
419 .data_type = QMI_OPT_FLAG,
420 .elem_len = 1,
421 .elem_size = sizeof(u8),
422 .array_type = NO_ARRAY,
423 .tlv_type = 0x17,
424 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
425 fw_mem_ready_enable_valid),
426 },
427 {
428 .data_type = QMI_UNSIGNED_1_BYTE,
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),
435 },
436 {
437 .data_type = QMI_OPT_FLAG,
438 .elem_len = 1,
439 .elem_size = sizeof(u8),
440 .array_type = NO_ARRAY,
441 .tlv_type = 0x18,
442 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
443 fw_init_done_enable_valid),
444 },
445 {
446 .data_type = QMI_UNSIGNED_1_BYTE,
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),
453 },
454
455 {
456 .data_type = QMI_OPT_FLAG,
457 .elem_len = 1,
458 .elem_size = sizeof(u8),
459 .array_type = NO_ARRAY,
460 .tlv_type = 0x19,
461 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
462 rejuvenate_enable_valid),
463 },
464 {
465 .data_type = QMI_UNSIGNED_1_BYTE,
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),
472 },
473 {
474 .data_type = QMI_OPT_FLAG,
475 .elem_len = 1,
476 .elem_size = sizeof(u8),
477 .array_type = NO_ARRAY,
478 .tlv_type = 0x1A,
479 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
480 xo_cal_enable_valid),
481 },
482 {
483 .data_type = QMI_UNSIGNED_1_BYTE,
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),
490 },
491 {
492 .data_type = QMI_OPT_FLAG,
493 .elem_len = 1,
494 .elem_size = sizeof(u8),
495 .array_type = NO_ARRAY,
496 .tlv_type = 0x1B,
497 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
498 cal_done_enable_valid),
499 },
500 {
501 .data_type = QMI_UNSIGNED_1_BYTE,
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),
508 },
509 {
510 .data_type = QMI_EOTI,
511 .array_type = NO_ARRAY,
512 .tlv_type = QMI_COMMON_TLV_TYPE,
513 },
514 };
515
516 static struct qmi_elem_info qmi_wlanfw_ind_register_resp_msg_v01_ei[] = {
517 {
518 .data_type = QMI_STRUCT,
519 .elem_len = 1,
520 .elem_size = sizeof(struct qmi_response_type_v01),
521 .array_type = NO_ARRAY,
522 .tlv_type = 0x02,
523 .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
524 resp),
525 .ei_array = qmi_response_type_v01_ei,
526 },
527 {
528 .data_type = QMI_OPT_FLAG,
529 .elem_len = 1,
530 .elem_size = sizeof(u8),
531 .array_type = NO_ARRAY,
532 .tlv_type = 0x10,
533 .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
534 fw_status_valid),
535 },
536 {
537 .data_type = QMI_UNSIGNED_8_BYTE,
538 .elem_len = 1,
539 .elem_size = sizeof(u64),
540 .array_type = NO_ARRAY,
541 .tlv_type = 0x10,
542 .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
543 fw_status),
544 },
545 {
546 .data_type = QMI_EOTI,
547 .array_type = NO_ARRAY,
548 .tlv_type = QMI_COMMON_TLV_TYPE,
549 },
550 };
551
552 static struct qmi_elem_info qmi_wlanfw_mem_cfg_s_v01_ei[] = {
553 {
554 .data_type = QMI_UNSIGNED_8_BYTE,
555 .elem_len = 1,
556 .elem_size = sizeof(u64),
557 .array_type = NO_ARRAY,
558 .tlv_type = 0,
559 .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, offset),
560 },
561 {
562 .data_type = QMI_UNSIGNED_4_BYTE,
563 .elem_len = 1,
564 .elem_size = sizeof(u32),
565 .array_type = NO_ARRAY,
566 .tlv_type = 0,
567 .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, size),
568 },
569 {
570 .data_type = QMI_UNSIGNED_1_BYTE,
571 .elem_len = 1,
572 .elem_size = sizeof(u8),
573 .array_type = NO_ARRAY,
574 .tlv_type = 0,
575 .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, secure_flag),
576 },
577 {
578 .data_type = QMI_EOTI,
579 .array_type = NO_ARRAY,
580 .tlv_type = QMI_COMMON_TLV_TYPE,
581 },
582 };
583
584 static struct qmi_elem_info qmi_wlanfw_mem_seg_s_v01_ei[] = {
585 {
586 .data_type = QMI_UNSIGNED_4_BYTE,
587 .elem_len = 1,
588 .elem_size = sizeof(u32),
589 .array_type = NO_ARRAY,
590 .tlv_type = 0,
591 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01,
592 size),
593 },
594 {
595 .data_type = QMI_SIGNED_4_BYTE_ENUM,
596 .elem_len = 1,
597 .elem_size = sizeof(enum qmi_wlanfw_mem_type_enum_v01),
598 .array_type = NO_ARRAY,
599 .tlv_type = 0,
600 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01, type),
601 },
602 {
603 .data_type = QMI_DATA_LEN,
604 .elem_len = 1,
605 .elem_size = sizeof(u8),
606 .array_type = NO_ARRAY,
607 .tlv_type = 0,
608 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg_len),
609 },
610 {
611 .data_type = QMI_STRUCT,
612 .elem_len = QMI_WLANFW_MAX_NUM_MEM_CFG_V01,
613 .elem_size = sizeof(struct qmi_wlanfw_mem_cfg_s_v01),
614 .array_type = VAR_LEN_ARRAY,
615 .tlv_type = 0,
616 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg),
617 .ei_array = qmi_wlanfw_mem_cfg_s_v01_ei,
618 },
619 {
620 .data_type = QMI_EOTI,
621 .array_type = NO_ARRAY,
622 .tlv_type = QMI_COMMON_TLV_TYPE,
623 },
624 };
625
626 static struct qmi_elem_info qmi_wlanfw_request_mem_ind_msg_v01_ei[] = {
627 {
628 .data_type = QMI_DATA_LEN,
629 .elem_len = 1,
630 .elem_size = sizeof(u8),
631 .array_type = NO_ARRAY,
632 .tlv_type = 0x01,
633 .offset = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
634 mem_seg_len),
635 },
636 {
637 .data_type = QMI_STRUCT,
638 .elem_len = ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
639 .elem_size = sizeof(struct qmi_wlanfw_mem_seg_s_v01),
640 .array_type = VAR_LEN_ARRAY,
641 .tlv_type = 0x01,
642 .offset = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
643 mem_seg),
644 .ei_array = qmi_wlanfw_mem_seg_s_v01_ei,
645 },
646 {
647 .data_type = QMI_EOTI,
648 .array_type = NO_ARRAY,
649 .tlv_type = QMI_COMMON_TLV_TYPE,
650 },
651 };
652
653 static struct qmi_elem_info qmi_wlanfw_mem_seg_resp_s_v01_ei[] = {
654 {
655 .data_type = QMI_UNSIGNED_8_BYTE,
656 .elem_len = 1,
657 .elem_size = sizeof(u64),
658 .array_type = NO_ARRAY,
659 .tlv_type = 0,
660 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, addr),
661 },
662 {
663 .data_type = QMI_UNSIGNED_4_BYTE,
664 .elem_len = 1,
665 .elem_size = sizeof(u32),
666 .array_type = NO_ARRAY,
667 .tlv_type = 0,
668 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, size),
669 },
670 {
671 .data_type = QMI_SIGNED_4_BYTE_ENUM,
672 .elem_len = 1,
673 .elem_size = sizeof(enum qmi_wlanfw_mem_type_enum_v01),
674 .array_type = NO_ARRAY,
675 .tlv_type = 0,
676 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, type),
677 },
678 {
679 .data_type = QMI_UNSIGNED_1_BYTE,
680 .elem_len = 1,
681 .elem_size = sizeof(u8),
682 .array_type = NO_ARRAY,
683 .tlv_type = 0,
684 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, restore),
685 },
686 {
687 .data_type = QMI_EOTI,
688 .array_type = NO_ARRAY,
689 .tlv_type = QMI_COMMON_TLV_TYPE,
690 },
691 };
692
693 static struct qmi_elem_info qmi_wlanfw_respond_mem_req_msg_v01_ei[] = {
694 {
695 .data_type = QMI_DATA_LEN,
696 .elem_len = 1,
697 .elem_size = sizeof(u8),
698 .array_type = NO_ARRAY,
699 .tlv_type = 0x01,
700 .offset = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
701 mem_seg_len),
702 },
703 {
704 .data_type = QMI_STRUCT,
705 .elem_len = ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
706 .elem_size = sizeof(struct qmi_wlanfw_mem_seg_resp_s_v01),
707 .array_type = VAR_LEN_ARRAY,
708 .tlv_type = 0x01,
709 .offset = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
710 mem_seg),
711 .ei_array = qmi_wlanfw_mem_seg_resp_s_v01_ei,
712 },
713 {
714 .data_type = QMI_EOTI,
715 .array_type = NO_ARRAY,
716 .tlv_type = QMI_COMMON_TLV_TYPE,
717 },
718 };
719
720 static struct qmi_elem_info qmi_wlanfw_respond_mem_resp_msg_v01_ei[] = {
721 {
722 .data_type = QMI_STRUCT,
723 .elem_len = 1,
724 .elem_size = sizeof(struct qmi_response_type_v01),
725 .array_type = NO_ARRAY,
726 .tlv_type = 0x02,
727 .offset = offsetof(struct qmi_wlanfw_respond_mem_resp_msg_v01,
728 resp),
729 .ei_array = qmi_response_type_v01_ei,
730 },
731 {
732 .data_type = QMI_EOTI,
733 .array_type = NO_ARRAY,
734 .tlv_type = QMI_COMMON_TLV_TYPE,
735 },
736 };
737
738 static struct qmi_elem_info qmi_wlanfw_cap_req_msg_v01_ei[] = {
739 {
740 .data_type = QMI_EOTI,
741 .array_type = NO_ARRAY,
742 .tlv_type = QMI_COMMON_TLV_TYPE,
743 },
744 };
745
746 static struct qmi_elem_info qmi_wlanfw_rf_chip_info_s_v01_ei[] = {
747 {
748 .data_type = QMI_UNSIGNED_4_BYTE,
749 .elem_len = 1,
750 .elem_size = sizeof(u32),
751 .array_type = NO_ARRAY,
752 .tlv_type = 0,
753 .offset = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
754 chip_id),
755 },
756 {
757 .data_type = QMI_UNSIGNED_4_BYTE,
758 .elem_len = 1,
759 .elem_size = sizeof(u32),
760 .array_type = NO_ARRAY,
761 .tlv_type = 0,
762 .offset = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
763 chip_family),
764 },
765 {
766 .data_type = QMI_EOTI,
767 .array_type = NO_ARRAY,
768 .tlv_type = QMI_COMMON_TLV_TYPE,
769 },
770 };
771
772 static struct qmi_elem_info qmi_wlanfw_rf_board_info_s_v01_ei[] = {
773 {
774 .data_type = QMI_UNSIGNED_4_BYTE,
775 .elem_len = 1,
776 .elem_size = sizeof(u32),
777 .array_type = NO_ARRAY,
778 .tlv_type = 0,
779 .offset = offsetof(struct qmi_wlanfw_rf_board_info_s_v01,
780 board_id),
781 },
782 {
783 .data_type = QMI_EOTI,
784 .array_type = NO_ARRAY,
785 .tlv_type = QMI_COMMON_TLV_TYPE,
786 },
787 };
788
789 static struct qmi_elem_info qmi_wlanfw_soc_info_s_v01_ei[] = {
790 {
791 .data_type = QMI_UNSIGNED_4_BYTE,
792 .elem_len = 1,
793 .elem_size = sizeof(u32),
794 .array_type = NO_ARRAY,
795 .tlv_type = 0,
796 .offset = offsetof(struct qmi_wlanfw_soc_info_s_v01, soc_id),
797 },
798 {
799 .data_type = QMI_EOTI,
800 .array_type = NO_ARRAY,
801 .tlv_type = QMI_COMMON_TLV_TYPE,
802 },
803 };
804
805 static struct qmi_elem_info qmi_wlanfw_fw_version_info_s_v01_ei[] = {
806 {
807 .data_type = QMI_UNSIGNED_4_BYTE,
808 .elem_len = 1,
809 .elem_size = sizeof(u32),
810 .array_type = NO_ARRAY,
811 .tlv_type = 0,
812 .offset = offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
813 fw_version),
814 },
815 {
816 .data_type = QMI_STRING,
817 .elem_len = ATH11K_QMI_WLANFW_MAX_TIMESTAMP_LEN_V01 + 1,
818 .elem_size = sizeof(char),
819 .array_type = NO_ARRAY,
820 .tlv_type = 0,
821 .offset = offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
822 fw_build_timestamp),
823 },
824 {
825 .data_type = QMI_EOTI,
826 .array_type = NO_ARRAY,
827 .tlv_type = QMI_COMMON_TLV_TYPE,
828 },
829 };
830
831 static struct qmi_elem_info qmi_wlanfw_cap_resp_msg_v01_ei[] = {
832 {
833 .data_type = QMI_STRUCT,
834 .elem_len = 1,
835 .elem_size = sizeof(struct qmi_response_type_v01),
836 .array_type = NO_ARRAY,
837 .tlv_type = 0x02,
838 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01, resp),
839 .ei_array = qmi_response_type_v01_ei,
840 },
841 {
842 .data_type = QMI_OPT_FLAG,
843 .elem_len = 1,
844 .elem_size = sizeof(u8),
845 .array_type = NO_ARRAY,
846 .tlv_type = 0x10,
847 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
848 chip_info_valid),
849 },
850 {
851 .data_type = QMI_STRUCT,
852 .elem_len = 1,
853 .elem_size = sizeof(struct qmi_wlanfw_rf_chip_info_s_v01),
854 .array_type = NO_ARRAY,
855 .tlv_type = 0x10,
856 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
857 chip_info),
858 .ei_array = qmi_wlanfw_rf_chip_info_s_v01_ei,
859 },
860 {
861 .data_type = QMI_OPT_FLAG,
862 .elem_len = 1,
863 .elem_size = sizeof(u8),
864 .array_type = NO_ARRAY,
865 .tlv_type = 0x11,
866 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
867 board_info_valid),
868 },
869 {
870 .data_type = QMI_STRUCT,
871 .elem_len = 1,
872 .elem_size = sizeof(struct qmi_wlanfw_rf_board_info_s_v01),
873 .array_type = NO_ARRAY,
874 .tlv_type = 0x11,
875 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
876 board_info),
877 .ei_array = qmi_wlanfw_rf_board_info_s_v01_ei,
878 },
879 {
880 .data_type = QMI_OPT_FLAG,
881 .elem_len = 1,
882 .elem_size = sizeof(u8),
883 .array_type = NO_ARRAY,
884 .tlv_type = 0x12,
885 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
886 soc_info_valid),
887 },
888 {
889 .data_type = QMI_STRUCT,
890 .elem_len = 1,
891 .elem_size = sizeof(struct qmi_wlanfw_soc_info_s_v01),
892 .array_type = NO_ARRAY,
893 .tlv_type = 0x12,
894 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
895 soc_info),
896 .ei_array = qmi_wlanfw_soc_info_s_v01_ei,
897 },
898 {
899 .data_type = QMI_OPT_FLAG,
900 .elem_len = 1,
901 .elem_size = sizeof(u8),
902 .array_type = NO_ARRAY,
903 .tlv_type = 0x13,
904 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
905 fw_version_info_valid),
906 },
907 {
908 .data_type = QMI_STRUCT,
909 .elem_len = 1,
910 .elem_size = sizeof(struct qmi_wlanfw_fw_version_info_s_v01),
911 .array_type = NO_ARRAY,
912 .tlv_type = 0x13,
913 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
914 fw_version_info),
915 .ei_array = qmi_wlanfw_fw_version_info_s_v01_ei,
916 },
917 {
918 .data_type = QMI_OPT_FLAG,
919 .elem_len = 1,
920 .elem_size = sizeof(u8),
921 .array_type = NO_ARRAY,
922 .tlv_type = 0x14,
923 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
924 fw_build_id_valid),
925 },
926 {
927 .data_type = QMI_STRING,
928 .elem_len = ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 + 1,
929 .elem_size = sizeof(char),
930 .array_type = NO_ARRAY,
931 .tlv_type = 0x14,
932 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
933 fw_build_id),
934 },
935 {
936 .data_type = QMI_OPT_FLAG,
937 .elem_len = 1,
938 .elem_size = sizeof(u8),
939 .array_type = NO_ARRAY,
940 .tlv_type = 0x15,
941 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
942 num_macs_valid),
943 },
944 {
945 .data_type = QMI_UNSIGNED_1_BYTE,
946 .elem_len = 1,
947 .elem_size = sizeof(u8),
948 .array_type = NO_ARRAY,
949 .tlv_type = 0x15,
950 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
951 num_macs),
952 },
953 {
954 .data_type = QMI_EOTI,
955 .array_type = NO_ARRAY,
956 .tlv_type = QMI_COMMON_TLV_TYPE,
957 },
958 };
959
960 static struct qmi_elem_info qmi_wlanfw_bdf_download_req_msg_v01_ei[] = {
961 {
962 .data_type = QMI_UNSIGNED_1_BYTE,
963 .elem_len = 1,
964 .elem_size = sizeof(u8),
965 .array_type = NO_ARRAY,
966 .tlv_type = 0x01,
967 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
968 valid),
969 },
970 {
971 .data_type = QMI_OPT_FLAG,
972 .elem_len = 1,
973 .elem_size = sizeof(u8),
974 .array_type = NO_ARRAY,
975 .tlv_type = 0x10,
976 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
977 file_id_valid),
978 },
979 {
980 .data_type = QMI_SIGNED_4_BYTE_ENUM,
981 .elem_len = 1,
982 .elem_size = sizeof(enum qmi_wlanfw_cal_temp_id_enum_v01),
983 .array_type = NO_ARRAY,
984 .tlv_type = 0x10,
985 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
986 file_id),
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 = 0x11,
994 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
995 total_size_valid),
996 },
997 {
998 .data_type = QMI_UNSIGNED_4_BYTE,
999 .elem_len = 1,
1000 .elem_size = sizeof(u32),
1001 .array_type = NO_ARRAY,
1002 .tlv_type = 0x11,
1003 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1004 total_size),
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 = 0x12,
1012 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1013 seg_id_valid),
1014 },
1015 {
1016 .data_type = QMI_UNSIGNED_4_BYTE,
1017 .elem_len = 1,
1018 .elem_size = sizeof(u32),
1019 .array_type = NO_ARRAY,
1020 .tlv_type = 0x12,
1021 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1022 seg_id),
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 = 0x13,
1030 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1031 data_valid),
1032 },
1033 {
1034 .data_type = QMI_DATA_LEN,
1035 .elem_len = 1,
1036 .elem_size = sizeof(u16),
1037 .array_type = NO_ARRAY,
1038 .tlv_type = 0x13,
1039 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1040 data_len),
1041 },
1042 {
1043 .data_type = QMI_UNSIGNED_1_BYTE,
1044 .elem_len = QMI_WLANFW_MAX_DATA_SIZE_V01,
1045 .elem_size = sizeof(u8),
1046 .array_type = VAR_LEN_ARRAY,
1047 .tlv_type = 0x13,
1048 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1049 data),
1050 },
1051 {
1052 .data_type = QMI_OPT_FLAG,
1053 .elem_len = 1,
1054 .elem_size = sizeof(u8),
1055 .array_type = NO_ARRAY,
1056 .tlv_type = 0x14,
1057 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1058 end_valid),
1059 },
1060 {
1061 .data_type = QMI_UNSIGNED_1_BYTE,
1062 .elem_len = 1,
1063 .elem_size = sizeof(u8),
1064 .array_type = NO_ARRAY,
1065 .tlv_type = 0x14,
1066 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1067 end),
1068 },
1069 {
1070 .data_type = QMI_OPT_FLAG,
1071 .elem_len = 1,
1072 .elem_size = sizeof(u8),
1073 .array_type = NO_ARRAY,
1074 .tlv_type = 0x15,
1075 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1076 bdf_type_valid),
1077 },
1078 {
1079 .data_type = QMI_UNSIGNED_1_BYTE,
1080 .elem_len = 1,
1081 .elem_size = sizeof(u8),
1082 .array_type = NO_ARRAY,
1083 .tlv_type = 0x15,
1084 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1085 bdf_type),
1086 },
1087
1088 {
1089 .data_type = QMI_EOTI,
1090 .array_type = NO_ARRAY,
1091 .tlv_type = QMI_COMMON_TLV_TYPE,
1092 },
1093 };
1094
1095 static struct qmi_elem_info qmi_wlanfw_bdf_download_resp_msg_v01_ei[] = {
1096 {
1097 .data_type = QMI_STRUCT,
1098 .elem_len = 1,
1099 .elem_size = sizeof(struct qmi_response_type_v01),
1100 .array_type = NO_ARRAY,
1101 .tlv_type = 0x02,
1102 .offset = offsetof(struct qmi_wlanfw_bdf_download_resp_msg_v01,
1103 resp),
1104 .ei_array = qmi_response_type_v01_ei,
1105 },
1106 {
1107 .data_type = QMI_EOTI,
1108 .array_type = NO_ARRAY,
1109 .tlv_type = QMI_COMMON_TLV_TYPE,
1110 },
1111 };
1112
1113 static struct qmi_elem_info qmi_wlanfw_m3_info_req_msg_v01_ei[] = {
1114 {
1115 .data_type = QMI_UNSIGNED_8_BYTE,
1116 .elem_len = 1,
1117 .elem_size = sizeof(u64),
1118 .array_type = NO_ARRAY,
1119 .tlv_type = 0x01,
1120 .offset = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, addr),
1121 },
1122 {
1123 .data_type = QMI_UNSIGNED_4_BYTE,
1124 .elem_len = 1,
1125 .elem_size = sizeof(u32),
1126 .array_type = NO_ARRAY,
1127 .tlv_type = 0x02,
1128 .offset = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, size),
1129 },
1130 {
1131 .data_type = QMI_EOTI,
1132 .array_type = NO_ARRAY,
1133 .tlv_type = QMI_COMMON_TLV_TYPE,
1134 },
1135 };
1136
1137 static struct qmi_elem_info qmi_wlanfw_m3_info_resp_msg_v01_ei[] = {
1138 {
1139 .data_type = QMI_STRUCT,
1140 .elem_len = 1,
1141 .elem_size = sizeof(struct qmi_response_type_v01),
1142 .array_type = NO_ARRAY,
1143 .tlv_type = 0x02,
1144 .offset = offsetof(struct qmi_wlanfw_m3_info_resp_msg_v01, resp),
1145 .ei_array = qmi_response_type_v01_ei,
1146 },
1147 {
1148 .data_type = QMI_EOTI,
1149 .array_type = NO_ARRAY,
1150 .tlv_type = QMI_COMMON_TLV_TYPE,
1151 },
1152 };
1153
1154 static struct qmi_elem_info qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei[] = {
1155 {
1156 .data_type = QMI_UNSIGNED_4_BYTE,
1157 .elem_len = 1,
1158 .elem_size = sizeof(u32),
1159 .array_type = NO_ARRAY,
1160 .tlv_type = 0,
1161 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1162 pipe_num),
1163 },
1164 {
1165 .data_type = QMI_SIGNED_4_BYTE_ENUM,
1166 .elem_len = 1,
1167 .elem_size = sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1168 .array_type = NO_ARRAY,
1169 .tlv_type = 0,
1170 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1171 pipe_dir),
1172 },
1173 {
1174 .data_type = QMI_UNSIGNED_4_BYTE,
1175 .elem_len = 1,
1176 .elem_size = sizeof(u32),
1177 .array_type = NO_ARRAY,
1178 .tlv_type = 0,
1179 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1180 nentries),
1181 },
1182 {
1183 .data_type = QMI_UNSIGNED_4_BYTE,
1184 .elem_len = 1,
1185 .elem_size = sizeof(u32),
1186 .array_type = NO_ARRAY,
1187 .tlv_type = 0,
1188 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1189 nbytes_max),
1190 },
1191 {
1192 .data_type = QMI_UNSIGNED_4_BYTE,
1193 .elem_len = 1,
1194 .elem_size = sizeof(u32),
1195 .array_type = NO_ARRAY,
1196 .tlv_type = 0,
1197 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1198 flags),
1199 },
1200 {
1201 .data_type = QMI_EOTI,
1202 .array_type = NO_ARRAY,
1203 .tlv_type = QMI_COMMON_TLV_TYPE,
1204 },
1205 };
1206
1207 static struct qmi_elem_info qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei[] = {
1208 {
1209 .data_type = QMI_UNSIGNED_4_BYTE,
1210 .elem_len = 1,
1211 .elem_size = sizeof(u32),
1212 .array_type = NO_ARRAY,
1213 .tlv_type = 0,
1214 .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1215 service_id),
1216 },
1217 {
1218 .data_type = QMI_SIGNED_4_BYTE_ENUM,
1219 .elem_len = 1,
1220 .elem_size = sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1221 .array_type = NO_ARRAY,
1222 .tlv_type = 0,
1223 .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1224 pipe_dir),
1225 },
1226 {
1227 .data_type = QMI_UNSIGNED_4_BYTE,
1228 .elem_len = 1,
1229 .elem_size = sizeof(u32),
1230 .array_type = NO_ARRAY,
1231 .tlv_type = 0,
1232 .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1233 pipe_num),
1234 },
1235 {
1236 .data_type = QMI_EOTI,
1237 .array_type = NO_ARRAY,
1238 .tlv_type = QMI_COMMON_TLV_TYPE,
1239 },
1240 };
1241
1242 static struct qmi_elem_info qmi_wlanfw_shadow_reg_cfg_s_v01_ei[] = {
1243 {
1244 .data_type = QMI_UNSIGNED_2_BYTE,
1245 .elem_len = 1,
1246 .elem_size = sizeof(u16),
1247 .array_type = NO_ARRAY,
1248 .tlv_type = 0,
1249 .offset = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01, id),
1250 },
1251 {
1252 .data_type = QMI_UNSIGNED_2_BYTE,
1253 .elem_len = 1,
1254 .elem_size = sizeof(u16),
1255 .array_type = NO_ARRAY,
1256 .tlv_type = 0,
1257 .offset = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01,
1258 offset),
1259 },
1260 {
1261 .data_type = QMI_EOTI,
1262 .array_type = QMI_COMMON_TLV_TYPE,
1263 },
1264 };
1265
1266 static struct qmi_elem_info qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei[] = {
1267 {
1268 .data_type = QMI_UNSIGNED_4_BYTE,
1269 .elem_len = 1,
1270 .elem_size = sizeof(u32),
1271 .array_type = NO_ARRAY,
1272 .tlv_type = 0,
1273 .offset = offsetof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01,
1274 addr),
1275 },
1276 {
1277 .data_type = QMI_EOTI,
1278 .array_type = NO_ARRAY,
1279 .tlv_type = QMI_COMMON_TLV_TYPE,
1280 },
1281 };
1282
1283 static struct qmi_elem_info qmi_wlanfw_wlan_mode_req_msg_v01_ei[] = {
1284 {
1285 .data_type = QMI_UNSIGNED_4_BYTE,
1286 .elem_len = 1,
1287 .elem_size = sizeof(u32),
1288 .array_type = NO_ARRAY,
1289 .tlv_type = 0x01,
1290 .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1291 mode),
1292 },
1293 {
1294 .data_type = QMI_OPT_FLAG,
1295 .elem_len = 1,
1296 .elem_size = sizeof(u8),
1297 .array_type = NO_ARRAY,
1298 .tlv_type = 0x10,
1299 .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1300 hw_debug_valid),
1301 },
1302 {
1303 .data_type = QMI_UNSIGNED_1_BYTE,
1304 .elem_len = 1,
1305 .elem_size = sizeof(u8),
1306 .array_type = NO_ARRAY,
1307 .tlv_type = 0x10,
1308 .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1309 hw_debug),
1310 },
1311 {
1312 .data_type = QMI_EOTI,
1313 .array_type = NO_ARRAY,
1314 .tlv_type = QMI_COMMON_TLV_TYPE,
1315 },
1316 };
1317
1318 static struct qmi_elem_info qmi_wlanfw_wlan_mode_resp_msg_v01_ei[] = {
1319 {
1320 .data_type = QMI_STRUCT,
1321 .elem_len = 1,
1322 .elem_size = sizeof(struct qmi_response_type_v01),
1323 .array_type = NO_ARRAY,
1324 .tlv_type = 0x02,
1325 .offset = offsetof(struct qmi_wlanfw_wlan_mode_resp_msg_v01,
1326 resp),
1327 .ei_array = qmi_response_type_v01_ei,
1328 },
1329 {
1330 .data_type = QMI_EOTI,
1331 .array_type = NO_ARRAY,
1332 .tlv_type = QMI_COMMON_TLV_TYPE,
1333 },
1334 };
1335
1336 static struct qmi_elem_info qmi_wlanfw_wlan_cfg_req_msg_v01_ei[] = {
1337 {
1338 .data_type = QMI_OPT_FLAG,
1339 .elem_len = 1,
1340 .elem_size = sizeof(u8),
1341 .array_type = NO_ARRAY,
1342 .tlv_type = 0x10,
1343 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1344 host_version_valid),
1345 },
1346 {
1347 .data_type = QMI_STRING,
1348 .elem_len = QMI_WLANFW_MAX_STR_LEN_V01 + 1,
1349 .elem_size = sizeof(char),
1350 .array_type = NO_ARRAY,
1351 .tlv_type = 0x10,
1352 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1353 host_version),
1354 },
1355 {
1356 .data_type = QMI_OPT_FLAG,
1357 .elem_len = 1,
1358 .elem_size = sizeof(u8),
1359 .array_type = NO_ARRAY,
1360 .tlv_type = 0x11,
1361 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1362 tgt_cfg_valid),
1363 },
1364 {
1365 .data_type = QMI_DATA_LEN,
1366 .elem_len = 1,
1367 .elem_size = sizeof(u8),
1368 .array_type = NO_ARRAY,
1369 .tlv_type = 0x11,
1370 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1371 tgt_cfg_len),
1372 },
1373 {
1374 .data_type = QMI_STRUCT,
1375 .elem_len = QMI_WLANFW_MAX_NUM_CE_V01,
1376 .elem_size = sizeof(
1377 struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01),
1378 .array_type = VAR_LEN_ARRAY,
1379 .tlv_type = 0x11,
1380 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1381 tgt_cfg),
1382 .ei_array = qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei,
1383 },
1384 {
1385 .data_type = QMI_OPT_FLAG,
1386 .elem_len = 1,
1387 .elem_size = sizeof(u8),
1388 .array_type = NO_ARRAY,
1389 .tlv_type = 0x12,
1390 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1391 svc_cfg_valid),
1392 },
1393 {
1394 .data_type = QMI_DATA_LEN,
1395 .elem_len = 1,
1396 .elem_size = sizeof(u8),
1397 .array_type = NO_ARRAY,
1398 .tlv_type = 0x12,
1399 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1400 svc_cfg_len),
1401 },
1402 {
1403 .data_type = QMI_STRUCT,
1404 .elem_len = QMI_WLANFW_MAX_NUM_SVC_V01,
1405 .elem_size = sizeof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01),
1406 .array_type = VAR_LEN_ARRAY,
1407 .tlv_type = 0x12,
1408 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1409 svc_cfg),
1410 .ei_array = qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei,
1411 },
1412 {
1413 .data_type = QMI_OPT_FLAG,
1414 .elem_len = 1,
1415 .elem_size = sizeof(u8),
1416 .array_type = NO_ARRAY,
1417 .tlv_type = 0x13,
1418 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1419 shadow_reg_valid),
1420 },
1421 {
1422 .data_type = QMI_DATA_LEN,
1423 .elem_len = 1,
1424 .elem_size = sizeof(u8),
1425 .array_type = NO_ARRAY,
1426 .tlv_type = 0x13,
1427 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1428 shadow_reg_len),
1429 },
1430 {
1431 .data_type = QMI_STRUCT,
1432 .elem_len = QMI_WLANFW_MAX_NUM_SHADOW_REG_V01,
1433 .elem_size = sizeof(struct qmi_wlanfw_shadow_reg_cfg_s_v01),
1434 .array_type = VAR_LEN_ARRAY,
1435 .tlv_type = 0x13,
1436 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1437 shadow_reg),
1438 .ei_array = qmi_wlanfw_shadow_reg_cfg_s_v01_ei,
1439 },
1440 {
1441 .data_type = QMI_OPT_FLAG,
1442 .elem_len = 1,
1443 .elem_size = sizeof(u8),
1444 .array_type = NO_ARRAY,
1445 .tlv_type = 0x14,
1446 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1447 shadow_reg_v2_valid),
1448 },
1449 {
1450 .data_type = QMI_DATA_LEN,
1451 .elem_len = 1,
1452 .elem_size = sizeof(u8),
1453 .array_type = NO_ARRAY,
1454 .tlv_type = 0x14,
1455 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1456 shadow_reg_v2_len),
1457 },
1458 {
1459 .data_type = QMI_STRUCT,
1460 .elem_len = QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01,
1461 .elem_size = sizeof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01),
1462 .array_type = VAR_LEN_ARRAY,
1463 .tlv_type = 0x14,
1464 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1465 shadow_reg_v2),
1466 .ei_array = qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei,
1467 },
1468 {
1469 .data_type = QMI_EOTI,
1470 .array_type = NO_ARRAY,
1471 .tlv_type = QMI_COMMON_TLV_TYPE,
1472 },
1473 };
1474
1475 static struct qmi_elem_info qmi_wlanfw_wlan_cfg_resp_msg_v01_ei[] = {
1476 {
1477 .data_type = QMI_STRUCT,
1478 .elem_len = 1,
1479 .elem_size = sizeof(struct qmi_response_type_v01),
1480 .array_type = NO_ARRAY,
1481 .tlv_type = 0x02,
1482 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_resp_msg_v01, resp),
1483 .ei_array = qmi_response_type_v01_ei,
1484 },
1485 {
1486 .data_type = QMI_EOTI,
1487 .array_type = NO_ARRAY,
1488 .tlv_type = QMI_COMMON_TLV_TYPE,
1489 },
1490 };
1491
1492 static struct qmi_elem_info qmi_wlanfw_mem_ready_ind_msg_v01_ei[] = {
1493 {
1494 .data_type = QMI_EOTI,
1495 .array_type = NO_ARRAY,
1496 },
1497 };
1498
1499 static struct qmi_elem_info qmi_wlanfw_fw_ready_ind_msg_v01_ei[] = {
1500 {
1501 .data_type = QMI_EOTI,
1502 .array_type = NO_ARRAY,
1503 },
1504 };
1505
1506 static struct qmi_elem_info qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei[] = {
1507 {
1508 .data_type = QMI_EOTI,
1509 .array_type = NO_ARRAY,
1510 },
1511 };
1512
ath11k_qmi_host_cap_send(struct ath11k_base * ab)1513 static int ath11k_qmi_host_cap_send(struct ath11k_base *ab)
1514 {
1515 struct qmi_wlanfw_host_cap_req_msg_v01 req;
1516 struct qmi_wlanfw_host_cap_resp_msg_v01 resp;
1517 struct qmi_txn txn = {};
1518 int ret = 0;
1519
1520 memset(&req, 0, sizeof(req));
1521 memset(&resp, 0, sizeof(resp));
1522
1523 req.num_clients_valid = 1;
1524 req.num_clients = 1;
1525 req.mem_cfg_mode = ab->qmi.target_mem_mode;
1526 req.mem_cfg_mode_valid = 1;
1527 req.bdf_support_valid = 1;
1528 req.bdf_support = 1;
1529
1530 if (ab->bus_params.m3_fw_support) {
1531 req.m3_support_valid = 1;
1532 req.m3_support = 1;
1533 req.m3_cache_support_valid = 1;
1534 req.m3_cache_support = 1;
1535 } else {
1536 req.m3_support_valid = 0;
1537 req.m3_support = 0;
1538 req.m3_cache_support_valid = 0;
1539 req.m3_cache_support = 0;
1540 }
1541
1542 req.cal_done_valid = 1;
1543 req.cal_done = ab->qmi.cal_done;
1544
1545 if (ab->hw_params.internal_sleep_clock) {
1546 req.nm_modem_valid = 1;
1547
1548 /* Notify firmware that this is non-qualcomm platform. */
1549 req.nm_modem |= HOST_CSTATE_BIT;
1550
1551 /* Notify firmware about the sleep clock selection,
1552 * nm_modem_bit[1] is used for this purpose. Host driver on
1553 * non-qualcomm platforms should select internal sleep
1554 * clock.
1555 */
1556 req.nm_modem |= SLEEP_CLOCK_SELECT_INTERNAL_BIT;
1557 }
1558
1559 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi host cap request\n");
1560
1561 ret = qmi_txn_init(&ab->qmi.handle, &txn,
1562 qmi_wlanfw_host_cap_resp_msg_v01_ei, &resp);
1563 if (ret < 0)
1564 goto out;
1565
1566 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1567 QMI_WLANFW_HOST_CAP_REQ_V01,
1568 QMI_WLANFW_HOST_CAP_REQ_MSG_V01_MAX_LEN,
1569 qmi_wlanfw_host_cap_req_msg_v01_ei, &req);
1570 if (ret < 0) {
1571 ath11k_warn(ab, "failed to send host capability request: %d\n", ret);
1572 goto out;
1573 }
1574
1575 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1576 if (ret < 0)
1577 goto out;
1578
1579 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1580 ath11k_warn(ab, "host capability request failed: %d %d\n",
1581 resp.resp.result, resp.resp.error);
1582 ret = -EINVAL;
1583 goto out;
1584 }
1585
1586 out:
1587 return ret;
1588 }
1589
ath11k_qmi_fw_ind_register_send(struct ath11k_base * ab)1590 static int ath11k_qmi_fw_ind_register_send(struct ath11k_base *ab)
1591 {
1592 struct qmi_wlanfw_ind_register_req_msg_v01 *req;
1593 struct qmi_wlanfw_ind_register_resp_msg_v01 *resp;
1594 struct qmi_handle *handle = &ab->qmi.handle;
1595 struct qmi_txn txn;
1596 int ret;
1597
1598 req = kzalloc(sizeof(*req), GFP_KERNEL);
1599 if (!req)
1600 return -ENOMEM;
1601
1602 resp = kzalloc(sizeof(*resp), GFP_KERNEL);
1603 if (!resp) {
1604 ret = -ENOMEM;
1605 goto resp_out;
1606 }
1607
1608 req->client_id_valid = 1;
1609 req->client_id = QMI_WLANFW_CLIENT_ID;
1610 req->fw_ready_enable_valid = 1;
1611 req->fw_ready_enable = 1;
1612 req->request_mem_enable_valid = 1;
1613 req->request_mem_enable = 1;
1614 req->fw_mem_ready_enable_valid = 1;
1615 req->fw_mem_ready_enable = 1;
1616 req->cal_done_enable_valid = 1;
1617 req->cal_done_enable = 1;
1618 req->fw_init_done_enable_valid = 1;
1619 req->fw_init_done_enable = 1;
1620
1621 req->pin_connect_result_enable_valid = 0;
1622 req->pin_connect_result_enable = 0;
1623
1624 ret = qmi_txn_init(handle, &txn,
1625 qmi_wlanfw_ind_register_resp_msg_v01_ei, resp);
1626 if (ret < 0)
1627 goto out;
1628
1629 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi indication register request\n");
1630
1631 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1632 QMI_WLANFW_IND_REGISTER_REQ_V01,
1633 QMI_WLANFW_IND_REGISTER_REQ_MSG_V01_MAX_LEN,
1634 qmi_wlanfw_ind_register_req_msg_v01_ei, req);
1635 if (ret < 0) {
1636 ath11k_warn(ab, "failed to send indication register request: %d\n",
1637 ret);
1638 goto out;
1639 }
1640
1641 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1642 if (ret < 0) {
1643 ath11k_warn(ab, "failed to register fw indication: %d\n", ret);
1644 goto out;
1645 }
1646
1647 if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
1648 ath11k_warn(ab, "firmware indication register request failed: %d %d\n",
1649 resp->resp.result, resp->resp.error);
1650 ret = -EINVAL;
1651 goto out;
1652 }
1653
1654 out:
1655 kfree(resp);
1656 resp_out:
1657 kfree(req);
1658 return ret;
1659 }
1660
ath11k_qmi_respond_fw_mem_request(struct ath11k_base * ab)1661 static int ath11k_qmi_respond_fw_mem_request(struct ath11k_base *ab)
1662 {
1663 struct qmi_wlanfw_respond_mem_req_msg_v01 *req;
1664 struct qmi_wlanfw_respond_mem_resp_msg_v01 resp;
1665 struct qmi_txn txn = {};
1666 int ret = 0, i;
1667 bool delayed;
1668
1669 req = kzalloc(sizeof(*req), GFP_KERNEL);
1670 if (!req)
1671 return -ENOMEM;
1672
1673 memset(&resp, 0, sizeof(resp));
1674
1675 /* For QCA6390 by default FW requests a block of ~4M contiguous
1676 * DMA memory, it's hard to allocate from OS. So host returns
1677 * failure to FW and FW will then request mulitple blocks of small
1678 * chunk size memory.
1679 */
1680 if (!ab->bus_params.fixed_mem_region && ab->qmi.target_mem_delayed) {
1681 delayed = true;
1682 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi delays mem_request %d\n",
1683 ab->qmi.mem_seg_count);
1684 memset(req, 0, sizeof(*req));
1685 } else {
1686 delayed = false;
1687 req->mem_seg_len = ab->qmi.mem_seg_count;
1688
1689 for (i = 0; i < req->mem_seg_len ; i++) {
1690 req->mem_seg[i].addr = ab->qmi.target_mem[i].paddr;
1691 req->mem_seg[i].size = ab->qmi.target_mem[i].size;
1692 req->mem_seg[i].type = ab->qmi.target_mem[i].type;
1693 ath11k_dbg(ab, ATH11K_DBG_QMI,
1694 "qmi req mem_seg[%d] %pad %u %u\n", i,
1695 &ab->qmi.target_mem[i].paddr,
1696 ab->qmi.target_mem[i].size,
1697 ab->qmi.target_mem[i].type);
1698 }
1699 }
1700
1701 ret = qmi_txn_init(&ab->qmi.handle, &txn,
1702 qmi_wlanfw_respond_mem_resp_msg_v01_ei, &resp);
1703 if (ret < 0)
1704 goto out;
1705
1706 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi respond memory request delayed %i\n",
1707 delayed);
1708
1709 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1710 QMI_WLANFW_RESPOND_MEM_REQ_V01,
1711 QMI_WLANFW_RESPOND_MEM_REQ_MSG_V01_MAX_LEN,
1712 qmi_wlanfw_respond_mem_req_msg_v01_ei, req);
1713 if (ret < 0) {
1714 ath11k_warn(ab, "failed to respond qmi memory request: %d\n",
1715 ret);
1716 goto out;
1717 }
1718
1719 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1720 if (ret < 0) {
1721 ath11k_warn(ab, "failed to wait qmi memory request: %d\n", ret);
1722 goto out;
1723 }
1724
1725 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1726 /* the error response is expected when
1727 * target_mem_delayed is true.
1728 */
1729 if (delayed && resp.resp.error == 0)
1730 goto out;
1731
1732 ath11k_warn(ab, "qmi respond memory request failed: %d %d\n",
1733 resp.resp.result, resp.resp.error);
1734 ret = -EINVAL;
1735 goto out;
1736 }
1737 out:
1738 kfree(req);
1739 return ret;
1740 }
1741
ath11k_qmi_free_target_mem_chunk(struct ath11k_base * ab)1742 static void ath11k_qmi_free_target_mem_chunk(struct ath11k_base *ab)
1743 {
1744 int i;
1745
1746 if (ab->bus_params.fixed_mem_region)
1747 return;
1748
1749 for (i = 0; i < ab->qmi.mem_seg_count; i++) {
1750 if (!ab->qmi.target_mem[i].vaddr)
1751 continue;
1752
1753 dma_free_coherent(ab->dev,
1754 ab->qmi.target_mem[i].size,
1755 ab->qmi.target_mem[i].vaddr,
1756 ab->qmi.target_mem[i].paddr);
1757 ab->qmi.target_mem[i].vaddr = NULL;
1758 }
1759 }
1760
ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base * ab)1761 static int ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base *ab)
1762 {
1763 int i;
1764 struct target_mem_chunk *chunk;
1765
1766 ab->qmi.target_mem_delayed = false;
1767
1768 for (i = 0; i < ab->qmi.mem_seg_count; i++) {
1769 chunk = &ab->qmi.target_mem[i];
1770 chunk->vaddr = dma_alloc_coherent(ab->dev,
1771 chunk->size,
1772 &chunk->paddr,
1773 GFP_KERNEL);
1774 if (!chunk->vaddr) {
1775 if (ab->qmi.mem_seg_count <= ATH11K_QMI_FW_MEM_REQ_SEGMENT_CNT) {
1776 ath11k_dbg(ab, ATH11K_DBG_QMI,
1777 "qmi dma allocation failed (%d B type %u), will try later with small size\n",
1778 chunk->size,
1779 chunk->type);
1780 ath11k_qmi_free_target_mem_chunk(ab);
1781 ab->qmi.target_mem_delayed = true;
1782 return 0;
1783 }
1784
1785 ath11k_err(ab, "failed to allocate dma memory for qmi (%d B type %u)\n",
1786 chunk->size,
1787 chunk->type);
1788 return -EINVAL;
1789 }
1790 }
1791
1792 return 0;
1793 }
1794
ath11k_qmi_assign_target_mem_chunk(struct ath11k_base * ab)1795 static int ath11k_qmi_assign_target_mem_chunk(struct ath11k_base *ab)
1796 {
1797 int i, idx;
1798
1799 for (i = 0, idx = 0; i < ab->qmi.mem_seg_count; i++) {
1800 switch (ab->qmi.target_mem[i].type) {
1801 case BDF_MEM_REGION_TYPE:
1802 ab->qmi.target_mem[idx].paddr = ab->hw_params.bdf_addr;
1803 ab->qmi.target_mem[idx].vaddr = NULL;
1804 ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
1805 ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
1806 idx++;
1807 break;
1808 case CALDB_MEM_REGION_TYPE:
1809 if (ab->qmi.target_mem[i].size > ATH11K_QMI_CALDB_SIZE) {
1810 ath11k_warn(ab, "qmi mem size is low to load caldata\n");
1811 return -EINVAL;
1812 }
1813
1814 if (ath11k_cold_boot_cal && ab->hw_params.cold_boot_calib) {
1815 ab->qmi.target_mem[idx].paddr =
1816 ATH11K_QMI_CALDB_ADDRESS;
1817 ab->qmi.target_mem[idx].vaddr =
1818 (void *)ATH11K_QMI_CALDB_ADDRESS;
1819 } else {
1820 ab->qmi.target_mem[idx].paddr = 0;
1821 ab->qmi.target_mem[idx].vaddr = NULL;
1822 }
1823 ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
1824 ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
1825 idx++;
1826 break;
1827 default:
1828 ath11k_warn(ab, "qmi ignore invalid mem req type %d\n",
1829 ab->qmi.target_mem[i].type);
1830 break;
1831 }
1832 }
1833 ab->qmi.mem_seg_count = idx;
1834
1835 return 0;
1836 }
1837
ath11k_qmi_request_target_cap(struct ath11k_base * ab)1838 static int ath11k_qmi_request_target_cap(struct ath11k_base *ab)
1839 {
1840 struct qmi_wlanfw_cap_req_msg_v01 req;
1841 struct qmi_wlanfw_cap_resp_msg_v01 resp;
1842 struct qmi_txn txn = {};
1843 int ret = 0;
1844 int r;
1845
1846 memset(&req, 0, sizeof(req));
1847 memset(&resp, 0, sizeof(resp));
1848
1849 ret = qmi_txn_init(&ab->qmi.handle, &txn,
1850 qmi_wlanfw_cap_resp_msg_v01_ei, &resp);
1851 if (ret < 0)
1852 goto out;
1853
1854 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi target cap request\n");
1855
1856 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1857 QMI_WLANFW_CAP_REQ_V01,
1858 QMI_WLANFW_CAP_REQ_MSG_V01_MAX_LEN,
1859 qmi_wlanfw_cap_req_msg_v01_ei, &req);
1860 if (ret < 0) {
1861 ath11k_warn(ab, "failed to send qmi cap request: %d\n",
1862 ret);
1863 goto out;
1864 }
1865
1866 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1867 if (ret < 0) {
1868 ath11k_warn(ab, "failed to wait qmi cap request: %d\n", ret);
1869 goto out;
1870 }
1871
1872 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1873 ath11k_warn(ab, "qmi cap request failed: %d %d\n",
1874 resp.resp.result, resp.resp.error);
1875 ret = -EINVAL;
1876 goto out;
1877 }
1878
1879 if (resp.chip_info_valid) {
1880 ab->qmi.target.chip_id = resp.chip_info.chip_id;
1881 ab->qmi.target.chip_family = resp.chip_info.chip_family;
1882 }
1883
1884 if (resp.board_info_valid)
1885 ab->qmi.target.board_id = resp.board_info.board_id;
1886 else
1887 ab->qmi.target.board_id = 0xFF;
1888
1889 if (resp.soc_info_valid)
1890 ab->qmi.target.soc_id = resp.soc_info.soc_id;
1891
1892 if (resp.fw_version_info_valid) {
1893 ab->qmi.target.fw_version = resp.fw_version_info.fw_version;
1894 strlcpy(ab->qmi.target.fw_build_timestamp,
1895 resp.fw_version_info.fw_build_timestamp,
1896 sizeof(ab->qmi.target.fw_build_timestamp));
1897 }
1898
1899 if (resp.fw_build_id_valid)
1900 strlcpy(ab->qmi.target.fw_build_id, resp.fw_build_id,
1901 sizeof(ab->qmi.target.fw_build_id));
1902
1903 ath11k_info(ab, "chip_id 0x%x chip_family 0x%x board_id 0x%x soc_id 0x%x\n",
1904 ab->qmi.target.chip_id, ab->qmi.target.chip_family,
1905 ab->qmi.target.board_id, ab->qmi.target.soc_id);
1906
1907 ath11k_info(ab, "fw_version 0x%x fw_build_timestamp %s fw_build_id %s",
1908 ab->qmi.target.fw_version,
1909 ab->qmi.target.fw_build_timestamp,
1910 ab->qmi.target.fw_build_id);
1911
1912 r = ath11k_core_check_dt(ab);
1913 if (r)
1914 ath11k_dbg(ab, ATH11K_DBG_QMI, "DT bdf variant name not set.\n");
1915
1916 out:
1917 return ret;
1918 }
1919
1920 static int
ath11k_qmi_prepare_bdf_download(struct ath11k_base * ab,int type,struct qmi_wlanfw_bdf_download_req_msg_v01 * req,void __iomem * bdf_addr)1921 ath11k_qmi_prepare_bdf_download(struct ath11k_base *ab, int type,
1922 struct qmi_wlanfw_bdf_download_req_msg_v01 *req,
1923 void __iomem *bdf_addr)
1924 {
1925 const struct firmware *fw_entry;
1926 struct ath11k_board_data bd;
1927 u32 fw_size;
1928 int ret;
1929
1930 switch (type) {
1931 case ATH11K_QMI_FILE_TYPE_BDF_GOLDEN:
1932 memset(&bd, 0, sizeof(bd));
1933
1934 ret = ath11k_core_fetch_bdf(ab, &bd);
1935 if (ret) {
1936 ath11k_warn(ab, "failed to load board file: %d\n", ret);
1937 return ret;
1938 }
1939
1940 fw_size = min_t(u32, ab->hw_params.fw.board_size, bd.len);
1941 memcpy_toio(bdf_addr, bd.data, fw_size);
1942 ath11k_core_free_bdf(ab, &bd);
1943 break;
1944 case ATH11K_QMI_FILE_TYPE_CALDATA:
1945 fw_entry = ath11k_core_firmware_request(ab, ATH11K_DEFAULT_CAL_FILE);
1946 if (IS_ERR(fw_entry)) {
1947 ret = PTR_ERR(fw_entry);
1948 ath11k_warn(ab, "failed to load %s: %d\n",
1949 ATH11K_DEFAULT_CAL_FILE, ret);
1950 return ret;
1951 }
1952
1953 fw_size = min_t(u32, ab->hw_params.fw.board_size,
1954 fw_entry->size);
1955
1956 memcpy_toio(bdf_addr + ATH11K_QMI_CALDATA_OFFSET,
1957 fw_entry->data, fw_size);
1958
1959 release_firmware(fw_entry);
1960 break;
1961 default:
1962 return -EINVAL;
1963 }
1964
1965 req->total_size = fw_size;
1966 return 0;
1967 }
1968
ath11k_qmi_load_bdf_fixed_addr(struct ath11k_base * ab)1969 static int ath11k_qmi_load_bdf_fixed_addr(struct ath11k_base *ab)
1970 {
1971 struct qmi_wlanfw_bdf_download_req_msg_v01 *req;
1972 struct qmi_wlanfw_bdf_download_resp_msg_v01 resp;
1973 struct qmi_txn txn = {};
1974 void __iomem *bdf_addr = NULL;
1975 int type, ret;
1976
1977 req = kzalloc(sizeof(*req), GFP_KERNEL);
1978 if (!req)
1979 return -ENOMEM;
1980 memset(&resp, 0, sizeof(resp));
1981
1982 bdf_addr = ioremap(ab->hw_params.bdf_addr, ATH11K_QMI_BDF_MAX_SIZE);
1983 if (!bdf_addr) {
1984 ath11k_warn(ab, "failed ioremap for board file\n");
1985 ret = -EIO;
1986 goto out;
1987 }
1988
1989 for (type = 0; type < ATH11K_QMI_MAX_FILE_TYPE; type++) {
1990 req->valid = 1;
1991 req->file_id_valid = 1;
1992 req->file_id = ab->qmi.target.board_id;
1993 req->total_size_valid = 1;
1994 req->seg_id_valid = 1;
1995 req->seg_id = type;
1996 req->data_valid = 0;
1997 req->data_len = ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE;
1998 req->bdf_type = 0;
1999 req->bdf_type_valid = 0;
2000 req->end_valid = 1;
2001 req->end = 1;
2002
2003 ret = ath11k_qmi_prepare_bdf_download(ab, type, req, bdf_addr);
2004 if (ret < 0)
2005 goto out_qmi_bdf;
2006
2007 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2008 qmi_wlanfw_bdf_download_resp_msg_v01_ei,
2009 &resp);
2010 if (ret < 0)
2011 goto out_qmi_bdf;
2012
2013 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi bdf download req fixed addr type %d\n",
2014 type);
2015
2016 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2017 QMI_WLANFW_BDF_DOWNLOAD_REQ_V01,
2018 QMI_WLANFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_LEN,
2019 qmi_wlanfw_bdf_download_req_msg_v01_ei, req);
2020 if (ret < 0) {
2021 qmi_txn_cancel(&txn);
2022 goto out_qmi_bdf;
2023 }
2024
2025 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2026 if (ret < 0)
2027 goto out_qmi_bdf;
2028
2029 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2030 ath11k_warn(ab, "board file download request failed: %d %d\n",
2031 resp.resp.result, resp.resp.error);
2032 ret = -EINVAL;
2033 goto out_qmi_bdf;
2034 }
2035 }
2036
2037 out_qmi_bdf:
2038 iounmap(bdf_addr);
2039 out:
2040 kfree(req);
2041 return ret;
2042 }
2043
ath11k_qmi_load_bdf_qmi(struct ath11k_base * ab)2044 static int ath11k_qmi_load_bdf_qmi(struct ath11k_base *ab)
2045 {
2046 struct qmi_wlanfw_bdf_download_req_msg_v01 *req;
2047 struct qmi_wlanfw_bdf_download_resp_msg_v01 resp;
2048 struct ath11k_board_data bd;
2049 unsigned int remaining;
2050 struct qmi_txn txn = {};
2051 int ret;
2052 const u8 *temp;
2053 int bdf_type;
2054
2055 req = kzalloc(sizeof(*req), GFP_KERNEL);
2056 if (!req)
2057 return -ENOMEM;
2058 memset(&resp, 0, sizeof(resp));
2059
2060 memset(&bd, 0, sizeof(bd));
2061 ret = ath11k_core_fetch_bdf(ab, &bd);
2062 if (ret) {
2063 ath11k_warn(ab, "failed to fetch board file: %d\n", ret);
2064 goto out;
2065 }
2066
2067 temp = bd.data;
2068 remaining = bd.len;
2069
2070 if (bd.len >= SELFMAG && memcmp(bd.data, ELFMAG, SELFMAG) == 0)
2071 bdf_type = ATH11K_QMI_BDF_TYPE_ELF;
2072 else
2073 bdf_type = ATH11K_QMI_BDF_TYPE_BIN;
2074
2075 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi bdf_type %d\n", bdf_type);
2076
2077 while (remaining) {
2078 req->valid = 1;
2079 req->file_id_valid = 1;
2080 req->file_id = ab->qmi.target.board_id;
2081 req->total_size_valid = 1;
2082 req->total_size = bd.len;
2083 req->seg_id_valid = 1;
2084 req->data_valid = 1;
2085 req->data_len = ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE;
2086 req->bdf_type = bdf_type;
2087 req->bdf_type_valid = 1;
2088 req->end_valid = 1;
2089 req->end = 0;
2090
2091 if (remaining > QMI_WLANFW_MAX_DATA_SIZE_V01) {
2092 req->data_len = QMI_WLANFW_MAX_DATA_SIZE_V01;
2093 } else {
2094 req->data_len = remaining;
2095 req->end = 1;
2096 }
2097
2098 memcpy(req->data, temp, req->data_len);
2099
2100 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2101 qmi_wlanfw_bdf_download_resp_msg_v01_ei,
2102 &resp);
2103 if (ret < 0)
2104 goto out_qmi_bdf;
2105
2106 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi bdf download request remaining %i\n",
2107 remaining);
2108
2109 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2110 QMI_WLANFW_BDF_DOWNLOAD_REQ_V01,
2111 QMI_WLANFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_LEN,
2112 qmi_wlanfw_bdf_download_req_msg_v01_ei, req);
2113 if (ret < 0) {
2114 qmi_txn_cancel(&txn);
2115 goto out_qmi_bdf;
2116 }
2117
2118 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2119 if (ret < 0)
2120 goto out_qmi_bdf;
2121
2122 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2123 ath11k_warn(ab, "bdf download request failed: %d %d\n",
2124 resp.resp.result, resp.resp.error);
2125 ret = resp.resp.result;
2126 goto out_qmi_bdf;
2127 }
2128 remaining -= req->data_len;
2129 temp += req->data_len;
2130 req->seg_id++;
2131 }
2132
2133 out_qmi_bdf:
2134 ath11k_core_free_bdf(ab, &bd);
2135
2136 out:
2137 kfree(req);
2138 return ret;
2139 }
2140
ath11k_qmi_m3_load(struct ath11k_base * ab)2141 static int ath11k_qmi_m3_load(struct ath11k_base *ab)
2142 {
2143 struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2144 const struct firmware *fw;
2145 char path[100];
2146 int ret;
2147
2148 if (m3_mem->vaddr || m3_mem->size)
2149 return 0;
2150
2151 fw = ath11k_core_firmware_request(ab, ATH11K_M3_FILE);
2152 if (IS_ERR(fw)) {
2153 ret = PTR_ERR(fw);
2154 ath11k_core_create_firmware_path(ab, ATH11K_M3_FILE,
2155 path, sizeof(path));
2156 ath11k_err(ab, "failed to load %s: %d\n", path, ret);
2157 return ret;
2158 }
2159
2160 m3_mem->vaddr = dma_alloc_coherent(ab->dev,
2161 fw->size, &m3_mem->paddr,
2162 GFP_KERNEL);
2163 if (!m3_mem->vaddr) {
2164 ath11k_err(ab, "failed to allocate memory for M3 with size %zu\n",
2165 fw->size);
2166 release_firmware(fw);
2167 return -ENOMEM;
2168 }
2169
2170 memcpy(m3_mem->vaddr, fw->data, fw->size);
2171 m3_mem->size = fw->size;
2172 release_firmware(fw);
2173
2174 return 0;
2175 }
2176
ath11k_qmi_m3_free(struct ath11k_base * ab)2177 static void ath11k_qmi_m3_free(struct ath11k_base *ab)
2178 {
2179 struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2180
2181 if (!ab->bus_params.m3_fw_support || !m3_mem->vaddr)
2182 return;
2183
2184 dma_free_coherent(ab->dev, m3_mem->size,
2185 m3_mem->vaddr, m3_mem->paddr);
2186 m3_mem->vaddr = NULL;
2187 }
2188
ath11k_qmi_wlanfw_m3_info_send(struct ath11k_base * ab)2189 static int ath11k_qmi_wlanfw_m3_info_send(struct ath11k_base *ab)
2190 {
2191 struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2192 struct qmi_wlanfw_m3_info_req_msg_v01 req;
2193 struct qmi_wlanfw_m3_info_resp_msg_v01 resp;
2194 struct qmi_txn txn = {};
2195 int ret = 0;
2196
2197 memset(&req, 0, sizeof(req));
2198 memset(&resp, 0, sizeof(resp));
2199
2200 if (ab->bus_params.m3_fw_support) {
2201 ret = ath11k_qmi_m3_load(ab);
2202 if (ret) {
2203 ath11k_err(ab, "failed to load m3 firmware: %d", ret);
2204 return ret;
2205 }
2206
2207 req.addr = m3_mem->paddr;
2208 req.size = m3_mem->size;
2209 } else {
2210 req.addr = 0;
2211 req.size = 0;
2212 }
2213
2214 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2215 qmi_wlanfw_m3_info_resp_msg_v01_ei, &resp);
2216 if (ret < 0)
2217 goto out;
2218
2219 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi m3 info req\n");
2220
2221 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2222 QMI_WLANFW_M3_INFO_REQ_V01,
2223 QMI_WLANFW_M3_INFO_REQ_MSG_V01_MAX_MSG_LEN,
2224 qmi_wlanfw_m3_info_req_msg_v01_ei, &req);
2225 if (ret < 0) {
2226 ath11k_warn(ab, "failed to send m3 information 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 m3 information request: %d\n", ret);
2234 goto out;
2235 }
2236
2237 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2238 ath11k_warn(ab, "m3 info request failed: %d %d\n",
2239 resp.resp.result, resp.resp.error);
2240 ret = -EINVAL;
2241 goto out;
2242 }
2243 out:
2244 return ret;
2245 }
2246
ath11k_qmi_wlanfw_mode_send(struct ath11k_base * ab,u32 mode)2247 static int ath11k_qmi_wlanfw_mode_send(struct ath11k_base *ab,
2248 u32 mode)
2249 {
2250 struct qmi_wlanfw_wlan_mode_req_msg_v01 req;
2251 struct qmi_wlanfw_wlan_mode_resp_msg_v01 resp;
2252 struct qmi_txn txn = {};
2253 int ret = 0;
2254
2255 memset(&req, 0, sizeof(req));
2256 memset(&resp, 0, sizeof(resp));
2257
2258 req.mode = mode;
2259 req.hw_debug_valid = 1;
2260 req.hw_debug = 0;
2261
2262 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2263 qmi_wlanfw_wlan_mode_resp_msg_v01_ei, &resp);
2264 if (ret < 0)
2265 goto out;
2266
2267 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wlan mode req mode %d\n", mode);
2268
2269 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2270 QMI_WLANFW_WLAN_MODE_REQ_V01,
2271 QMI_WLANFW_WLAN_MODE_REQ_MSG_V01_MAX_LEN,
2272 qmi_wlanfw_wlan_mode_req_msg_v01_ei, &req);
2273 if (ret < 0) {
2274 ath11k_warn(ab, "failed to send wlan mode request (mode %d): %d\n",
2275 mode, ret);
2276 goto out;
2277 }
2278
2279 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2280 if (ret < 0) {
2281 if (mode == ATH11K_FIRMWARE_MODE_OFF && ret == -ENETRESET) {
2282 ath11k_warn(ab, "WLFW service is dis-connected\n");
2283 return 0;
2284 }
2285 ath11k_warn(ab, "failed to wait wlan mode request (mode %d): %d\n",
2286 mode, ret);
2287 goto out;
2288 }
2289
2290 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2291 ath11k_warn(ab, "wlan mode request failed (mode: %d): %d %d\n",
2292 mode, resp.resp.result, resp.resp.error);
2293 ret = -EINVAL;
2294 goto out;
2295 }
2296
2297 out:
2298 return ret;
2299 }
2300
ath11k_qmi_wlanfw_wlan_cfg_send(struct ath11k_base * ab)2301 static int ath11k_qmi_wlanfw_wlan_cfg_send(struct ath11k_base *ab)
2302 {
2303 struct qmi_wlanfw_wlan_cfg_req_msg_v01 *req;
2304 struct qmi_wlanfw_wlan_cfg_resp_msg_v01 resp;
2305 struct ce_pipe_config *ce_cfg;
2306 struct service_to_pipe *svc_cfg;
2307 struct qmi_txn txn = {};
2308 int ret = 0, pipe_num;
2309
2310 ce_cfg = (struct ce_pipe_config *)ab->qmi.ce_cfg.tgt_ce;
2311 svc_cfg = (struct service_to_pipe *)ab->qmi.ce_cfg.svc_to_ce_map;
2312
2313 req = kzalloc(sizeof(*req), GFP_KERNEL);
2314 if (!req)
2315 return -ENOMEM;
2316
2317 memset(&resp, 0, sizeof(resp));
2318
2319 req->host_version_valid = 1;
2320 strlcpy(req->host_version, ATH11K_HOST_VERSION_STRING,
2321 sizeof(req->host_version));
2322
2323 req->tgt_cfg_valid = 1;
2324 /* This is number of CE configs */
2325 req->tgt_cfg_len = ab->qmi.ce_cfg.tgt_ce_len;
2326 for (pipe_num = 0; pipe_num < req->tgt_cfg_len ; pipe_num++) {
2327 req->tgt_cfg[pipe_num].pipe_num = ce_cfg[pipe_num].pipenum;
2328 req->tgt_cfg[pipe_num].pipe_dir = ce_cfg[pipe_num].pipedir;
2329 req->tgt_cfg[pipe_num].nentries = ce_cfg[pipe_num].nentries;
2330 req->tgt_cfg[pipe_num].nbytes_max = ce_cfg[pipe_num].nbytes_max;
2331 req->tgt_cfg[pipe_num].flags = ce_cfg[pipe_num].flags;
2332 }
2333
2334 req->svc_cfg_valid = 1;
2335 /* This is number of Service/CE configs */
2336 req->svc_cfg_len = ab->qmi.ce_cfg.svc_to_ce_map_len;
2337 for (pipe_num = 0; pipe_num < req->svc_cfg_len; pipe_num++) {
2338 req->svc_cfg[pipe_num].service_id = svc_cfg[pipe_num].service_id;
2339 req->svc_cfg[pipe_num].pipe_dir = svc_cfg[pipe_num].pipedir;
2340 req->svc_cfg[pipe_num].pipe_num = svc_cfg[pipe_num].pipenum;
2341 }
2342 req->shadow_reg_valid = 0;
2343
2344 /* set shadow v2 configuration */
2345 if (ab->hw_params.supports_shadow_regs) {
2346 req->shadow_reg_v2_valid = 1;
2347 req->shadow_reg_v2_len = min_t(u32,
2348 ab->qmi.ce_cfg.shadow_reg_v2_len,
2349 QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01);
2350 memcpy(&req->shadow_reg_v2, ab->qmi.ce_cfg.shadow_reg_v2,
2351 sizeof(u32) * req->shadow_reg_v2_len);
2352 } else {
2353 req->shadow_reg_v2_valid = 0;
2354 }
2355
2356 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2357 qmi_wlanfw_wlan_cfg_resp_msg_v01_ei, &resp);
2358 if (ret < 0)
2359 goto out;
2360
2361 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wlan cfg req\n");
2362
2363 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2364 QMI_WLANFW_WLAN_CFG_REQ_V01,
2365 QMI_WLANFW_WLAN_CFG_REQ_MSG_V01_MAX_LEN,
2366 qmi_wlanfw_wlan_cfg_req_msg_v01_ei, req);
2367 if (ret < 0) {
2368 ath11k_warn(ab, "failed to send wlan config request: %d\n",
2369 ret);
2370 goto out;
2371 }
2372
2373 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2374 if (ret < 0) {
2375 ath11k_warn(ab, "failed to wait wlan config request: %d\n", ret);
2376 goto out;
2377 }
2378
2379 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2380 ath11k_warn(ab, "wlan config request failed: %d %d\n",
2381 resp.resp.result, resp.resp.error);
2382 ret = -EINVAL;
2383 goto out;
2384 }
2385
2386 out:
2387 kfree(req);
2388 return ret;
2389 }
2390
ath11k_qmi_firmware_stop(struct ath11k_base * ab)2391 void ath11k_qmi_firmware_stop(struct ath11k_base *ab)
2392 {
2393 int ret;
2394
2395 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware stop\n");
2396
2397 ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_OFF);
2398 if (ret < 0) {
2399 ath11k_warn(ab, "qmi failed to send wlan mode off: %d\n", ret);
2400 return;
2401 }
2402 }
2403
ath11k_qmi_firmware_start(struct ath11k_base * ab,u32 mode)2404 int ath11k_qmi_firmware_start(struct ath11k_base *ab,
2405 u32 mode)
2406 {
2407 int ret;
2408
2409 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware start\n");
2410
2411 ret = ath11k_qmi_wlanfw_wlan_cfg_send(ab);
2412 if (ret < 0) {
2413 ath11k_warn(ab, "qmi failed to send wlan cfg: %d\n", ret);
2414 return ret;
2415 }
2416
2417 ret = ath11k_qmi_wlanfw_mode_send(ab, mode);
2418 if (ret < 0) {
2419 ath11k_warn(ab, "qmi failed to send wlan fw mode: %d\n", ret);
2420 return ret;
2421 }
2422
2423 return 0;
2424 }
2425
ath11k_qmi_process_coldboot_calibration(struct ath11k_base * ab)2426 static int ath11k_qmi_process_coldboot_calibration(struct ath11k_base *ab)
2427 {
2428 int timeout;
2429 int ret;
2430
2431 ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_COLD_BOOT);
2432 if (ret < 0) {
2433 ath11k_warn(ab, "qmi failed to send wlan fw mode: %d\n", ret);
2434 return ret;
2435 }
2436
2437 ath11k_dbg(ab, ATH11K_DBG_QMI, "Coldboot calibration wait started\n");
2438
2439 timeout = wait_event_timeout(ab->qmi.cold_boot_waitq,
2440 (ab->qmi.cal_done == 1),
2441 ATH11K_COLD_BOOT_FW_RESET_DELAY);
2442 if (timeout <= 0) {
2443 ath11k_warn(ab, "coldboot calibration timed out\n");
2444 return 0;
2445 }
2446
2447 ath11k_dbg(ab, ATH11K_DBG_QMI, "Coldboot calibration done\n");
2448
2449 return 0;
2450 }
2451
2452 static int
ath11k_qmi_driver_event_post(struct ath11k_qmi * qmi,enum ath11k_qmi_event_type type,void * data)2453 ath11k_qmi_driver_event_post(struct ath11k_qmi *qmi,
2454 enum ath11k_qmi_event_type type,
2455 void *data)
2456 {
2457 struct ath11k_qmi_driver_event *event;
2458
2459 event = kzalloc(sizeof(*event), GFP_ATOMIC);
2460 if (!event)
2461 return -ENOMEM;
2462
2463 event->type = type;
2464 event->data = data;
2465
2466 spin_lock(&qmi->event_lock);
2467 list_add_tail(&event->list, &qmi->event_list);
2468 spin_unlock(&qmi->event_lock);
2469
2470 queue_work(qmi->event_wq, &qmi->event_work);
2471
2472 return 0;
2473 }
2474
ath11k_qmi_event_server_arrive(struct ath11k_qmi * qmi)2475 static int ath11k_qmi_event_server_arrive(struct ath11k_qmi *qmi)
2476 {
2477 struct ath11k_base *ab = qmi->ab;
2478 int ret;
2479
2480 ret = ath11k_qmi_fw_ind_register_send(ab);
2481 if (ret < 0) {
2482 ath11k_warn(ab, "failed to send qmi firmware indication: %d\n",
2483 ret);
2484 return ret;
2485 }
2486
2487 ret = ath11k_qmi_host_cap_send(ab);
2488 if (ret < 0) {
2489 ath11k_warn(ab, "failed to send qmi host cap: %d\n", ret);
2490 return ret;
2491 }
2492
2493 return ret;
2494 }
2495
ath11k_qmi_event_mem_request(struct ath11k_qmi * qmi)2496 static int ath11k_qmi_event_mem_request(struct ath11k_qmi *qmi)
2497 {
2498 struct ath11k_base *ab = qmi->ab;
2499 int ret;
2500
2501 ret = ath11k_qmi_respond_fw_mem_request(ab);
2502 if (ret < 0) {
2503 ath11k_warn(ab, "qmi failed to respond fw mem req: %d\n", ret);
2504 return ret;
2505 }
2506
2507 return ret;
2508 }
2509
ath11k_qmi_event_load_bdf(struct ath11k_qmi * qmi)2510 static int ath11k_qmi_event_load_bdf(struct ath11k_qmi *qmi)
2511 {
2512 struct ath11k_base *ab = qmi->ab;
2513 int ret;
2514
2515 ret = ath11k_qmi_request_target_cap(ab);
2516 if (ret < 0) {
2517 ath11k_warn(ab, "failed to request qmi target capabilities: %d\n",
2518 ret);
2519 return ret;
2520 }
2521
2522 if (ab->bus_params.fixed_bdf_addr)
2523 ret = ath11k_qmi_load_bdf_fixed_addr(ab);
2524 else
2525 ret = ath11k_qmi_load_bdf_qmi(ab);
2526 if (ret < 0) {
2527 ath11k_warn(ab, "failed to load board data file: %d\n", ret);
2528 return ret;
2529 }
2530
2531 ret = ath11k_qmi_wlanfw_m3_info_send(ab);
2532 if (ret < 0) {
2533 ath11k_warn(ab, "failed to send qmi m3 info req: %d\n", ret);
2534 return ret;
2535 }
2536
2537 return ret;
2538 }
2539
ath11k_qmi_msg_mem_request_cb(struct qmi_handle * qmi_hdl,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * data)2540 static void ath11k_qmi_msg_mem_request_cb(struct qmi_handle *qmi_hdl,
2541 struct sockaddr_qrtr *sq,
2542 struct qmi_txn *txn,
2543 const void *data)
2544 {
2545 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2546 struct ath11k_base *ab = qmi->ab;
2547 const struct qmi_wlanfw_request_mem_ind_msg_v01 *msg = data;
2548 int i, ret;
2549
2550 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware request memory request\n");
2551
2552 if (msg->mem_seg_len == 0 ||
2553 msg->mem_seg_len > ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01)
2554 ath11k_warn(ab, "invalid memory segment length: %u\n",
2555 msg->mem_seg_len);
2556
2557 ab->qmi.mem_seg_count = msg->mem_seg_len;
2558
2559 for (i = 0; i < qmi->mem_seg_count ; i++) {
2560 ab->qmi.target_mem[i].type = msg->mem_seg[i].type;
2561 ab->qmi.target_mem[i].size = msg->mem_seg[i].size;
2562 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi mem seg type %d size %d\n",
2563 msg->mem_seg[i].type, msg->mem_seg[i].size);
2564 }
2565
2566 if (ab->bus_params.fixed_mem_region) {
2567 ret = ath11k_qmi_assign_target_mem_chunk(ab);
2568 if (ret) {
2569 ath11k_warn(ab, "failed to assign qmi target memory: %d\n",
2570 ret);
2571 return;
2572 }
2573 } else {
2574 ret = ath11k_qmi_alloc_target_mem_chunk(ab);
2575 if (ret) {
2576 ath11k_warn(ab, "failed to allocate qmi target memory: %d\n",
2577 ret);
2578 return;
2579 }
2580 }
2581
2582 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_REQUEST_MEM, NULL);
2583 }
2584
ath11k_qmi_msg_mem_ready_cb(struct qmi_handle * qmi_hdl,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * decoded)2585 static void ath11k_qmi_msg_mem_ready_cb(struct qmi_handle *qmi_hdl,
2586 struct sockaddr_qrtr *sq,
2587 struct qmi_txn *txn,
2588 const void *decoded)
2589 {
2590 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2591 struct ath11k_base *ab = qmi->ab;
2592
2593 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware memory ready indication\n");
2594 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_MEM_READY, NULL);
2595 }
2596
ath11k_qmi_msg_fw_ready_cb(struct qmi_handle * qmi_hdl,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * decoded)2597 static void ath11k_qmi_msg_fw_ready_cb(struct qmi_handle *qmi_hdl,
2598 struct sockaddr_qrtr *sq,
2599 struct qmi_txn *txn,
2600 const void *decoded)
2601 {
2602 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2603 struct ath11k_base *ab = qmi->ab;
2604
2605 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware ready\n");
2606 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_READY, NULL);
2607 }
2608
ath11k_qmi_msg_cold_boot_cal_done_cb(struct qmi_handle * qmi_hdl,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * decoded)2609 static void ath11k_qmi_msg_cold_boot_cal_done_cb(struct qmi_handle *qmi_hdl,
2610 struct sockaddr_qrtr *sq,
2611 struct qmi_txn *txn,
2612 const void *decoded)
2613 {
2614 struct ath11k_qmi *qmi = container_of(qmi_hdl,
2615 struct ath11k_qmi, handle);
2616 struct ath11k_base *ab = qmi->ab;
2617
2618 ab->qmi.cal_done = 1;
2619 wake_up(&ab->qmi.cold_boot_waitq);
2620 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi cold boot calibration done\n");
2621 }
2622
2623 static const struct qmi_msg_handler ath11k_qmi_msg_handlers[] = {
2624 {
2625 .type = QMI_INDICATION,
2626 .msg_id = QMI_WLFW_REQUEST_MEM_IND_V01,
2627 .ei = qmi_wlanfw_request_mem_ind_msg_v01_ei,
2628 .decoded_size = sizeof(struct qmi_wlanfw_request_mem_ind_msg_v01),
2629 .fn = ath11k_qmi_msg_mem_request_cb,
2630 },
2631 {
2632 .type = QMI_INDICATION,
2633 .msg_id = QMI_WLFW_FW_MEM_READY_IND_V01,
2634 .ei = qmi_wlanfw_mem_ready_ind_msg_v01_ei,
2635 .decoded_size = sizeof(struct qmi_wlanfw_fw_mem_ready_ind_msg_v01),
2636 .fn = ath11k_qmi_msg_mem_ready_cb,
2637 },
2638 {
2639 .type = QMI_INDICATION,
2640 .msg_id = QMI_WLFW_FW_READY_IND_V01,
2641 .ei = qmi_wlanfw_fw_ready_ind_msg_v01_ei,
2642 .decoded_size = sizeof(struct qmi_wlanfw_fw_ready_ind_msg_v01),
2643 .fn = ath11k_qmi_msg_fw_ready_cb,
2644 },
2645 {
2646 .type = QMI_INDICATION,
2647 .msg_id = QMI_WLFW_COLD_BOOT_CAL_DONE_IND_V01,
2648 .ei = qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei,
2649 .decoded_size =
2650 sizeof(struct qmi_wlanfw_fw_cold_cal_done_ind_msg_v01),
2651 .fn = ath11k_qmi_msg_cold_boot_cal_done_cb,
2652 },
2653 };
2654
ath11k_qmi_ops_new_server(struct qmi_handle * qmi_hdl,struct qmi_service * service)2655 static int ath11k_qmi_ops_new_server(struct qmi_handle *qmi_hdl,
2656 struct qmi_service *service)
2657 {
2658 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2659 struct ath11k_base *ab = qmi->ab;
2660 struct sockaddr_qrtr *sq = &qmi->sq;
2661 int ret;
2662
2663 sq->sq_family = AF_QIPCRTR;
2664 sq->sq_node = service->node;
2665 sq->sq_port = service->port;
2666
2667 ret = kernel_connect(qmi_hdl->sock, (struct sockaddr *)sq,
2668 sizeof(*sq), 0);
2669 if (ret) {
2670 ath11k_warn(ab, "failed to connect to qmi remote service: %d\n", ret);
2671 return ret;
2672 }
2673
2674 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wifi fw qmi service connected\n");
2675 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_ARRIVE, NULL);
2676
2677 return ret;
2678 }
2679
ath11k_qmi_ops_del_server(struct qmi_handle * qmi_hdl,struct qmi_service * service)2680 static void ath11k_qmi_ops_del_server(struct qmi_handle *qmi_hdl,
2681 struct qmi_service *service)
2682 {
2683 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2684 struct ath11k_base *ab = qmi->ab;
2685
2686 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wifi fw del server\n");
2687 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_EXIT, NULL);
2688 }
2689
2690 static const struct qmi_ops ath11k_qmi_ops = {
2691 .new_server = ath11k_qmi_ops_new_server,
2692 .del_server = ath11k_qmi_ops_del_server,
2693 };
2694
ath11k_qmi_driver_event_work(struct work_struct * work)2695 static void ath11k_qmi_driver_event_work(struct work_struct *work)
2696 {
2697 struct ath11k_qmi *qmi = container_of(work, struct ath11k_qmi,
2698 event_work);
2699 struct ath11k_qmi_driver_event *event;
2700 struct ath11k_base *ab = qmi->ab;
2701 int ret;
2702
2703 spin_lock(&qmi->event_lock);
2704 while (!list_empty(&qmi->event_list)) {
2705 event = list_first_entry(&qmi->event_list,
2706 struct ath11k_qmi_driver_event, list);
2707 list_del(&event->list);
2708 spin_unlock(&qmi->event_lock);
2709
2710 if (test_bit(ATH11K_FLAG_UNREGISTERING, &ab->dev_flags))
2711 return;
2712
2713 switch (event->type) {
2714 case ATH11K_QMI_EVENT_SERVER_ARRIVE:
2715 ret = ath11k_qmi_event_server_arrive(qmi);
2716 if (ret < 0)
2717 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
2718 break;
2719 case ATH11K_QMI_EVENT_SERVER_EXIT:
2720 set_bit(ATH11K_FLAG_CRASH_FLUSH, &ab->dev_flags);
2721 set_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
2722 break;
2723 case ATH11K_QMI_EVENT_REQUEST_MEM:
2724 ret = ath11k_qmi_event_mem_request(qmi);
2725 if (ret < 0)
2726 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
2727 break;
2728 case ATH11K_QMI_EVENT_FW_MEM_READY:
2729 ret = ath11k_qmi_event_load_bdf(qmi);
2730 if (ret < 0)
2731 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
2732 break;
2733 case ATH11K_QMI_EVENT_FW_READY:
2734 clear_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
2735 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) {
2736 ath11k_hal_dump_srng_stats(ab);
2737 queue_work(ab->workqueue, &ab->restart_work);
2738 break;
2739 }
2740
2741 if (ath11k_cold_boot_cal && ab->qmi.cal_done == 0 &&
2742 ab->hw_params.cold_boot_calib) {
2743 ath11k_qmi_process_coldboot_calibration(ab);
2744 } else {
2745 clear_bit(ATH11K_FLAG_CRASH_FLUSH,
2746 &ab->dev_flags);
2747 clear_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
2748 ath11k_core_qmi_firmware_ready(ab);
2749 set_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags);
2750 }
2751
2752 break;
2753 case ATH11K_QMI_EVENT_COLD_BOOT_CAL_DONE:
2754 break;
2755 default:
2756 ath11k_warn(ab, "invalid qmi event type: %d", event->type);
2757 break;
2758 }
2759 kfree(event);
2760 spin_lock(&qmi->event_lock);
2761 }
2762 spin_unlock(&qmi->event_lock);
2763 }
2764
ath11k_qmi_init_service(struct ath11k_base * ab)2765 int ath11k_qmi_init_service(struct ath11k_base *ab)
2766 {
2767 int ret;
2768
2769 memset(&ab->qmi.target, 0, sizeof(struct target_info));
2770 memset(&ab->qmi.target_mem, 0, sizeof(struct target_mem_chunk));
2771 ab->qmi.ab = ab;
2772
2773 ab->qmi.target_mem_mode = ATH11K_QMI_TARGET_MEM_MODE_DEFAULT;
2774 ret = qmi_handle_init(&ab->qmi.handle, ATH11K_QMI_RESP_LEN_MAX,
2775 &ath11k_qmi_ops, ath11k_qmi_msg_handlers);
2776 if (ret < 0) {
2777 ath11k_warn(ab, "failed to initialize qmi handle: %d\n", ret);
2778 return ret;
2779 }
2780
2781 ab->qmi.event_wq = alloc_workqueue("ath11k_qmi_driver_event",
2782 WQ_UNBOUND, 1);
2783 if (!ab->qmi.event_wq) {
2784 ath11k_err(ab, "failed to allocate workqueue\n");
2785 return -EFAULT;
2786 }
2787
2788 INIT_LIST_HEAD(&ab->qmi.event_list);
2789 spin_lock_init(&ab->qmi.event_lock);
2790 INIT_WORK(&ab->qmi.event_work, ath11k_qmi_driver_event_work);
2791
2792 ret = qmi_add_lookup(&ab->qmi.handle, ATH11K_QMI_WLFW_SERVICE_ID_V01,
2793 ATH11K_QMI_WLFW_SERVICE_VERS_V01,
2794 ab->qmi.service_ins_id);
2795 if (ret < 0) {
2796 ath11k_warn(ab, "failed to add qmi lookup: %d\n", ret);
2797 destroy_workqueue(ab->qmi.event_wq);
2798 return ret;
2799 }
2800
2801 return ret;
2802 }
2803
ath11k_qmi_deinit_service(struct ath11k_base * ab)2804 void ath11k_qmi_deinit_service(struct ath11k_base *ab)
2805 {
2806 qmi_handle_release(&ab->qmi.handle);
2807 cancel_work_sync(&ab->qmi.event_work);
2808 destroy_workqueue(ab->qmi.event_wq);
2809 ath11k_qmi_m3_free(ab);
2810 ath11k_qmi_free_target_mem_chunk(ab);
2811 }
2812 EXPORT_SYMBOL(ath11k_qmi_deinit_service);
2813
2814