0001
0002
0003
0004
0005
0006
0007 #include <linux/elf.h>
0008
0009 #include "qmi.h"
0010 #include "core.h"
0011 #include "debug.h"
0012 #include <linux/of.h>
0013 #include <linux/of_address.h>
0014 #include <linux/ioport.h>
0015 #include <linux/firmware.h>
0016 #include <linux/of_device.h>
0017 #include <linux/of_irq.h>
0018
0019 #define SLEEP_CLOCK_SELECT_INTERNAL_BIT 0x02
0020 #define HOST_CSTATE_BIT 0x04
0021 #define PLATFORM_CAP_PCIE_GLOBAL_RESET 0x08
0022
0023 #define FW_BUILD_ID_MASK "QC_IMAGE_VERSION_STRING="
0024
0025 bool ath11k_cold_boot_cal = 1;
0026 EXPORT_SYMBOL(ath11k_cold_boot_cal);
0027 module_param_named(cold_boot_cal, ath11k_cold_boot_cal, bool, 0644);
0028 MODULE_PARM_DESC(cold_boot_cal,
0029 "Decrease the channel switch time but increase the driver load time (Default: true)");
0030
0031 static struct qmi_elem_info qmi_wlanfw_host_cap_req_msg_v01_ei[] = {
0032 {
0033 .data_type = QMI_OPT_FLAG,
0034 .elem_len = 1,
0035 .elem_size = sizeof(u8),
0036 .array_type = NO_ARRAY,
0037 .tlv_type = 0x10,
0038 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0039 num_clients_valid),
0040 },
0041 {
0042 .data_type = QMI_UNSIGNED_4_BYTE,
0043 .elem_len = 1,
0044 .elem_size = sizeof(u32),
0045 .array_type = NO_ARRAY,
0046 .tlv_type = 0x10,
0047 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0048 num_clients),
0049 },
0050 {
0051 .data_type = QMI_OPT_FLAG,
0052 .elem_len = 1,
0053 .elem_size = sizeof(u8),
0054 .array_type = NO_ARRAY,
0055 .tlv_type = 0x11,
0056 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0057 wake_msi_valid),
0058 },
0059 {
0060 .data_type = QMI_UNSIGNED_4_BYTE,
0061 .elem_len = 1,
0062 .elem_size = sizeof(u32),
0063 .array_type = NO_ARRAY,
0064 .tlv_type = 0x11,
0065 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0066 wake_msi),
0067 },
0068 {
0069 .data_type = QMI_OPT_FLAG,
0070 .elem_len = 1,
0071 .elem_size = sizeof(u8),
0072 .array_type = NO_ARRAY,
0073 .tlv_type = 0x12,
0074 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0075 gpios_valid),
0076 },
0077 {
0078 .data_type = QMI_DATA_LEN,
0079 .elem_len = 1,
0080 .elem_size = sizeof(u8),
0081 .array_type = NO_ARRAY,
0082 .tlv_type = 0x12,
0083 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0084 gpios_len),
0085 },
0086 {
0087 .data_type = QMI_UNSIGNED_4_BYTE,
0088 .elem_len = QMI_WLFW_MAX_NUM_GPIO_V01,
0089 .elem_size = sizeof(u32),
0090 .array_type = VAR_LEN_ARRAY,
0091 .tlv_type = 0x12,
0092 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0093 gpios),
0094 },
0095 {
0096 .data_type = QMI_OPT_FLAG,
0097 .elem_len = 1,
0098 .elem_size = sizeof(u8),
0099 .array_type = NO_ARRAY,
0100 .tlv_type = 0x13,
0101 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0102 nm_modem_valid),
0103 },
0104 {
0105 .data_type = QMI_UNSIGNED_1_BYTE,
0106 .elem_len = 1,
0107 .elem_size = sizeof(u8),
0108 .array_type = NO_ARRAY,
0109 .tlv_type = 0x13,
0110 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0111 nm_modem),
0112 },
0113 {
0114 .data_type = QMI_OPT_FLAG,
0115 .elem_len = 1,
0116 .elem_size = sizeof(u8),
0117 .array_type = NO_ARRAY,
0118 .tlv_type = 0x14,
0119 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0120 bdf_support_valid),
0121 },
0122 {
0123 .data_type = QMI_UNSIGNED_1_BYTE,
0124 .elem_len = 1,
0125 .elem_size = sizeof(u8),
0126 .array_type = NO_ARRAY,
0127 .tlv_type = 0x14,
0128 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0129 bdf_support),
0130 },
0131 {
0132 .data_type = QMI_OPT_FLAG,
0133 .elem_len = 1,
0134 .elem_size = sizeof(u8),
0135 .array_type = NO_ARRAY,
0136 .tlv_type = 0x15,
0137 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0138 bdf_cache_support_valid),
0139 },
0140 {
0141 .data_type = QMI_UNSIGNED_1_BYTE,
0142 .elem_len = 1,
0143 .elem_size = sizeof(u8),
0144 .array_type = NO_ARRAY,
0145 .tlv_type = 0x15,
0146 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0147 bdf_cache_support),
0148 },
0149 {
0150 .data_type = QMI_OPT_FLAG,
0151 .elem_len = 1,
0152 .elem_size = sizeof(u8),
0153 .array_type = NO_ARRAY,
0154 .tlv_type = 0x16,
0155 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0156 m3_support_valid),
0157 },
0158 {
0159 .data_type = QMI_UNSIGNED_1_BYTE,
0160 .elem_len = 1,
0161 .elem_size = sizeof(u8),
0162 .array_type = NO_ARRAY,
0163 .tlv_type = 0x16,
0164 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0165 m3_support),
0166 },
0167 {
0168 .data_type = QMI_OPT_FLAG,
0169 .elem_len = 1,
0170 .elem_size = sizeof(u8),
0171 .array_type = NO_ARRAY,
0172 .tlv_type = 0x17,
0173 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0174 m3_cache_support_valid),
0175 },
0176 {
0177 .data_type = QMI_UNSIGNED_1_BYTE,
0178 .elem_len = 1,
0179 .elem_size = sizeof(u8),
0180 .array_type = NO_ARRAY,
0181 .tlv_type = 0x17,
0182 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0183 m3_cache_support),
0184 },
0185 {
0186 .data_type = QMI_OPT_FLAG,
0187 .elem_len = 1,
0188 .elem_size = sizeof(u8),
0189 .array_type = NO_ARRAY,
0190 .tlv_type = 0x18,
0191 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0192 cal_filesys_support_valid),
0193 },
0194 {
0195 .data_type = QMI_UNSIGNED_1_BYTE,
0196 .elem_len = 1,
0197 .elem_size = sizeof(u8),
0198 .array_type = NO_ARRAY,
0199 .tlv_type = 0x18,
0200 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0201 cal_filesys_support),
0202 },
0203 {
0204 .data_type = QMI_OPT_FLAG,
0205 .elem_len = 1,
0206 .elem_size = sizeof(u8),
0207 .array_type = NO_ARRAY,
0208 .tlv_type = 0x19,
0209 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0210 cal_cache_support_valid),
0211 },
0212 {
0213 .data_type = QMI_UNSIGNED_1_BYTE,
0214 .elem_len = 1,
0215 .elem_size = sizeof(u8),
0216 .array_type = NO_ARRAY,
0217 .tlv_type = 0x19,
0218 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0219 cal_cache_support),
0220 },
0221 {
0222 .data_type = QMI_OPT_FLAG,
0223 .elem_len = 1,
0224 .elem_size = sizeof(u8),
0225 .array_type = NO_ARRAY,
0226 .tlv_type = 0x1A,
0227 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0228 cal_done_valid),
0229 },
0230 {
0231 .data_type = QMI_UNSIGNED_1_BYTE,
0232 .elem_len = 1,
0233 .elem_size = sizeof(u8),
0234 .array_type = NO_ARRAY,
0235 .tlv_type = 0x1A,
0236 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0237 cal_done),
0238 },
0239 {
0240 .data_type = QMI_OPT_FLAG,
0241 .elem_len = 1,
0242 .elem_size = sizeof(u8),
0243 .array_type = NO_ARRAY,
0244 .tlv_type = 0x1B,
0245 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0246 mem_bucket_valid),
0247 },
0248 {
0249 .data_type = QMI_UNSIGNED_4_BYTE,
0250 .elem_len = 1,
0251 .elem_size = sizeof(u32),
0252 .array_type = NO_ARRAY,
0253 .tlv_type = 0x1B,
0254 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0255 mem_bucket),
0256 },
0257 {
0258 .data_type = QMI_OPT_FLAG,
0259 .elem_len = 1,
0260 .elem_size = sizeof(u8),
0261 .array_type = NO_ARRAY,
0262 .tlv_type = 0x1C,
0263 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0264 mem_cfg_mode_valid),
0265 },
0266 {
0267 .data_type = QMI_UNSIGNED_1_BYTE,
0268 .elem_len = 1,
0269 .elem_size = sizeof(u8),
0270 .array_type = NO_ARRAY,
0271 .tlv_type = 0x1C,
0272 .offset = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
0273 mem_cfg_mode),
0274 },
0275 {
0276 .data_type = QMI_EOTI,
0277 .array_type = NO_ARRAY,
0278 .tlv_type = QMI_COMMON_TLV_TYPE,
0279 },
0280 };
0281
0282 static struct qmi_elem_info qmi_wlanfw_host_cap_resp_msg_v01_ei[] = {
0283 {
0284 .data_type = QMI_STRUCT,
0285 .elem_len = 1,
0286 .elem_size = sizeof(struct qmi_response_type_v01),
0287 .array_type = NO_ARRAY,
0288 .tlv_type = 0x02,
0289 .offset = offsetof(struct qmi_wlanfw_host_cap_resp_msg_v01, resp),
0290 .ei_array = qmi_response_type_v01_ei,
0291 },
0292 {
0293 .data_type = QMI_EOTI,
0294 .array_type = NO_ARRAY,
0295 .tlv_type = QMI_COMMON_TLV_TYPE,
0296 },
0297 };
0298
0299 static struct qmi_elem_info qmi_wlanfw_ind_register_req_msg_v01_ei[] = {
0300 {
0301 .data_type = QMI_OPT_FLAG,
0302 .elem_len = 1,
0303 .elem_size = sizeof(u8),
0304 .array_type = NO_ARRAY,
0305 .tlv_type = 0x10,
0306 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0307 fw_ready_enable_valid),
0308 },
0309 {
0310 .data_type = QMI_UNSIGNED_1_BYTE,
0311 .elem_len = 1,
0312 .elem_size = sizeof(u8),
0313 .array_type = NO_ARRAY,
0314 .tlv_type = 0x10,
0315 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0316 fw_ready_enable),
0317 },
0318 {
0319 .data_type = QMI_OPT_FLAG,
0320 .elem_len = 1,
0321 .elem_size = sizeof(u8),
0322 .array_type = NO_ARRAY,
0323 .tlv_type = 0x11,
0324 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0325 initiate_cal_download_enable_valid),
0326 },
0327 {
0328 .data_type = QMI_UNSIGNED_1_BYTE,
0329 .elem_len = 1,
0330 .elem_size = sizeof(u8),
0331 .array_type = NO_ARRAY,
0332 .tlv_type = 0x11,
0333 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0334 initiate_cal_download_enable),
0335 },
0336 {
0337 .data_type = QMI_OPT_FLAG,
0338 .elem_len = 1,
0339 .elem_size = sizeof(u8),
0340 .array_type = NO_ARRAY,
0341 .tlv_type = 0x12,
0342 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0343 initiate_cal_update_enable_valid),
0344 },
0345 {
0346 .data_type = QMI_UNSIGNED_1_BYTE,
0347 .elem_len = 1,
0348 .elem_size = sizeof(u8),
0349 .array_type = NO_ARRAY,
0350 .tlv_type = 0x12,
0351 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0352 initiate_cal_update_enable),
0353 },
0354 {
0355 .data_type = QMI_OPT_FLAG,
0356 .elem_len = 1,
0357 .elem_size = sizeof(u8),
0358 .array_type = NO_ARRAY,
0359 .tlv_type = 0x13,
0360 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0361 msa_ready_enable_valid),
0362 },
0363 {
0364 .data_type = QMI_UNSIGNED_1_BYTE,
0365 .elem_len = 1,
0366 .elem_size = sizeof(u8),
0367 .array_type = NO_ARRAY,
0368 .tlv_type = 0x13,
0369 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0370 msa_ready_enable),
0371 },
0372 {
0373 .data_type = QMI_OPT_FLAG,
0374 .elem_len = 1,
0375 .elem_size = sizeof(u8),
0376 .array_type = NO_ARRAY,
0377 .tlv_type = 0x14,
0378 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0379 pin_connect_result_enable_valid),
0380 },
0381 {
0382 .data_type = QMI_UNSIGNED_1_BYTE,
0383 .elem_len = 1,
0384 .elem_size = sizeof(u8),
0385 .array_type = NO_ARRAY,
0386 .tlv_type = 0x14,
0387 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0388 pin_connect_result_enable),
0389 },
0390 {
0391 .data_type = QMI_OPT_FLAG,
0392 .elem_len = 1,
0393 .elem_size = sizeof(u8),
0394 .array_type = NO_ARRAY,
0395 .tlv_type = 0x15,
0396 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0397 client_id_valid),
0398 },
0399 {
0400 .data_type = QMI_UNSIGNED_4_BYTE,
0401 .elem_len = 1,
0402 .elem_size = sizeof(u32),
0403 .array_type = NO_ARRAY,
0404 .tlv_type = 0x15,
0405 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0406 client_id),
0407 },
0408 {
0409 .data_type = QMI_OPT_FLAG,
0410 .elem_len = 1,
0411 .elem_size = sizeof(u8),
0412 .array_type = NO_ARRAY,
0413 .tlv_type = 0x16,
0414 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0415 request_mem_enable_valid),
0416 },
0417 {
0418 .data_type = QMI_UNSIGNED_1_BYTE,
0419 .elem_len = 1,
0420 .elem_size = sizeof(u8),
0421 .array_type = NO_ARRAY,
0422 .tlv_type = 0x16,
0423 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0424 request_mem_enable),
0425 },
0426 {
0427 .data_type = QMI_OPT_FLAG,
0428 .elem_len = 1,
0429 .elem_size = sizeof(u8),
0430 .array_type = NO_ARRAY,
0431 .tlv_type = 0x17,
0432 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0433 fw_mem_ready_enable_valid),
0434 },
0435 {
0436 .data_type = QMI_UNSIGNED_1_BYTE,
0437 .elem_len = 1,
0438 .elem_size = sizeof(u8),
0439 .array_type = NO_ARRAY,
0440 .tlv_type = 0x17,
0441 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0442 fw_mem_ready_enable),
0443 },
0444 {
0445 .data_type = QMI_OPT_FLAG,
0446 .elem_len = 1,
0447 .elem_size = sizeof(u8),
0448 .array_type = NO_ARRAY,
0449 .tlv_type = 0x18,
0450 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0451 fw_init_done_enable_valid),
0452 },
0453 {
0454 .data_type = QMI_UNSIGNED_1_BYTE,
0455 .elem_len = 1,
0456 .elem_size = sizeof(u8),
0457 .array_type = NO_ARRAY,
0458 .tlv_type = 0x18,
0459 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0460 fw_init_done_enable),
0461 },
0462
0463 {
0464 .data_type = QMI_OPT_FLAG,
0465 .elem_len = 1,
0466 .elem_size = sizeof(u8),
0467 .array_type = NO_ARRAY,
0468 .tlv_type = 0x19,
0469 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0470 rejuvenate_enable_valid),
0471 },
0472 {
0473 .data_type = QMI_UNSIGNED_1_BYTE,
0474 .elem_len = 1,
0475 .elem_size = sizeof(u8),
0476 .array_type = NO_ARRAY,
0477 .tlv_type = 0x19,
0478 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0479 rejuvenate_enable),
0480 },
0481 {
0482 .data_type = QMI_OPT_FLAG,
0483 .elem_len = 1,
0484 .elem_size = sizeof(u8),
0485 .array_type = NO_ARRAY,
0486 .tlv_type = 0x1A,
0487 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0488 xo_cal_enable_valid),
0489 },
0490 {
0491 .data_type = QMI_UNSIGNED_1_BYTE,
0492 .elem_len = 1,
0493 .elem_size = sizeof(u8),
0494 .array_type = NO_ARRAY,
0495 .tlv_type = 0x1A,
0496 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0497 xo_cal_enable),
0498 },
0499 {
0500 .data_type = QMI_OPT_FLAG,
0501 .elem_len = 1,
0502 .elem_size = sizeof(u8),
0503 .array_type = NO_ARRAY,
0504 .tlv_type = 0x1B,
0505 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0506 cal_done_enable_valid),
0507 },
0508 {
0509 .data_type = QMI_UNSIGNED_1_BYTE,
0510 .elem_len = 1,
0511 .elem_size = sizeof(u8),
0512 .array_type = NO_ARRAY,
0513 .tlv_type = 0x1B,
0514 .offset = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
0515 cal_done_enable),
0516 },
0517 {
0518 .data_type = QMI_EOTI,
0519 .array_type = NO_ARRAY,
0520 .tlv_type = QMI_COMMON_TLV_TYPE,
0521 },
0522 };
0523
0524 static struct qmi_elem_info qmi_wlanfw_ind_register_resp_msg_v01_ei[] = {
0525 {
0526 .data_type = QMI_STRUCT,
0527 .elem_len = 1,
0528 .elem_size = sizeof(struct qmi_response_type_v01),
0529 .array_type = NO_ARRAY,
0530 .tlv_type = 0x02,
0531 .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
0532 resp),
0533 .ei_array = qmi_response_type_v01_ei,
0534 },
0535 {
0536 .data_type = QMI_OPT_FLAG,
0537 .elem_len = 1,
0538 .elem_size = sizeof(u8),
0539 .array_type = NO_ARRAY,
0540 .tlv_type = 0x10,
0541 .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
0542 fw_status_valid),
0543 },
0544 {
0545 .data_type = QMI_UNSIGNED_8_BYTE,
0546 .elem_len = 1,
0547 .elem_size = sizeof(u64),
0548 .array_type = NO_ARRAY,
0549 .tlv_type = 0x10,
0550 .offset = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
0551 fw_status),
0552 },
0553 {
0554 .data_type = QMI_EOTI,
0555 .array_type = NO_ARRAY,
0556 .tlv_type = QMI_COMMON_TLV_TYPE,
0557 },
0558 };
0559
0560 static struct qmi_elem_info qmi_wlanfw_mem_cfg_s_v01_ei[] = {
0561 {
0562 .data_type = QMI_UNSIGNED_8_BYTE,
0563 .elem_len = 1,
0564 .elem_size = sizeof(u64),
0565 .array_type = NO_ARRAY,
0566 .tlv_type = 0,
0567 .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, offset),
0568 },
0569 {
0570 .data_type = QMI_UNSIGNED_4_BYTE,
0571 .elem_len = 1,
0572 .elem_size = sizeof(u32),
0573 .array_type = NO_ARRAY,
0574 .tlv_type = 0,
0575 .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, size),
0576 },
0577 {
0578 .data_type = QMI_UNSIGNED_1_BYTE,
0579 .elem_len = 1,
0580 .elem_size = sizeof(u8),
0581 .array_type = NO_ARRAY,
0582 .tlv_type = 0,
0583 .offset = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, secure_flag),
0584 },
0585 {
0586 .data_type = QMI_EOTI,
0587 .array_type = NO_ARRAY,
0588 .tlv_type = QMI_COMMON_TLV_TYPE,
0589 },
0590 };
0591
0592 static struct qmi_elem_info qmi_wlanfw_mem_seg_s_v01_ei[] = {
0593 {
0594 .data_type = QMI_UNSIGNED_4_BYTE,
0595 .elem_len = 1,
0596 .elem_size = sizeof(u32),
0597 .array_type = NO_ARRAY,
0598 .tlv_type = 0,
0599 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01,
0600 size),
0601 },
0602 {
0603 .data_type = QMI_SIGNED_4_BYTE_ENUM,
0604 .elem_len = 1,
0605 .elem_size = sizeof(enum qmi_wlanfw_mem_type_enum_v01),
0606 .array_type = NO_ARRAY,
0607 .tlv_type = 0,
0608 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01, type),
0609 },
0610 {
0611 .data_type = QMI_DATA_LEN,
0612 .elem_len = 1,
0613 .elem_size = sizeof(u8),
0614 .array_type = NO_ARRAY,
0615 .tlv_type = 0,
0616 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg_len),
0617 },
0618 {
0619 .data_type = QMI_STRUCT,
0620 .elem_len = QMI_WLANFW_MAX_NUM_MEM_CFG_V01,
0621 .elem_size = sizeof(struct qmi_wlanfw_mem_cfg_s_v01),
0622 .array_type = VAR_LEN_ARRAY,
0623 .tlv_type = 0,
0624 .offset = offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg),
0625 .ei_array = qmi_wlanfw_mem_cfg_s_v01_ei,
0626 },
0627 {
0628 .data_type = QMI_EOTI,
0629 .array_type = NO_ARRAY,
0630 .tlv_type = QMI_COMMON_TLV_TYPE,
0631 },
0632 };
0633
0634 static struct qmi_elem_info qmi_wlanfw_request_mem_ind_msg_v01_ei[] = {
0635 {
0636 .data_type = QMI_DATA_LEN,
0637 .elem_len = 1,
0638 .elem_size = sizeof(u8),
0639 .array_type = NO_ARRAY,
0640 .tlv_type = 0x01,
0641 .offset = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
0642 mem_seg_len),
0643 },
0644 {
0645 .data_type = QMI_STRUCT,
0646 .elem_len = ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
0647 .elem_size = sizeof(struct qmi_wlanfw_mem_seg_s_v01),
0648 .array_type = VAR_LEN_ARRAY,
0649 .tlv_type = 0x01,
0650 .offset = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
0651 mem_seg),
0652 .ei_array = qmi_wlanfw_mem_seg_s_v01_ei,
0653 },
0654 {
0655 .data_type = QMI_EOTI,
0656 .array_type = NO_ARRAY,
0657 .tlv_type = QMI_COMMON_TLV_TYPE,
0658 },
0659 };
0660
0661 static struct qmi_elem_info qmi_wlanfw_mem_seg_resp_s_v01_ei[] = {
0662 {
0663 .data_type = QMI_UNSIGNED_8_BYTE,
0664 .elem_len = 1,
0665 .elem_size = sizeof(u64),
0666 .array_type = NO_ARRAY,
0667 .tlv_type = 0,
0668 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, addr),
0669 },
0670 {
0671 .data_type = QMI_UNSIGNED_4_BYTE,
0672 .elem_len = 1,
0673 .elem_size = sizeof(u32),
0674 .array_type = NO_ARRAY,
0675 .tlv_type = 0,
0676 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, size),
0677 },
0678 {
0679 .data_type = QMI_SIGNED_4_BYTE_ENUM,
0680 .elem_len = 1,
0681 .elem_size = sizeof(enum qmi_wlanfw_mem_type_enum_v01),
0682 .array_type = NO_ARRAY,
0683 .tlv_type = 0,
0684 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, type),
0685 },
0686 {
0687 .data_type = QMI_UNSIGNED_1_BYTE,
0688 .elem_len = 1,
0689 .elem_size = sizeof(u8),
0690 .array_type = NO_ARRAY,
0691 .tlv_type = 0,
0692 .offset = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, restore),
0693 },
0694 {
0695 .data_type = QMI_EOTI,
0696 .array_type = NO_ARRAY,
0697 .tlv_type = QMI_COMMON_TLV_TYPE,
0698 },
0699 };
0700
0701 static struct qmi_elem_info qmi_wlanfw_respond_mem_req_msg_v01_ei[] = {
0702 {
0703 .data_type = QMI_DATA_LEN,
0704 .elem_len = 1,
0705 .elem_size = sizeof(u8),
0706 .array_type = NO_ARRAY,
0707 .tlv_type = 0x01,
0708 .offset = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
0709 mem_seg_len),
0710 },
0711 {
0712 .data_type = QMI_STRUCT,
0713 .elem_len = ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
0714 .elem_size = sizeof(struct qmi_wlanfw_mem_seg_resp_s_v01),
0715 .array_type = VAR_LEN_ARRAY,
0716 .tlv_type = 0x01,
0717 .offset = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
0718 mem_seg),
0719 .ei_array = qmi_wlanfw_mem_seg_resp_s_v01_ei,
0720 },
0721 {
0722 .data_type = QMI_EOTI,
0723 .array_type = NO_ARRAY,
0724 .tlv_type = QMI_COMMON_TLV_TYPE,
0725 },
0726 };
0727
0728 static struct qmi_elem_info qmi_wlanfw_respond_mem_resp_msg_v01_ei[] = {
0729 {
0730 .data_type = QMI_STRUCT,
0731 .elem_len = 1,
0732 .elem_size = sizeof(struct qmi_response_type_v01),
0733 .array_type = NO_ARRAY,
0734 .tlv_type = 0x02,
0735 .offset = offsetof(struct qmi_wlanfw_respond_mem_resp_msg_v01,
0736 resp),
0737 .ei_array = qmi_response_type_v01_ei,
0738 },
0739 {
0740 .data_type = QMI_EOTI,
0741 .array_type = NO_ARRAY,
0742 .tlv_type = QMI_COMMON_TLV_TYPE,
0743 },
0744 };
0745
0746 static struct qmi_elem_info qmi_wlanfw_cap_req_msg_v01_ei[] = {
0747 {
0748 .data_type = QMI_EOTI,
0749 .array_type = NO_ARRAY,
0750 .tlv_type = QMI_COMMON_TLV_TYPE,
0751 },
0752 };
0753
0754 static struct qmi_elem_info qmi_wlanfw_device_info_req_msg_v01_ei[] = {
0755 {
0756 .data_type = QMI_EOTI,
0757 .array_type = NO_ARRAY,
0758 .tlv_type = QMI_COMMON_TLV_TYPE,
0759 },
0760 };
0761
0762 static struct qmi_elem_info qmi_wlfw_device_info_resp_msg_v01_ei[] = {
0763 {
0764 .data_type = QMI_STRUCT,
0765 .elem_len = 1,
0766 .elem_size = sizeof(struct qmi_response_type_v01),
0767 .array_type = NO_ARRAY,
0768 .tlv_type = 0x02,
0769 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
0770 resp),
0771 .ei_array = qmi_response_type_v01_ei,
0772 },
0773 {
0774 .data_type = QMI_OPT_FLAG,
0775 .elem_len = 1,
0776 .elem_size = sizeof(u8),
0777 .array_type = NO_ARRAY,
0778 .tlv_type = 0x10,
0779 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
0780 bar_addr_valid),
0781 },
0782 {
0783 .data_type = QMI_UNSIGNED_8_BYTE,
0784 .elem_len = 1,
0785 .elem_size = sizeof(u64),
0786 .array_type = NO_ARRAY,
0787 .tlv_type = 0x10,
0788 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
0789 bar_addr),
0790 },
0791 {
0792 .data_type = QMI_OPT_FLAG,
0793 .elem_len = 1,
0794 .elem_size = sizeof(u8),
0795 .array_type = NO_ARRAY,
0796 .tlv_type = 0x11,
0797 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
0798 bar_size_valid),
0799 },
0800 {
0801 .data_type = QMI_UNSIGNED_4_BYTE,
0802 .elem_len = 1,
0803 .elem_size = sizeof(u32),
0804 .array_type = NO_ARRAY,
0805 .tlv_type = 0x11,
0806 .offset = offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
0807 bar_size),
0808 },
0809 {
0810 .data_type = QMI_EOTI,
0811 .array_type = NO_ARRAY,
0812 .tlv_type = QMI_COMMON_TLV_TYPE,
0813 },
0814 };
0815
0816 static struct qmi_elem_info qmi_wlanfw_rf_chip_info_s_v01_ei[] = {
0817 {
0818 .data_type = QMI_UNSIGNED_4_BYTE,
0819 .elem_len = 1,
0820 .elem_size = sizeof(u32),
0821 .array_type = NO_ARRAY,
0822 .tlv_type = 0,
0823 .offset = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
0824 chip_id),
0825 },
0826 {
0827 .data_type = QMI_UNSIGNED_4_BYTE,
0828 .elem_len = 1,
0829 .elem_size = sizeof(u32),
0830 .array_type = NO_ARRAY,
0831 .tlv_type = 0,
0832 .offset = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
0833 chip_family),
0834 },
0835 {
0836 .data_type = QMI_EOTI,
0837 .array_type = NO_ARRAY,
0838 .tlv_type = QMI_COMMON_TLV_TYPE,
0839 },
0840 };
0841
0842 static struct qmi_elem_info qmi_wlanfw_rf_board_info_s_v01_ei[] = {
0843 {
0844 .data_type = QMI_UNSIGNED_4_BYTE,
0845 .elem_len = 1,
0846 .elem_size = sizeof(u32),
0847 .array_type = NO_ARRAY,
0848 .tlv_type = 0,
0849 .offset = offsetof(struct qmi_wlanfw_rf_board_info_s_v01,
0850 board_id),
0851 },
0852 {
0853 .data_type = QMI_EOTI,
0854 .array_type = NO_ARRAY,
0855 .tlv_type = QMI_COMMON_TLV_TYPE,
0856 },
0857 };
0858
0859 static struct qmi_elem_info qmi_wlanfw_soc_info_s_v01_ei[] = {
0860 {
0861 .data_type = QMI_UNSIGNED_4_BYTE,
0862 .elem_len = 1,
0863 .elem_size = sizeof(u32),
0864 .array_type = NO_ARRAY,
0865 .tlv_type = 0,
0866 .offset = offsetof(struct qmi_wlanfw_soc_info_s_v01, soc_id),
0867 },
0868 {
0869 .data_type = QMI_EOTI,
0870 .array_type = NO_ARRAY,
0871 .tlv_type = QMI_COMMON_TLV_TYPE,
0872 },
0873 };
0874
0875 static struct qmi_elem_info qmi_wlanfw_fw_version_info_s_v01_ei[] = {
0876 {
0877 .data_type = QMI_UNSIGNED_4_BYTE,
0878 .elem_len = 1,
0879 .elem_size = sizeof(u32),
0880 .array_type = NO_ARRAY,
0881 .tlv_type = 0,
0882 .offset = offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
0883 fw_version),
0884 },
0885 {
0886 .data_type = QMI_STRING,
0887 .elem_len = ATH11K_QMI_WLANFW_MAX_TIMESTAMP_LEN_V01 + 1,
0888 .elem_size = sizeof(char),
0889 .array_type = NO_ARRAY,
0890 .tlv_type = 0,
0891 .offset = offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
0892 fw_build_timestamp),
0893 },
0894 {
0895 .data_type = QMI_EOTI,
0896 .array_type = NO_ARRAY,
0897 .tlv_type = QMI_COMMON_TLV_TYPE,
0898 },
0899 };
0900
0901 static struct qmi_elem_info qmi_wlanfw_cap_resp_msg_v01_ei[] = {
0902 {
0903 .data_type = QMI_STRUCT,
0904 .elem_len = 1,
0905 .elem_size = sizeof(struct qmi_response_type_v01),
0906 .array_type = NO_ARRAY,
0907 .tlv_type = 0x02,
0908 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01, resp),
0909 .ei_array = qmi_response_type_v01_ei,
0910 },
0911 {
0912 .data_type = QMI_OPT_FLAG,
0913 .elem_len = 1,
0914 .elem_size = sizeof(u8),
0915 .array_type = NO_ARRAY,
0916 .tlv_type = 0x10,
0917 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
0918 chip_info_valid),
0919 },
0920 {
0921 .data_type = QMI_STRUCT,
0922 .elem_len = 1,
0923 .elem_size = sizeof(struct qmi_wlanfw_rf_chip_info_s_v01),
0924 .array_type = NO_ARRAY,
0925 .tlv_type = 0x10,
0926 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
0927 chip_info),
0928 .ei_array = qmi_wlanfw_rf_chip_info_s_v01_ei,
0929 },
0930 {
0931 .data_type = QMI_OPT_FLAG,
0932 .elem_len = 1,
0933 .elem_size = sizeof(u8),
0934 .array_type = NO_ARRAY,
0935 .tlv_type = 0x11,
0936 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
0937 board_info_valid),
0938 },
0939 {
0940 .data_type = QMI_STRUCT,
0941 .elem_len = 1,
0942 .elem_size = sizeof(struct qmi_wlanfw_rf_board_info_s_v01),
0943 .array_type = NO_ARRAY,
0944 .tlv_type = 0x11,
0945 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
0946 board_info),
0947 .ei_array = qmi_wlanfw_rf_board_info_s_v01_ei,
0948 },
0949 {
0950 .data_type = QMI_OPT_FLAG,
0951 .elem_len = 1,
0952 .elem_size = sizeof(u8),
0953 .array_type = NO_ARRAY,
0954 .tlv_type = 0x12,
0955 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
0956 soc_info_valid),
0957 },
0958 {
0959 .data_type = QMI_STRUCT,
0960 .elem_len = 1,
0961 .elem_size = sizeof(struct qmi_wlanfw_soc_info_s_v01),
0962 .array_type = NO_ARRAY,
0963 .tlv_type = 0x12,
0964 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
0965 soc_info),
0966 .ei_array = qmi_wlanfw_soc_info_s_v01_ei,
0967 },
0968 {
0969 .data_type = QMI_OPT_FLAG,
0970 .elem_len = 1,
0971 .elem_size = sizeof(u8),
0972 .array_type = NO_ARRAY,
0973 .tlv_type = 0x13,
0974 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
0975 fw_version_info_valid),
0976 },
0977 {
0978 .data_type = QMI_STRUCT,
0979 .elem_len = 1,
0980 .elem_size = sizeof(struct qmi_wlanfw_fw_version_info_s_v01),
0981 .array_type = NO_ARRAY,
0982 .tlv_type = 0x13,
0983 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
0984 fw_version_info),
0985 .ei_array = qmi_wlanfw_fw_version_info_s_v01_ei,
0986 },
0987 {
0988 .data_type = QMI_OPT_FLAG,
0989 .elem_len = 1,
0990 .elem_size = sizeof(u8),
0991 .array_type = NO_ARRAY,
0992 .tlv_type = 0x14,
0993 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
0994 fw_build_id_valid),
0995 },
0996 {
0997 .data_type = QMI_STRING,
0998 .elem_len = ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 + 1,
0999 .elem_size = sizeof(char),
1000 .array_type = NO_ARRAY,
1001 .tlv_type = 0x14,
1002 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1003 fw_build_id),
1004 },
1005 {
1006 .data_type = QMI_OPT_FLAG,
1007 .elem_len = 1,
1008 .elem_size = sizeof(u8),
1009 .array_type = NO_ARRAY,
1010 .tlv_type = 0x15,
1011 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1012 num_macs_valid),
1013 },
1014 {
1015 .data_type = QMI_UNSIGNED_1_BYTE,
1016 .elem_len = 1,
1017 .elem_size = sizeof(u8),
1018 .array_type = NO_ARRAY,
1019 .tlv_type = 0x15,
1020 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1021 num_macs),
1022 },
1023 {
1024 .data_type = QMI_OPT_FLAG,
1025 .elem_len = 1,
1026 .elem_size = sizeof(u8),
1027 .array_type = NO_ARRAY,
1028 .tlv_type = 0x16,
1029 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1030 voltage_mv_valid),
1031 },
1032 {
1033 .data_type = QMI_UNSIGNED_4_BYTE,
1034 .elem_len = 1,
1035 .elem_size = sizeof(u32),
1036 .array_type = NO_ARRAY,
1037 .tlv_type = 0x16,
1038 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1039 voltage_mv),
1040 },
1041 {
1042 .data_type = QMI_OPT_FLAG,
1043 .elem_len = 1,
1044 .elem_size = sizeof(u8),
1045 .array_type = NO_ARRAY,
1046 .tlv_type = 0x17,
1047 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1048 time_freq_hz_valid),
1049 },
1050 {
1051 .data_type = QMI_UNSIGNED_4_BYTE,
1052 .elem_len = 1,
1053 .elem_size = sizeof(u32),
1054 .array_type = NO_ARRAY,
1055 .tlv_type = 0x17,
1056 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1057 time_freq_hz),
1058 },
1059 {
1060 .data_type = QMI_OPT_FLAG,
1061 .elem_len = 1,
1062 .elem_size = sizeof(u8),
1063 .array_type = NO_ARRAY,
1064 .tlv_type = 0x18,
1065 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1066 otp_version_valid),
1067 },
1068 {
1069 .data_type = QMI_UNSIGNED_4_BYTE,
1070 .elem_len = 1,
1071 .elem_size = sizeof(u32),
1072 .array_type = NO_ARRAY,
1073 .tlv_type = 0x18,
1074 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1075 otp_version),
1076 },
1077 {
1078 .data_type = QMI_OPT_FLAG,
1079 .elem_len = 1,
1080 .elem_size = sizeof(u8),
1081 .array_type = NO_ARRAY,
1082 .tlv_type = 0x19,
1083 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1084 eeprom_read_timeout_valid),
1085 },
1086 {
1087 .data_type = QMI_UNSIGNED_4_BYTE,
1088 .elem_len = 1,
1089 .elem_size = sizeof(u32),
1090 .array_type = NO_ARRAY,
1091 .tlv_type = 0x19,
1092 .offset = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1093 eeprom_read_timeout),
1094 },
1095 {
1096 .data_type = QMI_EOTI,
1097 .array_type = NO_ARRAY,
1098 .tlv_type = QMI_COMMON_TLV_TYPE,
1099 },
1100 };
1101
1102 static struct qmi_elem_info qmi_wlanfw_bdf_download_req_msg_v01_ei[] = {
1103 {
1104 .data_type = QMI_UNSIGNED_1_BYTE,
1105 .elem_len = 1,
1106 .elem_size = sizeof(u8),
1107 .array_type = NO_ARRAY,
1108 .tlv_type = 0x01,
1109 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1110 valid),
1111 },
1112 {
1113 .data_type = QMI_OPT_FLAG,
1114 .elem_len = 1,
1115 .elem_size = sizeof(u8),
1116 .array_type = NO_ARRAY,
1117 .tlv_type = 0x10,
1118 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1119 file_id_valid),
1120 },
1121 {
1122 .data_type = QMI_SIGNED_4_BYTE_ENUM,
1123 .elem_len = 1,
1124 .elem_size = sizeof(enum qmi_wlanfw_cal_temp_id_enum_v01),
1125 .array_type = NO_ARRAY,
1126 .tlv_type = 0x10,
1127 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1128 file_id),
1129 },
1130 {
1131 .data_type = QMI_OPT_FLAG,
1132 .elem_len = 1,
1133 .elem_size = sizeof(u8),
1134 .array_type = NO_ARRAY,
1135 .tlv_type = 0x11,
1136 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1137 total_size_valid),
1138 },
1139 {
1140 .data_type = QMI_UNSIGNED_4_BYTE,
1141 .elem_len = 1,
1142 .elem_size = sizeof(u32),
1143 .array_type = NO_ARRAY,
1144 .tlv_type = 0x11,
1145 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1146 total_size),
1147 },
1148 {
1149 .data_type = QMI_OPT_FLAG,
1150 .elem_len = 1,
1151 .elem_size = sizeof(u8),
1152 .array_type = NO_ARRAY,
1153 .tlv_type = 0x12,
1154 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1155 seg_id_valid),
1156 },
1157 {
1158 .data_type = QMI_UNSIGNED_4_BYTE,
1159 .elem_len = 1,
1160 .elem_size = sizeof(u32),
1161 .array_type = NO_ARRAY,
1162 .tlv_type = 0x12,
1163 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1164 seg_id),
1165 },
1166 {
1167 .data_type = QMI_OPT_FLAG,
1168 .elem_len = 1,
1169 .elem_size = sizeof(u8),
1170 .array_type = NO_ARRAY,
1171 .tlv_type = 0x13,
1172 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1173 data_valid),
1174 },
1175 {
1176 .data_type = QMI_DATA_LEN,
1177 .elem_len = 1,
1178 .elem_size = sizeof(u16),
1179 .array_type = NO_ARRAY,
1180 .tlv_type = 0x13,
1181 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1182 data_len),
1183 },
1184 {
1185 .data_type = QMI_UNSIGNED_1_BYTE,
1186 .elem_len = QMI_WLANFW_MAX_DATA_SIZE_V01,
1187 .elem_size = sizeof(u8),
1188 .array_type = VAR_LEN_ARRAY,
1189 .tlv_type = 0x13,
1190 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1191 data),
1192 },
1193 {
1194 .data_type = QMI_OPT_FLAG,
1195 .elem_len = 1,
1196 .elem_size = sizeof(u8),
1197 .array_type = NO_ARRAY,
1198 .tlv_type = 0x14,
1199 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1200 end_valid),
1201 },
1202 {
1203 .data_type = QMI_UNSIGNED_1_BYTE,
1204 .elem_len = 1,
1205 .elem_size = sizeof(u8),
1206 .array_type = NO_ARRAY,
1207 .tlv_type = 0x14,
1208 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1209 end),
1210 },
1211 {
1212 .data_type = QMI_OPT_FLAG,
1213 .elem_len = 1,
1214 .elem_size = sizeof(u8),
1215 .array_type = NO_ARRAY,
1216 .tlv_type = 0x15,
1217 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1218 bdf_type_valid),
1219 },
1220 {
1221 .data_type = QMI_UNSIGNED_1_BYTE,
1222 .elem_len = 1,
1223 .elem_size = sizeof(u8),
1224 .array_type = NO_ARRAY,
1225 .tlv_type = 0x15,
1226 .offset = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1227 bdf_type),
1228 },
1229
1230 {
1231 .data_type = QMI_EOTI,
1232 .array_type = NO_ARRAY,
1233 .tlv_type = QMI_COMMON_TLV_TYPE,
1234 },
1235 };
1236
1237 static struct qmi_elem_info qmi_wlanfw_bdf_download_resp_msg_v01_ei[] = {
1238 {
1239 .data_type = QMI_STRUCT,
1240 .elem_len = 1,
1241 .elem_size = sizeof(struct qmi_response_type_v01),
1242 .array_type = NO_ARRAY,
1243 .tlv_type = 0x02,
1244 .offset = offsetof(struct qmi_wlanfw_bdf_download_resp_msg_v01,
1245 resp),
1246 .ei_array = qmi_response_type_v01_ei,
1247 },
1248 {
1249 .data_type = QMI_EOTI,
1250 .array_type = NO_ARRAY,
1251 .tlv_type = QMI_COMMON_TLV_TYPE,
1252 },
1253 };
1254
1255 static struct qmi_elem_info qmi_wlanfw_m3_info_req_msg_v01_ei[] = {
1256 {
1257 .data_type = QMI_UNSIGNED_8_BYTE,
1258 .elem_len = 1,
1259 .elem_size = sizeof(u64),
1260 .array_type = NO_ARRAY,
1261 .tlv_type = 0x01,
1262 .offset = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, addr),
1263 },
1264 {
1265 .data_type = QMI_UNSIGNED_4_BYTE,
1266 .elem_len = 1,
1267 .elem_size = sizeof(u32),
1268 .array_type = NO_ARRAY,
1269 .tlv_type = 0x02,
1270 .offset = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, size),
1271 },
1272 {
1273 .data_type = QMI_EOTI,
1274 .array_type = NO_ARRAY,
1275 .tlv_type = QMI_COMMON_TLV_TYPE,
1276 },
1277 };
1278
1279 static struct qmi_elem_info qmi_wlanfw_m3_info_resp_msg_v01_ei[] = {
1280 {
1281 .data_type = QMI_STRUCT,
1282 .elem_len = 1,
1283 .elem_size = sizeof(struct qmi_response_type_v01),
1284 .array_type = NO_ARRAY,
1285 .tlv_type = 0x02,
1286 .offset = offsetof(struct qmi_wlanfw_m3_info_resp_msg_v01, resp),
1287 .ei_array = qmi_response_type_v01_ei,
1288 },
1289 {
1290 .data_type = QMI_EOTI,
1291 .array_type = NO_ARRAY,
1292 .tlv_type = QMI_COMMON_TLV_TYPE,
1293 },
1294 };
1295
1296 static struct qmi_elem_info qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei[] = {
1297 {
1298 .data_type = QMI_UNSIGNED_4_BYTE,
1299 .elem_len = 1,
1300 .elem_size = sizeof(u32),
1301 .array_type = NO_ARRAY,
1302 .tlv_type = 0,
1303 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1304 pipe_num),
1305 },
1306 {
1307 .data_type = QMI_SIGNED_4_BYTE_ENUM,
1308 .elem_len = 1,
1309 .elem_size = sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1310 .array_type = NO_ARRAY,
1311 .tlv_type = 0,
1312 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1313 pipe_dir),
1314 },
1315 {
1316 .data_type = QMI_UNSIGNED_4_BYTE,
1317 .elem_len = 1,
1318 .elem_size = sizeof(u32),
1319 .array_type = NO_ARRAY,
1320 .tlv_type = 0,
1321 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1322 nentries),
1323 },
1324 {
1325 .data_type = QMI_UNSIGNED_4_BYTE,
1326 .elem_len = 1,
1327 .elem_size = sizeof(u32),
1328 .array_type = NO_ARRAY,
1329 .tlv_type = 0,
1330 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1331 nbytes_max),
1332 },
1333 {
1334 .data_type = QMI_UNSIGNED_4_BYTE,
1335 .elem_len = 1,
1336 .elem_size = sizeof(u32),
1337 .array_type = NO_ARRAY,
1338 .tlv_type = 0,
1339 .offset = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1340 flags),
1341 },
1342 {
1343 .data_type = QMI_EOTI,
1344 .array_type = NO_ARRAY,
1345 .tlv_type = QMI_COMMON_TLV_TYPE,
1346 },
1347 };
1348
1349 static struct qmi_elem_info qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei[] = {
1350 {
1351 .data_type = QMI_UNSIGNED_4_BYTE,
1352 .elem_len = 1,
1353 .elem_size = sizeof(u32),
1354 .array_type = NO_ARRAY,
1355 .tlv_type = 0,
1356 .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1357 service_id),
1358 },
1359 {
1360 .data_type = QMI_SIGNED_4_BYTE_ENUM,
1361 .elem_len = 1,
1362 .elem_size = sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1363 .array_type = NO_ARRAY,
1364 .tlv_type = 0,
1365 .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1366 pipe_dir),
1367 },
1368 {
1369 .data_type = QMI_UNSIGNED_4_BYTE,
1370 .elem_len = 1,
1371 .elem_size = sizeof(u32),
1372 .array_type = NO_ARRAY,
1373 .tlv_type = 0,
1374 .offset = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1375 pipe_num),
1376 },
1377 {
1378 .data_type = QMI_EOTI,
1379 .array_type = NO_ARRAY,
1380 .tlv_type = QMI_COMMON_TLV_TYPE,
1381 },
1382 };
1383
1384 static struct qmi_elem_info qmi_wlanfw_shadow_reg_cfg_s_v01_ei[] = {
1385 {
1386 .data_type = QMI_UNSIGNED_2_BYTE,
1387 .elem_len = 1,
1388 .elem_size = sizeof(u16),
1389 .array_type = NO_ARRAY,
1390 .tlv_type = 0,
1391 .offset = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01, id),
1392 },
1393 {
1394 .data_type = QMI_UNSIGNED_2_BYTE,
1395 .elem_len = 1,
1396 .elem_size = sizeof(u16),
1397 .array_type = NO_ARRAY,
1398 .tlv_type = 0,
1399 .offset = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01,
1400 offset),
1401 },
1402 {
1403 .data_type = QMI_EOTI,
1404 .array_type = QMI_COMMON_TLV_TYPE,
1405 },
1406 };
1407
1408 static struct qmi_elem_info qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei[] = {
1409 {
1410 .data_type = QMI_UNSIGNED_4_BYTE,
1411 .elem_len = 1,
1412 .elem_size = sizeof(u32),
1413 .array_type = NO_ARRAY,
1414 .tlv_type = 0,
1415 .offset = offsetof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01,
1416 addr),
1417 },
1418 {
1419 .data_type = QMI_EOTI,
1420 .array_type = NO_ARRAY,
1421 .tlv_type = QMI_COMMON_TLV_TYPE,
1422 },
1423 };
1424
1425 static struct qmi_elem_info qmi_wlanfw_wlan_mode_req_msg_v01_ei[] = {
1426 {
1427 .data_type = QMI_UNSIGNED_4_BYTE,
1428 .elem_len = 1,
1429 .elem_size = sizeof(u32),
1430 .array_type = NO_ARRAY,
1431 .tlv_type = 0x01,
1432 .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1433 mode),
1434 },
1435 {
1436 .data_type = QMI_OPT_FLAG,
1437 .elem_len = 1,
1438 .elem_size = sizeof(u8),
1439 .array_type = NO_ARRAY,
1440 .tlv_type = 0x10,
1441 .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1442 hw_debug_valid),
1443 },
1444 {
1445 .data_type = QMI_UNSIGNED_1_BYTE,
1446 .elem_len = 1,
1447 .elem_size = sizeof(u8),
1448 .array_type = NO_ARRAY,
1449 .tlv_type = 0x10,
1450 .offset = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1451 hw_debug),
1452 },
1453 {
1454 .data_type = QMI_EOTI,
1455 .array_type = NO_ARRAY,
1456 .tlv_type = QMI_COMMON_TLV_TYPE,
1457 },
1458 };
1459
1460 static struct qmi_elem_info qmi_wlanfw_wlan_mode_resp_msg_v01_ei[] = {
1461 {
1462 .data_type = QMI_STRUCT,
1463 .elem_len = 1,
1464 .elem_size = sizeof(struct qmi_response_type_v01),
1465 .array_type = NO_ARRAY,
1466 .tlv_type = 0x02,
1467 .offset = offsetof(struct qmi_wlanfw_wlan_mode_resp_msg_v01,
1468 resp),
1469 .ei_array = qmi_response_type_v01_ei,
1470 },
1471 {
1472 .data_type = QMI_EOTI,
1473 .array_type = NO_ARRAY,
1474 .tlv_type = QMI_COMMON_TLV_TYPE,
1475 },
1476 };
1477
1478 static struct qmi_elem_info qmi_wlanfw_wlan_cfg_req_msg_v01_ei[] = {
1479 {
1480 .data_type = QMI_OPT_FLAG,
1481 .elem_len = 1,
1482 .elem_size = sizeof(u8),
1483 .array_type = NO_ARRAY,
1484 .tlv_type = 0x10,
1485 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1486 host_version_valid),
1487 },
1488 {
1489 .data_type = QMI_STRING,
1490 .elem_len = QMI_WLANFW_MAX_STR_LEN_V01 + 1,
1491 .elem_size = sizeof(char),
1492 .array_type = NO_ARRAY,
1493 .tlv_type = 0x10,
1494 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1495 host_version),
1496 },
1497 {
1498 .data_type = QMI_OPT_FLAG,
1499 .elem_len = 1,
1500 .elem_size = sizeof(u8),
1501 .array_type = NO_ARRAY,
1502 .tlv_type = 0x11,
1503 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1504 tgt_cfg_valid),
1505 },
1506 {
1507 .data_type = QMI_DATA_LEN,
1508 .elem_len = 1,
1509 .elem_size = sizeof(u8),
1510 .array_type = NO_ARRAY,
1511 .tlv_type = 0x11,
1512 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1513 tgt_cfg_len),
1514 },
1515 {
1516 .data_type = QMI_STRUCT,
1517 .elem_len = QMI_WLANFW_MAX_NUM_CE_V01,
1518 .elem_size = sizeof(
1519 struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01),
1520 .array_type = VAR_LEN_ARRAY,
1521 .tlv_type = 0x11,
1522 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1523 tgt_cfg),
1524 .ei_array = qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei,
1525 },
1526 {
1527 .data_type = QMI_OPT_FLAG,
1528 .elem_len = 1,
1529 .elem_size = sizeof(u8),
1530 .array_type = NO_ARRAY,
1531 .tlv_type = 0x12,
1532 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1533 svc_cfg_valid),
1534 },
1535 {
1536 .data_type = QMI_DATA_LEN,
1537 .elem_len = 1,
1538 .elem_size = sizeof(u8),
1539 .array_type = NO_ARRAY,
1540 .tlv_type = 0x12,
1541 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1542 svc_cfg_len),
1543 },
1544 {
1545 .data_type = QMI_STRUCT,
1546 .elem_len = QMI_WLANFW_MAX_NUM_SVC_V01,
1547 .elem_size = sizeof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01),
1548 .array_type = VAR_LEN_ARRAY,
1549 .tlv_type = 0x12,
1550 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1551 svc_cfg),
1552 .ei_array = qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei,
1553 },
1554 {
1555 .data_type = QMI_OPT_FLAG,
1556 .elem_len = 1,
1557 .elem_size = sizeof(u8),
1558 .array_type = NO_ARRAY,
1559 .tlv_type = 0x13,
1560 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1561 shadow_reg_valid),
1562 },
1563 {
1564 .data_type = QMI_DATA_LEN,
1565 .elem_len = 1,
1566 .elem_size = sizeof(u8),
1567 .array_type = NO_ARRAY,
1568 .tlv_type = 0x13,
1569 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1570 shadow_reg_len),
1571 },
1572 {
1573 .data_type = QMI_STRUCT,
1574 .elem_len = QMI_WLANFW_MAX_NUM_SHADOW_REG_V01,
1575 .elem_size = sizeof(struct qmi_wlanfw_shadow_reg_cfg_s_v01),
1576 .array_type = VAR_LEN_ARRAY,
1577 .tlv_type = 0x13,
1578 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1579 shadow_reg),
1580 .ei_array = qmi_wlanfw_shadow_reg_cfg_s_v01_ei,
1581 },
1582 {
1583 .data_type = QMI_OPT_FLAG,
1584 .elem_len = 1,
1585 .elem_size = sizeof(u8),
1586 .array_type = NO_ARRAY,
1587 .tlv_type = 0x14,
1588 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1589 shadow_reg_v2_valid),
1590 },
1591 {
1592 .data_type = QMI_DATA_LEN,
1593 .elem_len = 1,
1594 .elem_size = sizeof(u8),
1595 .array_type = NO_ARRAY,
1596 .tlv_type = 0x14,
1597 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1598 shadow_reg_v2_len),
1599 },
1600 {
1601 .data_type = QMI_STRUCT,
1602 .elem_len = QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01,
1603 .elem_size = sizeof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01),
1604 .array_type = VAR_LEN_ARRAY,
1605 .tlv_type = 0x14,
1606 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1607 shadow_reg_v2),
1608 .ei_array = qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei,
1609 },
1610 {
1611 .data_type = QMI_EOTI,
1612 .array_type = NO_ARRAY,
1613 .tlv_type = QMI_COMMON_TLV_TYPE,
1614 },
1615 };
1616
1617 static struct qmi_elem_info qmi_wlanfw_wlan_cfg_resp_msg_v01_ei[] = {
1618 {
1619 .data_type = QMI_STRUCT,
1620 .elem_len = 1,
1621 .elem_size = sizeof(struct qmi_response_type_v01),
1622 .array_type = NO_ARRAY,
1623 .tlv_type = 0x02,
1624 .offset = offsetof(struct qmi_wlanfw_wlan_cfg_resp_msg_v01, resp),
1625 .ei_array = qmi_response_type_v01_ei,
1626 },
1627 {
1628 .data_type = QMI_EOTI,
1629 .array_type = NO_ARRAY,
1630 .tlv_type = QMI_COMMON_TLV_TYPE,
1631 },
1632 };
1633
1634 static struct qmi_elem_info qmi_wlanfw_mem_ready_ind_msg_v01_ei[] = {
1635 {
1636 .data_type = QMI_EOTI,
1637 .array_type = NO_ARRAY,
1638 },
1639 };
1640
1641 static struct qmi_elem_info qmi_wlanfw_fw_ready_ind_msg_v01_ei[] = {
1642 {
1643 .data_type = QMI_EOTI,
1644 .array_type = NO_ARRAY,
1645 },
1646 };
1647
1648 static struct qmi_elem_info qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei[] = {
1649 {
1650 .data_type = QMI_EOTI,
1651 .array_type = NO_ARRAY,
1652 },
1653 };
1654
1655 static struct qmi_elem_info qmi_wlanfw_wlan_ini_req_msg_v01_ei[] = {
1656 {
1657 .data_type = QMI_OPT_FLAG,
1658 .elem_len = 1,
1659 .elem_size = sizeof(u8),
1660 .array_type = NO_ARRAY,
1661 .tlv_type = 0x10,
1662 .offset = offsetof(struct qmi_wlanfw_wlan_ini_req_msg_v01,
1663 enablefwlog_valid),
1664 },
1665 {
1666 .data_type = QMI_UNSIGNED_1_BYTE,
1667 .elem_len = 1,
1668 .elem_size = sizeof(u8),
1669 .array_type = NO_ARRAY,
1670 .tlv_type = 0x10,
1671 .offset = offsetof(struct qmi_wlanfw_wlan_ini_req_msg_v01,
1672 enablefwlog),
1673 },
1674 {
1675 .data_type = QMI_EOTI,
1676 .array_type = NO_ARRAY,
1677 .tlv_type = QMI_COMMON_TLV_TYPE,
1678 },
1679 };
1680
1681 static struct qmi_elem_info qmi_wlanfw_wlan_ini_resp_msg_v01_ei[] = {
1682 {
1683 .data_type = QMI_STRUCT,
1684 .elem_len = 1,
1685 .elem_size = sizeof(struct qmi_response_type_v01),
1686 .array_type = NO_ARRAY,
1687 .tlv_type = 0x02,
1688 .offset = offsetof(struct qmi_wlanfw_wlan_ini_resp_msg_v01,
1689 resp),
1690 .ei_array = qmi_response_type_v01_ei,
1691 },
1692 {
1693 .data_type = QMI_EOTI,
1694 .array_type = NO_ARRAY,
1695 .tlv_type = QMI_COMMON_TLV_TYPE,
1696 },
1697 };
1698
1699 static int ath11k_qmi_host_cap_send(struct ath11k_base *ab)
1700 {
1701 struct qmi_wlanfw_host_cap_req_msg_v01 req;
1702 struct qmi_wlanfw_host_cap_resp_msg_v01 resp;
1703 struct qmi_txn txn;
1704 int ret = 0;
1705
1706 memset(&req, 0, sizeof(req));
1707 memset(&resp, 0, sizeof(resp));
1708
1709 req.num_clients_valid = 1;
1710 req.num_clients = 1;
1711 req.mem_cfg_mode = ab->qmi.target_mem_mode;
1712 req.mem_cfg_mode_valid = 1;
1713 req.bdf_support_valid = 1;
1714 req.bdf_support = 1;
1715
1716 if (ab->hw_params.m3_fw_support) {
1717 req.m3_support_valid = 1;
1718 req.m3_support = 1;
1719 req.m3_cache_support_valid = 1;
1720 req.m3_cache_support = 1;
1721 } else {
1722 req.m3_support_valid = 0;
1723 req.m3_support = 0;
1724 req.m3_cache_support_valid = 0;
1725 req.m3_cache_support = 0;
1726 }
1727
1728 req.cal_done_valid = 1;
1729 req.cal_done = ab->qmi.cal_done;
1730
1731 if (ab->hw_params.internal_sleep_clock) {
1732 req.nm_modem_valid = 1;
1733
1734
1735 req.nm_modem |= HOST_CSTATE_BIT;
1736
1737
1738
1739
1740
1741
1742 req.nm_modem |= SLEEP_CLOCK_SELECT_INTERNAL_BIT;
1743 }
1744
1745 if (ab->hw_params.global_reset)
1746 req.nm_modem |= PLATFORM_CAP_PCIE_GLOBAL_RESET;
1747
1748 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi host cap request\n");
1749
1750 ret = qmi_txn_init(&ab->qmi.handle, &txn,
1751 qmi_wlanfw_host_cap_resp_msg_v01_ei, &resp);
1752 if (ret < 0)
1753 goto out;
1754
1755 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1756 QMI_WLANFW_HOST_CAP_REQ_V01,
1757 QMI_WLANFW_HOST_CAP_REQ_MSG_V01_MAX_LEN,
1758 qmi_wlanfw_host_cap_req_msg_v01_ei, &req);
1759 if (ret < 0) {
1760 qmi_txn_cancel(&txn);
1761 ath11k_warn(ab, "failed to send host capability request: %d\n", ret);
1762 goto out;
1763 }
1764
1765 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1766 if (ret < 0)
1767 goto out;
1768
1769 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1770 ath11k_warn(ab, "host capability request failed: %d %d\n",
1771 resp.resp.result, resp.resp.error);
1772 ret = -EINVAL;
1773 goto out;
1774 }
1775
1776 out:
1777 return ret;
1778 }
1779
1780 static int ath11k_qmi_fw_ind_register_send(struct ath11k_base *ab)
1781 {
1782 struct qmi_wlanfw_ind_register_req_msg_v01 *req;
1783 struct qmi_wlanfw_ind_register_resp_msg_v01 *resp;
1784 struct qmi_handle *handle = &ab->qmi.handle;
1785 struct qmi_txn txn;
1786 int ret;
1787
1788 req = kzalloc(sizeof(*req), GFP_KERNEL);
1789 if (!req)
1790 return -ENOMEM;
1791
1792 resp = kzalloc(sizeof(*resp), GFP_KERNEL);
1793 if (!resp) {
1794 ret = -ENOMEM;
1795 goto resp_out;
1796 }
1797
1798 req->client_id_valid = 1;
1799 req->client_id = QMI_WLANFW_CLIENT_ID;
1800 req->fw_ready_enable_valid = 1;
1801 req->fw_ready_enable = 1;
1802 req->cal_done_enable_valid = 1;
1803 req->cal_done_enable = 1;
1804 req->fw_init_done_enable_valid = 1;
1805 req->fw_init_done_enable = 1;
1806
1807 req->pin_connect_result_enable_valid = 0;
1808 req->pin_connect_result_enable = 0;
1809
1810
1811
1812
1813
1814 if (!ab->hw_params.fixed_fw_mem) {
1815 req->request_mem_enable_valid = 1;
1816 req->request_mem_enable = 1;
1817 req->fw_mem_ready_enable_valid = 1;
1818 req->fw_mem_ready_enable = 1;
1819 }
1820
1821 ret = qmi_txn_init(handle, &txn,
1822 qmi_wlanfw_ind_register_resp_msg_v01_ei, resp);
1823 if (ret < 0)
1824 goto out;
1825
1826 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi indication register request\n");
1827
1828 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1829 QMI_WLANFW_IND_REGISTER_REQ_V01,
1830 QMI_WLANFW_IND_REGISTER_REQ_MSG_V01_MAX_LEN,
1831 qmi_wlanfw_ind_register_req_msg_v01_ei, req);
1832 if (ret < 0) {
1833 qmi_txn_cancel(&txn);
1834 ath11k_warn(ab, "failed to send indication register request: %d\n",
1835 ret);
1836 goto out;
1837 }
1838
1839 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1840 if (ret < 0) {
1841 ath11k_warn(ab, "failed to register fw indication: %d\n", ret);
1842 goto out;
1843 }
1844
1845 if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
1846 ath11k_warn(ab, "firmware indication register request failed: %d %d\n",
1847 resp->resp.result, resp->resp.error);
1848 ret = -EINVAL;
1849 goto out;
1850 }
1851
1852 out:
1853 kfree(resp);
1854 resp_out:
1855 kfree(req);
1856 return ret;
1857 }
1858
1859 static int ath11k_qmi_respond_fw_mem_request(struct ath11k_base *ab)
1860 {
1861 struct qmi_wlanfw_respond_mem_req_msg_v01 *req;
1862 struct qmi_wlanfw_respond_mem_resp_msg_v01 resp;
1863 struct qmi_txn txn;
1864 int ret = 0, i;
1865 bool delayed;
1866
1867 req = kzalloc(sizeof(*req), GFP_KERNEL);
1868 if (!req)
1869 return -ENOMEM;
1870
1871 memset(&resp, 0, sizeof(resp));
1872
1873
1874
1875
1876
1877
1878 if (!(ab->hw_params.fixed_mem_region ||
1879 test_bit(ATH11K_FLAG_FIXED_MEM_RGN, &ab->dev_flags)) &&
1880 ab->qmi.target_mem_delayed) {
1881 delayed = true;
1882 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi delays mem_request %d\n",
1883 ab->qmi.mem_seg_count);
1884 memset(req, 0, sizeof(*req));
1885 } else {
1886 delayed = false;
1887 req->mem_seg_len = ab->qmi.mem_seg_count;
1888
1889 for (i = 0; i < req->mem_seg_len ; i++) {
1890 req->mem_seg[i].addr = ab->qmi.target_mem[i].paddr;
1891 req->mem_seg[i].size = ab->qmi.target_mem[i].size;
1892 req->mem_seg[i].type = ab->qmi.target_mem[i].type;
1893 ath11k_dbg(ab, ATH11K_DBG_QMI,
1894 "qmi req mem_seg[%d] %pad %u %u\n", i,
1895 &ab->qmi.target_mem[i].paddr,
1896 ab->qmi.target_mem[i].size,
1897 ab->qmi.target_mem[i].type);
1898 }
1899 }
1900
1901 ret = qmi_txn_init(&ab->qmi.handle, &txn,
1902 qmi_wlanfw_respond_mem_resp_msg_v01_ei, &resp);
1903 if (ret < 0)
1904 goto out;
1905
1906 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi respond memory request delayed %i\n",
1907 delayed);
1908
1909 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1910 QMI_WLANFW_RESPOND_MEM_REQ_V01,
1911 QMI_WLANFW_RESPOND_MEM_REQ_MSG_V01_MAX_LEN,
1912 qmi_wlanfw_respond_mem_req_msg_v01_ei, req);
1913 if (ret < 0) {
1914 qmi_txn_cancel(&txn);
1915 ath11k_warn(ab, "failed to respond qmi memory request: %d\n",
1916 ret);
1917 goto out;
1918 }
1919
1920 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1921 if (ret < 0) {
1922 ath11k_warn(ab, "failed to wait qmi memory request: %d\n", ret);
1923 goto out;
1924 }
1925
1926 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1927
1928
1929
1930 if (delayed && resp.resp.error == 0)
1931 goto out;
1932
1933 ath11k_warn(ab, "qmi respond memory request failed: %d %d\n",
1934 resp.resp.result, resp.resp.error);
1935 ret = -EINVAL;
1936 goto out;
1937 }
1938 out:
1939 kfree(req);
1940 return ret;
1941 }
1942
1943 static void ath11k_qmi_free_target_mem_chunk(struct ath11k_base *ab)
1944 {
1945 int i;
1946
1947 for (i = 0; i < ab->qmi.mem_seg_count; i++) {
1948 if ((ab->hw_params.fixed_mem_region ||
1949 test_bit(ATH11K_FLAG_FIXED_MEM_RGN, &ab->dev_flags)) &&
1950 ab->qmi.target_mem[i].iaddr)
1951 iounmap(ab->qmi.target_mem[i].iaddr);
1952
1953 if (!ab->qmi.target_mem[i].vaddr)
1954 continue;
1955
1956 dma_free_coherent(ab->dev,
1957 ab->qmi.target_mem[i].size,
1958 ab->qmi.target_mem[i].vaddr,
1959 ab->qmi.target_mem[i].paddr);
1960 ab->qmi.target_mem[i].vaddr = NULL;
1961 }
1962 }
1963
1964 static int ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base *ab)
1965 {
1966 int i;
1967 struct target_mem_chunk *chunk;
1968
1969 ab->qmi.target_mem_delayed = false;
1970
1971 for (i = 0; i < ab->qmi.mem_seg_count; i++) {
1972 chunk = &ab->qmi.target_mem[i];
1973
1974
1975
1976
1977 if (chunk->vaddr) {
1978 if (chunk->prev_type == chunk->type ||
1979 chunk->prev_size == chunk->size)
1980 continue;
1981
1982
1983 dma_free_coherent(ab->dev, chunk->size,
1984 chunk->vaddr, chunk->paddr);
1985 chunk->vaddr = NULL;
1986 }
1987
1988 chunk->vaddr = dma_alloc_coherent(ab->dev,
1989 chunk->size,
1990 &chunk->paddr,
1991 GFP_KERNEL | __GFP_NOWARN);
1992 if (!chunk->vaddr) {
1993 if (ab->qmi.mem_seg_count <= ATH11K_QMI_FW_MEM_REQ_SEGMENT_CNT) {
1994 ath11k_dbg(ab, ATH11K_DBG_QMI,
1995 "qmi dma allocation failed (%d B type %u), will try later with small size\n",
1996 chunk->size,
1997 chunk->type);
1998 ath11k_qmi_free_target_mem_chunk(ab);
1999 ab->qmi.target_mem_delayed = true;
2000 return 0;
2001 }
2002
2003 ath11k_err(ab, "failed to allocate dma memory for qmi (%d B type %u)\n",
2004 chunk->size,
2005 chunk->type);
2006 return -EINVAL;
2007 }
2008 chunk->prev_type = chunk->type;
2009 chunk->prev_size = chunk->size;
2010 }
2011
2012 return 0;
2013 }
2014
2015 static int ath11k_qmi_assign_target_mem_chunk(struct ath11k_base *ab)
2016 {
2017 struct device *dev = ab->dev;
2018 struct device_node *hremote_node = NULL;
2019 struct resource res;
2020 u32 host_ddr_sz;
2021 int i, idx, ret;
2022
2023 for (i = 0, idx = 0; i < ab->qmi.mem_seg_count; i++) {
2024 switch (ab->qmi.target_mem[i].type) {
2025 case HOST_DDR_REGION_TYPE:
2026 hremote_node = of_parse_phandle(dev->of_node, "memory-region", 0);
2027 if (!hremote_node) {
2028 ath11k_dbg(ab, ATH11K_DBG_QMI,
2029 "qmi fail to get hremote_node\n");
2030 return -ENODEV;
2031 }
2032
2033 ret = of_address_to_resource(hremote_node, 0, &res);
2034 of_node_put(hremote_node);
2035 if (ret) {
2036 ath11k_dbg(ab, ATH11K_DBG_QMI,
2037 "qmi fail to get reg from hremote\n");
2038 return ret;
2039 }
2040
2041 if (res.end - res.start + 1 < ab->qmi.target_mem[i].size) {
2042 ath11k_dbg(ab, ATH11K_DBG_QMI,
2043 "qmi fail to assign memory of sz\n");
2044 return -EINVAL;
2045 }
2046
2047 ab->qmi.target_mem[idx].paddr = res.start;
2048 ab->qmi.target_mem[idx].iaddr =
2049 ioremap(ab->qmi.target_mem[idx].paddr,
2050 ab->qmi.target_mem[i].size);
2051 ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
2052 host_ddr_sz = ab->qmi.target_mem[i].size;
2053 ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
2054 idx++;
2055 break;
2056 case BDF_MEM_REGION_TYPE:
2057 ab->qmi.target_mem[idx].paddr = ab->hw_params.bdf_addr;
2058 ab->qmi.target_mem[idx].vaddr = NULL;
2059 ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
2060 ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
2061 idx++;
2062 break;
2063 case CALDB_MEM_REGION_TYPE:
2064 if (ab->qmi.target_mem[i].size > ATH11K_QMI_CALDB_SIZE) {
2065 ath11k_warn(ab, "qmi mem size is low to load caldata\n");
2066 return -EINVAL;
2067 }
2068
2069 if (ath11k_cold_boot_cal && ab->hw_params.cold_boot_calib) {
2070 if (hremote_node) {
2071 ab->qmi.target_mem[idx].paddr =
2072 res.start + host_ddr_sz;
2073 ab->qmi.target_mem[idx].iaddr =
2074 ioremap(ab->qmi.target_mem[idx].paddr,
2075 ab->qmi.target_mem[i].size);
2076 } else {
2077 ab->qmi.target_mem[idx].paddr =
2078 ATH11K_QMI_CALDB_ADDRESS;
2079 }
2080 } else {
2081 ab->qmi.target_mem[idx].paddr = 0;
2082 ab->qmi.target_mem[idx].vaddr = NULL;
2083 }
2084 ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
2085 ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
2086 idx++;
2087 break;
2088 default:
2089 ath11k_warn(ab, "qmi ignore invalid mem req type %d\n",
2090 ab->qmi.target_mem[i].type);
2091 break;
2092 }
2093 }
2094 ab->qmi.mem_seg_count = idx;
2095
2096 return 0;
2097 }
2098
2099 static int ath11k_qmi_request_device_info(struct ath11k_base *ab)
2100 {
2101 struct qmi_wlanfw_device_info_req_msg_v01 req = {};
2102 struct qmi_wlanfw_device_info_resp_msg_v01 resp = {};
2103 struct qmi_txn txn;
2104 void __iomem *bar_addr_va;
2105 int ret;
2106
2107
2108 if (!ab->hw_params.hybrid_bus_type)
2109 return 0;
2110
2111 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2112 qmi_wlfw_device_info_resp_msg_v01_ei, &resp);
2113 if (ret < 0)
2114 goto out;
2115
2116 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2117 QMI_WLANFW_DEVICE_INFO_REQ_V01,
2118 QMI_WLANFW_DEVICE_INFO_REQ_MSG_V01_MAX_LEN,
2119 qmi_wlanfw_device_info_req_msg_v01_ei, &req);
2120 if (ret < 0) {
2121 qmi_txn_cancel(&txn);
2122 ath11k_warn(ab, "failed to send qmi target device info request: %d\n",
2123 ret);
2124 goto out;
2125 }
2126
2127 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2128 if (ret < 0) {
2129 ath11k_warn(ab, "failed to wait qmi target device info request: %d\n",
2130 ret);
2131 goto out;
2132 }
2133
2134 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2135 ath11k_warn(ab, "qmi device info request failed: %d %d\n",
2136 resp.resp.result, resp.resp.error);
2137 ret = -EINVAL;
2138 goto out;
2139 }
2140
2141 if (!resp.bar_addr_valid || !resp.bar_size_valid) {
2142 ath11k_warn(ab, "qmi device info response invalid: %d %d\n",
2143 resp.resp.result, resp.resp.error);
2144 ret = -EINVAL;
2145 goto out;
2146 }
2147
2148 if (!resp.bar_addr ||
2149 resp.bar_size != ATH11K_QMI_DEVICE_BAR_SIZE) {
2150 ath11k_warn(ab, "qmi device info invalid address and size: %llu %u\n",
2151 resp.bar_addr, resp.bar_size);
2152 ret = -EINVAL;
2153 goto out;
2154 }
2155
2156 bar_addr_va = devm_ioremap(ab->dev, resp.bar_addr, resp.bar_size);
2157
2158 if (!bar_addr_va) {
2159 ath11k_warn(ab, "qmi device info ioremap failed\n");
2160 ab->mem_len = 0;
2161 ret = -EIO;
2162 goto out;
2163 }
2164
2165 ab->mem = bar_addr_va;
2166 ab->mem_len = resp.bar_size;
2167
2168 return 0;
2169 out:
2170 return ret;
2171 }
2172
2173 static int ath11k_qmi_request_target_cap(struct ath11k_base *ab)
2174 {
2175 struct qmi_wlanfw_cap_req_msg_v01 req;
2176 struct qmi_wlanfw_cap_resp_msg_v01 resp;
2177 struct qmi_txn txn;
2178 int ret = 0;
2179 int r;
2180 char *fw_build_id;
2181 int fw_build_id_mask_len;
2182
2183 memset(&req, 0, sizeof(req));
2184 memset(&resp, 0, sizeof(resp));
2185
2186 ret = qmi_txn_init(&ab->qmi.handle, &txn, qmi_wlanfw_cap_resp_msg_v01_ei,
2187 &resp);
2188 if (ret < 0)
2189 goto out;
2190
2191 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi target cap request\n");
2192
2193 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2194 QMI_WLANFW_CAP_REQ_V01,
2195 QMI_WLANFW_CAP_REQ_MSG_V01_MAX_LEN,
2196 qmi_wlanfw_cap_req_msg_v01_ei, &req);
2197 if (ret < 0) {
2198 qmi_txn_cancel(&txn);
2199 ath11k_warn(ab, "failed to send qmi cap request: %d\n",
2200 ret);
2201 goto out;
2202 }
2203
2204 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2205 if (ret < 0) {
2206 ath11k_warn(ab, "failed to wait qmi cap request: %d\n", ret);
2207 goto out;
2208 }
2209
2210 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2211 ath11k_warn(ab, "qmi cap request failed: %d %d\n",
2212 resp.resp.result, resp.resp.error);
2213 ret = -EINVAL;
2214 goto out;
2215 }
2216
2217 if (resp.chip_info_valid) {
2218 ab->qmi.target.chip_id = resp.chip_info.chip_id;
2219 ab->qmi.target.chip_family = resp.chip_info.chip_family;
2220 }
2221
2222 if (resp.board_info_valid)
2223 ab->qmi.target.board_id = resp.board_info.board_id;
2224 else
2225 ab->qmi.target.board_id = 0xFF;
2226
2227 if (resp.soc_info_valid)
2228 ab->qmi.target.soc_id = resp.soc_info.soc_id;
2229
2230 if (resp.fw_version_info_valid) {
2231 ab->qmi.target.fw_version = resp.fw_version_info.fw_version;
2232 strscpy(ab->qmi.target.fw_build_timestamp,
2233 resp.fw_version_info.fw_build_timestamp,
2234 sizeof(ab->qmi.target.fw_build_timestamp));
2235 }
2236
2237 if (resp.fw_build_id_valid)
2238 strscpy(ab->qmi.target.fw_build_id, resp.fw_build_id,
2239 sizeof(ab->qmi.target.fw_build_id));
2240
2241 if (resp.eeprom_read_timeout_valid) {
2242 ab->qmi.target.eeprom_caldata =
2243 resp.eeprom_read_timeout;
2244 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi cal data supported from eeprom\n");
2245 }
2246
2247 fw_build_id = ab->qmi.target.fw_build_id;
2248 fw_build_id_mask_len = strlen(FW_BUILD_ID_MASK);
2249 if (!strncmp(fw_build_id, FW_BUILD_ID_MASK, fw_build_id_mask_len))
2250 fw_build_id = fw_build_id + fw_build_id_mask_len;
2251
2252 ath11k_info(ab, "chip_id 0x%x chip_family 0x%x board_id 0x%x soc_id 0x%x\n",
2253 ab->qmi.target.chip_id, ab->qmi.target.chip_family,
2254 ab->qmi.target.board_id, ab->qmi.target.soc_id);
2255
2256 ath11k_info(ab, "fw_version 0x%x fw_build_timestamp %s fw_build_id %s",
2257 ab->qmi.target.fw_version,
2258 ab->qmi.target.fw_build_timestamp,
2259 fw_build_id);
2260
2261 r = ath11k_core_check_smbios(ab);
2262 if (r)
2263 ath11k_dbg(ab, ATH11K_DBG_QMI, "SMBIOS bdf variant name not set.\n");
2264
2265 r = ath11k_core_check_dt(ab);
2266 if (r)
2267 ath11k_dbg(ab, ATH11K_DBG_QMI, "DT bdf variant name not set.\n");
2268
2269 out:
2270 return ret;
2271 }
2272
2273 static int ath11k_qmi_load_file_target_mem(struct ath11k_base *ab,
2274 const u8 *data, u32 len, u8 type)
2275 {
2276 struct qmi_wlanfw_bdf_download_req_msg_v01 *req;
2277 struct qmi_wlanfw_bdf_download_resp_msg_v01 resp;
2278 struct qmi_txn txn;
2279 const u8 *temp = data;
2280 void __iomem *bdf_addr = NULL;
2281 int ret;
2282 u32 remaining = len;
2283
2284 req = kzalloc(sizeof(*req), GFP_KERNEL);
2285 if (!req)
2286 return -ENOMEM;
2287
2288 memset(&resp, 0, sizeof(resp));
2289
2290 if (ab->hw_params.fixed_bdf_addr) {
2291 bdf_addr = ioremap(ab->hw_params.bdf_addr, ab->hw_params.fw.board_size);
2292 if (!bdf_addr) {
2293 ath11k_warn(ab, "qmi ioremap error for bdf_addr\n");
2294 ret = -EIO;
2295 goto err_free_req;
2296 }
2297 }
2298
2299 while (remaining) {
2300 req->valid = 1;
2301 req->file_id_valid = 1;
2302 req->file_id = ab->qmi.target.board_id;
2303 req->total_size_valid = 1;
2304 req->total_size = remaining;
2305 req->seg_id_valid = 1;
2306 req->data_valid = 1;
2307 req->bdf_type = type;
2308 req->bdf_type_valid = 1;
2309 req->end_valid = 1;
2310 req->end = 0;
2311
2312 if (remaining > QMI_WLANFW_MAX_DATA_SIZE_V01) {
2313 req->data_len = QMI_WLANFW_MAX_DATA_SIZE_V01;
2314 } else {
2315 req->data_len = remaining;
2316 req->end = 1;
2317 }
2318
2319 if (ab->hw_params.fixed_bdf_addr ||
2320 type == ATH11K_QMI_FILE_TYPE_EEPROM) {
2321 req->data_valid = 0;
2322 req->end = 1;
2323 req->data_len = ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE;
2324 } else {
2325 memcpy(req->data, temp, req->data_len);
2326 }
2327
2328 if (ab->hw_params.fixed_bdf_addr) {
2329 if (type == ATH11K_QMI_FILE_TYPE_CALDATA)
2330 bdf_addr += ab->hw_params.fw.cal_offset;
2331
2332 memcpy_toio(bdf_addr, temp, len);
2333 }
2334
2335 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2336 qmi_wlanfw_bdf_download_resp_msg_v01_ei,
2337 &resp);
2338 if (ret < 0)
2339 goto err_iounmap;
2340
2341 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi bdf download req fixed addr type %d\n",
2342 type);
2343
2344 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2345 QMI_WLANFW_BDF_DOWNLOAD_REQ_V01,
2346 QMI_WLANFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_LEN,
2347 qmi_wlanfw_bdf_download_req_msg_v01_ei, req);
2348 if (ret < 0) {
2349 qmi_txn_cancel(&txn);
2350 goto err_iounmap;
2351 }
2352
2353 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2354 if (ret < 0) {
2355 ath11k_warn(ab, "failed to wait board file download request: %d\n",
2356 ret);
2357 goto err_iounmap;
2358 }
2359
2360 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2361 ath11k_warn(ab, "board file download request failed: %d %d\n",
2362 resp.resp.result, resp.resp.error);
2363 ret = -EINVAL;
2364 goto err_iounmap;
2365 }
2366
2367 if (ab->hw_params.fixed_bdf_addr ||
2368 type == ATH11K_QMI_FILE_TYPE_EEPROM) {
2369 remaining = 0;
2370 } else {
2371 remaining -= req->data_len;
2372 temp += req->data_len;
2373 req->seg_id++;
2374 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi bdf download request remaining %i\n",
2375 remaining);
2376 }
2377 }
2378
2379 err_iounmap:
2380 if (ab->hw_params.fixed_bdf_addr)
2381 iounmap(bdf_addr);
2382
2383 err_free_req:
2384 kfree(req);
2385
2386 return ret;
2387 }
2388
2389 static int ath11k_qmi_load_bdf_qmi(struct ath11k_base *ab,
2390 bool regdb)
2391 {
2392 struct device *dev = ab->dev;
2393 char filename[ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE];
2394 const struct firmware *fw_entry;
2395 struct ath11k_board_data bd;
2396 u32 fw_size, file_type;
2397 int ret = 0, bdf_type;
2398 const u8 *tmp;
2399
2400 memset(&bd, 0, sizeof(bd));
2401
2402 if (regdb) {
2403 ret = ath11k_core_fetch_regdb(ab, &bd);
2404 } else {
2405 ret = ath11k_core_fetch_bdf(ab, &bd);
2406 if (ret)
2407 ath11k_warn(ab, "qmi failed to fetch board file: %d\n", ret);
2408 }
2409
2410 if (ret)
2411 goto out;
2412
2413 if (regdb)
2414 bdf_type = ATH11K_QMI_BDF_TYPE_REGDB;
2415 else if (bd.len >= SELFMAG && memcmp(bd.data, ELFMAG, SELFMAG) == 0)
2416 bdf_type = ATH11K_QMI_BDF_TYPE_ELF;
2417 else
2418 bdf_type = ATH11K_QMI_BDF_TYPE_BIN;
2419
2420 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi bdf_type %d\n", bdf_type);
2421
2422 fw_size = min_t(u32, ab->hw_params.fw.board_size, bd.len);
2423
2424 ret = ath11k_qmi_load_file_target_mem(ab, bd.data, fw_size, bdf_type);
2425 if (ret < 0) {
2426 ath11k_warn(ab, "qmi failed to load bdf file\n");
2427 goto out;
2428 }
2429
2430
2431 if (bdf_type == ATH11K_QMI_BDF_TYPE_ELF || bdf_type == ATH11K_QMI_BDF_TYPE_REGDB)
2432 goto out;
2433
2434 if (ab->qmi.target.eeprom_caldata) {
2435 file_type = ATH11K_QMI_FILE_TYPE_EEPROM;
2436 tmp = filename;
2437 fw_size = ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE;
2438 } else {
2439 file_type = ATH11K_QMI_FILE_TYPE_CALDATA;
2440
2441
2442 snprintf(filename, sizeof(filename), "cal-%s-%s.bin",
2443 ath11k_bus_str(ab->hif.bus), dev_name(dev));
2444 fw_entry = ath11k_core_firmware_request(ab, filename);
2445 if (!IS_ERR(fw_entry))
2446 goto success;
2447
2448 fw_entry = ath11k_core_firmware_request(ab, ATH11K_DEFAULT_CAL_FILE);
2449 if (IS_ERR(fw_entry)) {
2450 ret = PTR_ERR(fw_entry);
2451 ath11k_warn(ab,
2452 "qmi failed to load CAL data file:%s\n",
2453 filename);
2454 goto out;
2455 }
2456 success:
2457 fw_size = min_t(u32, ab->hw_params.fw.board_size, fw_entry->size);
2458 tmp = fw_entry->data;
2459 }
2460
2461 ret = ath11k_qmi_load_file_target_mem(ab, tmp, fw_size, file_type);
2462 if (ret < 0) {
2463 ath11k_warn(ab, "qmi failed to load caldata\n");
2464 goto out_qmi_cal;
2465 }
2466
2467 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi caldata type: %u\n", file_type);
2468
2469 out_qmi_cal:
2470 if (!ab->qmi.target.eeprom_caldata)
2471 release_firmware(fw_entry);
2472 out:
2473 ath11k_core_free_bdf(ab, &bd);
2474 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi BDF download sequence completed\n");
2475
2476 return ret;
2477 }
2478
2479 static int ath11k_qmi_m3_load(struct ath11k_base *ab)
2480 {
2481 struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2482 const struct firmware *fw;
2483 char path[100];
2484 int ret;
2485
2486 fw = ath11k_core_firmware_request(ab, ATH11K_M3_FILE);
2487 if (IS_ERR(fw)) {
2488 ret = PTR_ERR(fw);
2489 ath11k_core_create_firmware_path(ab, ATH11K_M3_FILE,
2490 path, sizeof(path));
2491 ath11k_err(ab, "failed to load %s: %d\n", path, ret);
2492 return ret;
2493 }
2494
2495 if (m3_mem->vaddr || m3_mem->size)
2496 goto skip_m3_alloc;
2497
2498 m3_mem->vaddr = dma_alloc_coherent(ab->dev,
2499 fw->size, &m3_mem->paddr,
2500 GFP_KERNEL);
2501 if (!m3_mem->vaddr) {
2502 ath11k_err(ab, "failed to allocate memory for M3 with size %zu\n",
2503 fw->size);
2504 release_firmware(fw);
2505 return -ENOMEM;
2506 }
2507
2508 skip_m3_alloc:
2509 memcpy(m3_mem->vaddr, fw->data, fw->size);
2510 m3_mem->size = fw->size;
2511 release_firmware(fw);
2512
2513 return 0;
2514 }
2515
2516 static void ath11k_qmi_m3_free(struct ath11k_base *ab)
2517 {
2518 struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2519
2520 if (!ab->hw_params.m3_fw_support || !m3_mem->vaddr)
2521 return;
2522
2523 dma_free_coherent(ab->dev, m3_mem->size,
2524 m3_mem->vaddr, m3_mem->paddr);
2525 m3_mem->vaddr = NULL;
2526 m3_mem->size = 0;
2527 }
2528
2529 static int ath11k_qmi_wlanfw_m3_info_send(struct ath11k_base *ab)
2530 {
2531 struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2532 struct qmi_wlanfw_m3_info_req_msg_v01 req;
2533 struct qmi_wlanfw_m3_info_resp_msg_v01 resp;
2534 struct qmi_txn txn;
2535 int ret = 0;
2536
2537 memset(&req, 0, sizeof(req));
2538 memset(&resp, 0, sizeof(resp));
2539
2540 if (ab->hw_params.m3_fw_support) {
2541 ret = ath11k_qmi_m3_load(ab);
2542 if (ret) {
2543 ath11k_err(ab, "failed to load m3 firmware: %d", ret);
2544 return ret;
2545 }
2546
2547 req.addr = m3_mem->paddr;
2548 req.size = m3_mem->size;
2549 } else {
2550 req.addr = 0;
2551 req.size = 0;
2552 }
2553
2554 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2555 qmi_wlanfw_m3_info_resp_msg_v01_ei, &resp);
2556 if (ret < 0)
2557 goto out;
2558
2559 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi m3 info req\n");
2560
2561 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2562 QMI_WLANFW_M3_INFO_REQ_V01,
2563 QMI_WLANFW_M3_INFO_REQ_MSG_V01_MAX_MSG_LEN,
2564 qmi_wlanfw_m3_info_req_msg_v01_ei, &req);
2565 if (ret < 0) {
2566 qmi_txn_cancel(&txn);
2567 ath11k_warn(ab, "failed to send m3 information request: %d\n",
2568 ret);
2569 goto out;
2570 }
2571
2572 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2573 if (ret < 0) {
2574 ath11k_warn(ab, "failed to wait m3 information request: %d\n", ret);
2575 goto out;
2576 }
2577
2578 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2579 ath11k_warn(ab, "m3 info request failed: %d %d\n",
2580 resp.resp.result, resp.resp.error);
2581 ret = -EINVAL;
2582 goto out;
2583 }
2584 out:
2585 return ret;
2586 }
2587
2588 static int ath11k_qmi_wlanfw_mode_send(struct ath11k_base *ab,
2589 u32 mode)
2590 {
2591 struct qmi_wlanfw_wlan_mode_req_msg_v01 req;
2592 struct qmi_wlanfw_wlan_mode_resp_msg_v01 resp;
2593 struct qmi_txn txn;
2594 int ret = 0;
2595
2596 memset(&req, 0, sizeof(req));
2597 memset(&resp, 0, sizeof(resp));
2598
2599 req.mode = mode;
2600 req.hw_debug_valid = 1;
2601 req.hw_debug = 0;
2602
2603 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2604 qmi_wlanfw_wlan_mode_resp_msg_v01_ei, &resp);
2605 if (ret < 0)
2606 goto out;
2607
2608 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wlan mode req mode %d\n", mode);
2609
2610 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2611 QMI_WLANFW_WLAN_MODE_REQ_V01,
2612 QMI_WLANFW_WLAN_MODE_REQ_MSG_V01_MAX_LEN,
2613 qmi_wlanfw_wlan_mode_req_msg_v01_ei, &req);
2614 if (ret < 0) {
2615 qmi_txn_cancel(&txn);
2616 ath11k_warn(ab, "failed to send wlan mode request (mode %d): %d\n",
2617 mode, ret);
2618 goto out;
2619 }
2620
2621 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2622 if (ret < 0) {
2623 if (mode == ATH11K_FIRMWARE_MODE_OFF && ret == -ENETRESET) {
2624 ath11k_warn(ab, "WLFW service is dis-connected\n");
2625 return 0;
2626 }
2627 ath11k_warn(ab, "failed to wait wlan mode request (mode %d): %d\n",
2628 mode, ret);
2629 goto out;
2630 }
2631
2632 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2633 ath11k_warn(ab, "wlan mode request failed (mode: %d): %d %d\n",
2634 mode, resp.resp.result, resp.resp.error);
2635 ret = -EINVAL;
2636 goto out;
2637 }
2638
2639 out:
2640 return ret;
2641 }
2642
2643 static int ath11k_qmi_wlanfw_wlan_cfg_send(struct ath11k_base *ab)
2644 {
2645 struct qmi_wlanfw_wlan_cfg_req_msg_v01 *req;
2646 struct qmi_wlanfw_wlan_cfg_resp_msg_v01 resp;
2647 struct ce_pipe_config *ce_cfg;
2648 struct service_to_pipe *svc_cfg;
2649 struct qmi_txn txn;
2650 int ret = 0, pipe_num;
2651
2652 ce_cfg = (struct ce_pipe_config *)ab->qmi.ce_cfg.tgt_ce;
2653 svc_cfg = (struct service_to_pipe *)ab->qmi.ce_cfg.svc_to_ce_map;
2654
2655 req = kzalloc(sizeof(*req), GFP_KERNEL);
2656 if (!req)
2657 return -ENOMEM;
2658
2659 memset(&resp, 0, sizeof(resp));
2660
2661 req->host_version_valid = 1;
2662 strscpy(req->host_version, ATH11K_HOST_VERSION_STRING,
2663 sizeof(req->host_version));
2664
2665 req->tgt_cfg_valid = 1;
2666
2667 req->tgt_cfg_len = ab->qmi.ce_cfg.tgt_ce_len;
2668 for (pipe_num = 0; pipe_num < req->tgt_cfg_len ; pipe_num++) {
2669 req->tgt_cfg[pipe_num].pipe_num = ce_cfg[pipe_num].pipenum;
2670 req->tgt_cfg[pipe_num].pipe_dir = ce_cfg[pipe_num].pipedir;
2671 req->tgt_cfg[pipe_num].nentries = ce_cfg[pipe_num].nentries;
2672 req->tgt_cfg[pipe_num].nbytes_max = ce_cfg[pipe_num].nbytes_max;
2673 req->tgt_cfg[pipe_num].flags = ce_cfg[pipe_num].flags;
2674 }
2675
2676 req->svc_cfg_valid = 1;
2677
2678 req->svc_cfg_len = ab->qmi.ce_cfg.svc_to_ce_map_len;
2679 for (pipe_num = 0; pipe_num < req->svc_cfg_len; pipe_num++) {
2680 req->svc_cfg[pipe_num].service_id = svc_cfg[pipe_num].service_id;
2681 req->svc_cfg[pipe_num].pipe_dir = svc_cfg[pipe_num].pipedir;
2682 req->svc_cfg[pipe_num].pipe_num = svc_cfg[pipe_num].pipenum;
2683 }
2684 req->shadow_reg_valid = 0;
2685
2686
2687 if (ab->hw_params.supports_shadow_regs) {
2688 req->shadow_reg_v2_valid = 1;
2689 req->shadow_reg_v2_len = min_t(u32,
2690 ab->qmi.ce_cfg.shadow_reg_v2_len,
2691 QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01);
2692 memcpy(&req->shadow_reg_v2, ab->qmi.ce_cfg.shadow_reg_v2,
2693 sizeof(u32) * req->shadow_reg_v2_len);
2694 } else {
2695 req->shadow_reg_v2_valid = 0;
2696 }
2697
2698 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2699 qmi_wlanfw_wlan_cfg_resp_msg_v01_ei, &resp);
2700 if (ret < 0)
2701 goto out;
2702
2703 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wlan cfg req\n");
2704
2705 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2706 QMI_WLANFW_WLAN_CFG_REQ_V01,
2707 QMI_WLANFW_WLAN_CFG_REQ_MSG_V01_MAX_LEN,
2708 qmi_wlanfw_wlan_cfg_req_msg_v01_ei, req);
2709 if (ret < 0) {
2710 qmi_txn_cancel(&txn);
2711 ath11k_warn(ab, "failed to send wlan config request: %d\n",
2712 ret);
2713 goto out;
2714 }
2715
2716 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2717 if (ret < 0) {
2718 ath11k_warn(ab, "failed to wait wlan config request: %d\n", ret);
2719 goto out;
2720 }
2721
2722 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2723 ath11k_warn(ab, "wlan config request failed: %d %d\n",
2724 resp.resp.result, resp.resp.error);
2725 ret = -EINVAL;
2726 goto out;
2727 }
2728
2729 out:
2730 kfree(req);
2731 return ret;
2732 }
2733
2734 static int ath11k_qmi_wlanfw_wlan_ini_send(struct ath11k_base *ab, bool enable)
2735 {
2736 int ret;
2737 struct qmi_txn txn;
2738 struct qmi_wlanfw_wlan_ini_req_msg_v01 req = {};
2739 struct qmi_wlanfw_wlan_ini_resp_msg_v01 resp = {};
2740
2741 req.enablefwlog_valid = true;
2742 req.enablefwlog = enable ? 1 : 0;
2743
2744 ret = qmi_txn_init(&ab->qmi.handle, &txn,
2745 qmi_wlanfw_wlan_ini_resp_msg_v01_ei, &resp);
2746 if (ret < 0)
2747 goto out;
2748
2749 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2750 QMI_WLANFW_WLAN_INI_REQ_V01,
2751 QMI_WLANFW_WLAN_INI_REQ_MSG_V01_MAX_LEN,
2752 qmi_wlanfw_wlan_ini_req_msg_v01_ei, &req);
2753 if (ret < 0) {
2754 ath11k_warn(ab, "qmi failed to send wlan ini request, err = %d\n",
2755 ret);
2756 qmi_txn_cancel(&txn);
2757 goto out;
2758 }
2759
2760 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2761 if (ret < 0) {
2762 ath11k_warn(ab, "qmi failed wlan ini request, err = %d\n", ret);
2763 goto out;
2764 }
2765
2766 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2767 ath11k_warn(ab, "qmi wlan ini request failed, result: %d, err: %d\n",
2768 resp.resp.result, resp.resp.error);
2769 ret = -EINVAL;
2770 }
2771
2772 out:
2773 return ret;
2774 }
2775
2776 void ath11k_qmi_firmware_stop(struct ath11k_base *ab)
2777 {
2778 int ret;
2779
2780 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware stop\n");
2781
2782 ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_OFF);
2783 if (ret < 0) {
2784 ath11k_warn(ab, "qmi failed to send wlan mode off: %d\n", ret);
2785 return;
2786 }
2787 }
2788
2789 int ath11k_qmi_firmware_start(struct ath11k_base *ab,
2790 u32 mode)
2791 {
2792 int ret;
2793
2794 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware start\n");
2795
2796 if (ab->hw_params.fw_wmi_diag_event) {
2797 ret = ath11k_qmi_wlanfw_wlan_ini_send(ab, true);
2798 if (ret < 0) {
2799 ath11k_warn(ab, "qmi failed to send wlan fw ini:%d\n", ret);
2800 return ret;
2801 }
2802 }
2803
2804 ret = ath11k_qmi_wlanfw_wlan_cfg_send(ab);
2805 if (ret < 0) {
2806 ath11k_warn(ab, "qmi failed to send wlan cfg: %d\n", ret);
2807 return ret;
2808 }
2809
2810 ret = ath11k_qmi_wlanfw_mode_send(ab, mode);
2811 if (ret < 0) {
2812 ath11k_warn(ab, "qmi failed to send wlan fw mode: %d\n", ret);
2813 return ret;
2814 }
2815
2816 return 0;
2817 }
2818
2819 static int ath11k_qmi_process_coldboot_calibration(struct ath11k_base *ab)
2820 {
2821 int timeout;
2822 int ret;
2823
2824 ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_COLD_BOOT);
2825 if (ret < 0) {
2826 ath11k_warn(ab, "qmi failed to send wlan fw mode: %d\n", ret);
2827 return ret;
2828 }
2829
2830 ath11k_dbg(ab, ATH11K_DBG_QMI, "Coldboot calibration wait started\n");
2831
2832 timeout = wait_event_timeout(ab->qmi.cold_boot_waitq,
2833 (ab->qmi.cal_done == 1),
2834 ATH11K_COLD_BOOT_FW_RESET_DELAY);
2835 if (timeout <= 0) {
2836 ath11k_warn(ab, "coldboot calibration timed out\n");
2837 return 0;
2838 }
2839
2840 ath11k_dbg(ab, ATH11K_DBG_QMI, "Coldboot calibration done\n");
2841
2842 return 0;
2843 }
2844
2845 static int
2846 ath11k_qmi_driver_event_post(struct ath11k_qmi *qmi,
2847 enum ath11k_qmi_event_type type,
2848 void *data)
2849 {
2850 struct ath11k_qmi_driver_event *event;
2851
2852 event = kzalloc(sizeof(*event), GFP_ATOMIC);
2853 if (!event)
2854 return -ENOMEM;
2855
2856 event->type = type;
2857 event->data = data;
2858
2859 spin_lock(&qmi->event_lock);
2860 list_add_tail(&event->list, &qmi->event_list);
2861 spin_unlock(&qmi->event_lock);
2862
2863 queue_work(qmi->event_wq, &qmi->event_work);
2864
2865 return 0;
2866 }
2867
2868 static int ath11k_qmi_event_mem_request(struct ath11k_qmi *qmi)
2869 {
2870 struct ath11k_base *ab = qmi->ab;
2871 int ret;
2872
2873 ret = ath11k_qmi_respond_fw_mem_request(ab);
2874 if (ret < 0) {
2875 ath11k_warn(ab, "qmi failed to respond fw mem req: %d\n", ret);
2876 return ret;
2877 }
2878
2879 return ret;
2880 }
2881
2882 static int ath11k_qmi_event_load_bdf(struct ath11k_qmi *qmi)
2883 {
2884 struct ath11k_base *ab = qmi->ab;
2885 int ret;
2886
2887 ret = ath11k_qmi_request_target_cap(ab);
2888 if (ret < 0) {
2889 ath11k_warn(ab, "failed to request qmi target capabilities: %d\n",
2890 ret);
2891 return ret;
2892 }
2893
2894 ret = ath11k_qmi_request_device_info(ab);
2895 if (ret < 0) {
2896 ath11k_warn(ab, "failed to request qmi device info: %d\n", ret);
2897 return ret;
2898 }
2899
2900 if (ab->hw_params.supports_regdb)
2901 ath11k_qmi_load_bdf_qmi(ab, true);
2902
2903 ret = ath11k_qmi_load_bdf_qmi(ab, false);
2904 if (ret < 0) {
2905 ath11k_warn(ab, "failed to load board data file: %d\n", ret);
2906 return ret;
2907 }
2908
2909 return 0;
2910 }
2911
2912 static int ath11k_qmi_event_server_arrive(struct ath11k_qmi *qmi)
2913 {
2914 struct ath11k_base *ab = qmi->ab;
2915 int ret;
2916
2917 ret = ath11k_qmi_fw_ind_register_send(ab);
2918 if (ret < 0) {
2919 ath11k_warn(ab, "failed to send qmi firmware indication: %d\n",
2920 ret);
2921 return ret;
2922 }
2923
2924 ret = ath11k_qmi_host_cap_send(ab);
2925 if (ret < 0) {
2926 ath11k_warn(ab, "failed to send qmi host cap: %d\n", ret);
2927 return ret;
2928 }
2929
2930 if (!ab->hw_params.fixed_fw_mem)
2931 return ret;
2932
2933 ret = ath11k_qmi_event_load_bdf(qmi);
2934 if (ret < 0) {
2935 ath11k_warn(ab, "qmi failed to download BDF:%d\n", ret);
2936 return ret;
2937 }
2938
2939 return ret;
2940 }
2941
2942 static void ath11k_qmi_msg_mem_request_cb(struct qmi_handle *qmi_hdl,
2943 struct sockaddr_qrtr *sq,
2944 struct qmi_txn *txn,
2945 const void *data)
2946 {
2947 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2948 struct ath11k_base *ab = qmi->ab;
2949 const struct qmi_wlanfw_request_mem_ind_msg_v01 *msg = data;
2950 int i, ret;
2951
2952 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware request memory request\n");
2953
2954 if (msg->mem_seg_len == 0 ||
2955 msg->mem_seg_len > ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01)
2956 ath11k_warn(ab, "invalid memory segment length: %u\n",
2957 msg->mem_seg_len);
2958
2959 ab->qmi.mem_seg_count = msg->mem_seg_len;
2960
2961 for (i = 0; i < qmi->mem_seg_count ; i++) {
2962 ab->qmi.target_mem[i].type = msg->mem_seg[i].type;
2963 ab->qmi.target_mem[i].size = msg->mem_seg[i].size;
2964 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi mem seg type %d size %d\n",
2965 msg->mem_seg[i].type, msg->mem_seg[i].size);
2966 }
2967
2968 if (ab->hw_params.fixed_mem_region ||
2969 test_bit(ATH11K_FLAG_FIXED_MEM_RGN, &ab->dev_flags)) {
2970 ret = ath11k_qmi_assign_target_mem_chunk(ab);
2971 if (ret) {
2972 ath11k_warn(ab, "failed to assign qmi target memory: %d\n",
2973 ret);
2974 return;
2975 }
2976 } else {
2977 ret = ath11k_qmi_alloc_target_mem_chunk(ab);
2978 if (ret) {
2979 ath11k_warn(ab, "failed to allocate qmi target memory: %d\n",
2980 ret);
2981 return;
2982 }
2983 }
2984
2985 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_REQUEST_MEM, NULL);
2986 }
2987
2988 static void ath11k_qmi_msg_mem_ready_cb(struct qmi_handle *qmi_hdl,
2989 struct sockaddr_qrtr *sq,
2990 struct qmi_txn *txn,
2991 const void *decoded)
2992 {
2993 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2994 struct ath11k_base *ab = qmi->ab;
2995
2996 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware memory ready indication\n");
2997 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_MEM_READY, NULL);
2998 }
2999
3000 static void ath11k_qmi_msg_fw_ready_cb(struct qmi_handle *qmi_hdl,
3001 struct sockaddr_qrtr *sq,
3002 struct qmi_txn *txn,
3003 const void *decoded)
3004 {
3005 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3006 struct ath11k_base *ab = qmi->ab;
3007
3008 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware ready\n");
3009 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_READY, NULL);
3010 }
3011
3012 static void ath11k_qmi_msg_cold_boot_cal_done_cb(struct qmi_handle *qmi_hdl,
3013 struct sockaddr_qrtr *sq,
3014 struct qmi_txn *txn,
3015 const void *decoded)
3016 {
3017 struct ath11k_qmi *qmi = container_of(qmi_hdl,
3018 struct ath11k_qmi, handle);
3019 struct ath11k_base *ab = qmi->ab;
3020
3021 ab->qmi.cal_done = 1;
3022 wake_up(&ab->qmi.cold_boot_waitq);
3023 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi cold boot calibration done\n");
3024 }
3025
3026 static const struct qmi_msg_handler ath11k_qmi_msg_handlers[] = {
3027 {
3028 .type = QMI_INDICATION,
3029 .msg_id = QMI_WLFW_REQUEST_MEM_IND_V01,
3030 .ei = qmi_wlanfw_request_mem_ind_msg_v01_ei,
3031 .decoded_size = sizeof(struct qmi_wlanfw_request_mem_ind_msg_v01),
3032 .fn = ath11k_qmi_msg_mem_request_cb,
3033 },
3034 {
3035 .type = QMI_INDICATION,
3036 .msg_id = QMI_WLFW_FW_MEM_READY_IND_V01,
3037 .ei = qmi_wlanfw_mem_ready_ind_msg_v01_ei,
3038 .decoded_size = sizeof(struct qmi_wlanfw_fw_mem_ready_ind_msg_v01),
3039 .fn = ath11k_qmi_msg_mem_ready_cb,
3040 },
3041 {
3042 .type = QMI_INDICATION,
3043 .msg_id = QMI_WLFW_FW_READY_IND_V01,
3044 .ei = qmi_wlanfw_fw_ready_ind_msg_v01_ei,
3045 .decoded_size = sizeof(struct qmi_wlanfw_fw_ready_ind_msg_v01),
3046 .fn = ath11k_qmi_msg_fw_ready_cb,
3047 },
3048 {
3049 .type = QMI_INDICATION,
3050 .msg_id = QMI_WLFW_COLD_BOOT_CAL_DONE_IND_V01,
3051 .ei = qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei,
3052 .decoded_size =
3053 sizeof(struct qmi_wlanfw_fw_cold_cal_done_ind_msg_v01),
3054 .fn = ath11k_qmi_msg_cold_boot_cal_done_cb,
3055 },
3056 };
3057
3058 static int ath11k_qmi_ops_new_server(struct qmi_handle *qmi_hdl,
3059 struct qmi_service *service)
3060 {
3061 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3062 struct ath11k_base *ab = qmi->ab;
3063 struct sockaddr_qrtr *sq = &qmi->sq;
3064 int ret;
3065
3066 sq->sq_family = AF_QIPCRTR;
3067 sq->sq_node = service->node;
3068 sq->sq_port = service->port;
3069
3070 ret = kernel_connect(qmi_hdl->sock, (struct sockaddr *)sq,
3071 sizeof(*sq), 0);
3072 if (ret) {
3073 ath11k_warn(ab, "failed to connect to qmi remote service: %d\n", ret);
3074 return ret;
3075 }
3076
3077 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wifi fw qmi service connected\n");
3078 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_ARRIVE, NULL);
3079
3080 return ret;
3081 }
3082
3083 static void ath11k_qmi_ops_del_server(struct qmi_handle *qmi_hdl,
3084 struct qmi_service *service)
3085 {
3086 struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3087 struct ath11k_base *ab = qmi->ab;
3088
3089 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wifi fw del server\n");
3090 ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_EXIT, NULL);
3091 }
3092
3093 static const struct qmi_ops ath11k_qmi_ops = {
3094 .new_server = ath11k_qmi_ops_new_server,
3095 .del_server = ath11k_qmi_ops_del_server,
3096 };
3097
3098 static void ath11k_qmi_driver_event_work(struct work_struct *work)
3099 {
3100 struct ath11k_qmi *qmi = container_of(work, struct ath11k_qmi,
3101 event_work);
3102 struct ath11k_qmi_driver_event *event;
3103 struct ath11k_base *ab = qmi->ab;
3104 int ret;
3105
3106 spin_lock(&qmi->event_lock);
3107 while (!list_empty(&qmi->event_list)) {
3108 event = list_first_entry(&qmi->event_list,
3109 struct ath11k_qmi_driver_event, list);
3110 list_del(&event->list);
3111 spin_unlock(&qmi->event_lock);
3112
3113 if (test_bit(ATH11K_FLAG_UNREGISTERING, &ab->dev_flags)) {
3114 kfree(event);
3115 return;
3116 }
3117
3118 switch (event->type) {
3119 case ATH11K_QMI_EVENT_SERVER_ARRIVE:
3120 ret = ath11k_qmi_event_server_arrive(qmi);
3121 if (ret < 0)
3122 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3123 break;
3124 case ATH11K_QMI_EVENT_SERVER_EXIT:
3125 set_bit(ATH11K_FLAG_CRASH_FLUSH, &ab->dev_flags);
3126 set_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
3127 break;
3128 case ATH11K_QMI_EVENT_REQUEST_MEM:
3129 ret = ath11k_qmi_event_mem_request(qmi);
3130 if (ret < 0)
3131 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3132 break;
3133 case ATH11K_QMI_EVENT_FW_MEM_READY:
3134 ret = ath11k_qmi_event_load_bdf(qmi);
3135 if (ret < 0) {
3136 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3137 break;
3138 }
3139
3140 ret = ath11k_qmi_wlanfw_m3_info_send(ab);
3141 if (ret < 0) {
3142 ath11k_warn(ab,
3143 "failed to send qmi m3 info req: %d\n", ret);
3144 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3145 }
3146
3147 break;
3148 case ATH11K_QMI_EVENT_FW_READY:
3149 clear_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3150 if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) {
3151 ath11k_hal_dump_srng_stats(ab);
3152 queue_work(ab->workqueue, &ab->restart_work);
3153 break;
3154 }
3155
3156 if (ath11k_cold_boot_cal && ab->qmi.cal_done == 0 &&
3157 ab->hw_params.cold_boot_calib) {
3158 ath11k_qmi_process_coldboot_calibration(ab);
3159 } else {
3160 clear_bit(ATH11K_FLAG_CRASH_FLUSH,
3161 &ab->dev_flags);
3162 clear_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
3163 ret = ath11k_core_qmi_firmware_ready(ab);
3164 if (ret) {
3165 set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3166 break;
3167 }
3168 set_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags);
3169 }
3170
3171 break;
3172 case ATH11K_QMI_EVENT_COLD_BOOT_CAL_DONE:
3173 break;
3174 default:
3175 ath11k_warn(ab, "invalid qmi event type: %d", event->type);
3176 break;
3177 }
3178 kfree(event);
3179 spin_lock(&qmi->event_lock);
3180 }
3181 spin_unlock(&qmi->event_lock);
3182 }
3183
3184 int ath11k_qmi_init_service(struct ath11k_base *ab)
3185 {
3186 int ret;
3187
3188 memset(&ab->qmi.target, 0, sizeof(struct target_info));
3189 memset(&ab->qmi.target_mem, 0, sizeof(struct target_mem_chunk));
3190 ab->qmi.ab = ab;
3191
3192 ab->qmi.target_mem_mode = ab->hw_params.fw_mem_mode;
3193 ret = qmi_handle_init(&ab->qmi.handle, ATH11K_QMI_RESP_LEN_MAX,
3194 &ath11k_qmi_ops, ath11k_qmi_msg_handlers);
3195 if (ret < 0) {
3196 ath11k_warn(ab, "failed to initialize qmi handle: %d\n", ret);
3197 return ret;
3198 }
3199
3200 ab->qmi.event_wq = alloc_workqueue("ath11k_qmi_driver_event",
3201 WQ_UNBOUND, 1);
3202 if (!ab->qmi.event_wq) {
3203 ath11k_err(ab, "failed to allocate workqueue\n");
3204 return -EFAULT;
3205 }
3206
3207 INIT_LIST_HEAD(&ab->qmi.event_list);
3208 spin_lock_init(&ab->qmi.event_lock);
3209 INIT_WORK(&ab->qmi.event_work, ath11k_qmi_driver_event_work);
3210
3211 ret = qmi_add_lookup(&ab->qmi.handle, ATH11K_QMI_WLFW_SERVICE_ID_V01,
3212 ATH11K_QMI_WLFW_SERVICE_VERS_V01,
3213 ab->qmi.service_ins_id);
3214 if (ret < 0) {
3215 ath11k_warn(ab, "failed to add qmi lookup: %d\n", ret);
3216 destroy_workqueue(ab->qmi.event_wq);
3217 return ret;
3218 }
3219
3220 return ret;
3221 }
3222
3223 void ath11k_qmi_deinit_service(struct ath11k_base *ab)
3224 {
3225 qmi_handle_release(&ab->qmi.handle);
3226 cancel_work_sync(&ab->qmi.event_work);
3227 destroy_workqueue(ab->qmi.event_wq);
3228 ath11k_qmi_m3_free(ab);
3229 ath11k_qmi_free_target_mem_chunk(ab);
3230 }
3231 EXPORT_SYMBOL(ath11k_qmi_deinit_service);
3232
3233 void ath11k_qmi_free_resource(struct ath11k_base *ab)
3234 {
3235 ath11k_qmi_free_target_mem_chunk(ab);
3236 ath11k_qmi_m3_free(ab);
3237 }
