drivers/net/wireless/ath/ath11k/qmi.c

   1 // SPDX-License-Identifier: BSD-3-Clause-Clear
   2 /*
   3  * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include "qmi.h"
   7 #include "core.h"
   8 #include "debug.h"
   9 #include <linux/of.h>
  10 #include <linux/firmware.h>
  11
  12 static struct qmi_elem_info qmi_wlanfw_host_cap_req_msg_v01_ei[] = {
  13         {
  14                 .data_type      = QMI_OPT_FLAG,
  15                 .elem_len       = 1,
  16                 .elem_size      = sizeof(u8),
  17                 .array_type     = NO_ARRAY,
  18                 .tlv_type       = 0x10,
  19                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  20                                            num_clients_valid),
  21         },
  22         {
  23                 .data_type      = QMI_UNSIGNED_4_BYTE,
  24                 .elem_len       = 1,
  25                 .elem_size      = sizeof(u32),
  26                 .array_type     = NO_ARRAY,
  27                 .tlv_type       = 0x10,
  28                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  29                                            num_clients),
  30         },
  31         {
  32                 .data_type      = QMI_OPT_FLAG,
  33                 .elem_len       = 1,
  34                 .elem_size      = sizeof(u8),
  35                 .array_type     = NO_ARRAY,
  36                 .tlv_type       = 0x11,
  37                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  38                                            wake_msi_valid),
  39         },
  40         {
  41                 .data_type      = QMI_UNSIGNED_4_BYTE,
  42                 .elem_len       = 1,
  43                 .elem_size      = sizeof(u32),
  44                 .array_type     = NO_ARRAY,
  45                 .tlv_type       = 0x11,
  46                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  47                                            wake_msi),
  48         },
  49         {
  50                 .data_type      = QMI_OPT_FLAG,
  51                 .elem_len       = 1,
  52                 .elem_size      = sizeof(u8),
  53                 .array_type     = NO_ARRAY,
  54                 .tlv_type       = 0x12,
  55                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  56                                            gpios_valid),
  57         },
  58         {
  59                 .data_type      = QMI_DATA_LEN,
  60                 .elem_len       = 1,
  61                 .elem_size      = sizeof(u8),
  62                 .array_type     = NO_ARRAY,
  63                 .tlv_type       = 0x12,
  64                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  65                                            gpios_len),
  66         },
  67         {
  68                 .data_type      = QMI_UNSIGNED_4_BYTE,
  69                 .elem_len       = QMI_WLFW_MAX_NUM_GPIO_V01,
  70                 .elem_size      = sizeof(u32),
  71                 .array_type     = VAR_LEN_ARRAY,
  72                 .tlv_type       = 0x12,
  73                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  74                                            gpios),
  75         },
  76         {
  77                 .data_type      = QMI_OPT_FLAG,
  78                 .elem_len       = 1,
  79                 .elem_size      = sizeof(u8),
  80                 .array_type     = NO_ARRAY,
  81                 .tlv_type       = 0x13,
  82                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  83                                            nm_modem_valid),
  84         },
  85         {
  86                 .data_type      = QMI_UNSIGNED_1_BYTE,
  87                 .elem_len       = 1,
  88                 .elem_size      = sizeof(u8),
  89                 .array_type     = NO_ARRAY,
  90                 .tlv_type       = 0x13,
  91                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  92                                            nm_modem),
  93         },
  94         {
  95                 .data_type      = QMI_OPT_FLAG,
  96                 .elem_len       = 1,
  97                 .elem_size      = sizeof(u8),
  98                 .array_type     = NO_ARRAY,
  99                 .tlv_type       = 0x14,
 100                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 101                                            bdf_support_valid),
 102         },
 103         {
 104                 .data_type      = QMI_UNSIGNED_1_BYTE,
 105                 .elem_len       = 1,
 106                 .elem_size      = sizeof(u8),
 107                 .array_type     = NO_ARRAY,
 108                 .tlv_type       = 0x14,
 109                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 110                                            bdf_support),
 111         },
 112         {
 113                 .data_type      = QMI_OPT_FLAG,
 114                 .elem_len       = 1,
 115                 .elem_size      = sizeof(u8),
 116                 .array_type     = NO_ARRAY,
 117                 .tlv_type       = 0x15,
 118                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 119                                            bdf_cache_support_valid),
 120         },
 121         {
 122                 .data_type      = QMI_UNSIGNED_1_BYTE,
 123                 .elem_len       = 1,
 124                 .elem_size      = sizeof(u8),
 125                 .array_type     = NO_ARRAY,
 126                 .tlv_type       = 0x15,
 127                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 128                                            bdf_cache_support),
 129         },
 130         {
 131                 .data_type      = QMI_OPT_FLAG,
 132                 .elem_len       = 1,
 133                 .elem_size      = sizeof(u8),
 134                 .array_type     = NO_ARRAY,
 135                 .tlv_type       = 0x16,
 136                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 137                                            m3_support_valid),
 138         },
 139         {
 140                 .data_type      = QMI_UNSIGNED_1_BYTE,
 141                 .elem_len       = 1,
 142                 .elem_size      = sizeof(u8),
 143                 .array_type     = NO_ARRAY,
 144                 .tlv_type       = 0x16,
 145                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 146                                            m3_support),
 147         },
 148         {
 149                 .data_type      = QMI_OPT_FLAG,
 150                 .elem_len       = 1,
 151                 .elem_size      = sizeof(u8),
 152                 .array_type     = NO_ARRAY,
 153                 .tlv_type       = 0x17,
 154                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 155                                            m3_cache_support_valid),
 156         },
 157         {
 158                 .data_type      = QMI_UNSIGNED_1_BYTE,
 159                 .elem_len       = 1,
 160                 .elem_size      = sizeof(u8),
 161                 .array_type     = NO_ARRAY,
 162                 .tlv_type       = 0x17,
 163                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 164                                            m3_cache_support),
 165         },
 166         {
 167                 .data_type      = QMI_OPT_FLAG,
 168                 .elem_len       = 1,
 169                 .elem_size      = sizeof(u8),
 170                 .array_type     = NO_ARRAY,
 171                 .tlv_type       = 0x18,
 172                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 173                                            cal_filesys_support_valid),
 174         },
 175         {
 176                 .data_type      = QMI_UNSIGNED_1_BYTE,
 177                 .elem_len       = 1,
 178                 .elem_size      = sizeof(u8),
 179                 .array_type     = NO_ARRAY,
 180                 .tlv_type       = 0x18,
 181                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 182                                            cal_filesys_support),
 183         },
 184         {
 185                 .data_type      = QMI_OPT_FLAG,
 186                 .elem_len       = 1,
 187                 .elem_size      = sizeof(u8),
 188                 .array_type     = NO_ARRAY,
 189                 .tlv_type       = 0x19,
 190                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 191                                            cal_cache_support_valid),
 192         },
 193         {
 194                 .data_type      = QMI_UNSIGNED_1_BYTE,
 195                 .elem_len       = 1,
 196                 .elem_size      = sizeof(u8),
 197                 .array_type     = NO_ARRAY,
 198                 .tlv_type       = 0x19,
 199                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 200                                            cal_cache_support),
 201         },
 202         {
 203                 .data_type      = QMI_OPT_FLAG,
 204                 .elem_len       = 1,
 205                 .elem_size      = sizeof(u8),
 206                 .array_type     = NO_ARRAY,
 207                 .tlv_type       = 0x1A,
 208                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 209                                            cal_done_valid),
 210         },
 211         {
 212                 .data_type      = QMI_UNSIGNED_1_BYTE,
 213                 .elem_len       = 1,
 214                 .elem_size      = sizeof(u8),
 215                 .array_type     = NO_ARRAY,
 216                 .tlv_type       = 0x1A,
 217                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 218                                            cal_done),
 219         },
 220         {
 221                 .data_type      = QMI_OPT_FLAG,
 222                 .elem_len       = 1,
 223                 .elem_size      = sizeof(u8),
 224                 .array_type     = NO_ARRAY,
 225                 .tlv_type       = 0x1B,
 226                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 227                                            mem_bucket_valid),
 228         },
 229         {
 230                 .data_type      = QMI_UNSIGNED_4_BYTE,
 231                 .elem_len       = 1,
 232                 .elem_size      = sizeof(u32),
 233                 .array_type     = NO_ARRAY,
 234                 .tlv_type       = 0x1B,
 235                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 236                                            mem_bucket),
 237         },
 238         {
 239                 .data_type      = QMI_OPT_FLAG,
 240                 .elem_len       = 1,
 241                 .elem_size      = sizeof(u8),
 242                 .array_type     = NO_ARRAY,
 243                 .tlv_type       = 0x1C,
 244                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 245                                            mem_cfg_mode_valid),
 246         },
 247         {
 248                 .data_type      = QMI_UNSIGNED_1_BYTE,
 249                 .elem_len       = 1,
 250                 .elem_size      = sizeof(u8),
 251                 .array_type     = NO_ARRAY,
 252                 .tlv_type       = 0x1C,
 253                 .offset         = offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 254                                            mem_cfg_mode),
 255         },
 256         {
 257                 .data_type      = QMI_EOTI,
 258                 .array_type     = NO_ARRAY,
 259                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 260         },
 261 };
 262
 263 static struct qmi_elem_info qmi_wlanfw_host_cap_resp_msg_v01_ei[] = {
 264         {
 265                 .data_type      = QMI_STRUCT,
 266                 .elem_len       = 1,
 267                 .elem_size      = sizeof(struct qmi_response_type_v01),
 268                 .array_type     = NO_ARRAY,
 269                 .tlv_type       = 0x02,
 270                 .offset         = offsetof(struct qmi_wlanfw_host_cap_resp_msg_v01, resp),
 271                 .ei_array       = qmi_response_type_v01_ei,
 272         },
 273         {
 274                 .data_type      = QMI_EOTI,
 275                 .array_type     = NO_ARRAY,
 276                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 277         },
 278 };
 279
 280 static struct qmi_elem_info qmi_wlanfw_ind_register_req_msg_v01_ei[] = {
 281         {
 282                 .data_type      = QMI_OPT_FLAG,
 283                 .elem_len       = 1,
 284                 .elem_size      = sizeof(u8),
 285                 .array_type     = NO_ARRAY,
 286                 .tlv_type       = 0x10,
 287                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 288                                            fw_ready_enable_valid),
 289         },
 290         {
 291                 .data_type      = QMI_UNSIGNED_1_BYTE,
 292                 .elem_len       = 1,
 293                 .elem_size      = sizeof(u8),
 294                 .array_type     = NO_ARRAY,
 295                 .tlv_type       = 0x10,
 296                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 297                                            fw_ready_enable),
 298         },
 299         {
 300                 .data_type      = QMI_OPT_FLAG,
 301                 .elem_len       = 1,
 302                 .elem_size      = sizeof(u8),
 303                 .array_type     = NO_ARRAY,
 304                 .tlv_type       = 0x11,
 305                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 306                                            initiate_cal_download_enable_valid),
 307         },
 308         {
 309                 .data_type      = QMI_UNSIGNED_1_BYTE,
 310                 .elem_len       = 1,
 311                 .elem_size      = sizeof(u8),
 312                 .array_type     = NO_ARRAY,
 313                 .tlv_type       = 0x11,
 314                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 315                                            initiate_cal_download_enable),
 316         },
 317         {
 318                 .data_type      = QMI_OPT_FLAG,
 319                 .elem_len       = 1,
 320                 .elem_size      = sizeof(u8),
 321                 .array_type     = NO_ARRAY,
 322                 .tlv_type       = 0x12,
 323                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 324                                            initiate_cal_update_enable_valid),
 325         },
 326         {
 327                 .data_type      = QMI_UNSIGNED_1_BYTE,
 328                 .elem_len       = 1,
 329                 .elem_size      = sizeof(u8),
 330                 .array_type     = NO_ARRAY,
 331                 .tlv_type       = 0x12,
 332                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 333                                            initiate_cal_update_enable),
 334         },
 335         {
 336                 .data_type      = QMI_OPT_FLAG,
 337                 .elem_len       = 1,
 338                 .elem_size      = sizeof(u8),
 339                 .array_type     = NO_ARRAY,
 340                 .tlv_type       = 0x13,
 341                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 342                                            msa_ready_enable_valid),
 343         },
 344         {
 345                 .data_type      = QMI_UNSIGNED_1_BYTE,
 346                 .elem_len       = 1,
 347                 .elem_size      = sizeof(u8),
 348                 .array_type     = NO_ARRAY,
 349                 .tlv_type       = 0x13,
 350                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 351                                            msa_ready_enable),
 352         },
 353         {
 354                 .data_type      = QMI_OPT_FLAG,
 355                 .elem_len       = 1,
 356                 .elem_size      = sizeof(u8),
 357                 .array_type     = NO_ARRAY,
 358                 .tlv_type       = 0x14,
 359                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 360                                            pin_connect_result_enable_valid),
 361         },
 362         {
 363                 .data_type      = QMI_UNSIGNED_1_BYTE,
 364                 .elem_len       = 1,
 365                 .elem_size      = sizeof(u8),
 366                 .array_type     = NO_ARRAY,
 367                 .tlv_type       = 0x14,
 368                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 369                                            pin_connect_result_enable),
 370         },
 371         {
 372                 .data_type      = QMI_OPT_FLAG,
 373                 .elem_len       = 1,
 374                 .elem_size      = sizeof(u8),
 375                 .array_type     = NO_ARRAY,
 376                 .tlv_type       = 0x15,
 377                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 378                                            client_id_valid),
 379         },
 380         {
 381                 .data_type      = QMI_UNSIGNED_4_BYTE,
 382                 .elem_len       = 1,
 383                 .elem_size      = sizeof(u32),
 384                 .array_type     = NO_ARRAY,
 385                 .tlv_type       = 0x15,
 386                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 387                                            client_id),
 388         },
 389         {
 390                 .data_type      = QMI_OPT_FLAG,
 391                 .elem_len       = 1,
 392                 .elem_size      = sizeof(u8),
 393                 .array_type     = NO_ARRAY,
 394                 .tlv_type       = 0x16,
 395                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 396                                            request_mem_enable_valid),
 397         },
 398         {
 399                 .data_type      = QMI_UNSIGNED_1_BYTE,
 400                 .elem_len       = 1,
 401                 .elem_size      = sizeof(u8),
 402                 .array_type     = NO_ARRAY,
 403                 .tlv_type       = 0x16,
 404                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 405                                            request_mem_enable),
 406         },
 407         {
 408                 .data_type      = QMI_OPT_FLAG,
 409                 .elem_len       = 1,
 410                 .elem_size      = sizeof(u8),
 411                 .array_type     = NO_ARRAY,
 412                 .tlv_type       = 0x17,
 413                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 414                                            fw_mem_ready_enable_valid),
 415         },
 416         {
 417                 .data_type      = QMI_UNSIGNED_1_BYTE,
 418                 .elem_len       = 1,
 419                 .elem_size      = sizeof(u8),
 420                 .array_type     = NO_ARRAY,
 421                 .tlv_type       = 0x17,
 422                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 423                                            fw_mem_ready_enable),
 424         },
 425         {
 426                 .data_type      = QMI_OPT_FLAG,
 427                 .elem_len       = 1,
 428                 .elem_size      = sizeof(u8),
 429                 .array_type     = NO_ARRAY,
 430                 .tlv_type       = 0x18,
 431                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 432                                            fw_init_done_enable_valid),
 433         },
 434         {
 435                 .data_type      = QMI_UNSIGNED_1_BYTE,
 436                 .elem_len       = 1,
 437                 .elem_size      = sizeof(u8),
 438                 .array_type     = NO_ARRAY,
 439                 .tlv_type       = 0x18,
 440                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 441                                            fw_init_done_enable),
 442         },
 443
 444         {
 445                 .data_type      = QMI_OPT_FLAG,
 446                 .elem_len       = 1,
 447                 .elem_size      = sizeof(u8),
 448                 .array_type     = NO_ARRAY,
 449                 .tlv_type       = 0x19,
 450                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 451                                            rejuvenate_enable_valid),
 452         },
 453         {
 454                 .data_type      = QMI_UNSIGNED_1_BYTE,
 455                 .elem_len       = 1,
 456                 .elem_size      = sizeof(u8),
 457                 .array_type     = NO_ARRAY,
 458                 .tlv_type       = 0x19,
 459                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 460                                            rejuvenate_enable),
 461         },
 462         {
 463                 .data_type      = QMI_OPT_FLAG,
 464                 .elem_len       = 1,
 465                 .elem_size      = sizeof(u8),
 466                 .array_type     = NO_ARRAY,
 467                 .tlv_type       = 0x1A,
 468                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 469                                            xo_cal_enable_valid),
 470         },
 471         {
 472                 .data_type      = QMI_UNSIGNED_1_BYTE,
 473                 .elem_len       = 1,
 474                 .elem_size      = sizeof(u8),
 475                 .array_type     = NO_ARRAY,
 476                 .tlv_type       = 0x1A,
 477                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 478                                            xo_cal_enable),
 479         },
 480         {
 481                 .data_type      = QMI_OPT_FLAG,
 482                 .elem_len       = 1,
 483                 .elem_size      = sizeof(u8),
 484                 .array_type     = NO_ARRAY,
 485                 .tlv_type       = 0x1B,
 486                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 487                                            cal_done_enable_valid),
 488         },
 489         {
 490                 .data_type      = QMI_UNSIGNED_1_BYTE,
 491                 .elem_len       = 1,
 492                 .elem_size      = sizeof(u8),
 493                 .array_type     = NO_ARRAY,
 494                 .tlv_type       = 0x1B,
 495                 .offset         = offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 496                                            cal_done_enable),
 497         },
 498         {
 499                 .data_type      = QMI_EOTI,
 500                 .array_type     = NO_ARRAY,
 501                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 502         },
 503 };
 504
 505 static struct qmi_elem_info qmi_wlanfw_ind_register_resp_msg_v01_ei[] = {
 506         {
 507                 .data_type      = QMI_STRUCT,
 508                 .elem_len       = 1,
 509                 .elem_size      = sizeof(struct qmi_response_type_v01),
 510                 .array_type     = NO_ARRAY,
 511                 .tlv_type       = 0x02,
 512                 .offset         = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
 513                                            resp),
 514                 .ei_array       = qmi_response_type_v01_ei,
 515         },
 516         {
 517                 .data_type      = QMI_OPT_FLAG,
 518                 .elem_len       = 1,
 519                 .elem_size      = sizeof(u8),
 520                 .array_type     = NO_ARRAY,
 521                 .tlv_type       = 0x10,
 522                 .offset         = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
 523                                            fw_status_valid),
 524         },
 525         {
 526                 .data_type      = QMI_UNSIGNED_8_BYTE,
 527                 .elem_len       = 1,
 528                 .elem_size      = sizeof(u64),
 529                 .array_type     = NO_ARRAY,
 530                 .tlv_type       = 0x10,
 531                 .offset         = offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
 532                                            fw_status),
 533         },
 534         {
 535                 .data_type      = QMI_EOTI,
 536                 .array_type     = NO_ARRAY,
 537                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 538         },
 539 };
 540
 541 static struct qmi_elem_info qmi_wlanfw_mem_cfg_s_v01_ei[] = {
 542         {
 543                 .data_type      = QMI_UNSIGNED_8_BYTE,
 544                 .elem_len       = 1,
 545                 .elem_size      = sizeof(u64),
 546                 .array_type     = NO_ARRAY,
 547                 .tlv_type       = 0,
 548                 .offset         = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, offset),
 549         },
 550         {
 551                 .data_type      = QMI_UNSIGNED_4_BYTE,
 552                 .elem_len       = 1,
 553                 .elem_size      = sizeof(u32),
 554                 .array_type     = NO_ARRAY,
 555                 .tlv_type       = 0,
 556                 .offset         = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, size),
 557         },
 558         {
 559                 .data_type      = QMI_UNSIGNED_1_BYTE,
 560                 .elem_len       = 1,
 561                 .elem_size      = sizeof(u8),
 562                 .array_type     = NO_ARRAY,
 563                 .tlv_type       = 0,
 564                 .offset         = offsetof(struct qmi_wlanfw_mem_cfg_s_v01, secure_flag),
 565         },
 566         {
 567                 .data_type      = QMI_EOTI,
 568                 .array_type     = NO_ARRAY,
 569                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 570         },
 571 };
 572
 573 static struct qmi_elem_info qmi_wlanfw_mem_seg_s_v01_ei[] = {
 574         {
 575                 .data_type      = QMI_UNSIGNED_4_BYTE,
 576                 .elem_len       = 1,
 577                 .elem_size      = sizeof(u32),
 578                 .array_type     = NO_ARRAY,
 579                 .tlv_type       = 0,
 580                 .offset         = offsetof(struct qmi_wlanfw_mem_seg_s_v01,
 581                                   size),
 582         },
 583         {
 584                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
 585                 .elem_len       = 1,
 586                 .elem_size      = sizeof(enum qmi_wlanfw_mem_type_enum_v01),
 587                 .array_type     = NO_ARRAY,
 588                 .tlv_type       = 0,
 589                 .offset         = offsetof(struct qmi_wlanfw_mem_seg_s_v01, type),
 590         },
 591         {
 592                 .data_type      = QMI_DATA_LEN,
 593                 .elem_len       = 1,
 594                 .elem_size      = sizeof(u8),
 595                 .array_type     = NO_ARRAY,
 596                 .tlv_type       = 0,
 597                 .offset         = offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg_len),
 598         },
 599         {
 600                 .data_type      = QMI_STRUCT,
 601                 .elem_len       = QMI_WLANFW_MAX_NUM_MEM_CFG_V01,
 602                 .elem_size      = sizeof(struct qmi_wlanfw_mem_cfg_s_v01),
 603                 .array_type     = VAR_LEN_ARRAY,
 604                 .tlv_type       = 0,
 605                 .offset         = offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg),
 606                 .ei_array       = qmi_wlanfw_mem_cfg_s_v01_ei,
 607         },
 608         {
 609                 .data_type      = QMI_EOTI,
 610                 .array_type     = NO_ARRAY,
 611                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 612         },
 613 };
 614
 615 static struct qmi_elem_info qmi_wlanfw_request_mem_ind_msg_v01_ei[] = {
 616         {
 617                 .data_type      = QMI_DATA_LEN,
 618                 .elem_len       = 1,
 619                 .elem_size      = sizeof(u8),
 620                 .array_type     = NO_ARRAY,
 621                 .tlv_type       = 0x01,
 622                 .offset         = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
 623                                            mem_seg_len),
 624         },
 625         {
 626                 .data_type      = QMI_STRUCT,
 627                 .elem_len       = ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
 628                 .elem_size      = sizeof(struct qmi_wlanfw_mem_seg_s_v01),
 629                 .array_type     = VAR_LEN_ARRAY,
 630                 .tlv_type       = 0x01,
 631                 .offset         = offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
 632                                            mem_seg),
 633                 .ei_array       = qmi_wlanfw_mem_seg_s_v01_ei,
 634         },
 635         {
 636                 .data_type      = QMI_EOTI,
 637                 .array_type     = NO_ARRAY,
 638                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 639         },
 640 };
 641
 642 static struct qmi_elem_info qmi_wlanfw_mem_seg_resp_s_v01_ei[] = {
 643         {
 644                 .data_type      = QMI_UNSIGNED_8_BYTE,
 645                 .elem_len       = 1,
 646                 .elem_size      = sizeof(u64),
 647                 .array_type     = NO_ARRAY,
 648                 .tlv_type       = 0,
 649                 .offset         = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, addr),
 650         },
 651         {
 652                 .data_type      = QMI_UNSIGNED_4_BYTE,
 653                 .elem_len       = 1,
 654                 .elem_size      = sizeof(u32),
 655                 .array_type     = NO_ARRAY,
 656                 .tlv_type       = 0,
 657                 .offset         = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, size),
 658         },
 659         {
 660                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
 661                 .elem_len       = 1,
 662                 .elem_size      = sizeof(enum qmi_wlanfw_mem_type_enum_v01),
 663                 .array_type     = NO_ARRAY,
 664                 .tlv_type       = 0,
 665                 .offset         = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, type),
 666         },
 667         {
 668                 .data_type      = QMI_UNSIGNED_1_BYTE,
 669                 .elem_len       = 1,
 670                 .elem_size      = sizeof(u8),
 671                 .array_type     = NO_ARRAY,
 672                 .tlv_type       = 0,
 673                 .offset         = offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, restore),
 674         },
 675         {
 676                 .data_type      = QMI_EOTI,
 677                 .array_type     = NO_ARRAY,
 678                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 679         },
 680 };
 681
 682 static struct qmi_elem_info qmi_wlanfw_respond_mem_req_msg_v01_ei[] = {
 683         {
 684                 .data_type      = QMI_DATA_LEN,
 685                 .elem_len       = 1,
 686                 .elem_size      = sizeof(u8),
 687                 .array_type     = NO_ARRAY,
 688                 .tlv_type       = 0x01,
 689                 .offset         = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
 690                                            mem_seg_len),
 691         },
 692         {
 693                 .data_type      = QMI_STRUCT,
 694                 .elem_len       = ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
 695                 .elem_size      = sizeof(struct qmi_wlanfw_mem_seg_resp_s_v01),
 696                 .array_type     = VAR_LEN_ARRAY,
 697                 .tlv_type       = 0x01,
 698                 .offset         = offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
 699                                            mem_seg),
 700                 .ei_array       = qmi_wlanfw_mem_seg_resp_s_v01_ei,
 701         },
 702         {
 703                 .data_type      = QMI_EOTI,
 704                 .array_type     = NO_ARRAY,
 705                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 706         },
 707 };
 708
 709 static struct qmi_elem_info qmi_wlanfw_respond_mem_resp_msg_v01_ei[] = {
 710         {
 711                 .data_type      = QMI_STRUCT,
 712                 .elem_len       = 1,
 713                 .elem_size      = sizeof(struct qmi_response_type_v01),
 714                 .array_type     = NO_ARRAY,
 715                 .tlv_type       = 0x02,
 716                 .offset         = offsetof(struct qmi_wlanfw_respond_mem_resp_msg_v01,
 717                                            resp),
 718                 .ei_array       = qmi_response_type_v01_ei,
 719         },
 720         {
 721                 .data_type      = QMI_EOTI,
 722                 .array_type     = NO_ARRAY,
 723                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 724         },
 725 };
 726
 727 static struct qmi_elem_info qmi_wlanfw_cap_req_msg_v01_ei[] = {
 728         {
 729                 .data_type      = QMI_EOTI,
 730                 .array_type     = NO_ARRAY,
 731                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 732         },
 733 };
 734
 735 static struct qmi_elem_info qmi_wlanfw_rf_chip_info_s_v01_ei[] = {
 736         {
 737                 .data_type      = QMI_UNSIGNED_4_BYTE,
 738                 .elem_len       = 1,
 739                 .elem_size      = sizeof(u32),
 740                 .array_type     = NO_ARRAY,
 741                 .tlv_type       = 0,
 742                 .offset         = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
 743                                            chip_id),
 744         },
 745         {
 746                 .data_type      = QMI_UNSIGNED_4_BYTE,
 747                 .elem_len       = 1,
 748                 .elem_size      = sizeof(u32),
 749                 .array_type     = NO_ARRAY,
 750                 .tlv_type       = 0,
 751                 .offset         = offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
 752                                            chip_family),
 753         },
 754         {
 755                 .data_type      = QMI_EOTI,
 756                 .array_type     = NO_ARRAY,
 757                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 758         },
 759 };
 760
 761 static struct qmi_elem_info qmi_wlanfw_rf_board_info_s_v01_ei[] = {
 762         {
 763                 .data_type      = QMI_UNSIGNED_4_BYTE,
 764                 .elem_len       = 1,
 765                 .elem_size      = sizeof(u32),
 766                 .array_type     = NO_ARRAY,
 767                 .tlv_type       = 0,
 768                 .offset         = offsetof(struct qmi_wlanfw_rf_board_info_s_v01,
 769                                            board_id),
 770         },
 771         {
 772                 .data_type      = QMI_EOTI,
 773                 .array_type     = NO_ARRAY,
 774                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 775         },
 776 };
 777
 778 static struct qmi_elem_info qmi_wlanfw_soc_info_s_v01_ei[] = {
 779         {
 780                 .data_type      = QMI_UNSIGNED_4_BYTE,
 781                 .elem_len       = 1,
 782                 .elem_size      = sizeof(u32),
 783                 .array_type     = NO_ARRAY,
 784                 .tlv_type       = 0,
 785                 .offset         = offsetof(struct qmi_wlanfw_soc_info_s_v01, soc_id),
 786         },
 787         {
 788                 .data_type      = QMI_EOTI,
 789                 .array_type     = NO_ARRAY,
 790                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 791         },
 792 };
 793
 794 static struct qmi_elem_info qmi_wlanfw_fw_version_info_s_v01_ei[] = {
 795         {
 796                 .data_type      = QMI_UNSIGNED_4_BYTE,
 797                 .elem_len       = 1,
 798                 .elem_size      = sizeof(u32),
 799                 .array_type     = NO_ARRAY,
 800                 .tlv_type       = 0,
 801                 .offset         = offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
 802                                            fw_version),
 803         },
 804         {
 805                 .data_type      = QMI_STRING,
 806                 .elem_len       = ATH11K_QMI_WLANFW_MAX_TIMESTAMP_LEN_V01 + 1,
 807                 .elem_size      = sizeof(char),
 808                 .array_type     = NO_ARRAY,
 809                 .tlv_type       = 0,
 810                 .offset         = offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
 811                                            fw_build_timestamp),
 812         },
 813         {
 814                 .data_type      = QMI_EOTI,
 815                 .array_type     = NO_ARRAY,
 816                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 817         },
 818 };
 819
 820 static struct qmi_elem_info qmi_wlanfw_cap_resp_msg_v01_ei[] = {
 821         {
 822                 .data_type      = QMI_STRUCT,
 823                 .elem_len       = 1,
 824                 .elem_size      = sizeof(struct qmi_response_type_v01),
 825                 .array_type     = NO_ARRAY,
 826                 .tlv_type       = 0x02,
 827                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01, resp),
 828                 .ei_array       = qmi_response_type_v01_ei,
 829         },
 830         {
 831                 .data_type      = QMI_OPT_FLAG,
 832                 .elem_len       = 1,
 833                 .elem_size      = sizeof(u8),
 834                 .array_type     = NO_ARRAY,
 835                 .tlv_type       = 0x10,
 836                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 837                                            chip_info_valid),
 838         },
 839         {
 840                 .data_type      = QMI_STRUCT,
 841                 .elem_len       = 1,
 842                 .elem_size      = sizeof(struct qmi_wlanfw_rf_chip_info_s_v01),
 843                 .array_type     = NO_ARRAY,
 844                 .tlv_type       = 0x10,
 845                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 846                                            chip_info),
 847                 .ei_array       = qmi_wlanfw_rf_chip_info_s_v01_ei,
 848         },
 849         {
 850                 .data_type      = QMI_OPT_FLAG,
 851                 .elem_len       = 1,
 852                 .elem_size      = sizeof(u8),
 853                 .array_type     = NO_ARRAY,
 854                 .tlv_type       = 0x11,
 855                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 856                                            board_info_valid),
 857         },
 858         {
 859                 .data_type      = QMI_STRUCT,
 860                 .elem_len       = 1,
 861                 .elem_size      = sizeof(struct qmi_wlanfw_rf_board_info_s_v01),
 862                 .array_type     = NO_ARRAY,
 863                 .tlv_type       = 0x11,
 864                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 865                                            board_info),
 866                 .ei_array       = qmi_wlanfw_rf_board_info_s_v01_ei,
 867         },
 868         {
 869                 .data_type      = QMI_OPT_FLAG,
 870                 .elem_len       = 1,
 871                 .elem_size      = sizeof(u8),
 872                 .array_type     = NO_ARRAY,
 873                 .tlv_type       = 0x12,
 874                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 875                                            soc_info_valid),
 876         },
 877         {
 878                 .data_type      = QMI_STRUCT,
 879                 .elem_len       = 1,
 880                 .elem_size      = sizeof(struct qmi_wlanfw_soc_info_s_v01),
 881                 .array_type     = NO_ARRAY,
 882                 .tlv_type       = 0x12,
 883                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 884                                            soc_info),
 885                 .ei_array       = qmi_wlanfw_soc_info_s_v01_ei,
 886         },
 887         {
 888                 .data_type      = QMI_OPT_FLAG,
 889                 .elem_len       = 1,
 890                 .elem_size      = sizeof(u8),
 891                 .array_type     = NO_ARRAY,
 892                 .tlv_type       = 0x13,
 893                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 894                                            fw_version_info_valid),
 895         },
 896         {
 897                 .data_type      = QMI_STRUCT,
 898                 .elem_len       = 1,
 899                 .elem_size      = sizeof(struct qmi_wlanfw_fw_version_info_s_v01),
 900                 .array_type     = NO_ARRAY,
 901                 .tlv_type       = 0x13,
 902                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 903                                            fw_version_info),
 904                 .ei_array       = qmi_wlanfw_fw_version_info_s_v01_ei,
 905         },
 906         {
 907                 .data_type      = QMI_OPT_FLAG,
 908                 .elem_len       = 1,
 909                 .elem_size      = sizeof(u8),
 910                 .array_type     = NO_ARRAY,
 911                 .tlv_type       = 0x14,
 912                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 913                                            fw_build_id_valid),
 914         },
 915         {
 916                 .data_type      = QMI_STRING,
 917                 .elem_len       = ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 + 1,
 918                 .elem_size      = sizeof(char),
 919                 .array_type     = NO_ARRAY,
 920                 .tlv_type       = 0x14,
 921                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 922                                            fw_build_id),
 923         },
 924         {
 925                 .data_type      = QMI_OPT_FLAG,
 926                 .elem_len       = 1,
 927                 .elem_size      = sizeof(u8),
 928                 .array_type     = NO_ARRAY,
 929                 .tlv_type       = 0x15,
 930                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 931                                            num_macs_valid),
 932         },
 933         {
 934                 .data_type      = QMI_UNSIGNED_1_BYTE,
 935                 .elem_len       = 1,
 936                 .elem_size      = sizeof(u8),
 937                 .array_type     = NO_ARRAY,
 938                 .tlv_type       = 0x15,
 939                 .offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 940                                            num_macs),
 941         },
 942         {
 943                 .data_type      = QMI_EOTI,
 944                 .array_type     = NO_ARRAY,
 945                 .tlv_type       = QMI_COMMON_TLV_TYPE,
 946         },
 947 };
 948
 949 static struct qmi_elem_info qmi_wlanfw_bdf_download_req_msg_v01_ei[] = {
 950         {
 951                 .data_type      = QMI_UNSIGNED_1_BYTE,
 952                 .elem_len       = 1,
 953                 .elem_size      = sizeof(u8),
 954                 .array_type     = NO_ARRAY,
 955                 .tlv_type       = 0x01,
 956                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
 957                                            valid),
 958         },
 959         {
 960                 .data_type      = QMI_OPT_FLAG,
 961                 .elem_len       = 1,
 962                 .elem_size      = sizeof(u8),
 963                 .array_type     = NO_ARRAY,
 964                 .tlv_type       = 0x10,
 965                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
 966                                            file_id_valid),
 967         },
 968         {
 969                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
 970                 .elem_len       = 1,
 971                 .elem_size      = sizeof(enum qmi_wlanfw_cal_temp_id_enum_v01),
 972                 .array_type     = NO_ARRAY,
 973                 .tlv_type       = 0x10,
 974                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
 975                                            file_id),
 976         },
 977         {
 978                 .data_type      = QMI_OPT_FLAG,
 979                 .elem_len       = 1,
 980                 .elem_size      = sizeof(u8),
 981                 .array_type     = NO_ARRAY,
 982                 .tlv_type       = 0x11,
 983                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
 984                                            total_size_valid),
 985         },
 986         {
 987                 .data_type      = QMI_UNSIGNED_4_BYTE,
 988                 .elem_len       = 1,
 989                 .elem_size      = sizeof(u32),
 990                 .array_type     = NO_ARRAY,
 991                 .tlv_type       = 0x11,
 992                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
 993                                            total_size),
 994         },
 995         {
 996                 .data_type      = QMI_OPT_FLAG,
 997                 .elem_len       = 1,
 998                 .elem_size      = sizeof(u8),
 999                 .array_type     = NO_ARRAY,
1000                 .tlv_type       = 0x12,
1001                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1002                                            seg_id_valid),
1003         },
1004         {
1005                 .data_type      = QMI_UNSIGNED_4_BYTE,
1006                 .elem_len       = 1,
1007                 .elem_size      = sizeof(u32),
1008                 .array_type     = NO_ARRAY,
1009                 .tlv_type       = 0x12,
1010                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1011                                            seg_id),
1012         },
1013         {
1014                 .data_type      = QMI_OPT_FLAG,
1015                 .elem_len       = 1,
1016                 .elem_size      = sizeof(u8),
1017                 .array_type     = NO_ARRAY,
1018                 .tlv_type       = 0x13,
1019                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1020                                            data_valid),
1021         },
1022         {
1023                 .data_type      = QMI_DATA_LEN,
1024                 .elem_len       = 1,
1025                 .elem_size      = sizeof(u16),
1026                 .array_type     = NO_ARRAY,
1027                 .tlv_type       = 0x13,
1028                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1029                                            data_len),
1030         },
1031         {
1032                 .data_type      = QMI_UNSIGNED_1_BYTE,
1033                 .elem_len       = QMI_WLANFW_MAX_DATA_SIZE_V01,
1034                 .elem_size      = sizeof(u8),
1035                 .array_type     = VAR_LEN_ARRAY,
1036                 .tlv_type       = 0x13,
1037                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1038                                            data),
1039         },
1040         {
1041                 .data_type      = QMI_OPT_FLAG,
1042                 .elem_len       = 1,
1043                 .elem_size      = sizeof(u8),
1044                 .array_type     = NO_ARRAY,
1045                 .tlv_type       = 0x14,
1046                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1047                                            end_valid),
1048         },
1049         {
1050                 .data_type      = QMI_UNSIGNED_1_BYTE,
1051                 .elem_len       = 1,
1052                 .elem_size      = sizeof(u8),
1053                 .array_type     = NO_ARRAY,
1054                 .tlv_type       = 0x14,
1055                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1056                                            end),
1057         },
1058         {
1059                 .data_type      = QMI_OPT_FLAG,
1060                 .elem_len       = 1,
1061                 .elem_size      = sizeof(u8),
1062                 .array_type     = NO_ARRAY,
1063                 .tlv_type       = 0x15,
1064                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1065                                            bdf_type_valid),
1066         },
1067         {
1068                 .data_type      = QMI_UNSIGNED_1_BYTE,
1069                 .elem_len       = 1,
1070                 .elem_size      = sizeof(u8),
1071                 .array_type     = NO_ARRAY,
1072                 .tlv_type       = 0x15,
1073                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1074                                            bdf_type),
1075         },
1076
1077         {
1078                 .data_type      = QMI_EOTI,
1079                 .array_type     = NO_ARRAY,
1080                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1081         },
1082 };
1083
1084 static struct qmi_elem_info qmi_wlanfw_bdf_download_resp_msg_v01_ei[] = {
1085         {
1086                 .data_type      = QMI_STRUCT,
1087                 .elem_len       = 1,
1088                 .elem_size      = sizeof(struct qmi_response_type_v01),
1089                 .array_type     = NO_ARRAY,
1090                 .tlv_type       = 0x02,
1091                 .offset         = offsetof(struct qmi_wlanfw_bdf_download_resp_msg_v01,
1092                                            resp),
1093                 .ei_array       = qmi_response_type_v01_ei,
1094         },
1095         {
1096                 .data_type      = QMI_EOTI,
1097                 .array_type     = NO_ARRAY,
1098                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1099         },
1100 };
1101
1102 static struct qmi_elem_info qmi_wlanfw_m3_info_req_msg_v01_ei[] = {
1103         {
1104                 .data_type      = QMI_UNSIGNED_8_BYTE,
1105                 .elem_len       = 1,
1106                 .elem_size      = sizeof(u64),
1107                 .array_type     = NO_ARRAY,
1108                 .tlv_type       = 0x01,
1109                 .offset         = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, addr),
1110         },
1111         {
1112                 .data_type      = QMI_UNSIGNED_4_BYTE,
1113                 .elem_len       = 1,
1114                 .elem_size      = sizeof(u32),
1115                 .array_type     = NO_ARRAY,
1116                 .tlv_type       = 0x02,
1117                 .offset         = offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, size),
1118         },
1119         {
1120                 .data_type      = QMI_EOTI,
1121                 .array_type     = NO_ARRAY,
1122                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1123         },
1124 };
1125
1126 static struct qmi_elem_info qmi_wlanfw_m3_info_resp_msg_v01_ei[] = {
1127         {
1128                 .data_type      = QMI_STRUCT,
1129                 .elem_len       = 1,
1130                 .elem_size      = sizeof(struct qmi_response_type_v01),
1131                 .array_type     = NO_ARRAY,
1132                 .tlv_type       = 0x02,
1133                 .offset         = offsetof(struct qmi_wlanfw_m3_info_resp_msg_v01, resp),
1134                 .ei_array       = qmi_response_type_v01_ei,
1135         },
1136         {
1137                 .data_type      = QMI_EOTI,
1138                 .array_type     = NO_ARRAY,
1139                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1140         },
1141 };
1142
1143 static struct qmi_elem_info qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei[] = {
1144         {
1145                 .data_type      = QMI_UNSIGNED_4_BYTE,
1146                 .elem_len       = 1,
1147                 .elem_size      = sizeof(u32),
1148                 .array_type     = NO_ARRAY,
1149                 .tlv_type       = 0,
1150                 .offset         = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1151                                            pipe_num),
1152         },
1153         {
1154                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
1155                 .elem_len       = 1,
1156                 .elem_size      = sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1157                 .array_type     = NO_ARRAY,
1158                 .tlv_type       = 0,
1159                 .offset         = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1160                                            pipe_dir),
1161         },
1162         {
1163                 .data_type      = QMI_UNSIGNED_4_BYTE,
1164                 .elem_len       = 1,
1165                 .elem_size      = sizeof(u32),
1166                 .array_type     = NO_ARRAY,
1167                 .tlv_type       = 0,
1168                 .offset         = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1169                                            nentries),
1170         },
1171         {
1172                 .data_type      = QMI_UNSIGNED_4_BYTE,
1173                 .elem_len       = 1,
1174                 .elem_size      = sizeof(u32),
1175                 .array_type     = NO_ARRAY,
1176                 .tlv_type       = 0,
1177                 .offset         = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1178                                            nbytes_max),
1179         },
1180         {
1181                 .data_type      = QMI_UNSIGNED_4_BYTE,
1182                 .elem_len       = 1,
1183                 .elem_size      = sizeof(u32),
1184                 .array_type     = NO_ARRAY,
1185                 .tlv_type       = 0,
1186                 .offset         = offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1187                                            flags),
1188         },
1189         {
1190                 .data_type      = QMI_EOTI,
1191                 .array_type     = NO_ARRAY,
1192                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1193         },
1194 };
1195
1196 static struct qmi_elem_info qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei[] = {
1197         {
1198                 .data_type      = QMI_UNSIGNED_4_BYTE,
1199                 .elem_len       = 1,
1200                 .elem_size      = sizeof(u32),
1201                 .array_type     = NO_ARRAY,
1202                 .tlv_type       = 0,
1203                 .offset         = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1204                                            service_id),
1205         },
1206         {
1207                 .data_type      = QMI_SIGNED_4_BYTE_ENUM,
1208                 .elem_len       = 1,
1209                 .elem_size      = sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1210                 .array_type     = NO_ARRAY,
1211                 .tlv_type       = 0,
1212                 .offset         = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1213                                            pipe_dir),
1214         },
1215         {
1216                 .data_type      = QMI_UNSIGNED_4_BYTE,
1217                 .elem_len       = 1,
1218                 .elem_size      = sizeof(u32),
1219                 .array_type     = NO_ARRAY,
1220                 .tlv_type       = 0,
1221                 .offset         = offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1222                                            pipe_num),
1223         },
1224         {
1225                 .data_type      = QMI_EOTI,
1226                 .array_type     = NO_ARRAY,
1227                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1228         },
1229 };
1230
1231 static struct qmi_elem_info qmi_wlanfw_shadow_reg_cfg_s_v01_ei[] = {
1232         {
1233                 .data_type      = QMI_UNSIGNED_2_BYTE,
1234                 .elem_len       = 1,
1235                 .elem_size      = sizeof(u16),
1236                 .array_type     = NO_ARRAY,
1237                 .tlv_type       = 0,
1238                 .offset         = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01, id),
1239         },
1240         {
1241                 .data_type      = QMI_UNSIGNED_2_BYTE,
1242                 .elem_len       = 1,
1243                 .elem_size      = sizeof(u16),
1244                 .array_type     = NO_ARRAY,
1245                 .tlv_type       = 0,
1246                 .offset         = offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01,
1247                                            offset),
1248         },
1249         {
1250                 .data_type      = QMI_EOTI,
1251                 .array_type     = QMI_COMMON_TLV_TYPE,
1252         },
1253 };
1254
1255 static struct qmi_elem_info qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei[] = {
1256         {
1257                 .data_type      = QMI_UNSIGNED_4_BYTE,
1258                 .elem_len       = 1,
1259                 .elem_size      = sizeof(u32),
1260                 .array_type     = NO_ARRAY,
1261                 .tlv_type       = 0,
1262                 .offset         = offsetof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01,
1263                                            addr),
1264         },
1265         {
1266                 .data_type      = QMI_EOTI,
1267                 .array_type     = NO_ARRAY,
1268                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1269         },
1270 };
1271
1272 static struct qmi_elem_info qmi_wlanfw_wlan_mode_req_msg_v01_ei[] = {
1273         {
1274                 .data_type      = QMI_UNSIGNED_4_BYTE,
1275                 .elem_len       = 1,
1276                 .elem_size      = sizeof(u32),
1277                 .array_type     = NO_ARRAY,
1278                 .tlv_type       = 0x01,
1279                 .offset         = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1280                                            mode),
1281         },
1282         {
1283                 .data_type      = QMI_OPT_FLAG,
1284                 .elem_len       = 1,
1285                 .elem_size      = sizeof(u8),
1286                 .array_type     = NO_ARRAY,
1287                 .tlv_type       = 0x10,
1288                 .offset         = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1289                                            hw_debug_valid),
1290         },
1291         {
1292                 .data_type      = QMI_UNSIGNED_1_BYTE,
1293                 .elem_len       = 1,
1294                 .elem_size      = sizeof(u8),
1295                 .array_type     = NO_ARRAY,
1296                 .tlv_type       = 0x10,
1297                 .offset         = offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1298                                            hw_debug),
1299         },
1300         {
1301                 .data_type      = QMI_EOTI,
1302                 .array_type     = NO_ARRAY,
1303                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1304         },
1305 };
1306
1307 static struct qmi_elem_info qmi_wlanfw_wlan_mode_resp_msg_v01_ei[] = {
1308         {
1309                 .data_type      = QMI_STRUCT,
1310                 .elem_len       = 1,
1311                 .elem_size      = sizeof(struct qmi_response_type_v01),
1312                 .array_type     = NO_ARRAY,
1313                 .tlv_type       = 0x02,
1314                 .offset         = offsetof(struct qmi_wlanfw_wlan_mode_resp_msg_v01,
1315                                            resp),
1316                 .ei_array       = qmi_response_type_v01_ei,
1317         },
1318         {
1319                 .data_type      = QMI_EOTI,
1320                 .array_type     = NO_ARRAY,
1321                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1322         },
1323 };
1324
1325 static struct qmi_elem_info qmi_wlanfw_wlan_cfg_req_msg_v01_ei[] = {
1326         {
1327                 .data_type      = QMI_OPT_FLAG,
1328                 .elem_len       = 1,
1329                 .elem_size      = sizeof(u8),
1330                 .array_type     = NO_ARRAY,
1331                 .tlv_type       = 0x10,
1332                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1333                                            host_version_valid),
1334         },
1335         {
1336                 .data_type      = QMI_STRING,
1337                 .elem_len       = QMI_WLANFW_MAX_STR_LEN_V01 + 1,
1338                 .elem_size      = sizeof(char),
1339                 .array_type     = NO_ARRAY,
1340                 .tlv_type       = 0x10,
1341                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1342                                            host_version),
1343         },
1344         {
1345                 .data_type      = QMI_OPT_FLAG,
1346                 .elem_len       = 1,
1347                 .elem_size      = sizeof(u8),
1348                 .array_type     = NO_ARRAY,
1349                 .tlv_type       = 0x11,
1350                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1351                                            tgt_cfg_valid),
1352         },
1353         {
1354                 .data_type      = QMI_DATA_LEN,
1355                 .elem_len       = 1,
1356                 .elem_size      = sizeof(u8),
1357                 .array_type     = NO_ARRAY,
1358                 .tlv_type       = 0x11,
1359                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1360                                            tgt_cfg_len),
1361         },
1362         {
1363                 .data_type      = QMI_STRUCT,
1364                 .elem_len       = QMI_WLANFW_MAX_NUM_CE_V01,
1365                 .elem_size      = sizeof(
1366                                 struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01),
1367                 .array_type     = VAR_LEN_ARRAY,
1368                 .tlv_type       = 0x11,
1369                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1370                                            tgt_cfg),
1371                 .ei_array       = qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei,
1372         },
1373         {
1374                 .data_type      = QMI_OPT_FLAG,
1375                 .elem_len       = 1,
1376                 .elem_size      = sizeof(u8),
1377                 .array_type     = NO_ARRAY,
1378                 .tlv_type       = 0x12,
1379                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1380                                            svc_cfg_valid),
1381         },
1382         {
1383                 .data_type      = QMI_DATA_LEN,
1384                 .elem_len       = 1,
1385                 .elem_size      = sizeof(u8),
1386                 .array_type     = NO_ARRAY,
1387                 .tlv_type       = 0x12,
1388                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1389                                            svc_cfg_len),
1390         },
1391         {
1392                 .data_type      = QMI_STRUCT,
1393                 .elem_len       = QMI_WLANFW_MAX_NUM_SVC_V01,
1394                 .elem_size      = sizeof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01),
1395                 .array_type     = VAR_LEN_ARRAY,
1396                 .tlv_type       = 0x12,
1397                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1398                                            svc_cfg),
1399                 .ei_array       = qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei,
1400         },
1401         {
1402                 .data_type      = QMI_OPT_FLAG,
1403                 .elem_len       = 1,
1404                 .elem_size      = sizeof(u8),
1405                 .array_type     = NO_ARRAY,
1406                 .tlv_type       = 0x13,
1407                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1408                                            shadow_reg_valid),
1409         },
1410         {
1411                 .data_type      = QMI_DATA_LEN,
1412                 .elem_len       = 1,
1413                 .elem_size      = sizeof(u8),
1414                 .array_type     = NO_ARRAY,
1415                 .tlv_type       = 0x13,
1416                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1417                                            shadow_reg_len),
1418         },
1419         {
1420                 .data_type      = QMI_STRUCT,
1421                 .elem_len       = QMI_WLANFW_MAX_NUM_SHADOW_REG_V01,
1422                 .elem_size      = sizeof(struct qmi_wlanfw_shadow_reg_cfg_s_v01),
1423                 .array_type     = VAR_LEN_ARRAY,
1424                 .tlv_type       = 0x13,
1425                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1426                                            shadow_reg),
1427                 .ei_array       = qmi_wlanfw_shadow_reg_cfg_s_v01_ei,
1428         },
1429         {
1430                 .data_type      = QMI_OPT_FLAG,
1431                 .elem_len       = 1,
1432                 .elem_size      = sizeof(u8),
1433                 .array_type     = NO_ARRAY,
1434                 .tlv_type       = 0x14,
1435                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1436                                            shadow_reg_v2_valid),
1437         },
1438         {
1439                 .data_type      = QMI_DATA_LEN,
1440                 .elem_len       = 1,
1441                 .elem_size      = sizeof(u8),
1442                 .array_type     = NO_ARRAY,
1443                 .tlv_type       = 0x14,
1444                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1445                                            shadow_reg_v2_len),
1446         },
1447         {
1448                 .data_type      = QMI_STRUCT,
1449                 .elem_len       = QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01,
1450                 .elem_size      = sizeof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01),
1451                 .array_type     = VAR_LEN_ARRAY,
1452                 .tlv_type       = 0x14,
1453                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1454                                            shadow_reg_v2),
1455                 .ei_array       = qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei,
1456         },
1457         {
1458                 .data_type      = QMI_EOTI,
1459                 .array_type     = NO_ARRAY,
1460                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1461         },
1462 };
1463
1464 static struct qmi_elem_info qmi_wlanfw_wlan_cfg_resp_msg_v01_ei[] = {
1465         {
1466                 .data_type      = QMI_STRUCT,
1467                 .elem_len       = 1,
1468                 .elem_size      = sizeof(struct qmi_response_type_v01),
1469                 .array_type     = NO_ARRAY,
1470                 .tlv_type       = 0x02,
1471                 .offset         = offsetof(struct qmi_wlanfw_wlan_cfg_resp_msg_v01, resp),
1472                 .ei_array       = qmi_response_type_v01_ei,
1473         },
1474         {
1475                 .data_type      = QMI_EOTI,
1476                 .array_type     = NO_ARRAY,
1477                 .tlv_type       = QMI_COMMON_TLV_TYPE,
1478         },
1479 };
1480
1481 static struct qmi_elem_info qmi_wlanfw_mem_ready_ind_msg_v01_ei[] = {
1482         {
1483                 .data_type = QMI_EOTI,
1484                 .array_type = NO_ARRAY,
1485         },
1486 };
1487
1488 static struct qmi_elem_info qmi_wlanfw_fw_ready_ind_msg_v01_ei[] = {
1489         {
1490                 .data_type = QMI_EOTI,
1491                 .array_type = NO_ARRAY,
1492         },
1493 };
1494
1495 static struct qmi_elem_info qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei[] = {
1496         {
1497                 .data_type = QMI_EOTI,
1498                 .array_type = NO_ARRAY,
1499         },
1500 };
1501
1502 static int ath11k_qmi_host_cap_send(struct ath11k_base *ab)
1503 {
1504         struct qmi_wlanfw_host_cap_req_msg_v01 req;
1505         struct qmi_wlanfw_host_cap_resp_msg_v01 resp;
1506         struct qmi_txn txn = {};
1507         int ret = 0;
1508
1509         memset(&req, 0, sizeof(req));
1510         memset(&resp, 0, sizeof(resp));
1511
1512         req.num_clients_valid = 1;
1513         req.num_clients = 1;
1514         req.mem_cfg_mode = ab->qmi.target_mem_mode;
1515         req.mem_cfg_mode_valid = 1;
1516         req.bdf_support_valid = 1;
1517         req.bdf_support = 1;
1518
1519         req.m3_support_valid = 0;
1520         req.m3_support = 0;
1521
1522         req.m3_cache_support_valid = 0;
1523         req.m3_cache_support = 0;
1524
1525         req.cal_done_valid = 1;
1526         req.cal_done = ab->qmi.cal_done;
1527
1528         ret = qmi_txn_init(&ab->qmi.handle, &txn,
1529                            qmi_wlanfw_host_cap_resp_msg_v01_ei, &resp);
1530         if (ret < 0)
1531                 goto out;
1532
1533         ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1534                                QMI_WLANFW_HOST_CAP_REQ_V01,
1535                                QMI_WLANFW_HOST_CAP_REQ_MSG_V01_MAX_LEN,
1536                                qmi_wlanfw_host_cap_req_msg_v01_ei, &req);
1537         if (ret < 0) {
1538                 ath11k_warn(ab, "Failed to send host capability request,err = %d\n", ret);
1539                 goto out;
1540         }
1541
1542         ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1543         if (ret < 0)
1544                 goto out;
1545
1546         if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1547                 ath11k_warn(ab, "Host capability request failed, result: %d, err: %d\n",
1548                             resp.resp.result, resp.resp.error);
1549                 ret = -EINVAL;
1550                 goto out;
1551         }
1552
1553 out:
1554         return ret;
1555 }
1556
1557 static int ath11k_qmi_fw_ind_register_send(struct ath11k_base *ab)
1558 {
1559         struct qmi_wlanfw_ind_register_req_msg_v01 *req;
1560         struct qmi_wlanfw_ind_register_resp_msg_v01 *resp;
1561         struct qmi_handle *handle = &ab->qmi.handle;
1562         struct qmi_txn txn;
1563         int ret = 0;
1564
1565         req = kzalloc(sizeof(*req), GFP_KERNEL);
1566         if (!req)
1567                 return -ENOMEM;
1568
1569         resp = kzalloc(sizeof(*resp), GFP_KERNEL);
1570         if (!resp)
1571                 goto resp_out;
1572
1573         req->client_id_valid = 1;
1574         req->client_id = QMI_WLANFW_CLIENT_ID;
1575         req->fw_ready_enable_valid = 1;
1576         req->fw_ready_enable = 1;
1577         req->request_mem_enable_valid = 1;
1578         req->request_mem_enable = 1;
1579         req->fw_mem_ready_enable_valid = 1;
1580         req->fw_mem_ready_enable = 1;
1581         req->cal_done_enable_valid = 1;
1582         req->cal_done_enable = 1;
1583         req->fw_init_done_enable_valid = 1;
1584         req->fw_init_done_enable = 1;
1585
1586         req->pin_connect_result_enable_valid = 0;
1587         req->pin_connect_result_enable = 0;
1588
1589         ret = qmi_txn_init(handle, &txn,
1590                            qmi_wlanfw_ind_register_resp_msg_v01_ei, resp);
1591         if (ret < 0)
1592                 goto out;
1593
1594         ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1595                                QMI_WLANFW_IND_REGISTER_REQ_V01,
1596                                QMI_WLANFW_IND_REGISTER_REQ_MSG_V01_MAX_LEN,
1597                                qmi_wlanfw_ind_register_req_msg_v01_ei, req);
1598         if (ret < 0) {
1599                 ath11k_warn(ab, "Failed to send indication register request, err = %d\n",
1600                             ret);
1601                 goto out;
1602         }
1603
1604         ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1605         if (ret < 0) {
1606                 ath11k_warn(ab, "failed to register fw indication %d\n", ret);
1607                 goto out;
1608         }
1609
1610         if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
1611                 ath11k_warn(ab, "FW Ind register request failed, result: %d, err: %d\n",
1612                             resp->resp.result, resp->resp.error);
1613                 ret = -EINVAL;
1614                 goto out;
1615         }
1616
1617 out:
1618         kfree(resp);
1619 resp_out:
1620         kfree(req);
1621         return ret;
1622 }
1623
1624 static int ath11k_qmi_respond_fw_mem_request(struct ath11k_base *ab)
1625 {
1626         struct qmi_wlanfw_respond_mem_req_msg_v01 *req;
1627         struct qmi_wlanfw_respond_mem_resp_msg_v01 resp;
1628         struct qmi_txn txn = {};
1629         int ret = 0, i;
1630
1631         req = kzalloc(sizeof(*req), GFP_KERNEL);
1632         if (!req)
1633                 return -ENOMEM;
1634
1635         memset(&resp, 0, sizeof(resp));
1636
1637         req->mem_seg_len = ab->qmi.mem_seg_count;
1638
1639         ret = qmi_txn_init(&ab->qmi.handle, &txn,
1640                            qmi_wlanfw_respond_mem_resp_msg_v01_ei, &resp);
1641         if (ret < 0)
1642                 goto out;
1643
1644         for (i = 0; i < req->mem_seg_len ; i++) {
1645                 req->mem_seg[i].addr = ab->qmi.target_mem[i].paddr;
1646                 req->mem_seg[i].size = ab->qmi.target_mem[i].size;
1647                 req->mem_seg[i].type = ab->qmi.target_mem[i].type;
1648         }
1649
1650         ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1651                                QMI_WLANFW_RESPOND_MEM_REQ_V01,
1652                                QMI_WLANFW_RESPOND_MEM_REQ_MSG_V01_MAX_LEN,
1653                                qmi_wlanfw_respond_mem_req_msg_v01_ei, req);
1654         if (ret < 0) {
1655                 ath11k_warn(ab, "qmi failed to respond memory request, err = %d\n",
1656                             ret);
1657                 goto out;
1658         }
1659
1660         ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1661         if (ret < 0) {
1662                 ath11k_warn(ab, "qmi failed memory request, err = %d\n", ret);
1663                 goto out;
1664         }
1665
1666         if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1667                 ath11k_warn(ab, "Respond mem req failed, result: %d, err: %d\n",
1668                             resp.resp.result, resp.resp.error);
1669                 ret = -EINVAL;
1670                 goto out;
1671         }
1672 out:
1673         kfree(req);
1674         return ret;
1675 }
1676
1677 static int ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base *ab)
1678 {
1679         int i, idx;
1680
1681         for (i = 0, idx = 0; i < ab->qmi.mem_seg_count; i++) {
1682                 switch (ab->qmi.target_mem[i].type) {
1683                 case BDF_MEM_REGION_TYPE:
1684                         ab->qmi.target_mem[idx].paddr = ab->hw_params.bdf_addr;
1685                         ab->qmi.target_mem[idx].vaddr = ab->hw_params.bdf_addr;
1686                         ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
1687                         ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
1688                         idx++;
1689                         break;
1690                 case CALDB_MEM_REGION_TYPE:
1691                         if (ab->qmi.target_mem[i].size > ATH11K_QMI_CALDB_SIZE) {
1692                                 ath11k_warn(ab, "qmi mem size is low to load caldata\n");
1693                                 return -EINVAL;
1694                         }
1695                         /* TODO ath11k does not support cold boot calibration */
1696                         ab->qmi.target_mem[idx].paddr = 0;
1697                         ab->qmi.target_mem[idx].vaddr = 0;
1698                         ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
1699                         ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
1700                         idx++;
1701                         break;
1702                 default:
1703                         ath11k_warn(ab, "qmi ignore invalid mem req type %d\n",
1704                                     ab->qmi.target_mem[i].type);
1705                         break;
1706                 }
1707         }
1708         ab->qmi.mem_seg_count = idx;
1709
1710         return 0;
1711 }
1712
1713 static int ath11k_qmi_request_target_cap(struct ath11k_base *ab)
1714 {
1715         struct qmi_wlanfw_cap_req_msg_v01 req;
1716         struct qmi_wlanfw_cap_resp_msg_v01 resp;
1717         struct qmi_txn txn = {};
1718         int ret = 0;
1719
1720         memset(&req, 0, sizeof(req));
1721         memset(&resp, 0, sizeof(resp));
1722
1723         ret = qmi_txn_init(&ab->qmi.handle, &txn,
1724                            qmi_wlanfw_cap_resp_msg_v01_ei, &resp);
1725         if (ret < 0)
1726                 goto out;
1727
1728         ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1729                                QMI_WLANFW_CAP_REQ_V01,
1730                                QMI_WLANFW_CAP_REQ_MSG_V01_MAX_LEN,
1731                                qmi_wlanfw_cap_req_msg_v01_ei, &req);
1732         if (ret < 0) {
1733                 ath11k_warn(ab, "qmi failed to send target cap request, err = %d\n",
1734                             ret);
1735                 goto out;
1736         }
1737
1738         ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1739         if (ret < 0) {
1740                 ath11k_warn(ab, "qmi failed target cap request %d\n", ret);
1741                 goto out;
1742         }
1743
1744         if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1745                 ath11k_warn(ab, "qmi targetcap req failed, result: %d, err: %d\n",
1746                             resp.resp.result, resp.resp.error);
1747                 ret = -EINVAL;
1748                 goto out;
1749         }
1750
1751         if (resp.chip_info_valid) {
1752                 ab->qmi.target.chip_id = resp.chip_info.chip_id;
1753                 ab->qmi.target.chip_family = resp.chip_info.chip_family;
1754         }
1755
1756         if (resp.board_info_valid)
1757                 ab->qmi.target.board_id = resp.board_info.board_id;
1758         else
1759                 ab->qmi.target.board_id = 0xFF;
1760
1761         if (resp.soc_info_valid)
1762                 ab->qmi.target.soc_id = resp.soc_info.soc_id;
1763
1764         if (resp.fw_version_info_valid) {
1765                 ab->qmi.target.fw_version = resp.fw_version_info.fw_version;
1766                 strlcpy(ab->qmi.target.fw_build_timestamp,
1767                         resp.fw_version_info.fw_build_timestamp,
1768                         sizeof(ab->qmi.target.fw_build_timestamp));
1769         }
1770
1771         if (resp.fw_build_id_valid)
1772                 strlcpy(ab->qmi.target.fw_build_id, resp.fw_build_id,
1773                         sizeof(ab->qmi.target.fw_build_id));
1774
1775         ath11k_info(ab, "chip_id 0x%x chip_family 0x%x board_id 0x%x soc_id 0x%x\n",
1776                     ab->qmi.target.chip_id, ab->qmi.target.chip_family,
1777                     ab->qmi.target.board_id, ab->qmi.target.soc_id);
1778
1779         ath11k_info(ab, "fw_version 0x%x fw_build_timestamp %s fw_build_id %s",
1780                     ab->qmi.target.fw_version,
1781                     ab->qmi.target.fw_build_timestamp,
1782                     ab->qmi.target.fw_build_id);
1783
1784 out:
1785         return ret;
1786 }
1787
1788 static int
1789 ath11k_qmi_prepare_bdf_download(struct ath11k_base *ab, int type,
1790                                 struct qmi_wlanfw_bdf_download_req_msg_v01 *req,
1791                                 void __iomem *bdf_addr)
1792 {
1793         const struct firmware *fw_entry;
1794         struct ath11k_board_data bd;
1795         u32 fw_size;
1796         int ret = 0;
1797
1798         memset(&bd, 0, sizeof(bd));
1799
1800         switch (type) {
1801         case ATH11K_QMI_FILE_TYPE_BDF_GOLDEN:
1802                 ret = ath11k_core_fetch_bdf(ab, &bd);
1803                 if (ret) {
1804                         ath11k_warn(ab, "qmi failed to load BDF\n");
1805                         goto out;
1806                 }
1807
1808                 fw_size = min_t(u32, ab->hw_params.fw.board_size, bd.len);
1809                 memcpy_toio(bdf_addr, bd.data, fw_size);
1810                 ath11k_core_free_bdf(ab, &bd);
1811                 break;
1812         case ATH11K_QMI_FILE_TYPE_CALDATA:
1813                 fw_entry = ath11k_core_firmware_request(ab,
1814                                                         ATH11K_QMI_DEFAULT_CAL_FILE_NAME);
1815                 if (ret) {
1816                         ath11k_warn(ab, "failed to load %s: %d\n",
1817                                     ATH11K_QMI_DEFAULT_CAL_FILE_NAME, ret);
1818                         goto out;
1819                 }
1820
1821                 fw_size = min_t(u32, ab->hw_params.fw.board_size,
1822                                 fw_entry->size);
1823
1824                 memcpy_toio(bdf_addr + ATH11K_QMI_CALDATA_OFFSET,
1825                             fw_entry->data, fw_size);
1826
1827                 release_firmware(fw_entry);
1828                 break;
1829         default:
1830                 ret = -EINVAL;
1831                 goto out;
1832         }
1833
1834         req->total_size = fw_size;
1835
1836 out:
1837         return ret;
1838 }
1839
1840 static int ath11k_qmi_load_bdf(struct ath11k_base *ab)
1841 {
1842         struct qmi_wlanfw_bdf_download_req_msg_v01 *req;
1843         struct qmi_wlanfw_bdf_download_resp_msg_v01 resp;
1844         struct qmi_txn txn = {};
1845         void __iomem *bdf_addr = NULL;
1846         int type, ret;
1847
1848         req = kzalloc(sizeof(*req), GFP_KERNEL);
1849         if (!req)
1850                 return -ENOMEM;
1851         memset(&resp, 0, sizeof(resp));
1852
1853         bdf_addr = ioremap(ab->hw_params.bdf_addr, ATH11K_QMI_BDF_MAX_SIZE);
1854         if (!bdf_addr) {
1855                 ath11k_warn(ab, "qmi ioremap error for BDF\n");
1856                 ret = -EIO;
1857                 goto out;
1858         }
1859
1860         for (type = 0; type < ATH11K_QMI_MAX_FILE_TYPE; type++) {
1861                 req->valid = 1;
1862                 req->file_id_valid = 1;
1863                 req->file_id = ab->qmi.target.board_id;
1864                 req->total_size_valid = 1;
1865                 req->seg_id_valid = 1;
1866                 req->seg_id = type;
1867                 req->data_valid = 0;
1868                 req->data_len = ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE;
1869                 req->bdf_type = 0;
1870                 req->bdf_type_valid = 0;
1871                 req->end_valid = 1;
1872                 req->end = 1;
1873
1874                 ret = ath11k_qmi_prepare_bdf_download(ab, type, req, bdf_addr);
1875                 if (ret < 0)
1876                         goto out_qmi_bdf;
1877
1878                 ret = qmi_txn_init(&ab->qmi.handle, &txn,
1879                                    qmi_wlanfw_bdf_download_resp_msg_v01_ei,
1880                                    &resp);
1881                 if (ret < 0)
1882                         goto out_qmi_bdf;
1883
1884                 ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1885                                        QMI_WLANFW_BDF_DOWNLOAD_REQ_V01,
1886                                        QMI_WLANFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_LEN,
1887                                        qmi_wlanfw_bdf_download_req_msg_v01_ei, req);
1888                 if (ret < 0) {
1889                         qmi_txn_cancel(&txn);
1890                         goto out_qmi_bdf;
1891                 }
1892
1893                 ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1894                 if (ret < 0)
1895                         goto out_qmi_bdf;
1896
1897                 if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1898                         ath11k_warn(ab, "qmi BDF download failed, result: %d, err: %d\n",
1899                                     resp.resp.result, resp.resp.error);
1900                         ret = -EINVAL;
1901                         goto out_qmi_bdf;
1902                 }
1903         }
1904
1905 out_qmi_bdf:
1906         iounmap(bdf_addr);
1907 out:
1908         kfree(req);
1909         return ret;
1910 }
1911
1912 static int ath11k_qmi_wlanfw_m3_info_send(struct ath11k_base *ab)
1913 {
1914         struct qmi_wlanfw_m3_info_req_msg_v01 req;
1915         struct qmi_wlanfw_m3_info_resp_msg_v01 resp;
1916         struct qmi_txn txn = {};
1917         int ret = 0;
1918
1919         memset(&req, 0, sizeof(req));
1920         memset(&resp, 0, sizeof(resp));
1921         req.addr = 0;
1922         req.size = 0;
1923
1924         ret = qmi_txn_init(&ab->qmi.handle, &txn,
1925                            qmi_wlanfw_m3_info_resp_msg_v01_ei, &resp);
1926         if (ret < 0)
1927                 goto out;
1928
1929         ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1930                                QMI_WLANFW_M3_INFO_REQ_V01,
1931                                QMI_WLANFW_M3_INFO_REQ_MSG_V01_MAX_MSG_LEN,
1932                                qmi_wlanfw_m3_info_req_msg_v01_ei, &req);
1933         if (ret < 0) {
1934                 ath11k_warn(ab, "qmi failed to send M3 information request, err = %d\n",
1935                             ret);
1936                 goto out;
1937         }
1938
1939         ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1940         if (ret < 0) {
1941                 ath11k_warn(ab, "qmi failed M3 information request %d\n", ret);
1942                 goto out;
1943         }
1944
1945         if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1946                 ath11k_warn(ab, "qmi M3 info request failed, result: %d, err: %d\n",
1947                             resp.resp.result, resp.resp.error);
1948                 ret = -EINVAL;
1949                 goto out;
1950         }
1951 out:
1952         return ret;
1953 }
1954
1955 static int ath11k_qmi_wlanfw_mode_send(struct ath11k_base *ab,
1956                                        u32 mode)
1957 {
1958         struct qmi_wlanfw_wlan_mode_req_msg_v01 req;
1959         struct qmi_wlanfw_wlan_mode_resp_msg_v01 resp;
1960         struct qmi_txn txn = {};
1961         int ret = 0;
1962
1963         memset(&req, 0, sizeof(req));
1964         memset(&resp, 0, sizeof(resp));
1965
1966         req.mode = mode;
1967         req.hw_debug_valid = 1;
1968         req.hw_debug = 0;
1969
1970         ret = qmi_txn_init(&ab->qmi.handle, &txn,
1971                            qmi_wlanfw_wlan_mode_resp_msg_v01_ei, &resp);
1972         if (ret < 0)
1973                 goto out;
1974
1975         ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1976                                QMI_WLANFW_WLAN_MODE_REQ_V01,
1977                                QMI_WLANFW_WLAN_MODE_REQ_MSG_V01_MAX_LEN,
1978                                qmi_wlanfw_wlan_mode_req_msg_v01_ei, &req);
1979         if (ret < 0) {
1980                 ath11k_warn(ab, "qmi failed to send mode request, mode: %d, err = %d\n",
1981                             mode, ret);
1982                 goto out;
1983         }
1984
1985         ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1986         if (ret < 0) {
1987                 if (mode == ATH11K_FIRMWARE_MODE_OFF && ret == -ENETRESET) {
1988                         ath11k_warn(ab, "WLFW service is dis-connected\n");
1989                         return 0;
1990                 }
1991                 ath11k_warn(ab, "qmi failed set mode request, mode: %d, err = %d\n",
1992                             mode, ret);
1993                 goto out;
1994         }
1995
1996         if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1997                 ath11k_warn(ab, "Mode request failed, mode: %d, result: %d err: %d\n",
1998                             mode, resp.resp.result, resp.resp.error);
1999                 ret = -EINVAL;
2000                 goto out;
2001         }
2002
2003 out:
2004         return ret;
2005 }
2006
2007 static int ath11k_qmi_wlanfw_wlan_cfg_send(struct ath11k_base *ab)
2008 {
2009         struct qmi_wlanfw_wlan_cfg_req_msg_v01 *req;
2010         struct qmi_wlanfw_wlan_cfg_resp_msg_v01 resp;
2011         struct ce_pipe_config *ce_cfg;
2012         struct service_to_pipe *svc_cfg;
2013         struct qmi_txn txn = {};
2014         int ret = 0, pipe_num;
2015
2016         ce_cfg  = (struct ce_pipe_config *)ab->qmi.ce_cfg.tgt_ce;
2017         svc_cfg = (struct service_to_pipe *)ab->qmi.ce_cfg.svc_to_ce_map;
2018
2019         req = kzalloc(sizeof(*req), GFP_KERNEL);
2020         if (!req)
2021                 return -ENOMEM;
2022
2023         memset(&resp, 0, sizeof(resp));
2024
2025         req->host_version_valid = 1;
2026         strlcpy(req->host_version, ATH11K_HOST_VERSION_STRING,
2027                 sizeof(req->host_version));
2028
2029         req->tgt_cfg_valid = 1;
2030         /* This is number of CE configs */
2031         req->tgt_cfg_len = ab->qmi.ce_cfg.tgt_ce_len;
2032         for (pipe_num = 0; pipe_num <= req->tgt_cfg_len ; pipe_num++) {
2033                 req->tgt_cfg[pipe_num].pipe_num = ce_cfg[pipe_num].pipenum;
2034                 req->tgt_cfg[pipe_num].pipe_dir = ce_cfg[pipe_num].pipedir;
2035                 req->tgt_cfg[pipe_num].nentries = ce_cfg[pipe_num].nentries;
2036                 req->tgt_cfg[pipe_num].nbytes_max = ce_cfg[pipe_num].nbytes_max;
2037                 req->tgt_cfg[pipe_num].flags = ce_cfg[pipe_num].flags;
2038         }
2039
2040         req->svc_cfg_valid = 1;
2041         /* This is number of Service/CE configs */
2042         req->svc_cfg_len = ab->qmi.ce_cfg.svc_to_ce_map_len;
2043         for (pipe_num = 0; pipe_num < req->svc_cfg_len; pipe_num++) {
2044                 req->svc_cfg[pipe_num].service_id = svc_cfg[pipe_num].service_id;
2045                 req->svc_cfg[pipe_num].pipe_dir = svc_cfg[pipe_num].pipedir;
2046                 req->svc_cfg[pipe_num].pipe_num = svc_cfg[pipe_num].pipenum;
2047         }
2048         req->shadow_reg_valid = 0;
2049         req->shadow_reg_v2_valid = 0;
2050
2051         ret = qmi_txn_init(&ab->qmi.handle, &txn,
2052                            qmi_wlanfw_wlan_cfg_resp_msg_v01_ei, &resp);
2053         if (ret < 0)
2054                 goto out;
2055
2056         ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2057                                QMI_WLANFW_WLAN_CFG_REQ_V01,
2058                                QMI_WLANFW_WLAN_CFG_REQ_MSG_V01_MAX_LEN,
2059                                qmi_wlanfw_wlan_cfg_req_msg_v01_ei, req);
2060         if (ret < 0) {
2061                 ath11k_warn(ab, "qmi failed to send wlan config request, err = %d\n",
2062                             ret);
2063                 goto out;
2064         }
2065
2066         ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2067         if (ret < 0) {
2068                 ath11k_warn(ab, "qmi failed wlan config request, err = %d\n", ret);
2069                 goto out;
2070         }
2071
2072         if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2073                 ath11k_warn(ab, "qmi wlan config request failed, result: %d, err: %d\n",
2074                             resp.resp.result, resp.resp.error);
2075                 ret = -EINVAL;
2076                 goto out;
2077         }
2078
2079 out:
2080         kfree(req);
2081         return ret;
2082 }
2083
2084 void ath11k_qmi_firmware_stop(struct ath11k_base *ab)
2085 {
2086         int ret;
2087
2088         ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_OFF);
2089         if (ret < 0) {
2090                 ath11k_warn(ab, "qmi failed to send wlan mode off\n");
2091                 return;
2092         }
2093 }
2094
2095 int ath11k_qmi_firmware_start(struct ath11k_base *ab,
2096                               u32 mode)
2097 {
2098         int ret;
2099
2100         ret = ath11k_qmi_wlanfw_wlan_cfg_send(ab);
2101         if (ret < 0) {
2102                 ath11k_warn(ab, "qmi failed to send wlan cfg:%d\n", ret);
2103                 return ret;
2104         }
2105
2106         ret = ath11k_qmi_wlanfw_mode_send(ab, mode);
2107         if (ret < 0) {
2108                 ath11k_warn(ab, "qmi failed to send wlan fw mode:%d\n", ret);
2109                 return ret;
2110         }
2111
2112         return 0;
2113 }
2114
2115 static int
2116 ath11k_qmi_driver_event_post(struct ath11k_qmi *qmi,
2117                              enum ath11k_qmi_event_type type,
2118                              void *data)
2119 {
2120         struct ath11k_qmi_driver_event *event;
2121
2122         event = kzalloc(sizeof(*event), GFP_ATOMIC);
2123         if (!event)
2124                 return -ENOMEM;
2125
2126         event->type = type;
2127         event->data = data;
2128
2129         spin_lock(&qmi->event_lock);
2130         list_add_tail(&event->list, &qmi->event_list);
2131         spin_unlock(&qmi->event_lock);
2132
2133         queue_work(qmi->event_wq, &qmi->event_work);
2134
2135         return 0;
2136 }
2137
2138 static void ath11k_qmi_event_server_arrive(struct ath11k_qmi *qmi)
2139 {
2140         struct ath11k_base *ab = qmi->ab;
2141         int ret;
2142
2143         ret = ath11k_qmi_fw_ind_register_send(ab);
2144         if (ret < 0) {
2145                 ath11k_warn(ab, "qmi failed to send FW indication QMI:%d\n", ret);
2146                 return;
2147         }
2148
2149         ret = ath11k_qmi_host_cap_send(ab);
2150         if (ret < 0) {
2151                 ath11k_warn(ab, "qmi failed to send host cap QMI:%d\n", ret);
2152                 return;
2153         }
2154 }
2155
2156 static void ath11k_qmi_event_mem_request(struct ath11k_qmi *qmi)
2157 {
2158         struct ath11k_base *ab = qmi->ab;
2159         int ret;
2160
2161         ret = ath11k_qmi_respond_fw_mem_request(ab);
2162         if (ret < 0) {
2163                 ath11k_warn(ab, "qmi failed to respond fw mem req:%d\n", ret);
2164                 return;
2165         }
2166 }
2167
2168 static void ath11k_qmi_event_load_bdf(struct ath11k_qmi *qmi)
2169 {
2170         struct ath11k_base *ab = qmi->ab;
2171         int ret;
2172
2173         ret = ath11k_qmi_request_target_cap(ab);
2174         if (ret < 0) {
2175                 ath11k_warn(ab, "qmi failed to req target capabilities:%d\n", ret);
2176                 return;
2177         }
2178
2179         ret = ath11k_qmi_load_bdf(ab);
2180         if (ret < 0) {
2181                 ath11k_warn(ab, "qmi failed to load board data file:%d\n", ret);
2182                 return;
2183         }
2184
2185         ret = ath11k_qmi_wlanfw_m3_info_send(ab);
2186         if (ret < 0) {
2187                 ath11k_warn(ab, "qmi failed to send m3 info req:%d\n", ret);
2188                 return;
2189         }
2190 }
2191
2192 static void ath11k_qmi_msg_mem_request_cb(struct qmi_handle *qmi_hdl,
2193                                           struct sockaddr_qrtr *sq,
2194                                           struct qmi_txn *txn,
2195                                           const void *data)
2196 {
2197         struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2198         struct ath11k_base *ab = qmi->ab;
2199         const struct qmi_wlanfw_request_mem_ind_msg_v01 *msg = data;
2200         int i, ret;
2201
2202         ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware request memory request\n");
2203
2204         if (msg->mem_seg_len == 0 ||
2205             msg->mem_seg_len > ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01)
2206                 ath11k_warn(ab, "Invalid memory segment length: %u\n",
2207                             msg->mem_seg_len);
2208
2209         ab->qmi.mem_seg_count = msg->mem_seg_len;
2210
2211         for (i = 0; i < qmi->mem_seg_count ; i++) {
2212                 ab->qmi.target_mem[i].type = msg->mem_seg[i].type;
2213                 ab->qmi.target_mem[i].size = msg->mem_seg[i].size;
2214                 ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi mem seg type %d size %d\n",
2215                            msg->mem_seg[i].type, msg->mem_seg[i].size);
2216         }
2217
2218         ret = ath11k_qmi_alloc_target_mem_chunk(ab);
2219         if (ret < 0) {
2220                 ath11k_warn(ab, "qmi failed to alloc target memory:%d\n", ret);
2221                 return;
2222         }
2223
2224         ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_REQUEST_MEM, NULL);
2225 }
2226
2227 static void ath11k_qmi_msg_mem_ready_cb(struct qmi_handle *qmi_hdl,
2228                                         struct sockaddr_qrtr *sq,
2229                                         struct qmi_txn *txn,
2230                                         const void *decoded)
2231 {
2232         struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2233         struct ath11k_base *ab = qmi->ab;
2234
2235         ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware memory ready indication\n");
2236         ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_MEM_READY, NULL);
2237 }
2238
2239 static void ath11k_qmi_msg_fw_ready_cb(struct qmi_handle *qmi_hdl,
2240                                        struct sockaddr_qrtr *sq,
2241                                        struct qmi_txn *txn,
2242                                        const void *decoded)
2243 {
2244         struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2245         struct ath11k_base *ab = qmi->ab;
2246
2247         ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware ready\n");
2248         ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_READY, NULL);
2249 }
2250
2251 static void ath11k_qmi_msg_cold_boot_cal_done_cb(struct qmi_handle *qmi,
2252                                                  struct sockaddr_qrtr *sq,
2253                                                  struct qmi_txn *txn,
2254                                                  const void *decoded)
2255 {
2256 }
2257
2258 static const struct qmi_msg_handler ath11k_qmi_msg_handlers[] = {
2259         {
2260                 .type = QMI_INDICATION,
2261                 .msg_id = QMI_WLFW_REQUEST_MEM_IND_V01,
2262                 .ei = qmi_wlanfw_request_mem_ind_msg_v01_ei,
2263                 .decoded_size = sizeof(qmi_wlanfw_request_mem_ind_msg_v01_ei),
2264                 .fn = ath11k_qmi_msg_mem_request_cb,
2265         },
2266         {
2267                 .type = QMI_INDICATION,
2268                 .msg_id = QMI_WLFW_FW_MEM_READY_IND_V01,
2269                 .ei = qmi_wlanfw_mem_ready_ind_msg_v01_ei,
2270                 .decoded_size = sizeof(qmi_wlanfw_mem_ready_ind_msg_v01_ei),
2271                 .fn = ath11k_qmi_msg_mem_ready_cb,
2272         },
2273         {
2274                 .type = QMI_INDICATION,
2275                 .msg_id = QMI_WLFW_FW_READY_IND_V01,
2276                 .ei = qmi_wlanfw_fw_ready_ind_msg_v01_ei,
2277                 .decoded_size = sizeof(qmi_wlanfw_fw_ready_ind_msg_v01_ei),
2278                 .fn = ath11k_qmi_msg_fw_ready_cb,
2279         },
2280         {
2281                 .type = QMI_INDICATION,
2282                 .msg_id = QMI_WLFW_COLD_BOOT_CAL_DONE_IND_V01,
2283                 .ei = qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei,
2284                 .decoded_size =
2285                         sizeof(qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei),
2286                 .fn = ath11k_qmi_msg_cold_boot_cal_done_cb,
2287         },
2288 };
2289
2290 static int ath11k_qmi_ops_new_server(struct qmi_handle *qmi_hdl,
2291                                      struct qmi_service *service)
2292 {
2293         struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2294         struct ath11k_base *ab = qmi->ab;
2295         struct sockaddr_qrtr *sq = &qmi->sq;
2296         int ret;
2297
2298         sq->sq_family = AF_QIPCRTR;
2299         sq->sq_node = service->node;
2300         sq->sq_port = service->port;
2301
2302         ret = kernel_connect(qmi_hdl->sock, (struct sockaddr *)sq,
2303                              sizeof(*sq), 0);
2304         if (ret) {
2305                 ath11k_warn(ab, "qmi failed to connect to remote service %d\n", ret);
2306                 return ret;
2307         }
2308
2309         ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wifi fw qmi service connected\n");
2310         ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_ARRIVE, NULL);
2311
2312         return 0;
2313 }
2314
2315 static void ath11k_qmi_ops_del_server(struct qmi_handle *qmi_hdl,
2316                                       struct qmi_service *service)
2317 {
2318         struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2319         struct ath11k_base *ab = qmi->ab;
2320
2321         ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wifi fw del server\n");
2322         ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_EXIT, NULL);
2323 }
2324
2325 static const struct qmi_ops ath11k_qmi_ops = {
2326         .new_server = ath11k_qmi_ops_new_server,
2327         .del_server = ath11k_qmi_ops_del_server,
2328 };
2329
2330 static void ath11k_qmi_driver_event_work(struct work_struct *work)
2331 {
2332         struct ath11k_qmi *qmi = container_of(work, struct ath11k_qmi,
2333                                               event_work);
2334         struct ath11k_qmi_driver_event *event;
2335         struct ath11k_base *ab = qmi->ab;
2336
2337         spin_lock(&qmi->event_lock);
2338         while (!list_empty(&qmi->event_list)) {
2339                 event = list_first_entry(&qmi->event_list,
2340                                          struct ath11k_qmi_driver_event, list);
2341                 list_del(&event->list);
2342                 spin_unlock(&qmi->event_lock);
2343
2344                 if (test_bit(ATH11K_FLAG_UNREGISTERING, &ab->dev_flags))
2345                         return;
2346
2347                 switch (event->type) {
2348                 case ATH11K_QMI_EVENT_SERVER_ARRIVE:
2349                         ath11k_qmi_event_server_arrive(qmi);
2350                         break;
2351                 case ATH11K_QMI_EVENT_SERVER_EXIT:
2352                         set_bit(ATH11K_FLAG_CRASH_FLUSH, &ab->dev_flags);
2353                         set_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
2354                         break;
2355                 case ATH11K_QMI_EVENT_REQUEST_MEM:
2356                         ath11k_qmi_event_mem_request(qmi);
2357                         break;
2358                 case ATH11K_QMI_EVENT_FW_MEM_READY:
2359                         ath11k_qmi_event_load_bdf(qmi);
2360                         break;
2361                 case ATH11K_QMI_EVENT_FW_READY:
2362                         if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) {
2363                                 ath11k_hal_dump_srng_stats(ab);
2364                                 queue_work(ab->workqueue, &ab->restart_work);
2365                                 break;
2366                         }
2367
2368                         ath11k_core_qmi_firmware_ready(ab);
2369                         ab->qmi.cal_done = 1;
2370                         set_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags);
2371
2372                         break;
2373                 case ATH11K_QMI_EVENT_COLD_BOOT_CAL_DONE:
2374                         break;
2375                 default:
2376                         ath11k_warn(ab, "invalid event type: %d", event->type);
2377                         break;
2378                 }
2379                 kfree(event);
2380                 spin_lock(&qmi->event_lock);
2381         }
2382         spin_unlock(&qmi->event_lock);
2383 }
2384
2385 int ath11k_qmi_init_service(struct ath11k_base *ab)
2386 {
2387         int ret;
2388
2389         memset(&ab->qmi.target, 0, sizeof(struct target_info));
2390         memset(&ab->qmi.target_mem, 0, sizeof(struct target_mem_chunk));
2391         ab->qmi.ab = ab;
2392
2393         ab->qmi.target_mem_mode = ATH11K_QMI_TARGET_MEM_MODE_DEFAULT;
2394         ret = qmi_handle_init(&ab->qmi.handle, ATH11K_QMI_RESP_LEN_MAX,
2395                               &ath11k_qmi_ops, ath11k_qmi_msg_handlers);
2396         if (ret < 0) {
2397                 ath11k_warn(ab, "failed to initialize qmi handle\n");
2398                 return ret;
2399         }
2400
2401         ab->qmi.event_wq = alloc_workqueue("ath11k_qmi_driver_event",
2402                                            WQ_UNBOUND, 1);
2403         if (!ab->qmi.event_wq) {
2404                 ath11k_err(ab, "failed to allocate workqueue\n");
2405                 return -EFAULT;
2406         }
2407
2408         INIT_LIST_HEAD(&ab->qmi.event_list);
2409         spin_lock_init(&ab->qmi.event_lock);
2410         INIT_WORK(&ab->qmi.event_work, ath11k_qmi_driver_event_work);
2411
2412         ret = qmi_add_lookup(&ab->qmi.handle, ATH11K_QMI_WLFW_SERVICE_ID_V01,
2413                              ATH11K_QMI_WLFW_SERVICE_VERS_V01,
2414                              ATH11K_QMI_WLFW_SERVICE_INS_ID_V01);
2415         if (ret < 0) {
2416                 ath11k_warn(ab, "failed to add qmi lookup\n");
2417                 return ret;
2418         }
2419
2420         return ret;
2421 }
2422
2423 void ath11k_qmi_deinit_service(struct ath11k_base *ab)
2424 {
2425         qmi_handle_release(&ab->qmi.handle);
2426         cancel_work_sync(&ab->qmi.event_work);
2427         destroy_workqueue(ab->qmi.event_wq);
2428 }
2429