git.itanic.dy.fi Git - linux-stable/blob - 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-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 */
  12 struct 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 */
 119 struct 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 */
 137 struct 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 */
 154 struct 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 */
 172 struct 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 */
 190 struct 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 */
 211 struct 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 */
 232 struct 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 */
 253 struct 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 */
 648 struct 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 };