drivers/net/wireless/ath/ath11k/qmi.c

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