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