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