linux/drivers/net/ipa/ipa_qmi_msg.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2
   3/* Copyright (c) 2018, The Linux Foundation. All rights reserved.
   4 * Copyright (C) 2018-2020 Linaro Ltd.
   5 */
   6#include <linux/stddef.h>
   7#include <linux/soc/qcom/qmi.h>
   8
   9#include "ipa_qmi_msg.h"
  10
  11/* QMI message structure definition for struct ipa_indication_register_req */
  12struct qmi_elem_info ipa_indication_register_req_ei[] = {
  13        {
  14                .data_type      = QMI_OPT_FLAG,
  15                .elem_len       = 1,
  16                .elem_size      =
  17                        sizeof_field(struct ipa_indication_register_req,
  18                                     master_driver_init_complete_valid),
  19                .tlv_type       = 0x10,
  20                .offset         = offsetof(struct ipa_indication_register_req,
  21                                           master_driver_init_complete_valid),
  22        },
  23        {
  24                .data_type      = QMI_UNSIGNED_1_BYTE,
  25                .elem_len       = 1,
  26                .elem_size      =
  27                        sizeof_field(struct ipa_indication_register_req,
  28                                     master_driver_init_complete),
  29                .tlv_type       = 0x10,
  30                .offset         = offsetof(struct ipa_indication_register_req,
  31                                           master_driver_init_complete),
  32        },
  33        {
  34                .data_type      = QMI_OPT_FLAG,
  35                .elem_len       = 1,
  36                .elem_size      =
  37                        sizeof_field(struct ipa_indication_register_req,
  38                                     data_usage_quota_reached_valid),
  39                .tlv_type       = 0x11,
  40                .offset         = offsetof(struct ipa_indication_register_req,
  41                                           data_usage_quota_reached_valid),
  42        },
  43        {
  44                .data_type      = QMI_UNSIGNED_1_BYTE,
  45                .elem_len       = 1,
  46                .elem_size      =
  47                        sizeof_field(struct ipa_indication_register_req,
  48                                     data_usage_quota_reached),
  49                .tlv_type       = 0x11,
  50                .offset         = offsetof(struct ipa_indication_register_req,
  51                                           data_usage_quota_reached),
  52        },
  53        {
  54                .data_type      = QMI_OPT_FLAG,
  55                .elem_len       = 1,
  56                .elem_size      =
  57                        sizeof_field(struct ipa_indication_register_req,
  58                                     ipa_mhi_ready_ind_valid),
  59                .tlv_type       = 0x12,
  60                .offset         = offsetof(struct ipa_indication_register_req,
  61                                           ipa_mhi_ready_ind_valid),
  62        },
  63        {
  64                .data_type      = QMI_UNSIGNED_1_BYTE,
  65                .elem_len       = 1,
  66                .elem_size      =
  67                        sizeof_field(struct ipa_indication_register_req,
  68                                     ipa_mhi_ready_ind),
  69                .tlv_type       = 0x12,
  70                .offset         = offsetof(struct ipa_indication_register_req,
  71                                           ipa_mhi_ready_ind),
  72        },
  73        {
  74                .data_type      = QMI_OPT_FLAG,
  75                .elem_len       = 1,
  76                .elem_size      =
  77                        sizeof_field(struct ipa_indication_register_req,
  78                                     endpoint_desc_ind_valid),
  79                .tlv_type       = 0x13,
  80                .offset         = offsetof(struct ipa_indication_register_req,
  81                                           endpoint_desc_ind_valid),
  82        },
  83        {
  84                .data_type      = QMI_UNSIGNED_1_BYTE,
  85                .elem_len       = 1,
  86                .elem_size      =
  87                        sizeof_field(struct ipa_indication_register_req,
  88                                     endpoint_desc_ind),
  89                .tlv_type       = 0x13,
  90                .offset         = offsetof(struct ipa_indication_register_req,
  91                                           endpoint_desc_ind),
  92        },
  93        {
  94                .data_type      = QMI_OPT_FLAG,
  95                .elem_len       = 1,
  96                .elem_size      =
  97                        sizeof_field(struct ipa_indication_register_req,
  98                                     bw_change_ind_valid),
  99                .tlv_type       = 0x14,
 100                .offset         = offsetof(struct ipa_indication_register_req,
 101                                           bw_change_ind_valid),
 102        },
 103        {
 104                .data_type      = QMI_UNSIGNED_1_BYTE,
 105                .elem_len       = 1,
 106                .elem_size      =
 107                        sizeof_field(struct ipa_indication_register_req,
 108                                     bw_change_ind),
 109                .tlv_type       = 0x14,
 110                .offset         = offsetof(struct ipa_indication_register_req,
 111                                           bw_change_ind),
 112        },
 113        {
 114                .data_type      = QMI_EOTI,
 115        },
 116};
 117
 118/* QMI message structure definition for struct ipa_indication_register_rsp */
 119struct qmi_elem_info ipa_indication_register_rsp_ei[] = {
 120        {
 121                .data_type      = QMI_STRUCT,
 122                .elem_len       = 1,
 123                .elem_size      =
 124                        sizeof_field(struct ipa_indication_register_rsp,
 125                                     rsp),
 126                .tlv_type       = 0x02,
 127                .offset         = offsetof(struct ipa_indication_register_rsp,
 128                                           rsp),
 129                .ei_array       = qmi_response_type_v01_ei,
 130        },
 131        {
 132                .data_type      = QMI_EOTI,
 133        },
 134};
 135
 136/* QMI message structure definition for struct ipa_driver_init_complete_req */
 137struct qmi_elem_info ipa_driver_init_complete_req_ei[] = {
 138        {
 139                .data_type      = QMI_UNSIGNED_1_BYTE,
 140                .elem_len       = 1,
 141                .elem_size      =
 142                        sizeof_field(struct ipa_driver_init_complete_req,
 143                                     status),
 144                .tlv_type       = 0x01,
 145                .offset         = offsetof(struct ipa_driver_init_complete_req,
 146                                           status),
 147        },
 148        {
 149                .data_type      = QMI_EOTI,
 150        },
 151};
 152
 153/* QMI message structure definition for struct ipa_driver_init_complete_rsp */
 154struct qmi_elem_info ipa_driver_init_complete_rsp_ei[] = {
 155        {
 156                .data_type      = QMI_STRUCT,
 157                .elem_len       = 1,
 158                .elem_size      =
 159                        sizeof_field(struct ipa_driver_init_complete_rsp,
 160                                     rsp),
 161                .tlv_type       = 0x02,
 162                .offset         = offsetof(struct ipa_driver_init_complete_rsp,
 163                                           rsp),
 164                .ei_array       = qmi_response_type_v01_ei,
 165        },
 166        {
 167                .data_type      = QMI_EOTI,
 168        },
 169};
 170
 171/* QMI message structure definition for struct ipa_init_complete_ind */
 172struct qmi_elem_info ipa_init_complete_ind_ei[] = {
 173        {
 174                .data_type      = QMI_STRUCT,
 175                .elem_len       = 1,
 176                .elem_size      =
 177                        sizeof_field(struct ipa_init_complete_ind,
 178                                     status),
 179                .tlv_type       = 0x02,
 180                .offset         = offsetof(struct ipa_init_complete_ind,
 181                                           status),
 182                .ei_array       = qmi_response_type_v01_ei,
 183        },
 184        {
 185                .data_type      = QMI_EOTI,
 186        },
 187};
 188
 189/* QMI message structure definition for struct ipa_mem_bounds */
 190struct qmi_elem_info ipa_mem_bounds_ei[] = {
 191        {
 192                .data_type      = QMI_UNSIGNED_4_BYTE,
 193                .elem_len       = 1,
 194                .elem_size      =
 195                        sizeof_field(struct ipa_mem_bounds, start),
 196                .offset         = offsetof(struct ipa_mem_bounds, start),
 197        },
 198        {
 199                .data_type      = QMI_UNSIGNED_4_BYTE,
 200                .elem_len       = 1,
 201                .elem_size      =
 202                        sizeof_field(struct ipa_mem_bounds, end),
 203                .offset         = offsetof(struct ipa_mem_bounds, end),
 204        },
 205        {
 206                .data_type      = QMI_EOTI,
 207        },
 208};
 209
 210/* QMI message structure definition for struct ipa_mem_array */
 211struct qmi_elem_info ipa_mem_array_ei[] = {
 212        {
 213                .data_type      = QMI_UNSIGNED_4_BYTE,
 214                .elem_len       = 1,
 215                .elem_size      =
 216                        sizeof_field(struct ipa_mem_array, start),
 217                .offset         = offsetof(struct ipa_mem_array, start),
 218        },
 219        {
 220                .data_type      = QMI_UNSIGNED_4_BYTE,
 221                .elem_len       = 1,
 222                .elem_size      =
 223                        sizeof_field(struct ipa_mem_array, count),
 224                .offset         = offsetof(struct ipa_mem_array, count),
 225        },
 226        {
 227                .data_type      = QMI_EOTI,
 228        },
 229};
 230
 231/* QMI message structure definition for struct ipa_mem_range */
 232struct qmi_elem_info ipa_mem_range_ei[] = {
 233        {
 234                .data_type      = QMI_UNSIGNED_4_BYTE,
 235                .elem_len       = 1,
 236                .elem_size      =
 237                        sizeof_field(struct ipa_mem_range, start),
 238                .offset         = offsetof(struct ipa_mem_range, start),
 239        },
 240        {
 241                .data_type      = QMI_UNSIGNED_4_BYTE,
 242                .elem_len       = 1,
 243                .elem_size      =
 244                        sizeof_field(struct ipa_mem_range, size),
 245                .offset         = offsetof(struct ipa_mem_range, size),
 246        },
 247        {
 248                .data_type      = QMI_EOTI,
 249        },
 250};
 251
 252/* QMI message structure definition for struct ipa_init_modem_driver_req */
 253struct qmi_elem_info ipa_init_modem_driver_req_ei[] = {
 254        {
 255                .data_type      = QMI_OPT_FLAG,
 256                .elem_len       = 1,
 257                .elem_size      =
 258                        sizeof_field(struct ipa_init_modem_driver_req,
 259                                     platform_type_valid),
 260                .tlv_type       = 0x10,
 261                .offset         = offsetof(struct ipa_init_modem_driver_req,
 262                                           platform_type_valid),
 263        },
 264        {
 265                .data_type      = QMI_SIGNED_4_BYTE_ENUM,
 266                .elem_len       = 1,
 267                .elem_size      =
 268                        sizeof_field(struct ipa_init_modem_driver_req,
 269                                     platform_type),
 270                .tlv_type       = 0x10,
 271                .offset         = offsetof(struct ipa_init_modem_driver_req,
 272                                           platform_type),
 273        },
 274        {
 275                .data_type      = QMI_OPT_FLAG,
 276                .elem_len       = 1,
 277                .elem_size      =
 278                        sizeof_field(struct ipa_init_modem_driver_req,
 279                                     hdr_tbl_info_valid),
 280                .tlv_type       = 0x11,
 281                .offset         = offsetof(struct ipa_init_modem_driver_req,
 282                                           hdr_tbl_info_valid),
 283        },
 284        {
 285                .data_type      = QMI_STRUCT,
 286                .elem_len       = 1,
 287                .elem_size      =
 288                        sizeof_field(struct ipa_init_modem_driver_req,
 289                                     hdr_tbl_info),
 290                .tlv_type       = 0x11,
 291                .offset         = offsetof(struct ipa_init_modem_driver_req,
 292                                           hdr_tbl_info),
 293                .ei_array       = ipa_mem_bounds_ei,
 294        },
 295        {
 296                .data_type      = QMI_OPT_FLAG,
 297                .elem_len       = 1,
 298                .elem_size      =
 299                        sizeof_field(struct ipa_init_modem_driver_req,
 300                                     v4_route_tbl_info_valid),
 301                .tlv_type       = 0x12,
 302                .offset         = offsetof(struct ipa_init_modem_driver_req,
 303                                           v4_route_tbl_info_valid),
 304        },
 305        {
 306                .data_type      = QMI_STRUCT,
 307                .elem_len       = 1,
 308                .elem_size      =
 309                        sizeof_field(struct ipa_init_modem_driver_req,
 310                                     v4_route_tbl_info),
 311                .tlv_type       = 0x12,
 312                .offset         = offsetof(struct ipa_init_modem_driver_req,
 313                                           v4_route_tbl_info),
 314                .ei_array       = ipa_mem_array_ei,
 315        },
 316        {
 317                .data_type      = QMI_OPT_FLAG,
 318                .elem_len       = 1,
 319                .elem_size      =
 320                        sizeof_field(struct ipa_init_modem_driver_req,
 321                                     v6_route_tbl_info_valid),
 322                .tlv_type       = 0x13,
 323                .offset         = offsetof(struct ipa_init_modem_driver_req,
 324                                           v6_route_tbl_info_valid),
 325        },
 326        {
 327                .data_type      = QMI_STRUCT,
 328                .elem_len       = 1,
 329                .elem_size      =
 330                        sizeof_field(struct ipa_init_modem_driver_req,
 331                                     v6_route_tbl_info),
 332                .tlv_type       = 0x13,
 333                .offset         = offsetof(struct ipa_init_modem_driver_req,
 334                                           v6_route_tbl_info),
 335                .ei_array       = ipa_mem_array_ei,
 336        },
 337        {
 338                .data_type      = QMI_OPT_FLAG,
 339                .elem_len       = 1,
 340                .elem_size      =
 341                        sizeof_field(struct ipa_init_modem_driver_req,
 342                                     v4_filter_tbl_start_valid),
 343                .tlv_type       = 0x14,
 344                .offset         = offsetof(struct ipa_init_modem_driver_req,
 345                                           v4_filter_tbl_start_valid),
 346        },
 347        {
 348                .data_type      = QMI_UNSIGNED_4_BYTE,
 349                .elem_len       = 1,
 350                .elem_size      =
 351                        sizeof_field(struct ipa_init_modem_driver_req,
 352                                     v4_filter_tbl_start),
 353                .tlv_type       = 0x14,
 354                .offset         = offsetof(struct ipa_init_modem_driver_req,
 355                                           v4_filter_tbl_start),
 356        },
 357        {
 358                .data_type      = QMI_OPT_FLAG,
 359                .elem_len       = 1,
 360                .elem_size      =
 361                        sizeof_field(struct ipa_init_modem_driver_req,
 362                                     v6_filter_tbl_start_valid),
 363                .tlv_type       = 0x15,
 364                .offset         = offsetof(struct ipa_init_modem_driver_req,
 365                                           v6_filter_tbl_start_valid),
 366        },
 367        {
 368                .data_type      = QMI_UNSIGNED_4_BYTE,
 369                .elem_len       = 1,
 370                .elem_size      =
 371                        sizeof_field(struct ipa_init_modem_driver_req,
 372                                     v6_filter_tbl_start),
 373                .tlv_type       = 0x15,
 374                .offset         = offsetof(struct ipa_init_modem_driver_req,
 375                                           v6_filter_tbl_start),
 376        },
 377        {
 378                .data_type      = QMI_OPT_FLAG,
 379                .elem_len       = 1,
 380                .elem_size      =
 381                        sizeof_field(struct ipa_init_modem_driver_req,
 382                                     modem_mem_info_valid),
 383                .tlv_type       = 0x16,
 384                .offset         = offsetof(struct ipa_init_modem_driver_req,
 385                                           modem_mem_info_valid),
 386        },
 387        {
 388                .data_type      = QMI_STRUCT,
 389                .elem_len       = 1,
 390                .elem_size      =
 391                        sizeof_field(struct ipa_init_modem_driver_req,
 392                                     modem_mem_info),
 393                .tlv_type       = 0x16,
 394                .offset         = offsetof(struct ipa_init_modem_driver_req,
 395                                           modem_mem_info),
 396                .ei_array       = ipa_mem_range_ei,
 397        },
 398        {
 399                .data_type      = QMI_OPT_FLAG,
 400                .elem_len       = 1,
 401                .elem_size      =
 402                        sizeof_field(struct ipa_init_modem_driver_req,
 403                                     ctrl_comm_dest_end_pt_valid),
 404                .tlv_type       = 0x17,
 405                .offset         = offsetof(struct ipa_init_modem_driver_req,
 406                                           ctrl_comm_dest_end_pt_valid),
 407        },
 408        {
 409                .data_type      = QMI_UNSIGNED_4_BYTE,
 410                .elem_len       = 1,
 411                .elem_size      =
 412                        sizeof_field(struct ipa_init_modem_driver_req,
 413                                     ctrl_comm_dest_end_pt),
 414                .tlv_type       = 0x17,
 415                .offset         = offsetof(struct ipa_init_modem_driver_req,
 416                                           ctrl_comm_dest_end_pt),
 417        },
 418        {
 419                .data_type      = QMI_OPT_FLAG,
 420                .elem_len       = 1,
 421                .elem_size      =
 422                        sizeof_field(struct ipa_init_modem_driver_req,
 423                                     skip_uc_load_valid),
 424                .tlv_type       = 0x18,
 425                .offset         = offsetof(struct ipa_init_modem_driver_req,
 426                                           skip_uc_load_valid),
 427        },
 428        {
 429                .data_type      = QMI_UNSIGNED_1_BYTE,
 430                .elem_len       = 1,
 431                .elem_size      =
 432                        sizeof_field(struct ipa_init_modem_driver_req,
 433                                     skip_uc_load),
 434                .tlv_type       = 0x18,
 435                .offset         = offsetof(struct ipa_init_modem_driver_req,
 436                                           skip_uc_load),
 437        },
 438        {
 439                .data_type      = QMI_OPT_FLAG,
 440                .elem_len       = 1,
 441                .elem_size      =
 442                        sizeof_field(struct ipa_init_modem_driver_req,
 443                                     hdr_proc_ctx_tbl_info_valid),
 444                .tlv_type       = 0x19,
 445                .offset         = offsetof(struct ipa_init_modem_driver_req,
 446                                           hdr_proc_ctx_tbl_info_valid),
 447        },
 448        {
 449                .data_type      = QMI_STRUCT,
 450                .elem_len       = 1,
 451                .elem_size      =
 452                        sizeof_field(struct ipa_init_modem_driver_req,
 453                                     hdr_proc_ctx_tbl_info),
 454                .tlv_type       = 0x19,
 455                .offset         = offsetof(struct ipa_init_modem_driver_req,
 456                                           hdr_proc_ctx_tbl_info),
 457                .ei_array       = ipa_mem_bounds_ei,
 458        },
 459        {
 460                .data_type      = QMI_OPT_FLAG,
 461                .elem_len       = 1,
 462                .elem_size      =
 463                        sizeof_field(struct ipa_init_modem_driver_req,
 464                                     zip_tbl_info_valid),
 465                .tlv_type       = 0x1a,
 466                .offset         = offsetof(struct ipa_init_modem_driver_req,
 467                                           zip_tbl_info_valid),
 468        },
 469        {
 470                .data_type      = QMI_STRUCT,
 471                .elem_len       = 1,
 472                .elem_size      =
 473                        sizeof_field(struct ipa_init_modem_driver_req,
 474                                     zip_tbl_info),
 475                .tlv_type       = 0x1a,
 476                .offset         = offsetof(struct ipa_init_modem_driver_req,
 477                                           zip_tbl_info),
 478                .ei_array       = ipa_mem_bounds_ei,
 479        },
 480        {
 481                .data_type      = QMI_OPT_FLAG,
 482                .elem_len       = 1,
 483                .elem_size      =
 484                        sizeof_field(struct ipa_init_modem_driver_req,
 485                                     v4_hash_route_tbl_info_valid),
 486                .tlv_type       = 0x1b,
 487                .offset         = offsetof(struct ipa_init_modem_driver_req,
 488                                           v4_hash_route_tbl_info_valid),
 489        },
 490        {
 491                .data_type      = QMI_STRUCT,
 492                .elem_len       = 1,
 493                .elem_size      =
 494                        sizeof_field(struct ipa_init_modem_driver_req,
 495                                     v4_hash_route_tbl_info),
 496                .tlv_type       = 0x1b,
 497                .offset         = offsetof(struct ipa_init_modem_driver_req,
 498                                           v4_hash_route_tbl_info),
 499                .ei_array       = ipa_mem_array_ei,
 500        },
 501        {
 502                .data_type      = QMI_OPT_FLAG,
 503                .elem_len       = 1,
 504                .elem_size      =
 505                        sizeof_field(struct ipa_init_modem_driver_req,
 506                                     v6_hash_route_tbl_info_valid),
 507                .tlv_type       = 0x1c,
 508                .offset         = offsetof(struct ipa_init_modem_driver_req,
 509                                           v6_hash_route_tbl_info_valid),
 510        },
 511        {
 512                .data_type      = QMI_STRUCT,
 513                .elem_len       = 1,
 514                .elem_size      =
 515                        sizeof_field(struct ipa_init_modem_driver_req,
 516                                     v6_hash_route_tbl_info),
 517                .tlv_type       = 0x1c,
 518                .offset         = offsetof(struct ipa_init_modem_driver_req,
 519                                           v6_hash_route_tbl_info),
 520                .ei_array       = ipa_mem_array_ei,
 521        },
 522        {
 523                .data_type      = QMI_OPT_FLAG,
 524                .elem_len       = 1,
 525                .elem_size      =
 526                        sizeof_field(struct ipa_init_modem_driver_req,
 527                                     v4_hash_filter_tbl_start_valid),
 528                .tlv_type       = 0x1d,
 529                .offset         = offsetof(struct ipa_init_modem_driver_req,
 530                                           v4_hash_filter_tbl_start_valid),
 531        },
 532        {
 533                .data_type      = QMI_UNSIGNED_4_BYTE,
 534                .elem_len       = 1,
 535                .elem_size      =
 536                        sizeof_field(struct ipa_init_modem_driver_req,
 537                                     v4_hash_filter_tbl_start),
 538                .tlv_type       = 0x1d,
 539                .offset         = offsetof(struct ipa_init_modem_driver_req,
 540                                           v4_hash_filter_tbl_start),
 541        },
 542        {
 543                .data_type      = QMI_OPT_FLAG,
 544                .elem_len       = 1,
 545                .elem_size      =
 546                        sizeof_field(struct ipa_init_modem_driver_req,
 547                                     v6_hash_filter_tbl_start_valid),
 548                .tlv_type       = 0x1e,
 549                .offset         = offsetof(struct ipa_init_modem_driver_req,
 550                                           v6_hash_filter_tbl_start_valid),
 551        },
 552        {
 553                .data_type      = QMI_UNSIGNED_4_BYTE,
 554                .elem_len       = 1,
 555                .elem_size      =
 556                        sizeof_field(struct ipa_init_modem_driver_req,
 557                                     v6_hash_filter_tbl_start),
 558                .tlv_type       = 0x1e,
 559                .offset         = offsetof(struct ipa_init_modem_driver_req,
 560                                           v6_hash_filter_tbl_start),
 561        },
 562        {
 563                .data_type      = QMI_OPT_FLAG,
 564                .elem_len       = 1,
 565                .elem_size      =
 566                        sizeof_field(struct ipa_init_modem_driver_req,
 567                                     hw_stats_quota_base_addr_valid),
 568                .tlv_type       = 0x1f,
 569                .offset         = offsetof(struct ipa_init_modem_driver_req,
 570                                           hw_stats_quota_base_addr_valid),
 571        },
 572        {
 573                .data_type      = QMI_UNSIGNED_4_BYTE,
 574                .elem_len       = 1,
 575                .elem_size      =
 576                        sizeof_field(struct ipa_init_modem_driver_req,
 577                                     hw_stats_quota_base_addr),
 578                .tlv_type       = 0x1f,
 579                .offset         = offsetof(struct ipa_init_modem_driver_req,
 580                                           hw_stats_quota_base_addr),
 581        },
 582        {
 583                .data_type      = QMI_OPT_FLAG,
 584                .elem_len       = 1,
 585                .elem_size      =
 586                        sizeof_field(struct ipa_init_modem_driver_req,
 587                                     hw_stats_quota_size_valid),
 588                .tlv_type       = 0x20,
 589                .offset         = offsetof(struct ipa_init_modem_driver_req,
 590                                           hw_stats_quota_size_valid),
 591        },
 592        {
 593                .data_type      = QMI_UNSIGNED_4_BYTE,
 594                .elem_len       = 1,
 595                .elem_size      =
 596                        sizeof_field(struct ipa_init_modem_driver_req,
 597                                     hw_stats_quota_size),
 598                .tlv_type       = 0x20,
 599                .offset         = offsetof(struct ipa_init_modem_driver_req,
 600                                           hw_stats_quota_size),
 601        },
 602        {
 603                .data_type      = QMI_OPT_FLAG,
 604                .elem_len       = 1,
 605                .elem_size      =
 606                        sizeof_field(struct ipa_init_modem_driver_req,
 607                                     hw_stats_drop_base_addr_valid),
 608                .tlv_type       = 0x21,
 609                .offset         = offsetof(struct ipa_init_modem_driver_req,
 610                                           hw_stats_drop_base_addr_valid),
 611        },
 612        {
 613                .data_type      = QMI_UNSIGNED_4_BYTE,
 614                .elem_len       = 1,
 615                .elem_size      =
 616                        sizeof_field(struct ipa_init_modem_driver_req,
 617                                     hw_stats_drop_base_addr),
 618                .tlv_type       = 0x21,
 619                .offset         = offsetof(struct ipa_init_modem_driver_req,
 620                                           hw_stats_drop_base_addr),
 621        },
 622        {
 623                .data_type      = QMI_OPT_FLAG,
 624                .elem_len       = 1,
 625                .elem_size      =
 626                        sizeof_field(struct ipa_init_modem_driver_req,
 627                                     hw_stats_drop_size_valid),
 628                .tlv_type       = 0x22,
 629                .offset         = offsetof(struct ipa_init_modem_driver_req,
 630                                           hw_stats_drop_size_valid),
 631        },
 632        {
 633                .data_type      = QMI_UNSIGNED_4_BYTE,
 634                .elem_len       = 1,
 635                .elem_size      =
 636                        sizeof_field(struct ipa_init_modem_driver_req,
 637                                     hw_stats_drop_size),
 638                .tlv_type       = 0x22,
 639                .offset         = offsetof(struct ipa_init_modem_driver_req,
 640                                           hw_stats_drop_size),
 641        },
 642        {
 643                .data_type      = QMI_EOTI,
 644        },
 645};
 646
 647/* QMI message structure definition for struct ipa_init_modem_driver_rsp */
 648struct qmi_elem_info ipa_init_modem_driver_rsp_ei[] = {
 649        {
 650                .data_type      = QMI_STRUCT,
 651                .elem_len       = 1,
 652                .elem_size      =
 653                        sizeof_field(struct ipa_init_modem_driver_rsp,
 654                                     rsp),
 655                .tlv_type       = 0x02,
 656                .offset         = offsetof(struct ipa_init_modem_driver_rsp,
 657                                           rsp),
 658                .ei_array       = qmi_response_type_v01_ei,
 659        },
 660        {
 661                .data_type      = QMI_OPT_FLAG,
 662                .elem_len       = 1,
 663                .elem_size      =
 664                        sizeof_field(struct ipa_init_modem_driver_rsp,
 665                                     ctrl_comm_dest_end_pt_valid),
 666                .tlv_type       = 0x10,
 667                .offset         = offsetof(struct ipa_init_modem_driver_rsp,
 668                                           ctrl_comm_dest_end_pt_valid),
 669        },
 670        {
 671                .data_type      = QMI_UNSIGNED_4_BYTE,
 672                .elem_len       = 1,
 673                .elem_size      =
 674                        sizeof_field(struct ipa_init_modem_driver_rsp,
 675                                     ctrl_comm_dest_end_pt),
 676                .tlv_type       = 0x10,
 677                .offset         = offsetof(struct ipa_init_modem_driver_rsp,
 678                                           ctrl_comm_dest_end_pt),
 679        },
 680        {
 681                .data_type      = QMI_OPT_FLAG,
 682                .elem_len       = 1,
 683                .elem_size      =
 684                        sizeof_field(struct ipa_init_modem_driver_rsp,
 685                                     default_end_pt_valid),
 686                .tlv_type       = 0x11,
 687                .offset         = offsetof(struct ipa_init_modem_driver_rsp,
 688                                           default_end_pt_valid),
 689        },
 690        {
 691                .data_type      = QMI_UNSIGNED_4_BYTE,
 692                .elem_len       = 1,
 693                .elem_size      =
 694                        sizeof_field(struct ipa_init_modem_driver_rsp,
 695                                     default_end_pt),
 696                .tlv_type       = 0x11,
 697                .offset         = offsetof(struct ipa_init_modem_driver_rsp,
 698                                           default_end_pt),
 699        },
 700        {
 701                .data_type      = QMI_OPT_FLAG,
 702                .elem_len       = 1,
 703                .elem_size      =
 704                        sizeof_field(struct ipa_init_modem_driver_rsp,
 705                                     modem_driver_init_pending_valid),
 706                .tlv_type       = 0x12,
 707                .offset         = offsetof(struct ipa_init_modem_driver_rsp,
 708                                           modem_driver_init_pending_valid),
 709        },
 710        {
 711                .data_type      = QMI_UNSIGNED_1_BYTE,
 712                .elem_len       = 1,
 713                .elem_size      =
 714                        sizeof_field(struct ipa_init_modem_driver_rsp,
 715                                     modem_driver_init_pending),
 716                .tlv_type       = 0x12,
 717                .offset         = offsetof(struct ipa_init_modem_driver_rsp,
 718                                           modem_driver_init_pending),
 719        },
 720        {
 721                .data_type      = QMI_EOTI,
 722        },
 723};
 724