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