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