drivers/net/wireless/ath/ath10k/qmi_wlfw_v01.c

   1 // SPDX-License-Identifier: ISC
   2 /*
   3  * Copyright (c) 2018 The Linux Foundation. All rights reserved.
   4  * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
   5  */
   6
   7 #include <linux/soc/qcom/qmi.h>
   8 #include <linux/types.h>
   9 #include "qmi_wlfw_v01.h"
  10
  11 static const struct qmi_elem_info wlfw_ce_tgt_pipe_cfg_s_v01_ei[] = {
  12         {
  13                 .data_type      = QMI_UNSIGNED_4_BYTE,
  14                 .elem_len       = 1,
  15                 .elem_size      = sizeof(u32),
  16                 .array_type     = NO_ARRAY,
  17                 .tlv_type       = 0,
  18                 .offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
  19                                            pipe_num),
  20         },
  21         {
  22                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
  23                 .elem_len       = 1,
  24                 .elem_size      = sizeof(enum wlfw_pipedir_enum_v01),
  25                 .array_type     = NO_ARRAY,
  26                 .tlv_type       = 0,
  27                 .offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
  28                                            pipe_dir),
  29         },
  30         {
  31                 .data_type      = QMI_UNSIGNED_4_BYTE,
  32                 .elem_len       = 1,
  33                 .elem_size      = sizeof(u32),
  34                 .array_type     = NO_ARRAY,
  35                 .tlv_type       = 0,
  36                 .offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
  37                                            nentries),
  38         },
  39         {
  40                 .data_type      = QMI_UNSIGNED_4_BYTE,
  41                 .elem_len       = 1,
  42                 .elem_size      = sizeof(u32),
  43                 .array_type     = NO_ARRAY,
  44                 .tlv_type       = 0,
  45                 .offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
  46                                            nbytes_max),
  47         },
  48         {
  49                 .data_type      = QMI_UNSIGNED_4_BYTE,
  50                 .elem_len       = 1,
  51                 .elem_size      = sizeof(u32),
  52                 .array_type     = NO_ARRAY,
  53                 .tlv_type       = 0,
  54                 .offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
  55                                            flags),
  56         },
  57         {}
  58 };
  59
  60 static const struct qmi_elem_info wlfw_ce_svc_pipe_cfg_s_v01_ei[] = {
  61         {
  62                 .data_type      = QMI_UNSIGNED_4_BYTE,
  63                 .elem_len       = 1,
  64                 .elem_size      = sizeof(u32),
  65                 .array_type     = NO_ARRAY,
  66                 .tlv_type       = 0,
  67                 .offset         = offsetof(struct wlfw_ce_svc_pipe_cfg_s_v01,
  68                                            service_id),
  69         },
  70         {
  71                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
  72                 .elem_len       = 1,
  73                 .elem_size      = sizeof(enum wlfw_pipedir_enum_v01),
  74                 .array_type     = NO_ARRAY,
  75                 .tlv_type       = 0,
  76                 .offset         = offsetof(struct wlfw_ce_svc_pipe_cfg_s_v01,
  77                                            pipe_dir),
  78         },
  79         {
  80                 .data_type      = QMI_UNSIGNED_4_BYTE,
  81                 .elem_len       = 1,
  82                 .elem_size      = sizeof(u32),
  83                 .array_type     = NO_ARRAY,
  84                 .tlv_type       = 0,
  85                 .offset         = offsetof(struct wlfw_ce_svc_pipe_cfg_s_v01,
  86                                            pipe_num),
  87         },
  88         {}
  89 };
  90
  91 static const struct qmi_elem_info wlfw_shadow_reg_cfg_s_v01_ei[] = {
  92         {
  93                 .data_type      = QMI_UNSIGNED_2_BYTE,
  94                 .elem_len       = 1,
  95                 .elem_size      = sizeof(u16),
  96                 .array_type     = NO_ARRAY,
  97                 .tlv_type       = 0,
  98                 .offset         = offsetof(struct wlfw_shadow_reg_cfg_s_v01,
  99                                            id),
 100         },
 101         {
 102                 .data_type      = QMI_UNSIGNED_2_BYTE,
 103                 .elem_len       = 1,
 104                 .elem_size      = sizeof(u16),
 105                 .array_type     = NO_ARRAY,
 106                 .tlv_type       = 0,
 107                 .offset         = offsetof(struct wlfw_shadow_reg_cfg_s_v01,
 108                                            offset),
 109         },
 110         {}
 111 };
 112
 113 static const struct qmi_elem_info wlfw_shadow_reg_v2_cfg_s_v01_ei[] = {
 114         {
 115                 .data_type      = QMI_UNSIGNED_4_BYTE,
 116                 .elem_len       = 1,
 117                 .elem_size      = sizeof(u32),
 118                 .array_type     = NO_ARRAY,
 119                 .tlv_type       = 0,
 120                 .offset         = offsetof(struct wlfw_shadow_reg_v2_cfg_s_v01,
 121                                            addr),
 122         },
 123         {}
 124 };
 125
 126 static const struct qmi_elem_info wlfw_memory_region_info_s_v01_ei[] = {
 127         {
 128                 .data_type      = QMI_UNSIGNED_8_BYTE,
 129                 .elem_len       = 1,
 130                 .elem_size      = sizeof(u64),
 131                 .array_type     = NO_ARRAY,
 132                 .tlv_type       = 0,
 133                 .offset         = offsetof(struct wlfw_memory_region_info_s_v01,
 134                                            region_addr),
 135         },
 136         {
 137                 .data_type      = QMI_UNSIGNED_4_BYTE,
 138                 .elem_len       = 1,
 139                 .elem_size      = sizeof(u32),
 140                 .array_type     = NO_ARRAY,
 141                 .tlv_type       = 0,
 142                 .offset         = offsetof(struct wlfw_memory_region_info_s_v01,
 143                                            size),
 144         },
 145         {
 146                 .data_type      = QMI_UNSIGNED_1_BYTE,
 147                 .elem_len       = 1,
 148                 .elem_size      = sizeof(u8),
 149                 .array_type     = NO_ARRAY,
 150                 .tlv_type       = 0,
 151                 .offset         = offsetof(struct wlfw_memory_region_info_s_v01,
 152                                            secure_flag),
 153         },
 154         {}
 155 };
 156
 157 static const struct qmi_elem_info wlfw_mem_cfg_s_v01_ei[] = {
 158         {
 159                 .data_type      = QMI_UNSIGNED_8_BYTE,
 160                 .elem_len       = 1,
 161                 .elem_size      = sizeof(u64),
 162                 .array_type     = NO_ARRAY,
 163                 .tlv_type       = 0,
 164                 .offset         = offsetof(struct wlfw_mem_cfg_s_v01,
 165                                            offset),
 166         },
 167         {
 168                 .data_type      = QMI_UNSIGNED_4_BYTE,
 169                 .elem_len       = 1,
 170                 .elem_size      = sizeof(u32),
 171                 .array_type     = NO_ARRAY,
 172                 .tlv_type       = 0,
 173                 .offset         = offsetof(struct wlfw_mem_cfg_s_v01,
 174                                            size),
 175         },
 176         {
 177                 .data_type      = QMI_UNSIGNED_1_BYTE,
 178                 .elem_len       = 1,
 179                 .elem_size      = sizeof(u8),
 180                 .array_type     = NO_ARRAY,
 181                 .tlv_type       = 0,
 182                 .offset         = offsetof(struct wlfw_mem_cfg_s_v01,
 183                                            secure_flag),
 184         },
 185         {}
 186 };
 187
 188 static const struct qmi_elem_info wlfw_mem_seg_s_v01_ei[] = {
 189         {
 190                 .data_type      = QMI_UNSIGNED_4_BYTE,
 191                 .elem_len       = 1,
 192                 .elem_size      = sizeof(u32),
 193                 .array_type     = NO_ARRAY,
 194                 .tlv_type       = 0,
 195                 .offset         = offsetof(struct wlfw_mem_seg_s_v01,
 196                                            size),
 197         },
 198         {
 199                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
 200                 .elem_len       = 1,
 201                 .elem_size      = sizeof(enum wlfw_mem_type_enum_v01),
 202                 .array_type     = NO_ARRAY,
 203                 .tlv_type       = 0,
 204                 .offset         = offsetof(struct wlfw_mem_seg_s_v01,
 205                                            type),
 206         },
 207         {
 208                 .data_type      = QMI_DATA_LEN,
 209                 .elem_len       = 1,
 210                 .elem_size      = sizeof(u8),
 211                 .array_type     = NO_ARRAY,
 212                 .tlv_type       = 0,
 213                 .offset         = offsetof(struct wlfw_mem_seg_s_v01,
 214                                            mem_cfg_len),
 215         },
 216         {
 217                 .data_type      = QMI_STRUCT,
 218                 .elem_len       = QMI_WLFW_MAX_NUM_MEM_CFG_V01,
 219                 .elem_size      = sizeof(struct wlfw_mem_cfg_s_v01),
 220                 .array_type       = VAR_LEN_ARRAY,
 221                 .tlv_type       = 0,
 222                 .offset         = offsetof(struct wlfw_mem_seg_s_v01,
 223                                            mem_cfg),
 224                 .ei_array      = wlfw_mem_cfg_s_v01_ei,
 225         },
 226         {}
 227 };
 228
 229 static const struct qmi_elem_info wlfw_mem_seg_resp_s_v01_ei[] = {
 230         {
 231                 .data_type      = QMI_UNSIGNED_8_BYTE,
 232                 .elem_len       = 1,
 233                 .elem_size      = sizeof(u64),
 234                 .array_type     = NO_ARRAY,
 235                 .tlv_type       = 0,
 236                 .offset         = offsetof(struct wlfw_mem_seg_resp_s_v01,
 237                                            addr),
 238         },
 239         {
 240                 .data_type      = QMI_UNSIGNED_4_BYTE,
 241                 .elem_len       = 1,
 242                 .elem_size      = sizeof(u32),
 243                 .array_type     = NO_ARRAY,
 244                 .tlv_type       = 0,
 245                 .offset         = offsetof(struct wlfw_mem_seg_resp_s_v01,
 246                                            size),
 247         },
 248         {
 249                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
 250                 .elem_len       = 1,
 251                 .elem_size      = sizeof(enum wlfw_mem_type_enum_v01),
 252                 .array_type     = NO_ARRAY,
 253                 .tlv_type       = 0,
 254                 .offset         = offsetof(struct wlfw_mem_seg_resp_s_v01,
 255                                            type),
 256         },
 257         {}
 258 };
 259
 260 static const struct qmi_elem_info wlfw_rf_chip_info_s_v01_ei[] = {
 261         {
 262                 .data_type      = QMI_UNSIGNED_4_BYTE,
 263                 .elem_len       = 1,
 264                 .elem_size      = sizeof(u32),
 265                 .array_type     = NO_ARRAY,
 266                 .tlv_type       = 0,
 267                 .offset         = offsetof(struct wlfw_rf_chip_info_s_v01,
 268                                            chip_id),
 269         },
 270         {
 271                 .data_type      = QMI_UNSIGNED_4_BYTE,
 272                 .elem_len       = 1,
 273                 .elem_size      = sizeof(u32),
 274                 .array_type     = NO_ARRAY,
 275                 .tlv_type       = 0,
 276                 .offset         = offsetof(struct wlfw_rf_chip_info_s_v01,
 277                                            chip_family),
 278         },
 279         {}
 280 };
 281
 282 static const struct qmi_elem_info wlfw_rf_board_info_s_v01_ei[] = {
 283         {
 284                 .data_type      = QMI_UNSIGNED_4_BYTE,
 285                 .elem_len       = 1,
 286                 .elem_size      = sizeof(u32),
 287                 .array_type     = NO_ARRAY,
 288                 .tlv_type       = 0,
 289                 .offset         = offsetof(struct wlfw_rf_board_info_s_v01,
 290                                            board_id),
 291         },
 292         {}
 293 };
 294
 295 static const struct qmi_elem_info wlfw_soc_info_s_v01_ei[] = {
 296         {
 297                 .data_type      = QMI_UNSIGNED_4_BYTE,
 298                 .elem_len       = 1,
 299                 .elem_size      = sizeof(u32),
 300                 .array_type     = NO_ARRAY,
 301                 .tlv_type       = 0,
 302                 .offset         = offsetof(struct wlfw_soc_info_s_v01,
 303                                            soc_id),
 304         },
 305         {}
 306 };
 307
 308 static const struct qmi_elem_info wlfw_fw_version_info_s_v01_ei[] = {
 309         {
 310                 .data_type      = QMI_UNSIGNED_4_BYTE,
 311                 .elem_len       = 1,
 312                 .elem_size      = sizeof(u32),
 313                 .array_type     = NO_ARRAY,
 314                 .tlv_type       = 0,
 315                 .offset         = offsetof(struct wlfw_fw_version_info_s_v01,
 316                                            fw_version),
 317         },
 318         {
 319                 .data_type      = QMI_STRING,
 320                 .elem_len       = QMI_WLFW_MAX_TIMESTAMP_LEN_V01 + 1,
 321                 .elem_size      = sizeof(char),
 322                 .array_type     = NO_ARRAY,
 323                 .tlv_type       = 0,
 324                 .offset         = offsetof(struct wlfw_fw_version_info_s_v01,
 325                                            fw_build_timestamp),
 326         },
 327         {}
 328 };
 329
 330 const struct qmi_elem_info wlfw_ind_register_req_msg_v01_ei[] = {
 331         {
 332                 .data_type      = QMI_OPT_FLAG,
 333                 .elem_len       = 1,
 334                 .elem_size      = sizeof(u8),
 335                 .array_type     = NO_ARRAY,
 336                 .tlv_type       = 0x10,
 337                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 338                                            fw_ready_enable_valid),
 339         },
 340         {
 341                 .data_type      = QMI_UNSIGNED_1_BYTE,
 342                 .elem_len       = 1,
 343                 .elem_size      = sizeof(u8),
 344                 .array_type     = NO_ARRAY,
 345                 .tlv_type       = 0x10,
 346                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 347                                            fw_ready_enable),
 348         },
 349         {
 350                 .data_type      = QMI_OPT_FLAG,
 351                 .elem_len       = 1,
 352                 .elem_size      = sizeof(u8),
 353                 .array_type     = NO_ARRAY,
 354                 .tlv_type       = 0x11,
 355                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 356                                            initiate_cal_download_enable_valid),
 357         },
 358         {
 359                 .data_type      = QMI_UNSIGNED_1_BYTE,
 360                 .elem_len       = 1,
 361                 .elem_size      = sizeof(u8),
 362                 .array_type     = NO_ARRAY,
 363                 .tlv_type       = 0x11,
 364                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 365                                            initiate_cal_download_enable),
 366         },
 367         {
 368                 .data_type      = QMI_OPT_FLAG,
 369                 .elem_len       = 1,
 370                 .elem_size      = sizeof(u8),
 371                 .array_type     = NO_ARRAY,
 372                 .tlv_type       = 0x12,
 373                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 374                                            initiate_cal_update_enable_valid),
 375         },
 376         {
 377                 .data_type      = QMI_UNSIGNED_1_BYTE,
 378                 .elem_len       = 1,
 379                 .elem_size      = sizeof(u8),
 380                 .array_type     = NO_ARRAY,
 381                 .tlv_type       = 0x12,
 382                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 383                                            initiate_cal_update_enable),
 384         },
 385         {
 386                 .data_type      = QMI_OPT_FLAG,
 387                 .elem_len       = 1,
 388                 .elem_size      = sizeof(u8),
 389                 .array_type     = NO_ARRAY,
 390                 .tlv_type       = 0x13,
 391                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 392                                            msa_ready_enable_valid),
 393         },
 394         {
 395                 .data_type      = QMI_UNSIGNED_1_BYTE,
 396                 .elem_len       = 1,
 397                 .elem_size      = sizeof(u8),
 398                 .array_type     = NO_ARRAY,
 399                 .tlv_type       = 0x13,
 400                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 401                                            msa_ready_enable),
 402         },
 403         {
 404                 .data_type      = QMI_OPT_FLAG,
 405                 .elem_len       = 1,
 406                 .elem_size      = sizeof(u8),
 407                 .array_type     = NO_ARRAY,
 408                 .tlv_type       = 0x14,
 409                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 410                                            pin_connect_result_enable_valid),
 411         },
 412         {
 413                 .data_type      = QMI_UNSIGNED_1_BYTE,
 414                 .elem_len       = 1,
 415                 .elem_size      = sizeof(u8),
 416                 .array_type     = NO_ARRAY,
 417                 .tlv_type       = 0x14,
 418                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 419                                            pin_connect_result_enable),
 420         },
 421         {
 422                 .data_type      = QMI_OPT_FLAG,
 423                 .elem_len       = 1,
 424                 .elem_size      = sizeof(u8),
 425                 .array_type     = NO_ARRAY,
 426                 .tlv_type       = 0x15,
 427                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 428                                            client_id_valid),
 429         },
 430         {
 431                 .data_type      = QMI_UNSIGNED_4_BYTE,
 432                 .elem_len       = 1,
 433                 .elem_size      = sizeof(u32),
 434                 .array_type     = NO_ARRAY,
 435                 .tlv_type       = 0x15,
 436                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 437                                            client_id),
 438         },
 439         {
 440                 .data_type      = QMI_OPT_FLAG,
 441                 .elem_len       = 1,
 442                 .elem_size      = sizeof(u8),
 443                 .array_type     = NO_ARRAY,
 444                 .tlv_type       = 0x16,
 445                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 446                                            request_mem_enable_valid),
 447         },
 448         {
 449                 .data_type      = QMI_UNSIGNED_1_BYTE,
 450                 .elem_len       = 1,
 451                 .elem_size      = sizeof(u8),
 452                 .array_type     = NO_ARRAY,
 453                 .tlv_type       = 0x16,
 454                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 455                                            request_mem_enable),
 456         },
 457         {
 458                 .data_type      = QMI_OPT_FLAG,
 459                 .elem_len       = 1,
 460                 .elem_size      = sizeof(u8),
 461                 .array_type     = NO_ARRAY,
 462                 .tlv_type       = 0x17,
 463                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 464                                            mem_ready_enable_valid),
 465         },
 466         {
 467                 .data_type      = QMI_UNSIGNED_1_BYTE,
 468                 .elem_len       = 1,
 469                 .elem_size      = sizeof(u8),
 470                 .array_type     = NO_ARRAY,
 471                 .tlv_type       = 0x17,
 472                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 473                                            mem_ready_enable),
 474         },
 475         {
 476                 .data_type      = QMI_OPT_FLAG,
 477                 .elem_len       = 1,
 478                 .elem_size      = sizeof(u8),
 479                 .array_type     = NO_ARRAY,
 480                 .tlv_type       = 0x18,
 481                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 482                                            fw_init_done_enable_valid),
 483         },
 484         {
 485                 .data_type      = QMI_UNSIGNED_1_BYTE,
 486                 .elem_len       = 1,
 487                 .elem_size      = sizeof(u8),
 488                 .array_type     = NO_ARRAY,
 489                 .tlv_type       = 0x18,
 490                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 491                                            fw_init_done_enable),
 492         },
 493         {
 494                 .data_type      = QMI_OPT_FLAG,
 495                 .elem_len       = 1,
 496                 .elem_size      = sizeof(u8),
 497                 .array_type     = NO_ARRAY,
 498                 .tlv_type       = 0x19,
 499                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 500                                            rejuvenate_enable_valid),
 501         },
 502         {
 503                 .data_type      = QMI_UNSIGNED_4_BYTE,
 504                 .elem_len       = 1,
 505                 .elem_size      = sizeof(u32),
 506                 .array_type     = NO_ARRAY,
 507                 .tlv_type       = 0x19,
 508                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 509                                            rejuvenate_enable),
 510         },
 511         {
 512                 .data_type      = QMI_OPT_FLAG,
 513                 .elem_len       = 1,
 514                 .elem_size      = sizeof(u8),
 515                 .array_type     = NO_ARRAY,
 516                 .tlv_type       = 0x1A,
 517                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 518                                            xo_cal_enable_valid),
 519         },
 520         {
 521                 .data_type      = QMI_UNSIGNED_1_BYTE,
 522                 .elem_len       = 1,
 523                 .elem_size      = sizeof(u8),
 524                 .array_type     = NO_ARRAY,
 525                 .tlv_type       = 0x1A,
 526                 .offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
 527                                            xo_cal_enable),
 528         },
 529         {}
 530 };
 531
 532 const struct qmi_elem_info wlfw_ind_register_resp_msg_v01_ei[] = {
 533         {
 534                 .data_type      = QMI_STRUCT,
 535                 .elem_len       = 1,
 536                 .elem_size      = sizeof(struct qmi_response_type_v01),
 537                 .array_type     = NO_ARRAY,
 538                 .tlv_type       = 0x02,
 539                 .offset         = offsetof(struct wlfw_ind_register_resp_msg_v01,
 540                                            resp),
 541                 .ei_array      = qmi_response_type_v01_ei,
 542         },
 543         {
 544                 .data_type      = QMI_OPT_FLAG,
 545                 .elem_len       = 1,
 546                 .elem_size      = sizeof(u8),
 547                 .array_type     = NO_ARRAY,
 548                 .tlv_type       = 0x10,
 549                 .offset         = offsetof(struct wlfw_ind_register_resp_msg_v01,
 550                                            fw_status_valid),
 551         },
 552         {
 553                 .data_type      = QMI_UNSIGNED_8_BYTE,
 554                 .elem_len       = 1,
 555                 .elem_size      = sizeof(u64),
 556                 .array_type     = NO_ARRAY,
 557                 .tlv_type       = 0x10,
 558                 .offset         = offsetof(struct wlfw_ind_register_resp_msg_v01,
 559                                            fw_status),
 560         },
 561         {}
 562 };
 563
 564 const struct qmi_elem_info wlfw_fw_ready_ind_msg_v01_ei[] = {
 565         {}
 566 };
 567
 568 const struct qmi_elem_info wlfw_msa_ready_ind_msg_v01_ei[] = {
 569         {}
 570 };
 571
 572 const struct qmi_elem_info wlfw_pin_connect_result_ind_msg_v01_ei[] = {
 573         {
 574                 .data_type      = QMI_OPT_FLAG,
 575                 .elem_len       = 1,
 576                 .elem_size      = sizeof(u8),
 577                 .array_type     = NO_ARRAY,
 578                 .tlv_type       = 0x10,
 579                 .offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
 580                                            pwr_pin_result_valid),
 581         },
 582         {
 583                 .data_type      = QMI_UNSIGNED_4_BYTE,
 584                 .elem_len       = 1,
 585                 .elem_size      = sizeof(u32),
 586                 .array_type     = NO_ARRAY,
 587                 .tlv_type       = 0x10,
 588                 .offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
 589                                            pwr_pin_result),
 590         },
 591         {
 592                 .data_type      = QMI_OPT_FLAG,
 593                 .elem_len       = 1,
 594                 .elem_size      = sizeof(u8),
 595                 .array_type     = NO_ARRAY,
 596                 .tlv_type       = 0x11,
 597                 .offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
 598                                            phy_io_pin_result_valid),
 599         },
 600         {
 601                 .data_type      = QMI_UNSIGNED_4_BYTE,
 602                 .elem_len       = 1,
 603                 .elem_size      = sizeof(u32),
 604                 .array_type     = NO_ARRAY,
 605                 .tlv_type       = 0x11,
 606                 .offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
 607                                            phy_io_pin_result),
 608         },
 609         {
 610                 .data_type      = QMI_OPT_FLAG,
 611                 .elem_len       = 1,
 612                 .elem_size      = sizeof(u8),
 613                 .array_type     = NO_ARRAY,
 614                 .tlv_type       = 0x12,
 615                 .offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
 616                                            rf_pin_result_valid),
 617         },
 618         {
 619                 .data_type      = QMI_UNSIGNED_4_BYTE,
 620                 .elem_len       = 1,
 621                 .elem_size      = sizeof(u32),
 622                 .array_type     = NO_ARRAY,
 623                 .tlv_type       = 0x12,
 624                 .offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
 625                                            rf_pin_result),
 626         },
 627         {}
 628 };
 629
 630 const struct qmi_elem_info wlfw_wlan_mode_req_msg_v01_ei[] = {
 631         {
 632                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
 633                 .elem_len       = 1,
 634                 .elem_size      = sizeof(enum wlfw_driver_mode_enum_v01),
 635                 .array_type     = NO_ARRAY,
 636                 .tlv_type       = 0x01,
 637                 .offset         = offsetof(struct wlfw_wlan_mode_req_msg_v01,
 638                                            mode),
 639         },
 640         {
 641                 .data_type      = QMI_OPT_FLAG,
 642                 .elem_len       = 1,
 643                 .elem_size      = sizeof(u8),
 644                 .array_type     = NO_ARRAY,
 645                 .tlv_type       = 0x10,
 646                 .offset         = offsetof(struct wlfw_wlan_mode_req_msg_v01,
 647                                            hw_debug_valid),
 648         },
 649         {
 650                 .data_type      = QMI_UNSIGNED_1_BYTE,
 651                 .elem_len       = 1,
 652                 .elem_size      = sizeof(u8),
 653                 .array_type     = NO_ARRAY,
 654                 .tlv_type       = 0x10,
 655                 .offset         = offsetof(struct wlfw_wlan_mode_req_msg_v01,
 656                                            hw_debug),
 657         },
 658         {}
 659 };
 660
 661 const struct qmi_elem_info wlfw_wlan_mode_resp_msg_v01_ei[] = {
 662         {
 663                 .data_type      = QMI_STRUCT,
 664                 .elem_len       = 1,
 665                 .elem_size      = sizeof(struct qmi_response_type_v01),
 666                 .array_type     = NO_ARRAY,
 667                 .tlv_type       = 0x02,
 668                 .offset         = offsetof(struct wlfw_wlan_mode_resp_msg_v01,
 669                                            resp),
 670                 .ei_array      = qmi_response_type_v01_ei,
 671         },
 672         {}
 673 };
 674
 675 const struct qmi_elem_info wlfw_wlan_cfg_req_msg_v01_ei[] = {
 676         {
 677                 .data_type      = QMI_OPT_FLAG,
 678                 .elem_len       = 1,
 679                 .elem_size      = sizeof(u8),
 680                 .array_type     = NO_ARRAY,
 681                 .tlv_type       = 0x10,
 682                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 683                                            host_version_valid),
 684         },
 685         {
 686                 .data_type      = QMI_STRING,
 687                 .elem_len       = QMI_WLFW_MAX_STR_LEN_V01 + 1,
 688                 .elem_size      = sizeof(char),
 689                 .array_type     = NO_ARRAY,
 690                 .tlv_type       = 0x10,
 691                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 692                                            host_version),
 693         },
 694         {
 695                 .data_type      = QMI_OPT_FLAG,
 696                 .elem_len       = 1,
 697                 .elem_size      = sizeof(u8),
 698                 .array_type     = NO_ARRAY,
 699                 .tlv_type       = 0x11,
 700                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 701                                            tgt_cfg_valid),
 702         },
 703         {
 704                 .data_type      = QMI_DATA_LEN,
 705                 .elem_len       = 1,
 706                 .elem_size      = sizeof(u8),
 707                 .array_type     = NO_ARRAY,
 708                 .tlv_type       = 0x11,
 709                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 710                                            tgt_cfg_len),
 711         },
 712         {
 713                 .data_type      = QMI_STRUCT,
 714                 .elem_len       = QMI_WLFW_MAX_NUM_CE_V01,
 715                 .elem_size      = sizeof(struct wlfw_ce_tgt_pipe_cfg_s_v01),
 716                 .array_type       = VAR_LEN_ARRAY,
 717                 .tlv_type       = 0x11,
 718                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 719                                            tgt_cfg),
 720                 .ei_array      = wlfw_ce_tgt_pipe_cfg_s_v01_ei,
 721         },
 722         {
 723                 .data_type      = QMI_OPT_FLAG,
 724                 .elem_len       = 1,
 725                 .elem_size      = sizeof(u8),
 726                 .array_type     = NO_ARRAY,
 727                 .tlv_type       = 0x12,
 728                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 729                                            svc_cfg_valid),
 730         },
 731         {
 732                 .data_type      = QMI_DATA_LEN,
 733                 .elem_len       = 1,
 734                 .elem_size      = sizeof(u8),
 735                 .array_type     = NO_ARRAY,
 736                 .tlv_type       = 0x12,
 737                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 738                                            svc_cfg_len),
 739         },
 740         {
 741                 .data_type      = QMI_STRUCT,
 742                 .elem_len       = QMI_WLFW_MAX_NUM_SVC_V01,
 743                 .elem_size      = sizeof(struct wlfw_ce_svc_pipe_cfg_s_v01),
 744                 .array_type       = VAR_LEN_ARRAY,
 745                 .tlv_type       = 0x12,
 746                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 747                                            svc_cfg),
 748                 .ei_array      = wlfw_ce_svc_pipe_cfg_s_v01_ei,
 749         },
 750         {
 751                 .data_type      = QMI_OPT_FLAG,
 752                 .elem_len       = 1,
 753                 .elem_size      = sizeof(u8),
 754                 .array_type     = NO_ARRAY,
 755                 .tlv_type       = 0x13,
 756                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 757                                            shadow_reg_valid),
 758         },
 759         {
 760                 .data_type      = QMI_DATA_LEN,
 761                 .elem_len       = 1,
 762                 .elem_size      = sizeof(u8),
 763                 .array_type     = NO_ARRAY,
 764                 .tlv_type       = 0x13,
 765                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 766                                            shadow_reg_len),
 767         },
 768         {
 769                 .data_type      = QMI_STRUCT,
 770                 .elem_len       = QMI_WLFW_MAX_NUM_SHADOW_REG_V01,
 771                 .elem_size      = sizeof(struct wlfw_shadow_reg_cfg_s_v01),
 772                 .array_type       = VAR_LEN_ARRAY,
 773                 .tlv_type       = 0x13,
 774                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 775                                            shadow_reg),
 776                 .ei_array      = wlfw_shadow_reg_cfg_s_v01_ei,
 777         },
 778         {
 779                 .data_type      = QMI_OPT_FLAG,
 780                 .elem_len       = 1,
 781                 .elem_size      = sizeof(u8),
 782                 .array_type     = NO_ARRAY,
 783                 .tlv_type       = 0x14,
 784                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 785                                            shadow_reg_v2_valid),
 786         },
 787         {
 788                 .data_type      = QMI_DATA_LEN,
 789                 .elem_len       = 1,
 790                 .elem_size      = sizeof(u8),
 791                 .array_type     = NO_ARRAY,
 792                 .tlv_type       = 0x14,
 793                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 794                                            shadow_reg_v2_len),
 795         },
 796         {
 797                 .data_type      = QMI_STRUCT,
 798                 .elem_len       = QMI_WLFW_MAX_SHADOW_REG_V2,
 799                 .elem_size      = sizeof(struct wlfw_shadow_reg_v2_cfg_s_v01),
 800                 .array_type       = VAR_LEN_ARRAY,
 801                 .tlv_type       = 0x14,
 802                 .offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
 803                                            shadow_reg_v2),
 804                 .ei_array      = wlfw_shadow_reg_v2_cfg_s_v01_ei,
 805         },
 806         {}
 807 };
 808
 809 const struct qmi_elem_info wlfw_wlan_cfg_resp_msg_v01_ei[] = {
 810         {
 811                 .data_type      = QMI_STRUCT,
 812                 .elem_len       = 1,
 813                 .elem_size      = sizeof(struct qmi_response_type_v01),
 814                 .array_type     = NO_ARRAY,
 815                 .tlv_type       = 0x02,
 816                 .offset         = offsetof(struct wlfw_wlan_cfg_resp_msg_v01,
 817                                            resp),
 818                 .ei_array      = qmi_response_type_v01_ei,
 819         },
 820         {}
 821 };
 822
 823 const struct qmi_elem_info wlfw_cap_req_msg_v01_ei[] = {
 824         {}
 825 };
 826
 827 const struct qmi_elem_info wlfw_cap_resp_msg_v01_ei[] = {
 828         {
 829                 .data_type      = QMI_STRUCT,
 830                 .elem_len       = 1,
 831                 .elem_size      = sizeof(struct qmi_response_type_v01),
 832                 .array_type     = NO_ARRAY,
 833                 .tlv_type       = 0x02,
 834                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 835                                            resp),
 836                 .ei_array      = qmi_response_type_v01_ei,
 837         },
 838         {
 839                 .data_type      = QMI_OPT_FLAG,
 840                 .elem_len       = 1,
 841                 .elem_size      = sizeof(u8),
 842                 .array_type     = NO_ARRAY,
 843                 .tlv_type       = 0x10,
 844                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 845                                            chip_info_valid),
 846         },
 847         {
 848                 .data_type      = QMI_STRUCT,
 849                 .elem_len       = 1,
 850                 .elem_size      = sizeof(struct wlfw_rf_chip_info_s_v01),
 851                 .array_type     = NO_ARRAY,
 852                 .tlv_type       = 0x10,
 853                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 854                                            chip_info),
 855                 .ei_array      = wlfw_rf_chip_info_s_v01_ei,
 856         },
 857         {
 858                 .data_type      = QMI_OPT_FLAG,
 859                 .elem_len       = 1,
 860                 .elem_size      = sizeof(u8),
 861                 .array_type     = NO_ARRAY,
 862                 .tlv_type       = 0x11,
 863                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 864                                            board_info_valid),
 865         },
 866         {
 867                 .data_type      = QMI_STRUCT,
 868                 .elem_len       = 1,
 869                 .elem_size      = sizeof(struct wlfw_rf_board_info_s_v01),
 870                 .array_type     = NO_ARRAY,
 871                 .tlv_type       = 0x11,
 872                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 873                                            board_info),
 874                 .ei_array      = wlfw_rf_board_info_s_v01_ei,
 875         },
 876         {
 877                 .data_type      = QMI_OPT_FLAG,
 878                 .elem_len       = 1,
 879                 .elem_size      = sizeof(u8),
 880                 .array_type     = NO_ARRAY,
 881                 .tlv_type       = 0x12,
 882                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 883                                            soc_info_valid),
 884         },
 885         {
 886                 .data_type      = QMI_STRUCT,
 887                 .elem_len       = 1,
 888                 .elem_size      = sizeof(struct wlfw_soc_info_s_v01),
 889                 .array_type     = NO_ARRAY,
 890                 .tlv_type       = 0x12,
 891                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 892                                            soc_info),
 893                 .ei_array      = wlfw_soc_info_s_v01_ei,
 894         },
 895         {
 896                 .data_type      = QMI_OPT_FLAG,
 897                 .elem_len       = 1,
 898                 .elem_size      = sizeof(u8),
 899                 .array_type     = NO_ARRAY,
 900                 .tlv_type       = 0x13,
 901                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 902                                            fw_version_info_valid),
 903         },
 904         {
 905                 .data_type      = QMI_STRUCT,
 906                 .elem_len       = 1,
 907                 .elem_size      = sizeof(struct wlfw_fw_version_info_s_v01),
 908                 .array_type     = NO_ARRAY,
 909                 .tlv_type       = 0x13,
 910                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 911                                            fw_version_info),
 912                 .ei_array      = wlfw_fw_version_info_s_v01_ei,
 913         },
 914         {
 915                 .data_type      = QMI_OPT_FLAG,
 916                 .elem_len       = 1,
 917                 .elem_size      = sizeof(u8),
 918                 .array_type     = NO_ARRAY,
 919                 .tlv_type       = 0x14,
 920                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 921                                            fw_build_id_valid),
 922         },
 923         {
 924                 .data_type      = QMI_STRING,
 925                 .elem_len       = QMI_WLFW_MAX_BUILD_ID_LEN_V01 + 1,
 926                 .elem_size      = sizeof(char),
 927                 .array_type     = NO_ARRAY,
 928                 .tlv_type       = 0x14,
 929                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 930                                            fw_build_id),
 931         },
 932         {
 933                 .data_type      = QMI_OPT_FLAG,
 934                 .elem_len       = 1,
 935                 .elem_size      = sizeof(u8),
 936                 .array_type     = NO_ARRAY,
 937                 .tlv_type       = 0x15,
 938                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 939                                            num_macs_valid),
 940         },
 941         {
 942                 .data_type      = QMI_UNSIGNED_1_BYTE,
 943                 .elem_len       = 1,
 944                 .elem_size      = sizeof(u8),
 945                 .array_type     = NO_ARRAY,
 946                 .tlv_type       = 0x15,
 947                 .offset         = offsetof(struct wlfw_cap_resp_msg_v01,
 948                                            num_macs),
 949         },
 950         {}
 951 };
 952
 953 const struct qmi_elem_info wlfw_bdf_download_req_msg_v01_ei[] = {
 954         {
 955                 .data_type      = QMI_UNSIGNED_1_BYTE,
 956                 .elem_len       = 1,
 957                 .elem_size      = sizeof(u8),
 958                 .array_type     = NO_ARRAY,
 959                 .tlv_type       = 0x01,
 960                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
 961                                            valid),
 962         },
 963         {
 964                 .data_type      = QMI_OPT_FLAG,
 965                 .elem_len       = 1,
 966                 .elem_size      = sizeof(u8),
 967                 .array_type     = NO_ARRAY,
 968                 .tlv_type       = 0x10,
 969                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
 970                                            file_id_valid),
 971         },
 972         {
 973                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
 974                 .elem_len       = 1,
 975                 .elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
 976                 .array_type     = NO_ARRAY,
 977                 .tlv_type       = 0x10,
 978                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
 979                                            file_id),
 980         },
 981         {
 982                 .data_type      = QMI_OPT_FLAG,
 983                 .elem_len       = 1,
 984                 .elem_size      = sizeof(u8),
 985                 .array_type     = NO_ARRAY,
 986                 .tlv_type       = 0x11,
 987                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
 988                                            total_size_valid),
 989         },
 990         {
 991                 .data_type      = QMI_UNSIGNED_4_BYTE,
 992                 .elem_len       = 1,
 993                 .elem_size      = sizeof(u32),
 994                 .array_type     = NO_ARRAY,
 995                 .tlv_type       = 0x11,
 996                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
 997                                            total_size),
 998         },
 999         {
1000                 .data_type      = QMI_OPT_FLAG,
1001                 .elem_len       = 1,
1002                 .elem_size      = sizeof(u8),
1003                 .array_type     = NO_ARRAY,
1004                 .tlv_type       = 0x12,
1005                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1006                                            seg_id_valid),
1007         },
1008         {
1009                 .data_type      = QMI_UNSIGNED_4_BYTE,
1010                 .elem_len       = 1,
1011                 .elem_size      = sizeof(u32),
1012                 .array_type     = NO_ARRAY,
1013                 .tlv_type       = 0x12,
1014                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1015                                            seg_id),
1016         },
1017         {
1018                 .data_type      = QMI_OPT_FLAG,
1019                 .elem_len       = 1,
1020                 .elem_size      = sizeof(u8),
1021                 .array_type     = NO_ARRAY,
1022                 .tlv_type       = 0x13,
1023                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1024                                            data_valid),
1025         },
1026         {
1027                 .data_type      = QMI_DATA_LEN,
1028                 .elem_len       = 1,
1029                 .elem_size      = sizeof(u16),
1030                 .array_type     = NO_ARRAY,
1031                 .tlv_type       = 0x13,
1032                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1033                                            data_len),
1034         },
1035         {
1036                 .data_type      = QMI_UNSIGNED_1_BYTE,
1037                 .elem_len       = QMI_WLFW_MAX_DATA_SIZE_V01,
1038                 .elem_size      = sizeof(u8),
1039                 .array_type       = VAR_LEN_ARRAY,
1040                 .tlv_type       = 0x13,
1041                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1042                                            data),
1043         },
1044         {
1045                 .data_type      = QMI_OPT_FLAG,
1046                 .elem_len       = 1,
1047                 .elem_size      = sizeof(u8),
1048                 .array_type     = NO_ARRAY,
1049                 .tlv_type       = 0x14,
1050                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1051                                            end_valid),
1052         },
1053         {
1054                 .data_type      = QMI_UNSIGNED_1_BYTE,
1055                 .elem_len       = 1,
1056                 .elem_size      = sizeof(u8),
1057                 .array_type     = NO_ARRAY,
1058                 .tlv_type       = 0x14,
1059                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1060                                            end),
1061         },
1062         {
1063                 .data_type      = QMI_OPT_FLAG,
1064                 .elem_len       = 1,
1065                 .elem_size      = sizeof(u8),
1066                 .array_type     = NO_ARRAY,
1067                 .tlv_type       = 0x15,
1068                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1069                                            bdf_type_valid),
1070         },
1071         {
1072                 .data_type      = QMI_UNSIGNED_1_BYTE,
1073                 .elem_len       = 1,
1074                 .elem_size      = sizeof(u8),
1075                 .array_type     = NO_ARRAY,
1076                 .tlv_type       = 0x15,
1077                 .offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1078                                            bdf_type),
1079         },
1080         {}
1081 };
1082
1083 const struct qmi_elem_info wlfw_bdf_download_resp_msg_v01_ei[] = {
1084         {
1085                 .data_type      = QMI_STRUCT,
1086                 .elem_len       = 1,
1087                 .elem_size      = sizeof(struct qmi_response_type_v01),
1088                 .array_type     = NO_ARRAY,
1089                 .tlv_type       = 0x02,
1090                 .offset         = offsetof(struct wlfw_bdf_download_resp_msg_v01,
1091                                            resp),
1092                 .ei_array      = qmi_response_type_v01_ei,
1093         },
1094         {}
1095 };
1096
1097 const struct qmi_elem_info wlfw_cal_report_req_msg_v01_ei[] = {
1098         {
1099                 .data_type      = QMI_DATA_LEN,
1100                 .elem_len       = 1,
1101                 .elem_size      = sizeof(u8),
1102                 .array_type     = NO_ARRAY,
1103                 .tlv_type       = 0x01,
1104                 .offset         = offsetof(struct wlfw_cal_report_req_msg_v01,
1105                                            meta_data_len),
1106         },
1107         {
1108                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
1109                 .elem_len       = QMI_WLFW_MAX_NUM_CAL_V01,
1110                 .elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1111                 .array_type       = VAR_LEN_ARRAY,
1112                 .tlv_type       = 0x01,
1113                 .offset         = offsetof(struct wlfw_cal_report_req_msg_v01,
1114                                            meta_data),
1115         },
1116         {
1117                 .data_type      = QMI_OPT_FLAG,
1118                 .elem_len       = 1,
1119                 .elem_size      = sizeof(u8),
1120                 .array_type     = NO_ARRAY,
1121                 .tlv_type       = 0x10,
1122                 .offset         = offsetof(struct wlfw_cal_report_req_msg_v01,
1123                                            xo_cal_data_valid),
1124         },
1125         {
1126                 .data_type      = QMI_UNSIGNED_1_BYTE,
1127                 .elem_len       = 1,
1128                 .elem_size      = sizeof(u8),
1129                 .array_type     = NO_ARRAY,
1130                 .tlv_type       = 0x10,
1131                 .offset         = offsetof(struct wlfw_cal_report_req_msg_v01,
1132                                            xo_cal_data),
1133         },
1134         {}
1135 };
1136
1137 const struct qmi_elem_info wlfw_cal_report_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 wlfw_cal_report_resp_msg_v01,
1145                                            resp),
1146                 .ei_array      = qmi_response_type_v01_ei,
1147         },
1148         {}
1149 };
1150
1151 const struct qmi_elem_info wlfw_initiate_cal_download_ind_msg_v01_ei[] = {
1152         {
1153                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
1154                 .elem_len       = 1,
1155                 .elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1156                 .array_type     = NO_ARRAY,
1157                 .tlv_type       = 0x01,
1158                 .offset         = offsetof(struct wlfw_initiate_cal_download_ind_msg_v01,
1159                                            cal_id),
1160         },
1161         {}
1162 };
1163
1164 const struct qmi_elem_info wlfw_cal_download_req_msg_v01_ei[] = {
1165         {
1166                 .data_type      = QMI_UNSIGNED_1_BYTE,
1167                 .elem_len       = 1,
1168                 .elem_size      = sizeof(u8),
1169                 .array_type     = NO_ARRAY,
1170                 .tlv_type       = 0x01,
1171                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1172                                            valid),
1173         },
1174         {
1175                 .data_type      = QMI_OPT_FLAG,
1176                 .elem_len       = 1,
1177                 .elem_size      = sizeof(u8),
1178                 .array_type     = NO_ARRAY,
1179                 .tlv_type       = 0x10,
1180                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1181                                            file_id_valid),
1182         },
1183         {
1184                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
1185                 .elem_len       = 1,
1186                 .elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1187                 .array_type     = NO_ARRAY,
1188                 .tlv_type       = 0x10,
1189                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1190                                            file_id),
1191         },
1192         {
1193                 .data_type      = QMI_OPT_FLAG,
1194                 .elem_len       = 1,
1195                 .elem_size      = sizeof(u8),
1196                 .array_type     = NO_ARRAY,
1197                 .tlv_type       = 0x11,
1198                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1199                                            total_size_valid),
1200         },
1201         {
1202                 .data_type      = QMI_UNSIGNED_4_BYTE,
1203                 .elem_len       = 1,
1204                 .elem_size      = sizeof(u32),
1205                 .array_type     = NO_ARRAY,
1206                 .tlv_type       = 0x11,
1207                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1208                                            total_size),
1209         },
1210         {
1211                 .data_type      = QMI_OPT_FLAG,
1212                 .elem_len       = 1,
1213                 .elem_size      = sizeof(u8),
1214                 .array_type     = NO_ARRAY,
1215                 .tlv_type       = 0x12,
1216                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1217                                            seg_id_valid),
1218         },
1219         {
1220                 .data_type      = QMI_UNSIGNED_4_BYTE,
1221                 .elem_len       = 1,
1222                 .elem_size      = sizeof(u32),
1223                 .array_type     = NO_ARRAY,
1224                 .tlv_type       = 0x12,
1225                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1226                                            seg_id),
1227         },
1228         {
1229                 .data_type      = QMI_OPT_FLAG,
1230                 .elem_len       = 1,
1231                 .elem_size      = sizeof(u8),
1232                 .array_type     = NO_ARRAY,
1233                 .tlv_type       = 0x13,
1234                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1235                                            data_valid),
1236         },
1237         {
1238                 .data_type      = QMI_DATA_LEN,
1239                 .elem_len       = 1,
1240                 .elem_size      = sizeof(u16),
1241                 .array_type     = NO_ARRAY,
1242                 .tlv_type       = 0x13,
1243                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1244                                            data_len),
1245         },
1246         {
1247                 .data_type      = QMI_UNSIGNED_1_BYTE,
1248                 .elem_len       = QMI_WLFW_MAX_DATA_SIZE_V01,
1249                 .elem_size      = sizeof(u8),
1250                 .array_type       = VAR_LEN_ARRAY,
1251                 .tlv_type       = 0x13,
1252                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1253                                            data),
1254         },
1255         {
1256                 .data_type      = QMI_OPT_FLAG,
1257                 .elem_len       = 1,
1258                 .elem_size      = sizeof(u8),
1259                 .array_type     = NO_ARRAY,
1260                 .tlv_type       = 0x14,
1261                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1262                                            end_valid),
1263         },
1264         {
1265                 .data_type      = QMI_UNSIGNED_1_BYTE,
1266                 .elem_len       = 1,
1267                 .elem_size      = sizeof(u8),
1268                 .array_type     = NO_ARRAY,
1269                 .tlv_type       = 0x14,
1270                 .offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1271                                            end),
1272         },
1273         {}
1274 };
1275
1276 const struct qmi_elem_info wlfw_cal_download_resp_msg_v01_ei[] = {
1277         {
1278                 .data_type      = QMI_STRUCT,
1279                 .elem_len       = 1,
1280                 .elem_size      = sizeof(struct qmi_response_type_v01),
1281                 .array_type     = NO_ARRAY,
1282                 .tlv_type       = 0x02,
1283                 .offset         = offsetof(struct wlfw_cal_download_resp_msg_v01,
1284                                            resp),
1285                 .ei_array      = qmi_response_type_v01_ei,
1286         },
1287         {}
1288 };
1289
1290 const struct qmi_elem_info wlfw_initiate_cal_update_ind_msg_v01_ei[] = {
1291         {
1292                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
1293                 .elem_len       = 1,
1294                 .elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1295                 .array_type     = NO_ARRAY,
1296                 .tlv_type       = 0x01,
1297                 .offset         = offsetof(struct wlfw_initiate_cal_update_ind_msg_v01,
1298                                            cal_id),
1299         },
1300         {
1301                 .data_type      = QMI_UNSIGNED_4_BYTE,
1302                 .elem_len       = 1,
1303                 .elem_size      = sizeof(u32),
1304                 .array_type     = NO_ARRAY,
1305                 .tlv_type       = 0x02,
1306                 .offset         = offsetof(struct wlfw_initiate_cal_update_ind_msg_v01,
1307                                            total_size),
1308         },
1309         {}
1310 };
1311
1312 const struct qmi_elem_info wlfw_cal_update_req_msg_v01_ei[] = {
1313         {
1314                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
1315                 .elem_len       = 1,
1316                 .elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1317                 .array_type     = NO_ARRAY,
1318                 .tlv_type       = 0x01,
1319                 .offset         = offsetof(struct wlfw_cal_update_req_msg_v01,
1320                                            cal_id),
1321         },
1322         {
1323                 .data_type      = QMI_UNSIGNED_4_BYTE,
1324                 .elem_len       = 1,
1325                 .elem_size      = sizeof(u32),
1326                 .array_type     = NO_ARRAY,
1327                 .tlv_type       = 0x02,
1328                 .offset         = offsetof(struct wlfw_cal_update_req_msg_v01,
1329                                            seg_id),
1330         },
1331         {}
1332 };
1333
1334 const struct qmi_elem_info wlfw_cal_update_resp_msg_v01_ei[] = {
1335         {
1336                 .data_type      = QMI_STRUCT,
1337                 .elem_len       = 1,
1338                 .elem_size      = sizeof(struct qmi_response_type_v01),
1339                 .array_type     = NO_ARRAY,
1340                 .tlv_type       = 0x02,
1341                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1342                                            resp),
1343                 .ei_array      = qmi_response_type_v01_ei,
1344         },
1345         {
1346                 .data_type      = QMI_OPT_FLAG,
1347                 .elem_len       = 1,
1348                 .elem_size      = sizeof(u8),
1349                 .array_type     = NO_ARRAY,
1350                 .tlv_type       = 0x10,
1351                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1352                                            file_id_valid),
1353         },
1354         {
1355                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
1356                 .elem_len       = 1,
1357                 .elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1358                 .array_type     = NO_ARRAY,
1359                 .tlv_type       = 0x10,
1360                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1361                                            file_id),
1362         },
1363         {
1364                 .data_type      = QMI_OPT_FLAG,
1365                 .elem_len       = 1,
1366                 .elem_size      = sizeof(u8),
1367                 .array_type     = NO_ARRAY,
1368                 .tlv_type       = 0x11,
1369                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1370                                            total_size_valid),
1371         },
1372         {
1373                 .data_type      = QMI_UNSIGNED_4_BYTE,
1374                 .elem_len       = 1,
1375                 .elem_size      = sizeof(u32),
1376                 .array_type     = NO_ARRAY,
1377                 .tlv_type       = 0x11,
1378                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1379                                            total_size),
1380         },
1381         {
1382                 .data_type      = QMI_OPT_FLAG,
1383                 .elem_len       = 1,
1384                 .elem_size      = sizeof(u8),
1385                 .array_type     = NO_ARRAY,
1386                 .tlv_type       = 0x12,
1387                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1388                                            seg_id_valid),
1389         },
1390         {
1391                 .data_type      = QMI_UNSIGNED_4_BYTE,
1392                 .elem_len       = 1,
1393                 .elem_size      = sizeof(u32),
1394                 .array_type     = NO_ARRAY,
1395                 .tlv_type       = 0x12,
1396                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1397                                            seg_id),
1398         },
1399         {
1400                 .data_type      = QMI_OPT_FLAG,
1401                 .elem_len       = 1,
1402                 .elem_size      = sizeof(u8),
1403                 .array_type     = NO_ARRAY,
1404                 .tlv_type       = 0x13,
1405                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1406                                            data_valid),
1407         },
1408         {
1409                 .data_type      = QMI_DATA_LEN,
1410                 .elem_len       = 1,
1411                 .elem_size      = sizeof(u16),
1412                 .array_type     = NO_ARRAY,
1413                 .tlv_type       = 0x13,
1414                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1415                                            data_len),
1416         },
1417         {
1418                 .data_type      = QMI_UNSIGNED_1_BYTE,
1419                 .elem_len       = QMI_WLFW_MAX_DATA_SIZE_V01,
1420                 .elem_size      = sizeof(u8),
1421                 .array_type       = VAR_LEN_ARRAY,
1422                 .tlv_type       = 0x13,
1423                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1424                                            data),
1425         },
1426         {
1427                 .data_type      = QMI_OPT_FLAG,
1428                 .elem_len       = 1,
1429                 .elem_size      = sizeof(u8),
1430                 .array_type     = NO_ARRAY,
1431                 .tlv_type       = 0x14,
1432                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1433                                            end_valid),
1434         },
1435         {
1436                 .data_type      = QMI_UNSIGNED_1_BYTE,
1437                 .elem_len       = 1,
1438                 .elem_size      = sizeof(u8),
1439                 .array_type     = NO_ARRAY,
1440                 .tlv_type       = 0x14,
1441                 .offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1442                                            end),
1443         },
1444         {}
1445 };
1446
1447 const struct qmi_elem_info wlfw_msa_info_req_msg_v01_ei[] = {
1448         {
1449                 .data_type      = QMI_UNSIGNED_8_BYTE,
1450                 .elem_len       = 1,
1451                 .elem_size      = sizeof(u64),
1452                 .array_type     = NO_ARRAY,
1453                 .tlv_type       = 0x01,
1454                 .offset         = offsetof(struct wlfw_msa_info_req_msg_v01,
1455                                            msa_addr),
1456         },
1457         {
1458                 .data_type      = QMI_UNSIGNED_4_BYTE,
1459                 .elem_len       = 1,
1460                 .elem_size      = sizeof(u32),
1461                 .array_type     = NO_ARRAY,
1462                 .tlv_type       = 0x02,
1463                 .offset         = offsetof(struct wlfw_msa_info_req_msg_v01,
1464                                            size),
1465         },
1466         {}
1467 };
1468
1469 const struct qmi_elem_info wlfw_msa_info_resp_msg_v01_ei[] = {
1470         {
1471                 .data_type      = QMI_STRUCT,
1472                 .elem_len       = 1,
1473                 .elem_size      = sizeof(struct qmi_response_type_v01),
1474                 .array_type     = NO_ARRAY,
1475                 .tlv_type       = 0x02,
1476                 .offset         = offsetof(struct wlfw_msa_info_resp_msg_v01,
1477                                            resp),
1478                 .ei_array      = qmi_response_type_v01_ei,
1479         },
1480         {
1481                 .data_type      = QMI_DATA_LEN,
1482                 .elem_len       = 1,
1483                 .elem_size      = sizeof(u8),
1484                 .array_type     = NO_ARRAY,
1485                 .tlv_type       = 0x03,
1486                 .offset         = offsetof(struct wlfw_msa_info_resp_msg_v01,
1487                                            mem_region_info_len),
1488         },
1489         {
1490                 .data_type      = QMI_STRUCT,
1491                 .elem_len       = QMI_WLFW_MAX_MEM_REG_V01,
1492                 .elem_size      = sizeof(struct wlfw_memory_region_info_s_v01),
1493                 .array_type       = VAR_LEN_ARRAY,
1494                 .tlv_type       = 0x03,
1495                 .offset         = offsetof(struct wlfw_msa_info_resp_msg_v01,
1496                                            mem_region_info),
1497                 .ei_array      = wlfw_memory_region_info_s_v01_ei,
1498         },
1499         {}
1500 };
1501
1502 const struct qmi_elem_info wlfw_msa_ready_req_msg_v01_ei[] = {
1503         {}
1504 };
1505
1506 const struct qmi_elem_info wlfw_msa_ready_resp_msg_v01_ei[] = {
1507         {
1508                 .data_type      = QMI_STRUCT,
1509                 .elem_len       = 1,
1510                 .elem_size      = sizeof(struct qmi_response_type_v01),
1511                 .array_type     = NO_ARRAY,
1512                 .tlv_type       = 0x02,
1513                 .offset         = offsetof(struct wlfw_msa_ready_resp_msg_v01,
1514                                            resp),
1515                 .ei_array      = qmi_response_type_v01_ei,
1516         },
1517         {}
1518 };
1519
1520 const struct qmi_elem_info wlfw_ini_req_msg_v01_ei[] = {
1521         {
1522                 .data_type      = QMI_OPT_FLAG,
1523                 .elem_len       = 1,
1524                 .elem_size      = sizeof(u8),
1525                 .array_type     = NO_ARRAY,
1526                 .tlv_type       = 0x10,
1527                 .offset         = offsetof(struct wlfw_ini_req_msg_v01,
1528                                            enablefwlog_valid),
1529         },
1530         {
1531                 .data_type      = QMI_UNSIGNED_1_BYTE,
1532                 .elem_len       = 1,
1533                 .elem_size      = sizeof(u8),
1534                 .array_type     = NO_ARRAY,
1535                 .tlv_type       = 0x10,
1536                 .offset         = offsetof(struct wlfw_ini_req_msg_v01,
1537                                            enablefwlog),
1538         },
1539         {}
1540 };
1541
1542 const struct qmi_elem_info wlfw_ini_resp_msg_v01_ei[] = {
1543         {
1544                 .data_type      = QMI_STRUCT,
1545                 .elem_len       = 1,
1546                 .elem_size      = sizeof(struct qmi_response_type_v01),
1547                 .array_type     = NO_ARRAY,
1548                 .tlv_type       = 0x02,
1549                 .offset         = offsetof(struct wlfw_ini_resp_msg_v01,
1550                                            resp),
1551                 .ei_array      = qmi_response_type_v01_ei,
1552         },
1553         {}
1554 };
1555
1556 const struct qmi_elem_info wlfw_athdiag_read_req_msg_v01_ei[] = {
1557         {
1558                 .data_type      = QMI_UNSIGNED_4_BYTE,
1559                 .elem_len       = 1,
1560                 .elem_size      = sizeof(u32),
1561                 .array_type     = NO_ARRAY,
1562                 .tlv_type       = 0x01,
1563                 .offset         = offsetof(struct wlfw_athdiag_read_req_msg_v01,
1564                                            offset),
1565         },
1566         {
1567                 .data_type      = QMI_UNSIGNED_4_BYTE,
1568                 .elem_len       = 1,
1569                 .elem_size      = sizeof(u32),
1570                 .array_type     = NO_ARRAY,
1571                 .tlv_type       = 0x02,
1572                 .offset         = offsetof(struct wlfw_athdiag_read_req_msg_v01,
1573                                            mem_type),
1574         },
1575         {
1576                 .data_type      = QMI_UNSIGNED_4_BYTE,
1577                 .elem_len       = 1,
1578                 .elem_size      = sizeof(u32),
1579                 .array_type     = NO_ARRAY,
1580                 .tlv_type       = 0x03,
1581                 .offset         = offsetof(struct wlfw_athdiag_read_req_msg_v01,
1582                                            data_len),
1583         },
1584         {}
1585 };
1586
1587 const struct qmi_elem_info wlfw_athdiag_read_resp_msg_v01_ei[] = {
1588         {
1589                 .data_type      = QMI_STRUCT,
1590                 .elem_len       = 1,
1591                 .elem_size      = sizeof(struct qmi_response_type_v01),
1592                 .array_type     = NO_ARRAY,
1593                 .tlv_type       = 0x02,
1594                 .offset         = offsetof(struct wlfw_athdiag_read_resp_msg_v01,
1595                                            resp),
1596                 .ei_array      = qmi_response_type_v01_ei,
1597         },
1598         {
1599                 .data_type      = QMI_OPT_FLAG,
1600                 .elem_len       = 1,
1601                 .elem_size      = sizeof(u8),
1602                 .array_type     = NO_ARRAY,
1603                 .tlv_type       = 0x10,
1604                 .offset         = offsetof(struct wlfw_athdiag_read_resp_msg_v01,
1605                                            data_valid),
1606         },
1607         {
1608                 .data_type      = QMI_DATA_LEN,
1609                 .elem_len       = 1,
1610                 .elem_size      = sizeof(u16),
1611                 .array_type     = NO_ARRAY,
1612                 .tlv_type       = 0x10,
1613                 .offset         = offsetof(struct wlfw_athdiag_read_resp_msg_v01,
1614                                            data_len),
1615         },
1616         {
1617                 .data_type      = QMI_UNSIGNED_1_BYTE,
1618                 .elem_len       = QMI_WLFW_MAX_ATHDIAG_DATA_SIZE_V01,
1619                 .elem_size      = sizeof(u8),
1620                 .array_type       = VAR_LEN_ARRAY,
1621                 .tlv_type       = 0x10,
1622                 .offset         = offsetof(struct wlfw_athdiag_read_resp_msg_v01,
1623                                            data),
1624         },
1625         {}
1626 };
1627
1628 const struct qmi_elem_info wlfw_athdiag_write_req_msg_v01_ei[] = {
1629         {
1630                 .data_type      = QMI_UNSIGNED_4_BYTE,
1631                 .elem_len       = 1,
1632                 .elem_size      = sizeof(u32),
1633                 .array_type     = NO_ARRAY,
1634                 .tlv_type       = 0x01,
1635                 .offset         = offsetof(struct wlfw_athdiag_write_req_msg_v01,
1636                                            offset),
1637         },
1638         {
1639                 .data_type      = QMI_UNSIGNED_4_BYTE,
1640                 .elem_len       = 1,
1641                 .elem_size      = sizeof(u32),
1642                 .array_type     = NO_ARRAY,
1643                 .tlv_type       = 0x02,
1644                 .offset         = offsetof(struct wlfw_athdiag_write_req_msg_v01,
1645                                            mem_type),
1646         },
1647         {
1648                 .data_type      = QMI_DATA_LEN,
1649                 .elem_len       = 1,
1650                 .elem_size      = sizeof(u16),
1651                 .array_type     = NO_ARRAY,
1652                 .tlv_type       = 0x03,
1653                 .offset         = offsetof(struct wlfw_athdiag_write_req_msg_v01,
1654                                            data_len),
1655         },
1656         {
1657                 .data_type      = QMI_UNSIGNED_1_BYTE,
1658                 .elem_len       = QMI_WLFW_MAX_ATHDIAG_DATA_SIZE_V01,
1659                 .elem_size      = sizeof(u8),
1660                 .array_type       = VAR_LEN_ARRAY,
1661                 .tlv_type       = 0x03,
1662                 .offset         = offsetof(struct wlfw_athdiag_write_req_msg_v01,
1663                                            data),
1664         },
1665         {}
1666 };
1667
1668 const struct qmi_elem_info wlfw_athdiag_write_resp_msg_v01_ei[] = {
1669         {
1670                 .data_type      = QMI_STRUCT,
1671                 .elem_len       = 1,
1672                 .elem_size      = sizeof(struct qmi_response_type_v01),
1673                 .array_type     = NO_ARRAY,
1674                 .tlv_type       = 0x02,
1675                 .offset         = offsetof(struct wlfw_athdiag_write_resp_msg_v01,
1676                                            resp),
1677                 .ei_array      = qmi_response_type_v01_ei,
1678         },
1679         {}
1680 };
1681
1682 const struct qmi_elem_info wlfw_vbatt_req_msg_v01_ei[] = {
1683         {
1684                 .data_type      = QMI_UNSIGNED_8_BYTE,
1685                 .elem_len       = 1,
1686                 .elem_size      = sizeof(u64),
1687                 .array_type     = NO_ARRAY,
1688                 .tlv_type       = 0x01,
1689                 .offset         = offsetof(struct wlfw_vbatt_req_msg_v01,
1690                                            voltage_uv),
1691         },
1692         {}
1693 };
1694
1695 const struct qmi_elem_info wlfw_vbatt_resp_msg_v01_ei[] = {
1696         {
1697                 .data_type      = QMI_STRUCT,
1698                 .elem_len       = 1,
1699                 .elem_size      = sizeof(struct qmi_response_type_v01),
1700                 .array_type     = NO_ARRAY,
1701                 .tlv_type       = 0x02,
1702                 .offset         = offsetof(struct wlfw_vbatt_resp_msg_v01,
1703                                            resp),
1704                 .ei_array      = qmi_response_type_v01_ei,
1705         },
1706         {}
1707 };
1708
1709 const struct qmi_elem_info wlfw_mac_addr_req_msg_v01_ei[] = {
1710         {
1711                 .data_type      = QMI_OPT_FLAG,
1712                 .elem_len       = 1,
1713                 .elem_size      = sizeof(u8),
1714                 .array_type     = NO_ARRAY,
1715                 .tlv_type       = 0x10,
1716                 .offset         = offsetof(struct wlfw_mac_addr_req_msg_v01,
1717                                            mac_addr_valid),
1718         },
1719         {
1720                 .data_type      = QMI_UNSIGNED_1_BYTE,
1721                 .elem_len       = QMI_WLFW_MAC_ADDR_SIZE_V01,
1722                 .elem_size      = sizeof(u8),
1723                 .array_type       = STATIC_ARRAY,
1724                 .tlv_type       = 0x10,
1725                 .offset         = offsetof(struct wlfw_mac_addr_req_msg_v01,
1726                                            mac_addr),
1727         },
1728         {}
1729 };
1730
1731 const struct qmi_elem_info wlfw_mac_addr_resp_msg_v01_ei[] = {
1732         {
1733                 .data_type      = QMI_STRUCT,
1734                 .elem_len       = 1,
1735                 .elem_size      = sizeof(struct qmi_response_type_v01),
1736                 .array_type     = NO_ARRAY,
1737                 .tlv_type       = 0x02,
1738                 .offset         = offsetof(struct wlfw_mac_addr_resp_msg_v01,
1739                                            resp),
1740                 .ei_array      = qmi_response_type_v01_ei,
1741         },
1742         {}
1743 };
1744
1745 const struct qmi_elem_info wlfw_host_cap_req_msg_v01_ei[] = {
1746         {
1747                 .data_type      = QMI_OPT_FLAG,
1748                 .elem_len       = 1,
1749                 .elem_size      = sizeof(u8),
1750                 .array_type     = NO_ARRAY,
1751                 .tlv_type       = 0x10,
1752                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1753                                            daemon_support_valid),
1754         },
1755         {
1756                 .data_type      = QMI_UNSIGNED_4_BYTE,
1757                 .elem_len       = 1,
1758                 .elem_size      = sizeof(u32),
1759                 .array_type     = NO_ARRAY,
1760                 .tlv_type       = 0x10,
1761                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1762                                            daemon_support),
1763         },
1764         {
1765                 .data_type      = QMI_OPT_FLAG,
1766                 .elem_len       = 1,
1767                 .elem_size      = sizeof(u8),
1768                 .array_type     = NO_ARRAY,
1769                 .tlv_type       = 0x11,
1770                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1771                                            wake_msi_valid),
1772         },
1773         {
1774                 .data_type      = QMI_UNSIGNED_4_BYTE,
1775                 .elem_len       = 1,
1776                 .elem_size      = sizeof(u32),
1777                 .array_type     = NO_ARRAY,
1778                 .tlv_type       = 0x11,
1779                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1780                                            wake_msi),
1781         },
1782         {
1783                 .data_type      = QMI_OPT_FLAG,
1784                 .elem_len       = 1,
1785                 .elem_size      = sizeof(u8),
1786                 .array_type     = NO_ARRAY,
1787                 .tlv_type       = 0x12,
1788                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1789                                            gpios_valid),
1790         },
1791         {
1792                 .data_type      = QMI_DATA_LEN,
1793                 .elem_len       = 1,
1794                 .elem_size      = sizeof(u32),
1795                 .array_type     = NO_ARRAY,
1796                 .tlv_type       = 0x12,
1797                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1798                                            gpios_len),
1799         },
1800         {
1801                 .data_type      = QMI_UNSIGNED_4_BYTE,
1802                 .elem_len       = QMI_WLFW_MAX_NUM_GPIO_V01,
1803                 .elem_size      = sizeof(u32),
1804                 .array_type     = VAR_LEN_ARRAY,
1805                 .tlv_type       = 0x12,
1806                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1807                                            gpios),
1808         },
1809         {
1810                 .data_type      = QMI_OPT_FLAG,
1811                 .elem_len       = 1,
1812                 .elem_size      = sizeof(u8),
1813                 .array_type     = NO_ARRAY,
1814                 .tlv_type       = 0x13,
1815                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1816                                            nm_modem_valid),
1817         },
1818         {
1819                 .data_type      = QMI_UNSIGNED_1_BYTE,
1820                 .elem_len       = 1,
1821                 .elem_size      = sizeof(u8),
1822                 .array_type     = NO_ARRAY,
1823                 .tlv_type       = 0x13,
1824                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1825                                            nm_modem),
1826         },
1827         {
1828                 .data_type      = QMI_OPT_FLAG,
1829                 .elem_len       = 1,
1830                 .elem_size      = sizeof(u8),
1831                 .array_type     = NO_ARRAY,
1832                 .tlv_type       = 0x14,
1833                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1834                                            bdf_support_valid),
1835         },
1836         {
1837                 .data_type      = QMI_UNSIGNED_1_BYTE,
1838                 .elem_len       = 1,
1839                 .elem_size      = sizeof(u8),
1840                 .array_type     = NO_ARRAY,
1841                 .tlv_type       = 0x14,
1842                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1843                                            bdf_support),
1844         },
1845         {
1846                 .data_type      = QMI_OPT_FLAG,
1847                 .elem_len       = 1,
1848                 .elem_size      = sizeof(u8),
1849                 .array_type     = NO_ARRAY,
1850                 .tlv_type       = 0x15,
1851                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1852                                            bdf_cache_support_valid),
1853         },
1854         {
1855                 .data_type      = QMI_UNSIGNED_1_BYTE,
1856                 .elem_len       = 1,
1857                 .elem_size      = sizeof(u8),
1858                 .array_type     = NO_ARRAY,
1859                 .tlv_type       = 0x15,
1860                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1861                                            bdf_cache_support),
1862         },
1863         {
1864                 .data_type      = QMI_OPT_FLAG,
1865                 .elem_len       = 1,
1866                 .elem_size      = sizeof(u8),
1867                 .array_type     = NO_ARRAY,
1868                 .tlv_type       = 0x16,
1869                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1870                                            m3_support_valid),
1871         },
1872         {
1873                 .data_type      = QMI_UNSIGNED_1_BYTE,
1874                 .elem_len       = 1,
1875                 .elem_size      = sizeof(u8),
1876                 .array_type     = NO_ARRAY,
1877                 .tlv_type       = 0x16,
1878                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1879                                            m3_support),
1880         },
1881         {
1882                 .data_type      = QMI_OPT_FLAG,
1883                 .elem_len       = 1,
1884                 .elem_size      = sizeof(u8),
1885                 .array_type     = NO_ARRAY,
1886                 .tlv_type       = 0x17,
1887                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1888                                            m3_cache_support_valid),
1889         },
1890         {
1891                 .data_type      = QMI_UNSIGNED_1_BYTE,
1892                 .elem_len       = 1,
1893                 .elem_size      = sizeof(u8),
1894                 .array_type     = NO_ARRAY,
1895                 .tlv_type       = 0x17,
1896                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1897                                            m3_cache_support),
1898         },
1899         {
1900                 .data_type      = QMI_OPT_FLAG,
1901                 .elem_len       = 1,
1902                 .elem_size      = sizeof(u8),
1903                 .array_type     = NO_ARRAY,
1904                 .tlv_type       = 0x18,
1905                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1906                                            cal_filesys_support_valid),
1907         },
1908         {
1909                 .data_type      = QMI_UNSIGNED_1_BYTE,
1910                 .elem_len       = 1,
1911                 .elem_size      = sizeof(u8),
1912                 .array_type     = NO_ARRAY,
1913                 .tlv_type       = 0x18,
1914                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1915                                            cal_filesys_support),
1916         },
1917         {
1918                 .data_type      = QMI_OPT_FLAG,
1919                 .elem_len       = 1,
1920                 .elem_size      = sizeof(u8),
1921                 .array_type     = NO_ARRAY,
1922                 .tlv_type       = 0x19,
1923                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1924                                            cal_cache_support_valid),
1925         },
1926         {
1927                 .data_type      = QMI_UNSIGNED_1_BYTE,
1928                 .elem_len       = 1,
1929                 .elem_size      = sizeof(u8),
1930                 .array_type     = NO_ARRAY,
1931                 .tlv_type       = 0x19,
1932                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1933                                            cal_cache_support),
1934         },
1935         {
1936                 .data_type      = QMI_OPT_FLAG,
1937                 .elem_len       = 1,
1938                 .elem_size      = sizeof(u8),
1939                 .array_type     = NO_ARRAY,
1940                 .tlv_type       = 0x1A,
1941                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1942                                            cal_done_valid),
1943         },
1944         {
1945                 .data_type      = QMI_UNSIGNED_1_BYTE,
1946                 .elem_len       = 1,
1947                 .elem_size      = sizeof(u8),
1948                 .array_type     = NO_ARRAY,
1949                 .tlv_type       = 0x1A,
1950                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1951                                            cal_done),
1952         },
1953         {
1954                 .data_type      = QMI_OPT_FLAG,
1955                 .elem_len       = 1,
1956                 .elem_size      = sizeof(u8),
1957                 .array_type     = NO_ARRAY,
1958                 .tlv_type       = 0x1B,
1959                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1960                                            mem_bucket_valid),
1961         },
1962         {
1963                 .data_type      = QMI_UNSIGNED_4_BYTE,
1964                 .elem_len       = 1,
1965                 .elem_size      = sizeof(u32),
1966                 .array_type     = NO_ARRAY,
1967                 .tlv_type       = 0x1B,
1968                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1969                                            mem_bucket),
1970         },
1971         {
1972                 .data_type      = QMI_OPT_FLAG,
1973                 .elem_len       = 1,
1974                 .elem_size      = sizeof(u8),
1975                 .array_type     = NO_ARRAY,
1976                 .tlv_type       = 0x1C,
1977                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1978                                            mem_cfg_mode_valid),
1979         },
1980         {
1981                 .data_type      = QMI_UNSIGNED_1_BYTE,
1982                 .elem_len       = 1,
1983                 .elem_size      = sizeof(u8),
1984                 .array_type     = NO_ARRAY,
1985                 .tlv_type       = 0x1C,
1986                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1987                                            mem_cfg_mode),
1988         },
1989         {}
1990 };
1991
1992 const struct qmi_elem_info wlfw_host_cap_8bit_req_msg_v01_ei[] = {
1993         {
1994                 .data_type      = QMI_OPT_FLAG,
1995                 .elem_len       = 1,
1996                 .elem_size      = sizeof(u8),
1997                 .array_type     = NO_ARRAY,
1998                 .tlv_type       = 0x10,
1999                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
2000                                            daemon_support_valid),
2001         },
2002         {
2003                 .data_type      = QMI_UNSIGNED_1_BYTE,
2004                 .elem_len       = 1,
2005                 .elem_size      = sizeof(u8),
2006                 .array_type     = NO_ARRAY,
2007                 .tlv_type       = 0x10,
2008                 .offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
2009                                            daemon_support),
2010         },
2011         {}
2012 };
2013
2014 const struct qmi_elem_info wlfw_host_cap_resp_msg_v01_ei[] = {
2015         {
2016                 .data_type      = QMI_STRUCT,
2017                 .elem_len       = 1,
2018                 .elem_size      = sizeof(struct qmi_response_type_v01),
2019                 .array_type     = NO_ARRAY,
2020                 .tlv_type       = 0x02,
2021                 .offset         = offsetof(struct wlfw_host_cap_resp_msg_v01,
2022                                            resp),
2023                 .ei_array      = qmi_response_type_v01_ei,
2024         },
2025         {}
2026 };
2027
2028 const struct qmi_elem_info wlfw_request_mem_ind_msg_v01_ei[] = {
2029         {
2030                 .data_type      = QMI_DATA_LEN,
2031                 .elem_len       = 1,
2032                 .elem_size      = sizeof(u8),
2033                 .array_type     = NO_ARRAY,
2034                 .tlv_type       = 0x01,
2035                 .offset         = offsetof(struct wlfw_request_mem_ind_msg_v01,
2036                                            mem_seg_len),
2037         },
2038         {
2039                 .data_type      = QMI_STRUCT,
2040                 .elem_len       = QMI_WLFW_MAX_NUM_MEM_SEG_V01,
2041                 .elem_size      = sizeof(struct wlfw_mem_seg_s_v01),
2042                 .array_type       = VAR_LEN_ARRAY,
2043                 .tlv_type       = 0x01,
2044                 .offset         = offsetof(struct wlfw_request_mem_ind_msg_v01,
2045                                            mem_seg),
2046                 .ei_array      = wlfw_mem_seg_s_v01_ei,
2047         },
2048         {}
2049 };
2050
2051 const struct qmi_elem_info wlfw_respond_mem_req_msg_v01_ei[] = {
2052         {
2053                 .data_type      = QMI_DATA_LEN,
2054                 .elem_len       = 1,
2055                 .elem_size      = sizeof(u8),
2056                 .array_type     = NO_ARRAY,
2057                 .tlv_type       = 0x01,
2058                 .offset         = offsetof(struct wlfw_respond_mem_req_msg_v01,
2059                                            mem_seg_len),
2060         },
2061         {
2062                 .data_type      = QMI_STRUCT,
2063                 .elem_len       = QMI_WLFW_MAX_NUM_MEM_SEG_V01,
2064                 .elem_size      = sizeof(struct wlfw_mem_seg_resp_s_v01),
2065                 .array_type       = VAR_LEN_ARRAY,
2066                 .tlv_type       = 0x01,
2067                 .offset         = offsetof(struct wlfw_respond_mem_req_msg_v01,
2068                                            mem_seg),
2069                 .ei_array      = wlfw_mem_seg_resp_s_v01_ei,
2070         },
2071         {}
2072 };
2073
2074 const struct qmi_elem_info wlfw_respond_mem_resp_msg_v01_ei[] = {
2075         {
2076                 .data_type      = QMI_STRUCT,
2077                 .elem_len       = 1,
2078                 .elem_size      = sizeof(struct qmi_response_type_v01),
2079                 .array_type     = NO_ARRAY,
2080                 .tlv_type       = 0x02,
2081                 .offset         = offsetof(struct wlfw_respond_mem_resp_msg_v01,
2082                                            resp),
2083                 .ei_array      = qmi_response_type_v01_ei,
2084         },
2085         {}
2086 };
2087
2088 const struct qmi_elem_info wlfw_mem_ready_ind_msg_v01_ei[] = {
2089         {}
2090 };
2091
2092 const struct qmi_elem_info wlfw_fw_init_done_ind_msg_v01_ei[] = {
2093         {}
2094 };
2095
2096 const struct qmi_elem_info wlfw_rejuvenate_ind_msg_v01_ei[] = {
2097         {
2098                 .data_type      = QMI_OPT_FLAG,
2099                 .elem_len       = 1,
2100                 .elem_size      = sizeof(u8),
2101                 .array_type     = NO_ARRAY,
2102                 .tlv_type       = 0x10,
2103                 .offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2104                                            cause_for_rejuvenation_valid),
2105         },
2106         {
2107                 .data_type      = QMI_UNSIGNED_1_BYTE,
2108                 .elem_len       = 1,
2109                 .elem_size      = sizeof(u8),
2110                 .array_type     = NO_ARRAY,
2111                 .tlv_type       = 0x10,
2112                 .offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2113                                            cause_for_rejuvenation),
2114         },
2115         {
2116                 .data_type      = QMI_OPT_FLAG,
2117                 .elem_len       = 1,
2118                 .elem_size      = sizeof(u8),
2119                 .array_type     = NO_ARRAY,
2120                 .tlv_type       = 0x11,
2121                 .offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2122                                            requesting_sub_system_valid),
2123         },
2124         {
2125                 .data_type      = QMI_UNSIGNED_1_BYTE,
2126                 .elem_len       = 1,
2127                 .elem_size      = sizeof(u8),
2128                 .array_type     = NO_ARRAY,
2129                 .tlv_type       = 0x11,
2130                 .offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2131                                            requesting_sub_system),
2132         },
2133         {
2134                 .data_type      = QMI_OPT_FLAG,
2135                 .elem_len       = 1,
2136                 .elem_size      = sizeof(u8),
2137                 .array_type     = NO_ARRAY,
2138                 .tlv_type       = 0x12,
2139                 .offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2140                                            line_number_valid),
2141         },
2142         {
2143                 .data_type      = QMI_UNSIGNED_2_BYTE,
2144                 .elem_len       = 1,
2145                 .elem_size      = sizeof(u16),
2146                 .array_type     = NO_ARRAY,
2147                 .tlv_type       = 0x12,
2148                 .offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2149                                            line_number),
2150         },
2151         {
2152                 .data_type      = QMI_OPT_FLAG,
2153                 .elem_len       = 1,
2154                 .elem_size      = sizeof(u8),
2155                 .array_type     = NO_ARRAY,
2156                 .tlv_type       = 0x13,
2157                 .offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2158                                            function_name_valid),
2159         },
2160         {
2161                 .data_type      = QMI_STRING,
2162                 .elem_len       = QMI_WLFW_FUNCTION_NAME_LEN_V01 + 1,
2163                 .elem_size      = sizeof(char),
2164                 .array_type     = NO_ARRAY,
2165                 .tlv_type       = 0x13,
2166                 .offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2167                                            function_name),
2168         },
2169         {}
2170 };
2171
2172 const struct qmi_elem_info wlfw_rejuvenate_ack_req_msg_v01_ei[] = {
2173         {}
2174 };
2175
2176 const struct qmi_elem_info wlfw_rejuvenate_ack_resp_msg_v01_ei[] = {
2177         {
2178                 .data_type      = QMI_STRUCT,
2179                 .elem_len       = 1,
2180                 .elem_size      = sizeof(struct qmi_response_type_v01),
2181                 .array_type     = NO_ARRAY,
2182                 .tlv_type       = 0x02,
2183                 .offset         = offsetof(struct wlfw_rejuvenate_ack_resp_msg_v01,
2184                                            resp),
2185                 .ei_array      = qmi_response_type_v01_ei,
2186         },
2187         {}
2188 };
2189
2190 const struct qmi_elem_info wlfw_dynamic_feature_mask_req_msg_v01_ei[] = {
2191         {
2192                 .data_type      = QMI_OPT_FLAG,
2193                 .elem_len       = 1,
2194                 .elem_size      = sizeof(u8),
2195                 .array_type     = NO_ARRAY,
2196                 .tlv_type       = 0x10,
2197                 .offset         = offsetof(struct wlfw_dynamic_feature_mask_req_msg_v01,
2198                                            mask_valid),
2199         },
2200         {
2201                 .data_type      = QMI_UNSIGNED_8_BYTE,
2202                 .elem_len       = 1,
2203                 .elem_size      = sizeof(u64),
2204                 .array_type     = NO_ARRAY,
2205                 .tlv_type       = 0x10,
2206                 .offset         = offsetof(struct wlfw_dynamic_feature_mask_req_msg_v01,
2207                                            mask),
2208         },
2209         {}
2210 };
2211
2212 const struct qmi_elem_info wlfw_dynamic_feature_mask_resp_msg_v01_ei[] = {
2213         {
2214                 .data_type      = QMI_STRUCT,
2215                 .elem_len       = 1,
2216                 .elem_size      = sizeof(struct qmi_response_type_v01),
2217                 .array_type     = NO_ARRAY,
2218                 .tlv_type       = 0x02,
2219                 .offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2220                                            resp),
2221                 .ei_array      = qmi_response_type_v01_ei,
2222         },
2223         {
2224                 .data_type      = QMI_OPT_FLAG,
2225                 .elem_len       = 1,
2226                 .elem_size      = sizeof(u8),
2227                 .array_type     = NO_ARRAY,
2228                 .tlv_type       = 0x10,
2229                 .offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2230                                            prev_mask_valid),
2231         },
2232         {
2233                 .data_type      = QMI_UNSIGNED_8_BYTE,
2234                 .elem_len       = 1,
2235                 .elem_size      = sizeof(u64),
2236                 .array_type     = NO_ARRAY,
2237                 .tlv_type       = 0x10,
2238                 .offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2239                                            prev_mask),
2240         },
2241         {
2242                 .data_type      = QMI_OPT_FLAG,
2243                 .elem_len       = 1,
2244                 .elem_size      = sizeof(u8),
2245                 .array_type     = NO_ARRAY,
2246                 .tlv_type       = 0x11,
2247                 .offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2248                                            curr_mask_valid),
2249         },
2250         {
2251                 .data_type      = QMI_UNSIGNED_8_BYTE,
2252                 .elem_len       = 1,
2253                 .elem_size      = sizeof(u64),
2254                 .array_type     = NO_ARRAY,
2255                 .tlv_type       = 0x11,
2256                 .offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2257                                            curr_mask),
2258         },
2259         {}
2260 };
2261
2262 const struct qmi_elem_info wlfw_m3_info_req_msg_v01_ei[] = {
2263         {
2264                 .data_type      = QMI_UNSIGNED_8_BYTE,
2265                 .elem_len       = 1,
2266                 .elem_size      = sizeof(u64),
2267                 .array_type     = NO_ARRAY,
2268                 .tlv_type       = 0x01,
2269                 .offset         = offsetof(struct wlfw_m3_info_req_msg_v01,
2270                                            addr),
2271         },
2272         {
2273                 .data_type      = QMI_UNSIGNED_4_BYTE,
2274                 .elem_len       = 1,
2275                 .elem_size      = sizeof(u32),
2276                 .array_type     = NO_ARRAY,
2277                 .tlv_type       = 0x02,
2278                 .offset         = offsetof(struct wlfw_m3_info_req_msg_v01,
2279                                            size),
2280         },
2281         {}
2282 };
2283
2284 const struct qmi_elem_info wlfw_m3_info_resp_msg_v01_ei[] = {
2285         {
2286                 .data_type      = QMI_STRUCT,
2287                 .elem_len       = 1,
2288                 .elem_size      = sizeof(struct qmi_response_type_v01),
2289                 .array_type     = NO_ARRAY,
2290                 .tlv_type       = 0x02,
2291                 .offset         = offsetof(struct wlfw_m3_info_resp_msg_v01,
2292                                            resp),
2293                 .ei_array      = qmi_response_type_v01_ei,
2294         },
2295         {}
2296 };
2297
2298 const struct qmi_elem_info wlfw_xo_cal_ind_msg_v01_ei[] = {
2299         {
2300                 .data_type      = QMI_UNSIGNED_1_BYTE,
2301                 .elem_len       = 1,
2302                 .elem_size      = sizeof(u8),
2303                 .array_type     = NO_ARRAY,
2304                 .tlv_type       = 0x01,
2305                 .offset         = offsetof(struct wlfw_xo_cal_ind_msg_v01,
2306                                            xo_cal_data),
2307         },
2308         {}
2309 };