drivers/net/ipa/ipa_qmi_msg.c

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