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