1// SPDX-License-Identifier: BSD-3-Clause-Clear
   2/*
   3 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
   4 * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
   5 */
   6
   7#include <linux/elf.h>
   8
   9#include "qmi.h"
  10#include "core.h"
  11#include "debug.h"
  12#include <linux/of.h>
  13#include <linux/of_address.h>
  14#include <linux/ioport.h>
  15#include <linux/firmware.h>
  16#include <linux/of_device.h>
  17#include <linux/of_irq.h>
  18
  19#define SLEEP_CLOCK_SELECT_INTERNAL_BIT	0x02
  20#define HOST_CSTATE_BIT			0x04
  21#define PLATFORM_CAP_PCIE_GLOBAL_RESET	0x08
  22#define PLATFORM_CAP_PCIE_PME_D3COLD	0x10
  23
  24#define FW_BUILD_ID_MASK "QC_IMAGE_VERSION_STRING="
  25
  26bool ath11k_cold_boot_cal = 1;
  27EXPORT_SYMBOL(ath11k_cold_boot_cal);
  28module_param_named(cold_boot_cal, ath11k_cold_boot_cal, bool, 0644);
  29MODULE_PARM_DESC(cold_boot_cal,
  30		 "Decrease the channel switch time but increase the driver load time (Default: true)");
  31
  32static const struct qmi_elem_info qmi_wlanfw_host_cap_req_msg_v01_ei[] = {
  33	{
  34		.data_type	= QMI_OPT_FLAG,
  35		.elem_len	= 1,
  36		.elem_size	= sizeof(u8),
  37		.array_type	= NO_ARRAY,
  38		.tlv_type	= 0x10,
  39		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  40					   num_clients_valid),
  41	},
  42	{
  43		.data_type	= QMI_UNSIGNED_4_BYTE,
  44		.elem_len	= 1,
  45		.elem_size	= sizeof(u32),
  46		.array_type	= NO_ARRAY,
  47		.tlv_type	= 0x10,
  48		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  49					   num_clients),
  50	},
  51	{
  52		.data_type	= QMI_OPT_FLAG,
  53		.elem_len	= 1,
  54		.elem_size	= sizeof(u8),
  55		.array_type	= NO_ARRAY,
  56		.tlv_type	= 0x11,
  57		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  58					   wake_msi_valid),
  59	},
  60	{
  61		.data_type	= QMI_UNSIGNED_4_BYTE,
  62		.elem_len	= 1,
  63		.elem_size	= sizeof(u32),
  64		.array_type	= NO_ARRAY,
  65		.tlv_type	= 0x11,
  66		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  67					   wake_msi),
  68	},
  69	{
  70		.data_type	= QMI_OPT_FLAG,
  71		.elem_len	= 1,
  72		.elem_size	= sizeof(u8),
  73		.array_type	= NO_ARRAY,
  74		.tlv_type	= 0x12,
  75		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  76					   gpios_valid),
  77	},
  78	{
  79		.data_type	= QMI_DATA_LEN,
  80		.elem_len	= 1,
  81		.elem_size	= sizeof(u8),
  82		.array_type	= NO_ARRAY,
  83		.tlv_type	= 0x12,
  84		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  85					   gpios_len),
  86	},
  87	{
  88		.data_type	= QMI_UNSIGNED_4_BYTE,
  89		.elem_len	= QMI_WLFW_MAX_NUM_GPIO_V01,
  90		.elem_size	= sizeof(u32),
  91		.array_type	= VAR_LEN_ARRAY,
  92		.tlv_type	= 0x12,
  93		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
  94					   gpios),
  95	},
  96	{
  97		.data_type	= QMI_OPT_FLAG,
  98		.elem_len	= 1,
  99		.elem_size	= sizeof(u8),
 100		.array_type	= NO_ARRAY,
 101		.tlv_type	= 0x13,
 102		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 103					   nm_modem_valid),
 104	},
 105	{
 106		.data_type	= QMI_UNSIGNED_1_BYTE,
 107		.elem_len	= 1,
 108		.elem_size	= sizeof(u8),
 109		.array_type	= NO_ARRAY,
 110		.tlv_type	= 0x13,
 111		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 112					   nm_modem),
 113	},
 114	{
 115		.data_type	= QMI_OPT_FLAG,
 116		.elem_len	= 1,
 117		.elem_size	= sizeof(u8),
 118		.array_type	= NO_ARRAY,
 119		.tlv_type	= 0x14,
 120		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 121					   bdf_support_valid),
 122	},
 123	{
 124		.data_type	= QMI_UNSIGNED_1_BYTE,
 125		.elem_len	= 1,
 126		.elem_size	= sizeof(u8),
 127		.array_type	= NO_ARRAY,
 128		.tlv_type	= 0x14,
 129		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 130					   bdf_support),
 131	},
 132	{
 133		.data_type	= QMI_OPT_FLAG,
 134		.elem_len	= 1,
 135		.elem_size	= sizeof(u8),
 136		.array_type	= NO_ARRAY,
 137		.tlv_type	= 0x15,
 138		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 139					   bdf_cache_support_valid),
 140	},
 141	{
 142		.data_type	= QMI_UNSIGNED_1_BYTE,
 143		.elem_len	= 1,
 144		.elem_size	= sizeof(u8),
 145		.array_type	= NO_ARRAY,
 146		.tlv_type	= 0x15,
 147		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 148					   bdf_cache_support),
 149	},
 150	{
 151		.data_type	= QMI_OPT_FLAG,
 152		.elem_len	= 1,
 153		.elem_size	= sizeof(u8),
 154		.array_type	= NO_ARRAY,
 155		.tlv_type	= 0x16,
 156		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 157					   m3_support_valid),
 158	},
 159	{
 160		.data_type	= QMI_UNSIGNED_1_BYTE,
 161		.elem_len	= 1,
 162		.elem_size	= sizeof(u8),
 163		.array_type	= NO_ARRAY,
 164		.tlv_type	= 0x16,
 165		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 166					   m3_support),
 167	},
 168	{
 169		.data_type	= QMI_OPT_FLAG,
 170		.elem_len	= 1,
 171		.elem_size	= sizeof(u8),
 172		.array_type	= NO_ARRAY,
 173		.tlv_type	= 0x17,
 174		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 175					   m3_cache_support_valid),
 176	},
 177	{
 178		.data_type	= QMI_UNSIGNED_1_BYTE,
 179		.elem_len	= 1,
 180		.elem_size	= sizeof(u8),
 181		.array_type	= NO_ARRAY,
 182		.tlv_type	= 0x17,
 183		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 184					   m3_cache_support),
 185	},
 186	{
 187		.data_type	= QMI_OPT_FLAG,
 188		.elem_len	= 1,
 189		.elem_size	= sizeof(u8),
 190		.array_type	= NO_ARRAY,
 191		.tlv_type	= 0x18,
 192		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 193					   cal_filesys_support_valid),
 194	},
 195	{
 196		.data_type	= QMI_UNSIGNED_1_BYTE,
 197		.elem_len	= 1,
 198		.elem_size	= sizeof(u8),
 199		.array_type	= NO_ARRAY,
 200		.tlv_type	= 0x18,
 201		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 202					   cal_filesys_support),
 203	},
 204	{
 205		.data_type	= QMI_OPT_FLAG,
 206		.elem_len	= 1,
 207		.elem_size	= sizeof(u8),
 208		.array_type	= NO_ARRAY,
 209		.tlv_type	= 0x19,
 210		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 211					   cal_cache_support_valid),
 212	},
 213	{
 214		.data_type	= QMI_UNSIGNED_1_BYTE,
 215		.elem_len	= 1,
 216		.elem_size	= sizeof(u8),
 217		.array_type	= NO_ARRAY,
 218		.tlv_type	= 0x19,
 219		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 220					   cal_cache_support),
 221	},
 222	{
 223		.data_type	= QMI_OPT_FLAG,
 224		.elem_len	= 1,
 225		.elem_size	= sizeof(u8),
 226		.array_type	= NO_ARRAY,
 227		.tlv_type	= 0x1A,
 228		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 229					   cal_done_valid),
 230	},
 231	{
 232		.data_type	= QMI_UNSIGNED_1_BYTE,
 233		.elem_len	= 1,
 234		.elem_size	= sizeof(u8),
 235		.array_type	= NO_ARRAY,
 236		.tlv_type	= 0x1A,
 237		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 238					   cal_done),
 239	},
 240	{
 241		.data_type	= QMI_OPT_FLAG,
 242		.elem_len	= 1,
 243		.elem_size	= sizeof(u8),
 244		.array_type	= NO_ARRAY,
 245		.tlv_type	= 0x1B,
 246		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 247					   mem_bucket_valid),
 248	},
 249	{
 250		.data_type	= QMI_UNSIGNED_4_BYTE,
 251		.elem_len	= 1,
 252		.elem_size	= sizeof(u32),
 253		.array_type	= NO_ARRAY,
 254		.tlv_type	= 0x1B,
 255		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 256					   mem_bucket),
 257	},
 258	{
 259		.data_type	= QMI_OPT_FLAG,
 260		.elem_len	= 1,
 261		.elem_size	= sizeof(u8),
 262		.array_type	= NO_ARRAY,
 263		.tlv_type	= 0x1C,
 264		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 265					   mem_cfg_mode_valid),
 266	},
 267	{
 268		.data_type	= QMI_UNSIGNED_1_BYTE,
 269		.elem_len	= 1,
 270		.elem_size	= sizeof(u8),
 271		.array_type	= NO_ARRAY,
 272		.tlv_type	= 0x1C,
 273		.offset		= offsetof(struct qmi_wlanfw_host_cap_req_msg_v01,
 274					   mem_cfg_mode),
 275	},
 276	{
 277		.data_type	= QMI_EOTI,
 278		.array_type	= NO_ARRAY,
 279		.tlv_type	= QMI_COMMON_TLV_TYPE,
 280	},
 281};
 282
 283static const struct qmi_elem_info qmi_wlanfw_host_cap_resp_msg_v01_ei[] = {
 284	{
 285		.data_type	= QMI_STRUCT,
 286		.elem_len	= 1,
 287		.elem_size	= sizeof(struct qmi_response_type_v01),
 288		.array_type	= NO_ARRAY,
 289		.tlv_type	= 0x02,
 290		.offset		= offsetof(struct qmi_wlanfw_host_cap_resp_msg_v01, resp),
 291		.ei_array	= qmi_response_type_v01_ei,
 292	},
 293	{
 294		.data_type	= QMI_EOTI,
 295		.array_type	= NO_ARRAY,
 296		.tlv_type	= QMI_COMMON_TLV_TYPE,
 297	},
 298};
 299
 300static const struct qmi_elem_info qmi_wlanfw_ind_register_req_msg_v01_ei[] = {
 301	{
 302		.data_type	= QMI_OPT_FLAG,
 303		.elem_len	= 1,
 304		.elem_size	= sizeof(u8),
 305		.array_type	= NO_ARRAY,
 306		.tlv_type	= 0x10,
 307		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 308					   fw_ready_enable_valid),
 309	},
 310	{
 311		.data_type	= QMI_UNSIGNED_1_BYTE,
 312		.elem_len	= 1,
 313		.elem_size	= sizeof(u8),
 314		.array_type	= NO_ARRAY,
 315		.tlv_type	= 0x10,
 316		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 317					   fw_ready_enable),
 318	},
 319	{
 320		.data_type	= QMI_OPT_FLAG,
 321		.elem_len	= 1,
 322		.elem_size	= sizeof(u8),
 323		.array_type	= NO_ARRAY,
 324		.tlv_type	= 0x11,
 325		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 326					   initiate_cal_download_enable_valid),
 327	},
 328	{
 329		.data_type	= QMI_UNSIGNED_1_BYTE,
 330		.elem_len	= 1,
 331		.elem_size	= sizeof(u8),
 332		.array_type	= NO_ARRAY,
 333		.tlv_type	= 0x11,
 334		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 335					   initiate_cal_download_enable),
 336	},
 337	{
 338		.data_type	= QMI_OPT_FLAG,
 339		.elem_len	= 1,
 340		.elem_size	= sizeof(u8),
 341		.array_type	= NO_ARRAY,
 342		.tlv_type	= 0x12,
 343		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 344					   initiate_cal_update_enable_valid),
 345	},
 346	{
 347		.data_type	= QMI_UNSIGNED_1_BYTE,
 348		.elem_len	= 1,
 349		.elem_size	= sizeof(u8),
 350		.array_type	= NO_ARRAY,
 351		.tlv_type	= 0x12,
 352		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 353					   initiate_cal_update_enable),
 354	},
 355	{
 356		.data_type	= QMI_OPT_FLAG,
 357		.elem_len	= 1,
 358		.elem_size	= sizeof(u8),
 359		.array_type	= NO_ARRAY,
 360		.tlv_type	= 0x13,
 361		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 362					   msa_ready_enable_valid),
 363	},
 364	{
 365		.data_type	= QMI_UNSIGNED_1_BYTE,
 366		.elem_len	= 1,
 367		.elem_size	= sizeof(u8),
 368		.array_type	= NO_ARRAY,
 369		.tlv_type	= 0x13,
 370		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 371					   msa_ready_enable),
 372	},
 373	{
 374		.data_type	= QMI_OPT_FLAG,
 375		.elem_len	= 1,
 376		.elem_size	= sizeof(u8),
 377		.array_type	= NO_ARRAY,
 378		.tlv_type	= 0x14,
 379		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 380					   pin_connect_result_enable_valid),
 381	},
 382	{
 383		.data_type	= QMI_UNSIGNED_1_BYTE,
 384		.elem_len	= 1,
 385		.elem_size	= sizeof(u8),
 386		.array_type	= NO_ARRAY,
 387		.tlv_type	= 0x14,
 388		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 389					   pin_connect_result_enable),
 390	},
 391	{
 392		.data_type	= QMI_OPT_FLAG,
 393		.elem_len	= 1,
 394		.elem_size	= sizeof(u8),
 395		.array_type	= NO_ARRAY,
 396		.tlv_type	= 0x15,
 397		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 398					   client_id_valid),
 399	},
 400	{
 401		.data_type	= QMI_UNSIGNED_4_BYTE,
 402		.elem_len	= 1,
 403		.elem_size	= sizeof(u32),
 404		.array_type	= NO_ARRAY,
 405		.tlv_type	= 0x15,
 406		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 407					   client_id),
 408	},
 409	{
 410		.data_type	= QMI_OPT_FLAG,
 411		.elem_len	= 1,
 412		.elem_size	= sizeof(u8),
 413		.array_type	= NO_ARRAY,
 414		.tlv_type	= 0x16,
 415		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 416					   request_mem_enable_valid),
 417	},
 418	{
 419		.data_type	= QMI_UNSIGNED_1_BYTE,
 420		.elem_len	= 1,
 421		.elem_size	= sizeof(u8),
 422		.array_type	= NO_ARRAY,
 423		.tlv_type	= 0x16,
 424		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 425					   request_mem_enable),
 426	},
 427	{
 428		.data_type	= QMI_OPT_FLAG,
 429		.elem_len	= 1,
 430		.elem_size	= sizeof(u8),
 431		.array_type	= NO_ARRAY,
 432		.tlv_type	= 0x17,
 433		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 434					   fw_mem_ready_enable_valid),
 435	},
 436	{
 437		.data_type	= QMI_UNSIGNED_1_BYTE,
 438		.elem_len	= 1,
 439		.elem_size	= sizeof(u8),
 440		.array_type	= NO_ARRAY,
 441		.tlv_type	= 0x17,
 442		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 443					   fw_mem_ready_enable),
 444	},
 445	{
 446		.data_type	= QMI_OPT_FLAG,
 447		.elem_len	= 1,
 448		.elem_size	= sizeof(u8),
 449		.array_type	= NO_ARRAY,
 450		.tlv_type	= 0x18,
 451		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 452					   fw_init_done_enable_valid),
 453	},
 454	{
 455		.data_type	= QMI_UNSIGNED_1_BYTE,
 456		.elem_len	= 1,
 457		.elem_size	= sizeof(u8),
 458		.array_type	= NO_ARRAY,
 459		.tlv_type	= 0x18,
 460		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 461					   fw_init_done_enable),
 462	},
 463
 464	{
 465		.data_type	= QMI_OPT_FLAG,
 466		.elem_len	= 1,
 467		.elem_size	= sizeof(u8),
 468		.array_type	= NO_ARRAY,
 469		.tlv_type	= 0x19,
 470		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 471					   rejuvenate_enable_valid),
 472	},
 473	{
 474		.data_type	= QMI_UNSIGNED_1_BYTE,
 475		.elem_len	= 1,
 476		.elem_size	= sizeof(u8),
 477		.array_type	= NO_ARRAY,
 478		.tlv_type	= 0x19,
 479		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 480					   rejuvenate_enable),
 481	},
 482	{
 483		.data_type	= QMI_OPT_FLAG,
 484		.elem_len	= 1,
 485		.elem_size	= sizeof(u8),
 486		.array_type	= NO_ARRAY,
 487		.tlv_type	= 0x1A,
 488		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 489					   xo_cal_enable_valid),
 490	},
 491	{
 492		.data_type	= QMI_UNSIGNED_1_BYTE,
 493		.elem_len	= 1,
 494		.elem_size	= sizeof(u8),
 495		.array_type	= NO_ARRAY,
 496		.tlv_type	= 0x1A,
 497		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 498					   xo_cal_enable),
 499	},
 500	{
 501		.data_type	= QMI_OPT_FLAG,
 502		.elem_len	= 1,
 503		.elem_size	= sizeof(u8),
 504		.array_type	= NO_ARRAY,
 505		.tlv_type	= 0x1B,
 506		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 507					   cal_done_enable_valid),
 508	},
 509	{
 510		.data_type	= QMI_UNSIGNED_1_BYTE,
 511		.elem_len	= 1,
 512		.elem_size	= sizeof(u8),
 513		.array_type	= NO_ARRAY,
 514		.tlv_type	= 0x1B,
 515		.offset		= offsetof(struct qmi_wlanfw_ind_register_req_msg_v01,
 516					   cal_done_enable),
 517	},
 518	{
 519		.data_type	= QMI_EOTI,
 520		.array_type	= NO_ARRAY,
 521		.tlv_type	= QMI_COMMON_TLV_TYPE,
 522	},
 523};
 524
 525static const struct qmi_elem_info qmi_wlanfw_ind_register_resp_msg_v01_ei[] = {
 526	{
 527		.data_type	= QMI_STRUCT,
 528		.elem_len	= 1,
 529		.elem_size	= sizeof(struct qmi_response_type_v01),
 530		.array_type	= NO_ARRAY,
 531		.tlv_type	= 0x02,
 532		.offset		= offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
 533					   resp),
 534		.ei_array	= qmi_response_type_v01_ei,
 535	},
 536	{
 537		.data_type	= QMI_OPT_FLAG,
 538		.elem_len	= 1,
 539		.elem_size	= sizeof(u8),
 540		.array_type	= NO_ARRAY,
 541		.tlv_type	= 0x10,
 542		.offset		= offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
 543					   fw_status_valid),
 544	},
 545	{
 546		.data_type	= QMI_UNSIGNED_8_BYTE,
 547		.elem_len	= 1,
 548		.elem_size	= sizeof(u64),
 549		.array_type	= NO_ARRAY,
 550		.tlv_type	= 0x10,
 551		.offset		= offsetof(struct qmi_wlanfw_ind_register_resp_msg_v01,
 552					   fw_status),
 553	},
 554	{
 555		.data_type	= QMI_EOTI,
 556		.array_type	= NO_ARRAY,
 557		.tlv_type	= QMI_COMMON_TLV_TYPE,
 558	},
 559};
 560
 561static const struct qmi_elem_info qmi_wlanfw_mem_cfg_s_v01_ei[] = {
 562	{
 563		.data_type	= QMI_UNSIGNED_8_BYTE,
 564		.elem_len	= 1,
 565		.elem_size	= sizeof(u64),
 566		.array_type	= NO_ARRAY,
 567		.tlv_type	= 0,
 568		.offset		= offsetof(struct qmi_wlanfw_mem_cfg_s_v01, offset),
 569	},
 570	{
 571		.data_type	= QMI_UNSIGNED_4_BYTE,
 572		.elem_len	= 1,
 573		.elem_size	= sizeof(u32),
 574		.array_type	= NO_ARRAY,
 575		.tlv_type	= 0,
 576		.offset		= offsetof(struct qmi_wlanfw_mem_cfg_s_v01, size),
 577	},
 578	{
 579		.data_type	= QMI_UNSIGNED_1_BYTE,
 580		.elem_len	= 1,
 581		.elem_size	= sizeof(u8),
 582		.array_type	= NO_ARRAY,
 583		.tlv_type	= 0,
 584		.offset		= offsetof(struct qmi_wlanfw_mem_cfg_s_v01, secure_flag),
 585	},
 586	{
 587		.data_type	= QMI_EOTI,
 588		.array_type	= NO_ARRAY,
 589		.tlv_type	= QMI_COMMON_TLV_TYPE,
 590	},
 591};
 592
 593static const struct qmi_elem_info qmi_wlanfw_mem_seg_s_v01_ei[] = {
 594	{
 595		.data_type	= QMI_UNSIGNED_4_BYTE,
 596		.elem_len	= 1,
 597		.elem_size	= sizeof(u32),
 598		.array_type	= NO_ARRAY,
 599		.tlv_type	= 0,
 600		.offset		= offsetof(struct qmi_wlanfw_mem_seg_s_v01,
 601				  size),
 602	},
 603	{
 604		.data_type	= QMI_SIGNED_4_BYTE_ENUM,
 605		.elem_len	= 1,
 606		.elem_size	= sizeof(enum qmi_wlanfw_mem_type_enum_v01),
 607		.array_type	= NO_ARRAY,
 608		.tlv_type	= 0,
 609		.offset		= offsetof(struct qmi_wlanfw_mem_seg_s_v01, type),
 610	},
 611	{
 612		.data_type	= QMI_DATA_LEN,
 613		.elem_len	= 1,
 614		.elem_size	= sizeof(u8),
 615		.array_type	= NO_ARRAY,
 616		.tlv_type	= 0,
 617		.offset		= offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg_len),
 618	},
 619	{
 620		.data_type	= QMI_STRUCT,
 621		.elem_len	= QMI_WLANFW_MAX_NUM_MEM_CFG_V01,
 622		.elem_size	= sizeof(struct qmi_wlanfw_mem_cfg_s_v01),
 623		.array_type	= VAR_LEN_ARRAY,
 624		.tlv_type	= 0,
 625		.offset		= offsetof(struct qmi_wlanfw_mem_seg_s_v01, mem_cfg),
 626		.ei_array	= qmi_wlanfw_mem_cfg_s_v01_ei,
 627	},
 628	{
 629		.data_type	= QMI_EOTI,
 630		.array_type	= NO_ARRAY,
 631		.tlv_type	= QMI_COMMON_TLV_TYPE,
 632	},
 633};
 634
 635static const struct qmi_elem_info qmi_wlanfw_request_mem_ind_msg_v01_ei[] = {
 636	{
 637		.data_type	= QMI_DATA_LEN,
 638		.elem_len	= 1,
 639		.elem_size	= sizeof(u8),
 640		.array_type	= NO_ARRAY,
 641		.tlv_type	= 0x01,
 642		.offset		= offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
 643					   mem_seg_len),
 644	},
 645	{
 646		.data_type	= QMI_STRUCT,
 647		.elem_len	= ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
 648		.elem_size	= sizeof(struct qmi_wlanfw_mem_seg_s_v01),
 649		.array_type	= VAR_LEN_ARRAY,
 650		.tlv_type	= 0x01,
 651		.offset		= offsetof(struct qmi_wlanfw_request_mem_ind_msg_v01,
 652					   mem_seg),
 653		.ei_array	= qmi_wlanfw_mem_seg_s_v01_ei,
 654	},
 655	{
 656		.data_type	= QMI_EOTI,
 657		.array_type	= NO_ARRAY,
 658		.tlv_type	= QMI_COMMON_TLV_TYPE,
 659	},
 660};
 661
 662static const struct qmi_elem_info qmi_wlanfw_mem_seg_resp_s_v01_ei[] = {
 663	{
 664		.data_type	= QMI_UNSIGNED_8_BYTE,
 665		.elem_len	= 1,
 666		.elem_size	= sizeof(u64),
 667		.array_type	= NO_ARRAY,
 668		.tlv_type	= 0,
 669		.offset		= offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, addr),
 670	},
 671	{
 672		.data_type	= QMI_UNSIGNED_4_BYTE,
 673		.elem_len	= 1,
 674		.elem_size	= sizeof(u32),
 675		.array_type	= NO_ARRAY,
 676		.tlv_type	= 0,
 677		.offset		= offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, size),
 678	},
 679	{
 680		.data_type	= QMI_SIGNED_4_BYTE_ENUM,
 681		.elem_len	= 1,
 682		.elem_size	= sizeof(enum qmi_wlanfw_mem_type_enum_v01),
 683		.array_type	= NO_ARRAY,
 684		.tlv_type	= 0,
 685		.offset		= offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, type),
 686	},
 687	{
 688		.data_type	= QMI_UNSIGNED_1_BYTE,
 689		.elem_len	= 1,
 690		.elem_size	= sizeof(u8),
 691		.array_type	= NO_ARRAY,
 692		.tlv_type	= 0,
 693		.offset		= offsetof(struct qmi_wlanfw_mem_seg_resp_s_v01, restore),
 694	},
 695	{
 696		.data_type	= QMI_EOTI,
 697		.array_type	= NO_ARRAY,
 698		.tlv_type	= QMI_COMMON_TLV_TYPE,
 699	},
 700};
 701
 702static const struct qmi_elem_info qmi_wlanfw_respond_mem_req_msg_v01_ei[] = {
 703	{
 704		.data_type	= QMI_DATA_LEN,
 705		.elem_len	= 1,
 706		.elem_size	= sizeof(u8),
 707		.array_type	= NO_ARRAY,
 708		.tlv_type	= 0x01,
 709		.offset		= offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
 710					   mem_seg_len),
 711	},
 712	{
 713		.data_type	= QMI_STRUCT,
 714		.elem_len	= ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01,
 715		.elem_size	= sizeof(struct qmi_wlanfw_mem_seg_resp_s_v01),
 716		.array_type	= VAR_LEN_ARRAY,
 717		.tlv_type	= 0x01,
 718		.offset		= offsetof(struct qmi_wlanfw_respond_mem_req_msg_v01,
 719					   mem_seg),
 720		.ei_array	= qmi_wlanfw_mem_seg_resp_s_v01_ei,
 721	},
 722	{
 723		.data_type	= QMI_EOTI,
 724		.array_type	= NO_ARRAY,
 725		.tlv_type	= QMI_COMMON_TLV_TYPE,
 726	},
 727};
 728
 729static const struct qmi_elem_info qmi_wlanfw_respond_mem_resp_msg_v01_ei[] = {
 730	{
 731		.data_type	= QMI_STRUCT,
 732		.elem_len	= 1,
 733		.elem_size	= sizeof(struct qmi_response_type_v01),
 734		.array_type	= NO_ARRAY,
 735		.tlv_type	= 0x02,
 736		.offset		= offsetof(struct qmi_wlanfw_respond_mem_resp_msg_v01,
 737					   resp),
 738		.ei_array	= qmi_response_type_v01_ei,
 739	},
 740	{
 741		.data_type	= QMI_EOTI,
 742		.array_type	= NO_ARRAY,
 743		.tlv_type	= QMI_COMMON_TLV_TYPE,
 744	},
 745};
 746
 747static const struct qmi_elem_info qmi_wlanfw_cap_req_msg_v01_ei[] = {
 748	{
 749		.data_type	= QMI_EOTI,
 750		.array_type	= NO_ARRAY,
 751		.tlv_type	= QMI_COMMON_TLV_TYPE,
 752	},
 753};
 754
 755static const struct qmi_elem_info qmi_wlanfw_device_info_req_msg_v01_ei[] = {
 756	{
 757		.data_type      = QMI_EOTI,
 758		.array_type     = NO_ARRAY,
 759		.tlv_type       = QMI_COMMON_TLV_TYPE,
 760	},
 761};
 762
 763static const struct qmi_elem_info qmi_wlfw_device_info_resp_msg_v01_ei[] = {
 764	{
 765		.data_type	= QMI_STRUCT,
 766		.elem_len	= 1,
 767		.elem_size	= sizeof(struct qmi_response_type_v01),
 768		.array_type	= NO_ARRAY,
 769		.tlv_type	= 0x02,
 770		.offset		= offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
 771					   resp),
 772		.ei_array	= qmi_response_type_v01_ei,
 773	},
 774	{
 775		.data_type	= QMI_OPT_FLAG,
 776		.elem_len	= 1,
 777		.elem_size	= sizeof(u8),
 778		.array_type	= NO_ARRAY,
 779		.tlv_type	= 0x10,
 780		.offset		= offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
 781					   bar_addr_valid),
 782	},
 783	{
 784		.data_type	= QMI_UNSIGNED_8_BYTE,
 785		.elem_len	= 1,
 786		.elem_size	= sizeof(u64),
 787		.array_type	= NO_ARRAY,
 788		.tlv_type	= 0x10,
 789		.offset		= offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
 790					   bar_addr),
 791	},
 792	{
 793		.data_type	= QMI_OPT_FLAG,
 794		.elem_len	= 1,
 795		.elem_size	= sizeof(u8),
 796		.array_type	= NO_ARRAY,
 797		.tlv_type	= 0x11,
 798		.offset		= offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
 799					   bar_size_valid),
 800	},
 801	{
 802		.data_type	= QMI_UNSIGNED_4_BYTE,
 803		.elem_len	= 1,
 804		.elem_size	= sizeof(u32),
 805		.array_type	= NO_ARRAY,
 806		.tlv_type	= 0x11,
 807		.offset		= offsetof(struct qmi_wlanfw_device_info_resp_msg_v01,
 808					   bar_size),
 809	},
 810	{
 811		.data_type	= QMI_EOTI,
 812		.array_type	= NO_ARRAY,
 813		.tlv_type	= QMI_COMMON_TLV_TYPE,
 814	},
 815};
 816
 817static const struct qmi_elem_info qmi_wlanfw_rf_chip_info_s_v01_ei[] = {
 818	{
 819		.data_type	= QMI_UNSIGNED_4_BYTE,
 820		.elem_len	= 1,
 821		.elem_size	= sizeof(u32),
 822		.array_type	= NO_ARRAY,
 823		.tlv_type	= 0,
 824		.offset		= offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
 825					   chip_id),
 826	},
 827	{
 828		.data_type	= QMI_UNSIGNED_4_BYTE,
 829		.elem_len	= 1,
 830		.elem_size	= sizeof(u32),
 831		.array_type	= NO_ARRAY,
 832		.tlv_type	= 0,
 833		.offset		= offsetof(struct qmi_wlanfw_rf_chip_info_s_v01,
 834					   chip_family),
 835	},
 836	{
 837		.data_type	= QMI_EOTI,
 838		.array_type	= NO_ARRAY,
 839		.tlv_type	= QMI_COMMON_TLV_TYPE,
 840	},
 841};
 842
 843static const struct qmi_elem_info qmi_wlanfw_rf_board_info_s_v01_ei[] = {
 844	{
 845		.data_type	= QMI_UNSIGNED_4_BYTE,
 846		.elem_len	= 1,
 847		.elem_size	= sizeof(u32),
 848		.array_type	= NO_ARRAY,
 849		.tlv_type	= 0,
 850		.offset		= offsetof(struct qmi_wlanfw_rf_board_info_s_v01,
 851					   board_id),
 852	},
 853	{
 854		.data_type	= QMI_EOTI,
 855		.array_type	= NO_ARRAY,
 856		.tlv_type	= QMI_COMMON_TLV_TYPE,
 857	},
 858};
 859
 860static const struct qmi_elem_info qmi_wlanfw_soc_info_s_v01_ei[] = {
 861	{
 862		.data_type	= QMI_UNSIGNED_4_BYTE,
 863		.elem_len	= 1,
 864		.elem_size	= sizeof(u32),
 865		.array_type	= NO_ARRAY,
 866		.tlv_type	= 0,
 867		.offset		= offsetof(struct qmi_wlanfw_soc_info_s_v01, soc_id),
 868	},
 869	{
 870		.data_type	= QMI_EOTI,
 871		.array_type	= NO_ARRAY,
 872		.tlv_type	= QMI_COMMON_TLV_TYPE,
 873	},
 874};
 875
 876static const struct qmi_elem_info qmi_wlanfw_fw_version_info_s_v01_ei[] = {
 877	{
 878		.data_type	= QMI_UNSIGNED_4_BYTE,
 879		.elem_len	= 1,
 880		.elem_size	= sizeof(u32),
 881		.array_type	= NO_ARRAY,
 882		.tlv_type	= 0,
 883		.offset		= offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
 884					   fw_version),
 885	},
 886	{
 887		.data_type	= QMI_STRING,
 888		.elem_len	= ATH11K_QMI_WLANFW_MAX_TIMESTAMP_LEN_V01 + 1,
 889		.elem_size	= sizeof(char),
 890		.array_type	= NO_ARRAY,
 891		.tlv_type	= 0,
 892		.offset		= offsetof(struct qmi_wlanfw_fw_version_info_s_v01,
 893					   fw_build_timestamp),
 894	},
 895	{
 896		.data_type	= QMI_EOTI,
 897		.array_type	= NO_ARRAY,
 898		.tlv_type	= QMI_COMMON_TLV_TYPE,
 899	},
 900};
 901
 902static const struct qmi_elem_info qmi_wlanfw_cap_resp_msg_v01_ei[] = {
 903	{
 904		.data_type	= QMI_STRUCT,
 905		.elem_len	= 1,
 906		.elem_size	= sizeof(struct qmi_response_type_v01),
 907		.array_type	= NO_ARRAY,
 908		.tlv_type	= 0x02,
 909		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01, resp),
 910		.ei_array	= qmi_response_type_v01_ei,
 911	},
 912	{
 913		.data_type	= QMI_OPT_FLAG,
 914		.elem_len	= 1,
 915		.elem_size	= sizeof(u8),
 916		.array_type	= NO_ARRAY,
 917		.tlv_type	= 0x10,
 918		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 919					   chip_info_valid),
 920	},
 921	{
 922		.data_type	= QMI_STRUCT,
 923		.elem_len	= 1,
 924		.elem_size	= sizeof(struct qmi_wlanfw_rf_chip_info_s_v01),
 925		.array_type	= NO_ARRAY,
 926		.tlv_type	= 0x10,
 927		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 928					   chip_info),
 929		.ei_array	= qmi_wlanfw_rf_chip_info_s_v01_ei,
 930	},
 931	{
 932		.data_type	= QMI_OPT_FLAG,
 933		.elem_len	= 1,
 934		.elem_size	= sizeof(u8),
 935		.array_type	= NO_ARRAY,
 936		.tlv_type	= 0x11,
 937		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 938					   board_info_valid),
 939	},
 940	{
 941		.data_type	= QMI_STRUCT,
 942		.elem_len	= 1,
 943		.elem_size	= sizeof(struct qmi_wlanfw_rf_board_info_s_v01),
 944		.array_type	= NO_ARRAY,
 945		.tlv_type	= 0x11,
 946		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 947					   board_info),
 948		.ei_array	= qmi_wlanfw_rf_board_info_s_v01_ei,
 949	},
 950	{
 951		.data_type	= QMI_OPT_FLAG,
 952		.elem_len	= 1,
 953		.elem_size	= sizeof(u8),
 954		.array_type	= NO_ARRAY,
 955		.tlv_type	= 0x12,
 956		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 957					   soc_info_valid),
 958	},
 959	{
 960		.data_type	= QMI_STRUCT,
 961		.elem_len	= 1,
 962		.elem_size	= sizeof(struct qmi_wlanfw_soc_info_s_v01),
 963		.array_type	= NO_ARRAY,
 964		.tlv_type	= 0x12,
 965		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 966					   soc_info),
 967		.ei_array	= qmi_wlanfw_soc_info_s_v01_ei,
 968	},
 969	{
 970		.data_type	= QMI_OPT_FLAG,
 971		.elem_len	= 1,
 972		.elem_size	= sizeof(u8),
 973		.array_type	= NO_ARRAY,
 974		.tlv_type	= 0x13,
 975		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 976					   fw_version_info_valid),
 977	},
 978	{
 979		.data_type	= QMI_STRUCT,
 980		.elem_len	= 1,
 981		.elem_size	= sizeof(struct qmi_wlanfw_fw_version_info_s_v01),
 982		.array_type	= NO_ARRAY,
 983		.tlv_type	= 0x13,
 984		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 985					   fw_version_info),
 986		.ei_array	= qmi_wlanfw_fw_version_info_s_v01_ei,
 987	},
 988	{
 989		.data_type	= QMI_OPT_FLAG,
 990		.elem_len	= 1,
 991		.elem_size	= sizeof(u8),
 992		.array_type	= NO_ARRAY,
 993		.tlv_type	= 0x14,
 994		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
 995					   fw_build_id_valid),
 996	},
 997	{
 998		.data_type	= QMI_STRING,
 999		.elem_len	= ATH11K_QMI_WLANFW_MAX_BUILD_ID_LEN_V01 + 1,
1000		.elem_size	= sizeof(char),
1001		.array_type	= NO_ARRAY,
1002		.tlv_type	= 0x14,
1003		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1004					   fw_build_id),
1005	},
1006	{
1007		.data_type	= QMI_OPT_FLAG,
1008		.elem_len	= 1,
1009		.elem_size	= sizeof(u8),
1010		.array_type	= NO_ARRAY,
1011		.tlv_type	= 0x15,
1012		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1013					   num_macs_valid),
1014	},
1015	{
1016		.data_type	= QMI_UNSIGNED_1_BYTE,
1017		.elem_len	= 1,
1018		.elem_size	= sizeof(u8),
1019		.array_type	= NO_ARRAY,
1020		.tlv_type	= 0x15,
1021		.offset		= offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1022					   num_macs),
1023	},
1024	{
1025		.data_type      = QMI_OPT_FLAG,
1026		.elem_len       = 1,
1027		.elem_size      = sizeof(u8),
1028		.array_type     = NO_ARRAY,
1029		.tlv_type       = 0x16,
1030		.offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1031					   voltage_mv_valid),
1032	},
1033	{
1034		.data_type      = QMI_UNSIGNED_4_BYTE,
1035		.elem_len       = 1,
1036		.elem_size      = sizeof(u32),
1037		.array_type     = NO_ARRAY,
1038		.tlv_type       = 0x16,
1039		.offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1040					   voltage_mv),
1041	},
1042	{
1043		.data_type      = QMI_OPT_FLAG,
1044		.elem_len       = 1,
1045		.elem_size      = sizeof(u8),
1046		.array_type     = NO_ARRAY,
1047		.tlv_type       = 0x17,
1048		.offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1049					   time_freq_hz_valid),
1050	},
1051	{
1052		.data_type      = QMI_UNSIGNED_4_BYTE,
1053		.elem_len       = 1,
1054		.elem_size      = sizeof(u32),
1055		.array_type     = NO_ARRAY,
1056		.tlv_type       = 0x17,
1057		.offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1058					   time_freq_hz),
1059	},
1060	{
1061		.data_type      = QMI_OPT_FLAG,
1062		.elem_len       = 1,
1063		.elem_size      = sizeof(u8),
1064		.array_type     = NO_ARRAY,
1065		.tlv_type       = 0x18,
1066		.offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1067					   otp_version_valid),
1068	},
1069	{
1070		.data_type      = QMI_UNSIGNED_4_BYTE,
1071		.elem_len       = 1,
1072		.elem_size      = sizeof(u32),
1073		.array_type     = NO_ARRAY,
1074		.tlv_type       = 0x18,
1075		.offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1076					   otp_version),
1077	},
1078	{
1079		.data_type      = QMI_OPT_FLAG,
1080		.elem_len       = 1,
1081		.elem_size      = sizeof(u8),
1082		.array_type     = NO_ARRAY,
1083		.tlv_type       = 0x19,
1084		.offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1085					   eeprom_read_timeout_valid),
1086	},
1087	{
1088		.data_type      = QMI_UNSIGNED_4_BYTE,
1089		.elem_len       = 1,
1090		.elem_size      = sizeof(u32),
1091		.array_type     = NO_ARRAY,
1092		.tlv_type       = 0x19,
1093		.offset         = offsetof(struct qmi_wlanfw_cap_resp_msg_v01,
1094					   eeprom_read_timeout),
1095	},
1096	{
1097		.data_type	= QMI_EOTI,
1098		.array_type	= NO_ARRAY,
1099		.tlv_type	= QMI_COMMON_TLV_TYPE,
1100	},
1101};
1102
1103static const struct qmi_elem_info qmi_wlanfw_bdf_download_req_msg_v01_ei[] = {
1104	{
1105		.data_type	= QMI_UNSIGNED_1_BYTE,
1106		.elem_len	= 1,
1107		.elem_size	= sizeof(u8),
1108		.array_type	= NO_ARRAY,
1109		.tlv_type	= 0x01,
1110		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1111					   valid),
1112	},
1113	{
1114		.data_type	= QMI_OPT_FLAG,
1115		.elem_len	= 1,
1116		.elem_size	= sizeof(u8),
1117		.array_type	= NO_ARRAY,
1118		.tlv_type	= 0x10,
1119		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1120					   file_id_valid),
1121	},
1122	{
1123		.data_type	= QMI_SIGNED_4_BYTE_ENUM,
1124		.elem_len	= 1,
1125		.elem_size	= sizeof(enum qmi_wlanfw_cal_temp_id_enum_v01),
1126		.array_type	= NO_ARRAY,
1127		.tlv_type	= 0x10,
1128		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1129					   file_id),
1130	},
1131	{
1132		.data_type	= QMI_OPT_FLAG,
1133		.elem_len	= 1,
1134		.elem_size	= sizeof(u8),
1135		.array_type	= NO_ARRAY,
1136		.tlv_type	= 0x11,
1137		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1138					   total_size_valid),
1139	},
1140	{
1141		.data_type	= QMI_UNSIGNED_4_BYTE,
1142		.elem_len	= 1,
1143		.elem_size	= sizeof(u32),
1144		.array_type	= NO_ARRAY,
1145		.tlv_type	= 0x11,
1146		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1147					   total_size),
1148	},
1149	{
1150		.data_type	= QMI_OPT_FLAG,
1151		.elem_len	= 1,
1152		.elem_size	= sizeof(u8),
1153		.array_type	= NO_ARRAY,
1154		.tlv_type	= 0x12,
1155		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1156					   seg_id_valid),
1157	},
1158	{
1159		.data_type	= QMI_UNSIGNED_4_BYTE,
1160		.elem_len	= 1,
1161		.elem_size	= sizeof(u32),
1162		.array_type	= NO_ARRAY,
1163		.tlv_type	= 0x12,
1164		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1165					   seg_id),
1166	},
1167	{
1168		.data_type	= QMI_OPT_FLAG,
1169		.elem_len	= 1,
1170		.elem_size	= sizeof(u8),
1171		.array_type	= NO_ARRAY,
1172		.tlv_type	= 0x13,
1173		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1174					   data_valid),
1175	},
1176	{
1177		.data_type	= QMI_DATA_LEN,
1178		.elem_len	= 1,
1179		.elem_size	= sizeof(u16),
1180		.array_type	= NO_ARRAY,
1181		.tlv_type	= 0x13,
1182		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1183					   data_len),
1184	},
1185	{
1186		.data_type	= QMI_UNSIGNED_1_BYTE,
1187		.elem_len	= QMI_WLANFW_MAX_DATA_SIZE_V01,
1188		.elem_size	= sizeof(u8),
1189		.array_type	= VAR_LEN_ARRAY,
1190		.tlv_type	= 0x13,
1191		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1192					   data),
1193	},
1194	{
1195		.data_type	= QMI_OPT_FLAG,
1196		.elem_len	= 1,
1197		.elem_size	= sizeof(u8),
1198		.array_type	= NO_ARRAY,
1199		.tlv_type	= 0x14,
1200		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1201					   end_valid),
1202	},
1203	{
1204		.data_type	= QMI_UNSIGNED_1_BYTE,
1205		.elem_len	= 1,
1206		.elem_size	= sizeof(u8),
1207		.array_type	= NO_ARRAY,
1208		.tlv_type	= 0x14,
1209		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1210					   end),
1211	},
1212	{
1213		.data_type	= QMI_OPT_FLAG,
1214		.elem_len	= 1,
1215		.elem_size	= sizeof(u8),
1216		.array_type	= NO_ARRAY,
1217		.tlv_type	= 0x15,
1218		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1219					   bdf_type_valid),
1220	},
1221	{
1222		.data_type	= QMI_UNSIGNED_1_BYTE,
1223		.elem_len	= 1,
1224		.elem_size	= sizeof(u8),
1225		.array_type	= NO_ARRAY,
1226		.tlv_type	= 0x15,
1227		.offset		= offsetof(struct qmi_wlanfw_bdf_download_req_msg_v01,
1228					   bdf_type),
1229	},
1230
1231	{
1232		.data_type	= QMI_EOTI,
1233		.array_type	= NO_ARRAY,
1234		.tlv_type	= QMI_COMMON_TLV_TYPE,
1235	},
1236};
1237
1238static const struct qmi_elem_info qmi_wlanfw_bdf_download_resp_msg_v01_ei[] = {
1239	{
1240		.data_type	= QMI_STRUCT,
1241		.elem_len	= 1,
1242		.elem_size	= sizeof(struct qmi_response_type_v01),
1243		.array_type	= NO_ARRAY,
1244		.tlv_type	= 0x02,
1245		.offset		= offsetof(struct qmi_wlanfw_bdf_download_resp_msg_v01,
1246					   resp),
1247		.ei_array	= qmi_response_type_v01_ei,
1248	},
1249	{
1250		.data_type	= QMI_EOTI,
1251		.array_type	= NO_ARRAY,
1252		.tlv_type	= QMI_COMMON_TLV_TYPE,
1253	},
1254};
1255
1256static const struct qmi_elem_info qmi_wlanfw_m3_info_req_msg_v01_ei[] = {
1257	{
1258		.data_type	= QMI_UNSIGNED_8_BYTE,
1259		.elem_len	= 1,
1260		.elem_size	= sizeof(u64),
1261		.array_type	= NO_ARRAY,
1262		.tlv_type	= 0x01,
1263		.offset		= offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, addr),
1264	},
1265	{
1266		.data_type	= QMI_UNSIGNED_4_BYTE,
1267		.elem_len	= 1,
1268		.elem_size	= sizeof(u32),
1269		.array_type	= NO_ARRAY,
1270		.tlv_type	= 0x02,
1271		.offset		= offsetof(struct qmi_wlanfw_m3_info_req_msg_v01, size),
1272	},
1273	{
1274		.data_type	= QMI_EOTI,
1275		.array_type	= NO_ARRAY,
1276		.tlv_type	= QMI_COMMON_TLV_TYPE,
1277	},
1278};
1279
1280static const struct qmi_elem_info qmi_wlanfw_m3_info_resp_msg_v01_ei[] = {
1281	{
1282		.data_type	= QMI_STRUCT,
1283		.elem_len	= 1,
1284		.elem_size	= sizeof(struct qmi_response_type_v01),
1285		.array_type	= NO_ARRAY,
1286		.tlv_type	= 0x02,
1287		.offset		= offsetof(struct qmi_wlanfw_m3_info_resp_msg_v01, resp),
1288		.ei_array	= qmi_response_type_v01_ei,
1289	},
1290	{
1291		.data_type	= QMI_EOTI,
1292		.array_type	= NO_ARRAY,
1293		.tlv_type	= QMI_COMMON_TLV_TYPE,
1294	},
1295};
1296
1297static const struct qmi_elem_info qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei[] = {
1298	{
1299		.data_type	= QMI_UNSIGNED_4_BYTE,
1300		.elem_len	= 1,
1301		.elem_size	= sizeof(u32),
1302		.array_type	= NO_ARRAY,
1303		.tlv_type	= 0,
1304		.offset		= offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1305					   pipe_num),
1306	},
1307	{
1308		.data_type	= QMI_SIGNED_4_BYTE_ENUM,
1309		.elem_len	= 1,
1310		.elem_size	= sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1311		.array_type	= NO_ARRAY,
1312		.tlv_type	= 0,
1313		.offset		= offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1314					   pipe_dir),
1315	},
1316	{
1317		.data_type	= QMI_UNSIGNED_4_BYTE,
1318		.elem_len	= 1,
1319		.elem_size	= sizeof(u32),
1320		.array_type	= NO_ARRAY,
1321		.tlv_type	= 0,
1322		.offset		= offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1323					   nentries),
1324	},
1325	{
1326		.data_type	= QMI_UNSIGNED_4_BYTE,
1327		.elem_len	= 1,
1328		.elem_size	= sizeof(u32),
1329		.array_type	= NO_ARRAY,
1330		.tlv_type	= 0,
1331		.offset		= offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1332					   nbytes_max),
1333	},
1334	{
1335		.data_type	= QMI_UNSIGNED_4_BYTE,
1336		.elem_len	= 1,
1337		.elem_size	= sizeof(u32),
1338		.array_type	= NO_ARRAY,
1339		.tlv_type	= 0,
1340		.offset		= offsetof(struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01,
1341					   flags),
1342	},
1343	{
1344		.data_type	= QMI_EOTI,
1345		.array_type	= NO_ARRAY,
1346		.tlv_type	= QMI_COMMON_TLV_TYPE,
1347	},
1348};
1349
1350static const struct qmi_elem_info qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei[] = {
1351	{
1352		.data_type	= QMI_UNSIGNED_4_BYTE,
1353		.elem_len	= 1,
1354		.elem_size	= sizeof(u32),
1355		.array_type	= NO_ARRAY,
1356		.tlv_type	= 0,
1357		.offset		= offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1358					   service_id),
1359	},
1360	{
1361		.data_type	= QMI_SIGNED_4_BYTE_ENUM,
1362		.elem_len	= 1,
1363		.elem_size	= sizeof(enum qmi_wlanfw_pipedir_enum_v01),
1364		.array_type	= NO_ARRAY,
1365		.tlv_type	= 0,
1366		.offset		= offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1367					   pipe_dir),
1368	},
1369	{
1370		.data_type	= QMI_UNSIGNED_4_BYTE,
1371		.elem_len	= 1,
1372		.elem_size	= sizeof(u32),
1373		.array_type	= NO_ARRAY,
1374		.tlv_type	= 0,
1375		.offset		= offsetof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01,
1376					   pipe_num),
1377	},
1378	{
1379		.data_type	= QMI_EOTI,
1380		.array_type	= NO_ARRAY,
1381		.tlv_type	= QMI_COMMON_TLV_TYPE,
1382	},
1383};
1384
1385static const struct qmi_elem_info qmi_wlanfw_shadow_reg_cfg_s_v01_ei[] = {
1386	{
1387		.data_type	= QMI_UNSIGNED_2_BYTE,
1388		.elem_len	= 1,
1389		.elem_size	= sizeof(u16),
1390		.array_type	= NO_ARRAY,
1391		.tlv_type	= 0,
1392		.offset		= offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01, id),
1393	},
1394	{
1395		.data_type	= QMI_UNSIGNED_2_BYTE,
1396		.elem_len	= 1,
1397		.elem_size	= sizeof(u16),
1398		.array_type	= NO_ARRAY,
1399		.tlv_type	= 0,
1400		.offset		= offsetof(struct qmi_wlanfw_shadow_reg_cfg_s_v01,
1401					   offset),
1402	},
1403	{
1404		.data_type	= QMI_EOTI,
1405		.array_type	= QMI_COMMON_TLV_TYPE,
1406	},
1407};
1408
1409static const struct qmi_elem_info qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei[] = {
1410	{
1411		.data_type	= QMI_UNSIGNED_4_BYTE,
1412		.elem_len	= 1,
1413		.elem_size	= sizeof(u32),
1414		.array_type	= NO_ARRAY,
1415		.tlv_type	= 0,
1416		.offset		= offsetof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01,
1417					   addr),
1418	},
1419	{
1420		.data_type	= QMI_EOTI,
1421		.array_type	= NO_ARRAY,
1422		.tlv_type	= QMI_COMMON_TLV_TYPE,
1423	},
1424};
1425
1426static const struct qmi_elem_info qmi_wlanfw_wlan_mode_req_msg_v01_ei[] = {
1427	{
1428		.data_type	= QMI_UNSIGNED_4_BYTE,
1429		.elem_len	= 1,
1430		.elem_size	= sizeof(u32),
1431		.array_type	= NO_ARRAY,
1432		.tlv_type	= 0x01,
1433		.offset		= offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1434					   mode),
1435	},
1436	{
1437		.data_type	= QMI_OPT_FLAG,
1438		.elem_len	= 1,
1439		.elem_size	= sizeof(u8),
1440		.array_type	= NO_ARRAY,
1441		.tlv_type	= 0x10,
1442		.offset		= offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1443					   hw_debug_valid),
1444	},
1445	{
1446		.data_type	= QMI_UNSIGNED_1_BYTE,
1447		.elem_len	= 1,
1448		.elem_size	= sizeof(u8),
1449		.array_type	= NO_ARRAY,
1450		.tlv_type	= 0x10,
1451		.offset		= offsetof(struct qmi_wlanfw_wlan_mode_req_msg_v01,
1452					   hw_debug),
1453	},
1454	{
1455		.data_type	= QMI_EOTI,
1456		.array_type	= NO_ARRAY,
1457		.tlv_type	= QMI_COMMON_TLV_TYPE,
1458	},
1459};
1460
1461static const struct qmi_elem_info qmi_wlanfw_wlan_mode_resp_msg_v01_ei[] = {
1462	{
1463		.data_type	= QMI_STRUCT,
1464		.elem_len	= 1,
1465		.elem_size	= sizeof(struct qmi_response_type_v01),
1466		.array_type	= NO_ARRAY,
1467		.tlv_type	= 0x02,
1468		.offset		= offsetof(struct qmi_wlanfw_wlan_mode_resp_msg_v01,
1469					   resp),
1470		.ei_array	= qmi_response_type_v01_ei,
1471	},
1472	{
1473		.data_type	= QMI_EOTI,
1474		.array_type	= NO_ARRAY,
1475		.tlv_type	= QMI_COMMON_TLV_TYPE,
1476	},
1477};
1478
1479static const struct qmi_elem_info qmi_wlanfw_wlan_cfg_req_msg_v01_ei[] = {
1480	{
1481		.data_type	= QMI_OPT_FLAG,
1482		.elem_len	= 1,
1483		.elem_size	= sizeof(u8),
1484		.array_type	= NO_ARRAY,
1485		.tlv_type	= 0x10,
1486		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1487					   host_version_valid),
1488	},
1489	{
1490		.data_type	= QMI_STRING,
1491		.elem_len	= QMI_WLANFW_MAX_STR_LEN_V01 + 1,
1492		.elem_size	= sizeof(char),
1493		.array_type	= NO_ARRAY,
1494		.tlv_type	= 0x10,
1495		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1496					   host_version),
1497	},
1498	{
1499		.data_type	= QMI_OPT_FLAG,
1500		.elem_len	= 1,
1501		.elem_size	= sizeof(u8),
1502		.array_type	= NO_ARRAY,
1503		.tlv_type	= 0x11,
1504		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1505					   tgt_cfg_valid),
1506	},
1507	{
1508		.data_type	= QMI_DATA_LEN,
1509		.elem_len	= 1,
1510		.elem_size	= sizeof(u8),
1511		.array_type	= NO_ARRAY,
1512		.tlv_type	= 0x11,
1513		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1514					   tgt_cfg_len),
1515	},
1516	{
1517		.data_type	= QMI_STRUCT,
1518		.elem_len	= QMI_WLANFW_MAX_NUM_CE_V01,
1519		.elem_size	= sizeof(
1520				struct qmi_wlanfw_ce_tgt_pipe_cfg_s_v01),
1521		.array_type	= VAR_LEN_ARRAY,
1522		.tlv_type	= 0x11,
1523		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1524					   tgt_cfg),
1525		.ei_array	= qmi_wlanfw_ce_tgt_pipe_cfg_s_v01_ei,
1526	},
1527	{
1528		.data_type	= QMI_OPT_FLAG,
1529		.elem_len	= 1,
1530		.elem_size	= sizeof(u8),
1531		.array_type	= NO_ARRAY,
1532		.tlv_type	= 0x12,
1533		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1534					   svc_cfg_valid),
1535	},
1536	{
1537		.data_type	= QMI_DATA_LEN,
1538		.elem_len	= 1,
1539		.elem_size	= sizeof(u8),
1540		.array_type	= NO_ARRAY,
1541		.tlv_type	= 0x12,
1542		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1543					   svc_cfg_len),
1544	},
1545	{
1546		.data_type	= QMI_STRUCT,
1547		.elem_len	= QMI_WLANFW_MAX_NUM_SVC_V01,
1548		.elem_size	= sizeof(struct qmi_wlanfw_ce_svc_pipe_cfg_s_v01),
1549		.array_type	= VAR_LEN_ARRAY,
1550		.tlv_type	= 0x12,
1551		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1552					   svc_cfg),
1553		.ei_array	= qmi_wlanfw_ce_svc_pipe_cfg_s_v01_ei,
1554	},
1555	{
1556		.data_type	= QMI_OPT_FLAG,
1557		.elem_len	= 1,
1558		.elem_size	= sizeof(u8),
1559		.array_type	= NO_ARRAY,
1560		.tlv_type	= 0x13,
1561		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1562					   shadow_reg_valid),
1563	},
1564	{
1565		.data_type	= QMI_DATA_LEN,
1566		.elem_len	= 1,
1567		.elem_size	= sizeof(u8),
1568		.array_type	= NO_ARRAY,
1569		.tlv_type	= 0x13,
1570		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1571					   shadow_reg_len),
1572	},
1573	{
1574		.data_type	= QMI_STRUCT,
1575		.elem_len	= QMI_WLANFW_MAX_NUM_SHADOW_REG_V01,
1576		.elem_size	= sizeof(struct qmi_wlanfw_shadow_reg_cfg_s_v01),
1577		.array_type	= VAR_LEN_ARRAY,
1578		.tlv_type	= 0x13,
1579		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1580					   shadow_reg),
1581		.ei_array	= qmi_wlanfw_shadow_reg_cfg_s_v01_ei,
1582	},
1583	{
1584		.data_type	= QMI_OPT_FLAG,
1585		.elem_len	= 1,
1586		.elem_size	= sizeof(u8),
1587		.array_type	= NO_ARRAY,
1588		.tlv_type	= 0x14,
1589		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1590					   shadow_reg_v2_valid),
1591	},
1592	{
1593		.data_type	= QMI_DATA_LEN,
1594		.elem_len	= 1,
1595		.elem_size	= sizeof(u8),
1596		.array_type	= NO_ARRAY,
1597		.tlv_type	= 0x14,
1598		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1599					   shadow_reg_v2_len),
1600	},
1601	{
1602		.data_type	= QMI_STRUCT,
1603		.elem_len	= QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01,
1604		.elem_size	= sizeof(struct qmi_wlanfw_shadow_reg_v2_cfg_s_v01),
1605		.array_type	= VAR_LEN_ARRAY,
1606		.tlv_type	= 0x14,
1607		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_req_msg_v01,
1608					   shadow_reg_v2),
1609		.ei_array	= qmi_wlanfw_shadow_reg_v2_cfg_s_v01_ei,
1610	},
1611	{
1612		.data_type	= QMI_EOTI,
1613		.array_type	= NO_ARRAY,
1614		.tlv_type	= QMI_COMMON_TLV_TYPE,
1615	},
1616};
1617
1618static const struct qmi_elem_info qmi_wlanfw_wlan_cfg_resp_msg_v01_ei[] = {
1619	{
1620		.data_type	= QMI_STRUCT,
1621		.elem_len	= 1,
1622		.elem_size	= sizeof(struct qmi_response_type_v01),
1623		.array_type	= NO_ARRAY,
1624		.tlv_type	= 0x02,
1625		.offset		= offsetof(struct qmi_wlanfw_wlan_cfg_resp_msg_v01, resp),
1626		.ei_array	= qmi_response_type_v01_ei,
1627	},
1628	{
1629		.data_type	= QMI_EOTI,
1630		.array_type	= NO_ARRAY,
1631		.tlv_type	= QMI_COMMON_TLV_TYPE,
1632	},
1633};
1634
1635static const struct qmi_elem_info qmi_wlanfw_mem_ready_ind_msg_v01_ei[] = {
1636	{
1637		.data_type = QMI_EOTI,
1638		.array_type = NO_ARRAY,
1639	},
1640};
1641
1642static const struct qmi_elem_info qmi_wlanfw_fw_ready_ind_msg_v01_ei[] = {
1643	{
1644		.data_type = QMI_EOTI,
1645		.array_type = NO_ARRAY,
1646	},
1647};
1648
1649static const struct qmi_elem_info qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei[] = {
1650	{
1651		.data_type = QMI_EOTI,
1652		.array_type = NO_ARRAY,
1653	},
1654};
1655
1656static const struct qmi_elem_info qmi_wlanfw_wlan_ini_req_msg_v01_ei[] = {
1657	{
1658		.data_type	= QMI_OPT_FLAG,
1659		.elem_len	= 1,
1660		.elem_size	= sizeof(u8),
1661		.array_type	= NO_ARRAY,
1662		.tlv_type	= 0x10,
1663		.offset		= offsetof(struct qmi_wlanfw_wlan_ini_req_msg_v01,
1664					   enablefwlog_valid),
1665	},
1666	{
1667		.data_type	= QMI_UNSIGNED_1_BYTE,
1668		.elem_len	= 1,
1669		.elem_size	= sizeof(u8),
1670		.array_type	= NO_ARRAY,
1671		.tlv_type	= 0x10,
1672		.offset		= offsetof(struct qmi_wlanfw_wlan_ini_req_msg_v01,
1673					   enablefwlog),
1674	},
1675	{
1676		.data_type	= QMI_EOTI,
1677		.array_type	= NO_ARRAY,
1678		.tlv_type	= QMI_COMMON_TLV_TYPE,
1679	},
1680};
1681
1682static const struct qmi_elem_info qmi_wlanfw_wlan_ini_resp_msg_v01_ei[] = {
1683	{
1684		.data_type	= QMI_STRUCT,
1685		.elem_len	= 1,
1686		.elem_size	= sizeof(struct qmi_response_type_v01),
1687		.array_type	= NO_ARRAY,
1688		.tlv_type	= 0x02,
1689		.offset		= offsetof(struct qmi_wlanfw_wlan_ini_resp_msg_v01,
1690					   resp),
1691		.ei_array	= qmi_response_type_v01_ei,
1692	},
1693	{
1694		.data_type	= QMI_EOTI,
1695		.array_type	= NO_ARRAY,
1696		.tlv_type	= QMI_COMMON_TLV_TYPE,
1697	},
1698};
1699
1700static const struct qmi_elem_info qmi_wlfw_fw_init_done_ind_msg_v01_ei[] = {
1701	{
1702		.data_type = QMI_EOTI,
1703		.array_type = NO_ARRAY,
1704	},
1705};
1706
1707static int ath11k_qmi_host_cap_send(struct ath11k_base *ab)
1708{
1709	struct qmi_wlanfw_host_cap_req_msg_v01 req;
1710	struct qmi_wlanfw_host_cap_resp_msg_v01 resp;
1711	struct qmi_txn txn;
1712	int ret = 0;
1713
1714	memset(&req, 0, sizeof(req));
1715	memset(&resp, 0, sizeof(resp));
1716
1717	req.num_clients_valid = 1;
1718	req.num_clients = 1;
1719	req.mem_cfg_mode = ab->qmi.target_mem_mode;
1720	req.mem_cfg_mode_valid = 1;
1721	req.bdf_support_valid = 1;
1722	req.bdf_support = 1;
1723
1724	if (ab->hw_params.m3_fw_support) {
1725		req.m3_support_valid = 1;
1726		req.m3_support = 1;
1727		req.m3_cache_support_valid = 1;
1728		req.m3_cache_support = 1;
1729	} else {
1730		req.m3_support_valid = 0;
1731		req.m3_support = 0;
1732		req.m3_cache_support_valid = 0;
1733		req.m3_cache_support = 0;
1734	}
1735
1736	req.cal_done_valid = 1;
1737	req.cal_done = ab->qmi.cal_done;
1738
1739	if (ab->hw_params.internal_sleep_clock) {
1740		req.nm_modem_valid = 1;
1741
1742		/* Notify firmware that this is non-qualcomm platform. */
1743		req.nm_modem |= HOST_CSTATE_BIT;
1744
1745		/* Notify firmware about the sleep clock selection,
1746		 * nm_modem_bit[1] is used for this purpose. Host driver on
1747		 * non-qualcomm platforms should select internal sleep
1748		 * clock.
1749		 */
1750		req.nm_modem |= SLEEP_CLOCK_SELECT_INTERNAL_BIT;
1751	}
1752
1753	if (ab->hw_params.global_reset)
1754		req.nm_modem |= PLATFORM_CAP_PCIE_GLOBAL_RESET;
1755
1756	req.nm_modem |= PLATFORM_CAP_PCIE_PME_D3COLD;
1757
1758	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi host cap request\n");
1759
1760	ret = qmi_txn_init(&ab->qmi.handle, &txn,
1761			   qmi_wlanfw_host_cap_resp_msg_v01_ei, &resp);
1762	if (ret < 0)
1763		goto out;
1764
1765	ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1766			       QMI_WLANFW_HOST_CAP_REQ_V01,
1767			       QMI_WLANFW_HOST_CAP_REQ_MSG_V01_MAX_LEN,
1768			       qmi_wlanfw_host_cap_req_msg_v01_ei, &req);
1769	if (ret < 0) {
1770		qmi_txn_cancel(&txn);
1771		ath11k_warn(ab, "failed to send host capability request: %d\n", ret);
1772		goto out;
1773	}
1774
1775	ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1776	if (ret < 0)
1777		goto out;
1778
1779	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1780		ath11k_warn(ab, "host capability request failed: %d %d\n",
1781			    resp.resp.result, resp.resp.error);
1782		ret = -EINVAL;
1783		goto out;
1784	}
1785
1786out:
1787	return ret;
1788}
1789
1790static int ath11k_qmi_fw_ind_register_send(struct ath11k_base *ab)
1791{
1792	struct qmi_wlanfw_ind_register_req_msg_v01 *req;
1793	struct qmi_wlanfw_ind_register_resp_msg_v01 *resp;
1794	struct qmi_handle *handle = &ab->qmi.handle;
1795	struct qmi_txn txn;
1796	int ret;
1797
1798	req = kzalloc(sizeof(*req), GFP_KERNEL);
1799	if (!req)
1800		return -ENOMEM;
1801
1802	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
1803	if (!resp) {
1804		ret = -ENOMEM;
1805		goto resp_out;
1806	}
1807
1808	req->client_id_valid = 1;
1809	req->client_id = QMI_WLANFW_CLIENT_ID;
1810	req->fw_ready_enable_valid = 1;
1811	req->fw_ready_enable = 1;
1812	req->cal_done_enable_valid = 1;
1813	req->cal_done_enable = 1;
1814	req->fw_init_done_enable_valid = 1;
1815	req->fw_init_done_enable = 1;
1816
1817	req->pin_connect_result_enable_valid = 0;
1818	req->pin_connect_result_enable = 0;
1819
1820	/* WCN6750 doesn't request for DDR memory via QMI,
1821	 * instead it uses a fixed 12MB reserved memory
1822	 * region in DDR.
1823	 */
1824	if (!ab->hw_params.fixed_fw_mem) {
1825		req->request_mem_enable_valid = 1;
1826		req->request_mem_enable = 1;
1827		req->fw_mem_ready_enable_valid = 1;
1828		req->fw_mem_ready_enable = 1;
1829	}
1830
1831	ret = qmi_txn_init(handle, &txn,
1832			   qmi_wlanfw_ind_register_resp_msg_v01_ei, resp);
1833	if (ret < 0)
1834		goto out;
1835
1836	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi indication register request\n");
1837
1838	ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1839			       QMI_WLANFW_IND_REGISTER_REQ_V01,
1840			       QMI_WLANFW_IND_REGISTER_REQ_MSG_V01_MAX_LEN,
1841			       qmi_wlanfw_ind_register_req_msg_v01_ei, req);
1842	if (ret < 0) {
1843		qmi_txn_cancel(&txn);
1844		ath11k_warn(ab, "failed to send indication register request: %d\n",
1845			    ret);
1846		goto out;
1847	}
1848
1849	ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1850	if (ret < 0) {
1851		ath11k_warn(ab, "failed to register fw indication: %d\n", ret);
1852		goto out;
1853	}
1854
1855	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
1856		ath11k_warn(ab, "firmware indication register request failed: %d %d\n",
1857			    resp->resp.result, resp->resp.error);
1858		ret = -EINVAL;
1859		goto out;
1860	}
1861
1862out:
1863	kfree(resp);
1864resp_out:
1865	kfree(req);
1866	return ret;
1867}
1868
1869static int ath11k_qmi_respond_fw_mem_request(struct ath11k_base *ab)
1870{
1871	struct qmi_wlanfw_respond_mem_req_msg_v01 *req;
1872	struct qmi_wlanfw_respond_mem_resp_msg_v01 resp;
1873	struct qmi_txn txn;
1874	int ret = 0, i;
1875	bool delayed;
1876
1877	req = kzalloc(sizeof(*req), GFP_KERNEL);
1878	if (!req)
1879		return -ENOMEM;
1880
1881	memset(&resp, 0, sizeof(resp));
1882
1883	/* For QCA6390 by default FW requests a block of ~4M contiguous
1884	 * DMA memory, it's hard to allocate from OS. So host returns
1885	 * failure to FW and FW will then request multiple blocks of small
1886	 * chunk size memory.
1887	 */
1888	if (!(ab->hw_params.fixed_mem_region ||
1889	      test_bit(ATH11K_FLAG_FIXED_MEM_RGN, &ab->dev_flags)) &&
1890	      ab->qmi.target_mem_delayed) {
1891		delayed = true;
1892		ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi delays mem_request %d\n",
1893			   ab->qmi.mem_seg_count);
1894		memset(req, 0, sizeof(*req));
1895	} else {
1896		delayed = false;
1897		req->mem_seg_len = ab->qmi.mem_seg_count;
1898
1899		for (i = 0; i < req->mem_seg_len ; i++) {
1900			req->mem_seg[i].addr = ab->qmi.target_mem[i].paddr;
1901			req->mem_seg[i].size = ab->qmi.target_mem[i].size;
1902			req->mem_seg[i].type = ab->qmi.target_mem[i].type;
1903			ath11k_dbg(ab, ATH11K_DBG_QMI,
1904				   "qmi req mem_seg[%d] %pad %u %u\n", i,
1905				    &ab->qmi.target_mem[i].paddr,
1906				    ab->qmi.target_mem[i].size,
1907				    ab->qmi.target_mem[i].type);
1908		}
1909	}
1910
1911	ret = qmi_txn_init(&ab->qmi.handle, &txn,
1912			   qmi_wlanfw_respond_mem_resp_msg_v01_ei, &resp);
1913	if (ret < 0)
1914		goto out;
1915
1916	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi respond memory request delayed %i\n",
1917		   delayed);
1918
1919	ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
1920			       QMI_WLANFW_RESPOND_MEM_REQ_V01,
1921			       QMI_WLANFW_RESPOND_MEM_REQ_MSG_V01_MAX_LEN,
1922			       qmi_wlanfw_respond_mem_req_msg_v01_ei, req);
1923	if (ret < 0) {
1924		qmi_txn_cancel(&txn);
1925		ath11k_warn(ab, "failed to respond qmi memory request: %d\n",
1926			    ret);
1927		goto out;
1928	}
1929
1930	ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
1931	if (ret < 0) {
1932		ath11k_warn(ab, "failed to wait qmi memory request: %d\n", ret);
1933		goto out;
1934	}
1935
1936	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
1937		/* the error response is expected when
1938		 * target_mem_delayed is true.
1939		 */
1940		if (delayed && resp.resp.error == 0)
1941			goto out;
1942
1943		ath11k_warn(ab, "qmi respond memory request failed: %d %d\n",
1944			    resp.resp.result, resp.resp.error);
1945		ret = -EINVAL;
1946		goto out;
1947	}
1948out:
1949	kfree(req);
1950	return ret;
1951}
1952
1953static void ath11k_qmi_free_target_mem_chunk(struct ath11k_base *ab)
1954{
1955	int i;
1956
1957	for (i = 0; i < ab->qmi.mem_seg_count; i++) {
1958		if ((ab->hw_params.fixed_mem_region ||
1959		     test_bit(ATH11K_FLAG_FIXED_MEM_RGN, &ab->dev_flags)) &&
1960		     ab->qmi.target_mem[i].iaddr)
1961			iounmap(ab->qmi.target_mem[i].iaddr);
1962
1963		if (!ab->qmi.target_mem[i].vaddr)
1964			continue;
1965
1966		dma_free_coherent(ab->dev,
1967				  ab->qmi.target_mem[i].prev_size,
1968				  ab->qmi.target_mem[i].vaddr,
1969				  ab->qmi.target_mem[i].paddr);
1970		ab->qmi.target_mem[i].vaddr = NULL;
1971	}
1972}
1973
1974static int ath11k_qmi_alloc_target_mem_chunk(struct ath11k_base *ab)
1975{
1976	int i;
1977	struct target_mem_chunk *chunk;
1978
1979	ab->qmi.target_mem_delayed = false;
1980
1981	for (i = 0; i < ab->qmi.mem_seg_count; i++) {
1982		chunk = &ab->qmi.target_mem[i];
1983
1984		/* Firmware reloads in coldboot/firmware recovery.
1985		 * in such case, no need to allocate memory for FW again.
1986		 */
1987		if (chunk->vaddr) {
1988			if (chunk->prev_type == chunk->type &&
1989			    chunk->prev_size == chunk->size)
1990				continue;
1991
1992			/* cannot reuse the existing chunk */
1993			dma_free_coherent(ab->dev, chunk->prev_size,
1994					  chunk->vaddr, chunk->paddr);
1995			chunk->vaddr = NULL;
1996		}
1997
1998		chunk->vaddr = dma_alloc_coherent(ab->dev,
1999						  chunk->size,
2000						  &chunk->paddr,
2001						  GFP_KERNEL | __GFP_NOWARN);
2002		if (!chunk->vaddr) {
2003			if (ab->qmi.mem_seg_count <= ATH11K_QMI_FW_MEM_REQ_SEGMENT_CNT) {
2004				ath11k_dbg(ab, ATH11K_DBG_QMI,
2005					   "qmi dma allocation failed (%d B type %u), will try later with small size\n",
2006					    chunk->size,
2007					    chunk->type);
2008				ath11k_qmi_free_target_mem_chunk(ab);
2009				ab->qmi.target_mem_delayed = true;
2010				return 0;
2011			}
2012
2013			ath11k_err(ab, "failed to allocate dma memory for qmi (%d B type %u)\n",
2014				   chunk->size,
2015				   chunk->type);
2016			return -EINVAL;
2017		}
2018		chunk->prev_type = chunk->type;
2019		chunk->prev_size = chunk->size;
2020	}
2021
2022	return 0;
2023}
2024
2025static int ath11k_qmi_assign_target_mem_chunk(struct ath11k_base *ab)
2026{
2027	struct device *dev = ab->dev;
2028	struct device_node *hremote_node = NULL;
2029	struct resource res;
2030	u32 host_ddr_sz;
2031	int i, idx, ret;
2032
2033	for (i = 0, idx = 0; i < ab->qmi.mem_seg_count; i++) {
2034		switch (ab->qmi.target_mem[i].type) {
2035		case HOST_DDR_REGION_TYPE:
2036			hremote_node = of_parse_phandle(dev->of_node, "memory-region", 0);
2037			if (!hremote_node) {
2038				ath11k_dbg(ab, ATH11K_DBG_QMI,
2039					   "qmi fail to get hremote_node\n");
2040				return -ENODEV;
2041			}
2042
2043			ret = of_address_to_resource(hremote_node, 0, &res);
2044			of_node_put(hremote_node);
2045			if (ret) {
2046				ath11k_dbg(ab, ATH11K_DBG_QMI,
2047					   "qmi fail to get reg from hremote\n");
2048				return ret;
2049			}
2050
2051			if (res.end - res.start + 1 < ab->qmi.target_mem[i].size) {
2052				ath11k_dbg(ab, ATH11K_DBG_QMI,
2053					   "qmi fail to assign memory of sz\n");
2054				return -EINVAL;
2055			}
2056
2057			ab->qmi.target_mem[idx].paddr = res.start;
2058			ab->qmi.target_mem[idx].iaddr =
2059				ioremap(ab->qmi.target_mem[idx].paddr,
2060					ab->qmi.target_mem[i].size);
2061			ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
2062			host_ddr_sz = ab->qmi.target_mem[i].size;
2063			ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
2064			idx++;
2065			break;
2066		case BDF_MEM_REGION_TYPE:
2067			ab->qmi.target_mem[idx].paddr = ab->hw_params.bdf_addr;
2068			ab->qmi.target_mem[idx].vaddr = NULL;
2069			ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
2070			ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
2071			idx++;
2072			break;
2073		case CALDB_MEM_REGION_TYPE:
2074			if (ab->qmi.target_mem[i].size > ATH11K_QMI_CALDB_SIZE) {
2075				ath11k_warn(ab, "qmi mem size is low to load caldata\n");
2076				return -EINVAL;
2077			}
2078
2079			if (ath11k_cold_boot_cal && ab->hw_params.cold_boot_calib) {
2080				if (hremote_node) {
2081					ab->qmi.target_mem[idx].paddr =
2082							res.start + host_ddr_sz;
2083					ab->qmi.target_mem[idx].iaddr =
2084						ioremap(ab->qmi.target_mem[idx].paddr,
2085							ab->qmi.target_mem[i].size);
2086				} else {
2087					ab->qmi.target_mem[idx].paddr =
2088						ATH11K_QMI_CALDB_ADDRESS;
2089				}
2090			} else {
2091				ab->qmi.target_mem[idx].paddr = 0;
2092				ab->qmi.target_mem[idx].vaddr = NULL;
2093			}
2094			ab->qmi.target_mem[idx].size = ab->qmi.target_mem[i].size;
2095			ab->qmi.target_mem[idx].type = ab->qmi.target_mem[i].type;
2096			idx++;
2097			break;
2098		default:
2099			ath11k_warn(ab, "qmi ignore invalid mem req type %d\n",
2100				    ab->qmi.target_mem[i].type);
2101			break;
2102		}
2103	}
2104	ab->qmi.mem_seg_count = idx;
2105
2106	return 0;
2107}
2108
2109static int ath11k_qmi_request_device_info(struct ath11k_base *ab)
2110{
2111	struct qmi_wlanfw_device_info_req_msg_v01 req = {};
2112	struct qmi_wlanfw_device_info_resp_msg_v01 resp = {};
2113	struct qmi_txn txn;
2114	void __iomem *bar_addr_va;
2115	int ret;
2116
2117	/* device info message req is only sent for hybrid bus devices */
2118	if (!ab->hw_params.hybrid_bus_type)
2119		return 0;
2120
2121	ret = qmi_txn_init(&ab->qmi.handle, &txn,
2122			   qmi_wlfw_device_info_resp_msg_v01_ei, &resp);
2123	if (ret < 0)
2124		goto out;
2125
2126	ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2127			       QMI_WLANFW_DEVICE_INFO_REQ_V01,
2128			       QMI_WLANFW_DEVICE_INFO_REQ_MSG_V01_MAX_LEN,
2129			       qmi_wlanfw_device_info_req_msg_v01_ei, &req);
2130	if (ret < 0) {
2131		qmi_txn_cancel(&txn);
2132		ath11k_warn(ab, "failed to send qmi target device info request: %d\n",
2133			    ret);
2134		goto out;
2135	}
2136
2137	ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2138	if (ret < 0) {
2139		ath11k_warn(ab, "failed to wait qmi target device info request: %d\n",
2140			    ret);
2141		goto out;
2142	}
2143
2144	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2145		ath11k_warn(ab, "qmi device info request failed: %d %d\n",
2146			    resp.resp.result, resp.resp.error);
2147		ret = -EINVAL;
2148		goto out;
2149	}
2150
2151	if (!resp.bar_addr_valid || !resp.bar_size_valid) {
2152		ath11k_warn(ab, "qmi device info response invalid: %d %d\n",
2153			    resp.resp.result, resp.resp.error);
2154		ret = -EINVAL;
2155		goto out;
2156	}
2157
2158	if (!resp.bar_addr ||
2159	    resp.bar_size != ATH11K_QMI_DEVICE_BAR_SIZE) {
2160		ath11k_warn(ab, "qmi device info invalid address and size: %llu %u\n",
2161			    resp.bar_addr, resp.bar_size);
2162		ret = -EINVAL;
2163		goto out;
2164	}
2165
2166	bar_addr_va = devm_ioremap(ab->dev, resp.bar_addr, resp.bar_size);
2167
2168	if (!bar_addr_va) {
2169		ath11k_warn(ab, "qmi device info ioremap failed\n");
2170		ab->mem_len = 0;
2171		ret = -EIO;
2172		goto out;
2173	}
2174
2175	ab->mem = bar_addr_va;
2176	ab->mem_len = resp.bar_size;
2177
2178	return 0;
2179out:
2180	return ret;
2181}
2182
2183static int ath11k_qmi_request_target_cap(struct ath11k_base *ab)
2184{
2185	struct qmi_wlanfw_cap_req_msg_v01 req;
2186	struct qmi_wlanfw_cap_resp_msg_v01 resp;
2187	struct qmi_txn txn;
2188	int ret = 0;
2189	int r;
2190	char *fw_build_id;
2191	int fw_build_id_mask_len;
2192
2193	memset(&req, 0, sizeof(req));
2194	memset(&resp, 0, sizeof(resp));
2195
2196	ret = qmi_txn_init(&ab->qmi.handle, &txn, qmi_wlanfw_cap_resp_msg_v01_ei,
2197			   &resp);
2198	if (ret < 0)
2199		goto out;
2200
2201	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi target cap request\n");
2202
2203	ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2204			       QMI_WLANFW_CAP_REQ_V01,
2205			       QMI_WLANFW_CAP_REQ_MSG_V01_MAX_LEN,
2206			       qmi_wlanfw_cap_req_msg_v01_ei, &req);
2207	if (ret < 0) {
2208		qmi_txn_cancel(&txn);
2209		ath11k_warn(ab, "failed to send qmi cap request: %d\n",
2210			    ret);
2211		goto out;
2212	}
2213
2214	ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2215	if (ret < 0) {
2216		ath11k_warn(ab, "failed to wait qmi cap request: %d\n", ret);
2217		goto out;
2218	}
2219
2220	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2221		ath11k_warn(ab, "qmi cap request failed: %d %d\n",
2222			    resp.resp.result, resp.resp.error);
2223		ret = -EINVAL;
2224		goto out;
2225	}
2226
2227	if (resp.chip_info_valid) {
2228		ab->qmi.target.chip_id = resp.chip_info.chip_id;
2229		ab->qmi.target.chip_family = resp.chip_info.chip_family;
2230	}
2231
2232	if (resp.board_info_valid)
2233		ab->qmi.target.board_id = resp.board_info.board_id;
2234	else
2235		ab->qmi.target.board_id = 0xFF;
2236
2237	if (resp.soc_info_valid)
2238		ab->qmi.target.soc_id = resp.soc_info.soc_id;
2239
2240	if (resp.fw_version_info_valid) {
2241		ab->qmi.target.fw_version = resp.fw_version_info.fw_version;
2242		strscpy(ab->qmi.target.fw_build_timestamp,
2243			resp.fw_version_info.fw_build_timestamp,
2244			sizeof(ab->qmi.target.fw_build_timestamp));
2245	}
2246
2247	if (resp.fw_build_id_valid)
2248		strscpy(ab->qmi.target.fw_build_id, resp.fw_build_id,
2249			sizeof(ab->qmi.target.fw_build_id));
2250
2251	if (resp.eeprom_read_timeout_valid) {
2252		ab->qmi.target.eeprom_caldata =
2253					resp.eeprom_read_timeout;
2254		ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi cal data supported from eeprom\n");
2255	}
2256
2257	fw_build_id = ab->qmi.target.fw_build_id;
2258	fw_build_id_mask_len = strlen(FW_BUILD_ID_MASK);
2259	if (!strncmp(fw_build_id, FW_BUILD_ID_MASK, fw_build_id_mask_len))
2260		fw_build_id = fw_build_id + fw_build_id_mask_len;
2261
2262	ath11k_info(ab, "chip_id 0x%x chip_family 0x%x board_id 0x%x soc_id 0x%x\n",
2263		    ab->qmi.target.chip_id, ab->qmi.target.chip_family,
2264		    ab->qmi.target.board_id, ab->qmi.target.soc_id);
2265
2266	ath11k_info(ab, "fw_version 0x%x fw_build_timestamp %s fw_build_id %s",
2267		    ab->qmi.target.fw_version,
2268		    ab->qmi.target.fw_build_timestamp,
2269		    fw_build_id);
2270
2271	r = ath11k_core_check_smbios(ab);
2272	if (r)
2273		ath11k_dbg(ab, ATH11K_DBG_QMI, "SMBIOS bdf variant name not set.\n");
2274
2275	r = ath11k_core_check_dt(ab);
2276	if (r)
2277		ath11k_dbg(ab, ATH11K_DBG_QMI, "DT bdf variant name not set.\n");
2278
2279out:
2280	return ret;
2281}
2282
2283static int ath11k_qmi_load_file_target_mem(struct ath11k_base *ab,
2284					   const u8 *data, u32 len, u8 type)
2285{
2286	struct qmi_wlanfw_bdf_download_req_msg_v01 *req;
2287	struct qmi_wlanfw_bdf_download_resp_msg_v01 resp;
2288	struct qmi_txn txn;
2289	const u8 *temp = data;
2290	void __iomem *bdf_addr = NULL;
2291	int ret;
2292	u32 remaining = len;
2293
2294	req = kzalloc(sizeof(*req), GFP_KERNEL);
2295	if (!req)
2296		return -ENOMEM;
2297
2298	memset(&resp, 0, sizeof(resp));
2299
2300	if (ab->hw_params.fixed_bdf_addr) {
2301		bdf_addr = ioremap(ab->hw_params.bdf_addr, ab->hw_params.fw.board_size);
2302		if (!bdf_addr) {
2303			ath11k_warn(ab, "qmi ioremap error for bdf_addr\n");
2304			ret = -EIO;
2305			goto err_free_req;
2306		}
2307	}
2308
2309	while (remaining) {
2310		req->valid = 1;
2311		req->file_id_valid = 1;
2312		req->file_id = ab->qmi.target.board_id;
2313		req->total_size_valid = 1;
2314		req->total_size = remaining;
2315		req->seg_id_valid = 1;
2316		req->data_valid = 1;
2317		req->bdf_type = type;
2318		req->bdf_type_valid = 1;
2319		req->end_valid = 1;
2320		req->end = 0;
2321
2322		if (remaining > QMI_WLANFW_MAX_DATA_SIZE_V01) {
2323			req->data_len = QMI_WLANFW_MAX_DATA_SIZE_V01;
2324		} else {
2325			req->data_len = remaining;
2326			req->end = 1;
2327		}
2328
2329		if (ab->hw_params.fixed_bdf_addr ||
2330		    type == ATH11K_QMI_FILE_TYPE_EEPROM) {
2331			req->data_valid = 0;
2332			req->end = 1;
2333			req->data_len = ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE;
2334		} else {
2335			memcpy(req->data, temp, req->data_len);
2336		}
2337
2338		if (ab->hw_params.fixed_bdf_addr) {
2339			if (type == ATH11K_QMI_FILE_TYPE_CALDATA)
2340				bdf_addr += ab->hw_params.fw.cal_offset;
2341
2342			memcpy_toio(bdf_addr, temp, len);
2343		}
2344
2345		ret = qmi_txn_init(&ab->qmi.handle, &txn,
2346				   qmi_wlanfw_bdf_download_resp_msg_v01_ei,
2347				   &resp);
2348		if (ret < 0)
2349			goto err_iounmap;
2350
2351		ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi bdf download req fixed addr type %d\n",
2352			   type);
2353
2354		ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2355				       QMI_WLANFW_BDF_DOWNLOAD_REQ_V01,
2356				       QMI_WLANFW_BDF_DOWNLOAD_REQ_MSG_V01_MAX_LEN,
2357				       qmi_wlanfw_bdf_download_req_msg_v01_ei, req);
2358		if (ret < 0) {
2359			qmi_txn_cancel(&txn);
2360			goto err_iounmap;
2361		}
2362
2363		ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2364		if (ret < 0) {
2365			ath11k_warn(ab, "failed to wait board file download request: %d\n",
2366				    ret);
2367			goto err_iounmap;
2368		}
2369
2370		if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2371			ath11k_warn(ab, "board file download request failed: %d %d\n",
2372				    resp.resp.result, resp.resp.error);
2373			ret = -EINVAL;
2374			goto err_iounmap;
2375		}
2376
2377		if (ab->hw_params.fixed_bdf_addr ||
2378		    type == ATH11K_QMI_FILE_TYPE_EEPROM) {
2379			remaining = 0;
2380		} else {
2381			remaining -= req->data_len;
2382			temp += req->data_len;
2383			req->seg_id++;
2384			ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi bdf download request remaining %i\n",
2385				   remaining);
2386		}
2387	}
2388
2389err_iounmap:
2390	if (ab->hw_params.fixed_bdf_addr)
2391		iounmap(bdf_addr);
2392
2393err_free_req:
2394	kfree(req);
2395
2396	return ret;
2397}
2398
2399static int ath11k_qmi_load_bdf_qmi(struct ath11k_base *ab,
2400				   bool regdb)
2401{
2402	struct device *dev = ab->dev;
2403	char filename[ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE];
2404	const struct firmware *fw_entry;
2405	struct ath11k_board_data bd;
2406	u32 fw_size, file_type;
2407	int ret = 0, bdf_type;
2408	const u8 *tmp;
2409
2410	memset(&bd, 0, sizeof(bd));
2411
2412	if (regdb) {
2413		ret = ath11k_core_fetch_regdb(ab, &bd);
2414	} else {
2415		ret = ath11k_core_fetch_bdf(ab, &bd);
2416		if (ret)
2417			ath11k_warn(ab, "qmi failed to fetch board file: %d\n", ret);
2418	}
2419
2420	if (ret)
2421		goto out;
2422
2423	if (regdb)
2424		bdf_type = ATH11K_QMI_BDF_TYPE_REGDB;
2425	else if (bd.len >= SELFMAG && memcmp(bd.data, ELFMAG, SELFMAG) == 0)
2426		bdf_type = ATH11K_QMI_BDF_TYPE_ELF;
2427	else
2428		bdf_type = ATH11K_QMI_BDF_TYPE_BIN;
2429
2430	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi bdf_type %d\n", bdf_type);
2431
2432	fw_size = min_t(u32, ab->hw_params.fw.board_size, bd.len);
2433
2434	ret = ath11k_qmi_load_file_target_mem(ab, bd.data, fw_size, bdf_type);
2435	if (ret < 0) {
2436		ath11k_warn(ab, "qmi failed to load bdf file\n");
2437		goto out;
2438	}
2439
2440	/* QCA6390/WCN6855 does not support cal data, skip it */
2441	if (bdf_type == ATH11K_QMI_BDF_TYPE_ELF || bdf_type == ATH11K_QMI_BDF_TYPE_REGDB)
2442		goto out;
2443
2444	if (ab->qmi.target.eeprom_caldata) {
2445		file_type = ATH11K_QMI_FILE_TYPE_EEPROM;
2446		tmp = filename;
2447		fw_size = ATH11K_QMI_MAX_BDF_FILE_NAME_SIZE;
2448	} else {
2449		file_type = ATH11K_QMI_FILE_TYPE_CALDATA;
2450
2451		/* cal-<bus>-<id>.bin */
2452		snprintf(filename, sizeof(filename), "cal-%s-%s.bin",
2453			 ath11k_bus_str(ab->hif.bus), dev_name(dev));
2454		fw_entry = ath11k_core_firmware_request(ab, filename);
2455		if (!IS_ERR(fw_entry))
2456			goto success;
2457
2458		fw_entry = ath11k_core_firmware_request(ab, ATH11K_DEFAULT_CAL_FILE);
2459		if (IS_ERR(fw_entry)) {
2460			ret = PTR_ERR(fw_entry);
2461			ath11k_warn(ab,
2462				    "qmi failed to load CAL data file:%s\n",
2463				    filename);
2464			goto out;
2465		}
2466success:
2467		fw_size = min_t(u32, ab->hw_params.fw.board_size, fw_entry->size);
2468		tmp = fw_entry->data;
2469	}
2470
2471	ret = ath11k_qmi_load_file_target_mem(ab, tmp, fw_size, file_type);
2472	if (ret < 0) {
2473		ath11k_warn(ab, "qmi failed to load caldata\n");
2474		goto out_qmi_cal;
2475	}
2476
2477	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi caldata type: %u\n", file_type);
2478
2479out_qmi_cal:
2480	if (!ab->qmi.target.eeprom_caldata)
2481		release_firmware(fw_entry);
2482out:
2483	ath11k_core_free_bdf(ab, &bd);
2484	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi BDF download sequence completed\n");
2485
2486	return ret;
2487}
2488
2489static int ath11k_qmi_m3_load(struct ath11k_base *ab)
2490{
2491	struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2492	const struct firmware *fw;
2493	char path[100];
2494	int ret;
2495
2496	fw = ath11k_core_firmware_request(ab, ATH11K_M3_FILE);
2497	if (IS_ERR(fw)) {
2498		ret = PTR_ERR(fw);
2499		ath11k_core_create_firmware_path(ab, ATH11K_M3_FILE,
2500						 path, sizeof(path));
2501		ath11k_err(ab, "failed to load %s: %d\n", path, ret);
2502		return ret;
2503	}
2504
2505	if (m3_mem->vaddr || m3_mem->size)
2506		goto skip_m3_alloc;
2507
2508	m3_mem->vaddr = dma_alloc_coherent(ab->dev,
2509					   fw->size, &m3_mem->paddr,
2510					   GFP_KERNEL);
2511	if (!m3_mem->vaddr) {
2512		ath11k_err(ab, "failed to allocate memory for M3 with size %zu\n",
2513			   fw->size);
2514		release_firmware(fw);
2515		return -ENOMEM;
2516	}
2517
2518skip_m3_alloc:
2519	memcpy(m3_mem->vaddr, fw->data, fw->size);
2520	m3_mem->size = fw->size;
2521	release_firmware(fw);
2522
2523	return 0;
2524}
2525
2526static void ath11k_qmi_m3_free(struct ath11k_base *ab)
2527{
2528	struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2529
2530	if (!ab->hw_params.m3_fw_support || !m3_mem->vaddr)
2531		return;
2532
2533	dma_free_coherent(ab->dev, m3_mem->size,
2534			  m3_mem->vaddr, m3_mem->paddr);
2535	m3_mem->vaddr = NULL;
2536	m3_mem->size = 0;
2537}
2538
2539static int ath11k_qmi_wlanfw_m3_info_send(struct ath11k_base *ab)
2540{
2541	struct m3_mem_region *m3_mem = &ab->qmi.m3_mem;
2542	struct qmi_wlanfw_m3_info_req_msg_v01 req;
2543	struct qmi_wlanfw_m3_info_resp_msg_v01 resp;
2544	struct qmi_txn txn;
2545	int ret = 0;
2546
2547	memset(&req, 0, sizeof(req));
2548	memset(&resp, 0, sizeof(resp));
2549
2550	if (ab->hw_params.m3_fw_support) {
2551		ret = ath11k_qmi_m3_load(ab);
2552		if (ret) {
2553			ath11k_err(ab, "failed to load m3 firmware: %d", ret);
2554			return ret;
2555		}
2556
2557		req.addr = m3_mem->paddr;
2558		req.size = m3_mem->size;
2559	} else {
2560		req.addr = 0;
2561		req.size = 0;
2562	}
2563
2564	ret = qmi_txn_init(&ab->qmi.handle, &txn,
2565			   qmi_wlanfw_m3_info_resp_msg_v01_ei, &resp);
2566	if (ret < 0)
2567		goto out;
2568
2569	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi m3 info req\n");
2570
2571	ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2572			       QMI_WLANFW_M3_INFO_REQ_V01,
2573			       QMI_WLANFW_M3_INFO_REQ_MSG_V01_MAX_MSG_LEN,
2574			       qmi_wlanfw_m3_info_req_msg_v01_ei, &req);
2575	if (ret < 0) {
2576		qmi_txn_cancel(&txn);
2577		ath11k_warn(ab, "failed to send m3 information request: %d\n",
2578			    ret);
2579		goto out;
2580	}
2581
2582	ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2583	if (ret < 0) {
2584		ath11k_warn(ab, "failed to wait m3 information request: %d\n", ret);
2585		goto out;
2586	}
2587
2588	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2589		ath11k_warn(ab, "m3 info request failed: %d %d\n",
2590			    resp.resp.result, resp.resp.error);
2591		ret = -EINVAL;
2592		goto out;
2593	}
2594out:
2595	return ret;
2596}
2597
2598static int ath11k_qmi_wlanfw_mode_send(struct ath11k_base *ab,
2599				       u32 mode)
2600{
2601	struct qmi_wlanfw_wlan_mode_req_msg_v01 req;
2602	struct qmi_wlanfw_wlan_mode_resp_msg_v01 resp;
2603	struct qmi_txn txn;
2604	int ret = 0;
2605
2606	memset(&req, 0, sizeof(req));
2607	memset(&resp, 0, sizeof(resp));
2608
2609	req.mode = mode;
2610	req.hw_debug_valid = 1;
2611	req.hw_debug = 0;
2612
2613	ret = qmi_txn_init(&ab->qmi.handle, &txn,
2614			   qmi_wlanfw_wlan_mode_resp_msg_v01_ei, &resp);
2615	if (ret < 0)
2616		goto out;
2617
2618	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wlan mode req mode %d\n", mode);
2619
2620	ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2621			       QMI_WLANFW_WLAN_MODE_REQ_V01,
2622			       QMI_WLANFW_WLAN_MODE_REQ_MSG_V01_MAX_LEN,
2623			       qmi_wlanfw_wlan_mode_req_msg_v01_ei, &req);
2624	if (ret < 0) {
2625		qmi_txn_cancel(&txn);
2626		ath11k_warn(ab, "failed to send wlan mode request (mode %d): %d\n",
2627			    mode, ret);
2628		goto out;
2629	}
2630
2631	ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2632	if (ret < 0) {
2633		if (mode == ATH11K_FIRMWARE_MODE_OFF && ret == -ENETRESET) {
2634			ath11k_warn(ab, "WLFW service is dis-connected\n");
2635			return 0;
2636		}
2637		ath11k_warn(ab, "failed to wait wlan mode request (mode %d): %d\n",
2638			    mode, ret);
2639		goto out;
2640	}
2641
2642	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2643		ath11k_warn(ab, "wlan mode request failed (mode: %d): %d %d\n",
2644			    mode, resp.resp.result, resp.resp.error);
2645		ret = -EINVAL;
2646		goto out;
2647	}
2648
2649out:
2650	return ret;
2651}
2652
2653static int ath11k_qmi_wlanfw_wlan_cfg_send(struct ath11k_base *ab)
2654{
2655	struct qmi_wlanfw_wlan_cfg_req_msg_v01 *req;
2656	struct qmi_wlanfw_wlan_cfg_resp_msg_v01 resp;
2657	struct ce_pipe_config *ce_cfg;
2658	struct service_to_pipe *svc_cfg;
2659	struct qmi_txn txn;
2660	int ret = 0, pipe_num;
2661
2662	ce_cfg	= (struct ce_pipe_config *)ab->qmi.ce_cfg.tgt_ce;
2663	svc_cfg	= (struct service_to_pipe *)ab->qmi.ce_cfg.svc_to_ce_map;
2664
2665	req = kzalloc(sizeof(*req), GFP_KERNEL);
2666	if (!req)
2667		return -ENOMEM;
2668
2669	memset(&resp, 0, sizeof(resp));
2670
2671	req->host_version_valid = 1;
2672	strscpy(req->host_version, ATH11K_HOST_VERSION_STRING,
2673		sizeof(req->host_version));
2674
2675	req->tgt_cfg_valid = 1;
2676	/* This is number of CE configs */
2677	req->tgt_cfg_len = ab->qmi.ce_cfg.tgt_ce_len;
2678	for (pipe_num = 0; pipe_num < req->tgt_cfg_len ; pipe_num++) {
2679		req->tgt_cfg[pipe_num].pipe_num = ce_cfg[pipe_num].pipenum;
2680		req->tgt_cfg[pipe_num].pipe_dir = ce_cfg[pipe_num].pipedir;
2681		req->tgt_cfg[pipe_num].nentries = ce_cfg[pipe_num].nentries;
2682		req->tgt_cfg[pipe_num].nbytes_max = ce_cfg[pipe_num].nbytes_max;
2683		req->tgt_cfg[pipe_num].flags = ce_cfg[pipe_num].flags;
2684	}
2685
2686	req->svc_cfg_valid = 1;
2687	/* This is number of Service/CE configs */
2688	req->svc_cfg_len = ab->qmi.ce_cfg.svc_to_ce_map_len;
2689	for (pipe_num = 0; pipe_num < req->svc_cfg_len; pipe_num++) {
2690		req->svc_cfg[pipe_num].service_id = svc_cfg[pipe_num].service_id;
2691		req->svc_cfg[pipe_num].pipe_dir = svc_cfg[pipe_num].pipedir;
2692		req->svc_cfg[pipe_num].pipe_num = svc_cfg[pipe_num].pipenum;
2693	}
2694	req->shadow_reg_valid = 0;
2695
2696	/* set shadow v2 configuration */
2697	if (ab->hw_params.supports_shadow_regs) {
2698		req->shadow_reg_v2_valid = 1;
2699		req->shadow_reg_v2_len = min_t(u32,
2700					       ab->qmi.ce_cfg.shadow_reg_v2_len,
2701					       QMI_WLANFW_MAX_NUM_SHADOW_REG_V2_V01);
2702		memcpy(&req->shadow_reg_v2, ab->qmi.ce_cfg.shadow_reg_v2,
2703		       sizeof(u32) * req->shadow_reg_v2_len);
2704	} else {
2705		req->shadow_reg_v2_valid = 0;
2706	}
2707
2708	ret = qmi_txn_init(&ab->qmi.handle, &txn,
2709			   qmi_wlanfw_wlan_cfg_resp_msg_v01_ei, &resp);
2710	if (ret < 0)
2711		goto out;
2712
2713	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wlan cfg req\n");
2714
2715	ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2716			       QMI_WLANFW_WLAN_CFG_REQ_V01,
2717			       QMI_WLANFW_WLAN_CFG_REQ_MSG_V01_MAX_LEN,
2718			       qmi_wlanfw_wlan_cfg_req_msg_v01_ei, req);
2719	if (ret < 0) {
2720		qmi_txn_cancel(&txn);
2721		ath11k_warn(ab, "failed to send wlan config request: %d\n",
2722			    ret);
2723		goto out;
2724	}
2725
2726	ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2727	if (ret < 0) {
2728		ath11k_warn(ab, "failed to wait wlan config request: %d\n", ret);
2729		goto out;
2730	}
2731
2732	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2733		ath11k_warn(ab, "wlan config request failed: %d %d\n",
2734			    resp.resp.result, resp.resp.error);
2735		ret = -EINVAL;
2736		goto out;
2737	}
2738
2739out:
2740	kfree(req);
2741	return ret;
2742}
2743
2744static int ath11k_qmi_wlanfw_wlan_ini_send(struct ath11k_base *ab, bool enable)
2745{
2746	int ret;
2747	struct qmi_txn txn;
2748	struct qmi_wlanfw_wlan_ini_req_msg_v01 req = {};
2749	struct qmi_wlanfw_wlan_ini_resp_msg_v01 resp = {};
2750
2751	req.enablefwlog_valid = true;
2752	req.enablefwlog = enable ? 1 : 0;
2753
2754	ret = qmi_txn_init(&ab->qmi.handle, &txn,
2755			   qmi_wlanfw_wlan_ini_resp_msg_v01_ei, &resp);
2756	if (ret < 0)
2757		goto out;
2758
2759	ret = qmi_send_request(&ab->qmi.handle, NULL, &txn,
2760			       QMI_WLANFW_WLAN_INI_REQ_V01,
2761			       QMI_WLANFW_WLAN_INI_REQ_MSG_V01_MAX_LEN,
2762			       qmi_wlanfw_wlan_ini_req_msg_v01_ei, &req);
2763	if (ret < 0) {
2764		ath11k_warn(ab, "qmi failed to send wlan ini request, err = %d\n",
2765			    ret);
2766		qmi_txn_cancel(&txn);
2767		goto out;
2768	}
2769
2770	ret = qmi_txn_wait(&txn, msecs_to_jiffies(ATH11K_QMI_WLANFW_TIMEOUT_MS));
2771	if (ret < 0) {
2772		ath11k_warn(ab, "qmi failed wlan ini request, err = %d\n", ret);
2773		goto out;
2774	}
2775
2776	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
2777		ath11k_warn(ab, "qmi wlan ini request failed, result: %d, err: %d\n",
2778			    resp.resp.result, resp.resp.error);
2779		ret = -EINVAL;
2780	}
2781
2782out:
2783	return ret;
2784}
2785
2786void ath11k_qmi_firmware_stop(struct ath11k_base *ab)
2787{
2788	int ret;
2789
2790	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware stop\n");
2791
2792	ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_OFF);
2793	if (ret < 0) {
2794		ath11k_warn(ab, "qmi failed to send wlan mode off: %d\n", ret);
2795		return;
2796	}
2797}
2798
2799int ath11k_qmi_firmware_start(struct ath11k_base *ab,
2800			      u32 mode)
2801{
2802	int ret;
2803
2804	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware start\n");
2805
2806	if (ab->hw_params.fw_wmi_diag_event) {
2807		ret = ath11k_qmi_wlanfw_wlan_ini_send(ab, true);
2808		if (ret < 0) {
2809			ath11k_warn(ab, "qmi failed to send wlan fw ini:%d\n", ret);
2810			return ret;
2811		}
2812	}
2813
2814	ret = ath11k_qmi_wlanfw_wlan_cfg_send(ab);
2815	if (ret < 0) {
2816		ath11k_warn(ab, "qmi failed to send wlan cfg: %d\n", ret);
2817		return ret;
2818	}
2819
2820	ret = ath11k_qmi_wlanfw_mode_send(ab, mode);
2821	if (ret < 0) {
2822		ath11k_warn(ab, "qmi failed to send wlan fw mode: %d\n", ret);
2823		return ret;
2824	}
2825
2826	return 0;
2827}
2828
2829static int ath11k_qmi_process_coldboot_calibration(struct ath11k_base *ab)
2830{
2831	int timeout;
2832	int ret;
2833
2834	ret = ath11k_qmi_wlanfw_mode_send(ab, ATH11K_FIRMWARE_MODE_COLD_BOOT);
2835	if (ret < 0) {
2836		ath11k_warn(ab, "qmi failed to send wlan fw mode: %d\n", ret);
2837		return ret;
2838	}
2839
2840	ath11k_dbg(ab, ATH11K_DBG_QMI, "Coldboot calibration wait started\n");
2841
2842	timeout = wait_event_timeout(ab->qmi.cold_boot_waitq,
2843				     (ab->qmi.cal_done  == 1),
2844				     ATH11K_COLD_BOOT_FW_RESET_DELAY);
2845	if (timeout <= 0) {
2846		ath11k_warn(ab, "coldboot calibration timed out\n");
2847		return 0;
2848	}
2849
2850	ath11k_dbg(ab, ATH11K_DBG_QMI, "Coldboot calibration done\n");
2851
2852	return 0;
2853}
2854
2855static int
2856ath11k_qmi_driver_event_post(struct ath11k_qmi *qmi,
2857			     enum ath11k_qmi_event_type type,
2858			     void *data)
2859{
2860	struct ath11k_qmi_driver_event *event;
2861
2862	event = kzalloc(sizeof(*event), GFP_ATOMIC);
2863	if (!event)
2864		return -ENOMEM;
2865
2866	event->type = type;
2867	event->data = data;
2868
2869	spin_lock(&qmi->event_lock);
2870	list_add_tail(&event->list, &qmi->event_list);
2871	spin_unlock(&qmi->event_lock);
2872
2873	queue_work(qmi->event_wq, &qmi->event_work);
2874
2875	return 0;
2876}
2877
2878static int ath11k_qmi_event_mem_request(struct ath11k_qmi *qmi)
2879{
2880	struct ath11k_base *ab = qmi->ab;
2881	int ret;
2882
2883	ret = ath11k_qmi_respond_fw_mem_request(ab);
2884	if (ret < 0) {
2885		ath11k_warn(ab, "qmi failed to respond fw mem req: %d\n", ret);
2886		return ret;
2887	}
2888
2889	return ret;
2890}
2891
2892static int ath11k_qmi_event_load_bdf(struct ath11k_qmi *qmi)
2893{
2894	struct ath11k_base *ab = qmi->ab;
2895	int ret;
2896
2897	ret = ath11k_qmi_request_target_cap(ab);
2898	if (ret < 0) {
2899		ath11k_warn(ab, "failed to request qmi target capabilities: %d\n",
2900			    ret);
2901		return ret;
2902	}
2903
2904	ret = ath11k_qmi_request_device_info(ab);
2905	if (ret < 0) {
2906		ath11k_warn(ab, "failed to request qmi device info: %d\n", ret);
2907		return ret;
2908	}
2909
2910	if (ab->hw_params.supports_regdb)
2911		ath11k_qmi_load_bdf_qmi(ab, true);
2912
2913	ret = ath11k_qmi_load_bdf_qmi(ab, false);
2914	if (ret < 0) {
2915		ath11k_warn(ab, "failed to load board data file: %d\n", ret);
2916		return ret;
2917	}
2918
2919	return 0;
2920}
2921
2922static int ath11k_qmi_event_server_arrive(struct ath11k_qmi *qmi)
2923{
2924	struct ath11k_base *ab = qmi->ab;
2925	int ret;
2926
2927	ret = ath11k_qmi_fw_ind_register_send(ab);
2928	if (ret < 0) {
2929		ath11k_warn(ab, "failed to send qmi firmware indication: %d\n",
2930			    ret);
2931		return ret;
2932	}
2933
2934	ret = ath11k_qmi_host_cap_send(ab);
2935	if (ret < 0) {
2936		ath11k_warn(ab, "failed to send qmi host cap: %d\n", ret);
2937		return ret;
2938	}
2939
2940	if (!ab->hw_params.fixed_fw_mem)
2941		return ret;
2942
2943	ret = ath11k_qmi_event_load_bdf(qmi);
2944	if (ret < 0) {
2945		ath11k_warn(ab, "qmi failed to download BDF:%d\n", ret);
2946		return ret;
2947	}
2948
2949	return ret;
2950}
2951
2952static void ath11k_qmi_msg_mem_request_cb(struct qmi_handle *qmi_hdl,
2953					  struct sockaddr_qrtr *sq,
2954					  struct qmi_txn *txn,
2955					  const void *data)
2956{
2957	struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
2958	struct ath11k_base *ab = qmi->ab;
2959	const struct qmi_wlanfw_request_mem_ind_msg_v01 *msg = data;
2960	int i, ret;
2961
2962	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware request memory request\n");
2963
2964	if (msg->mem_seg_len == 0 ||
2965	    msg->mem_seg_len > ATH11K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01)
2966		ath11k_warn(ab, "invalid memory segment length: %u\n",
2967			    msg->mem_seg_len);
2968
2969	ab->qmi.mem_seg_count = msg->mem_seg_len;
2970
2971	for (i = 0; i < qmi->mem_seg_count ; i++) {
2972		ab->qmi.target_mem[i].type = msg->mem_seg[i].type;
2973		ab->qmi.target_mem[i].size = msg->mem_seg[i].size;
2974		ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi mem seg type %d size %d\n",
2975			   msg->mem_seg[i].type, msg->mem_seg[i].size);
2976	}
2977
2978	if (ab->hw_params.fixed_mem_region ||
2979	    test_bit(ATH11K_FLAG_FIXED_MEM_RGN, &ab->dev_flags)) {
2980		ret = ath11k_qmi_assign_target_mem_chunk(ab);
2981		if (ret) {
2982			ath11k_warn(ab, "failed to assign qmi target memory: %d\n",
2983				    ret);
2984			return;
2985		}
2986	} else {
2987		ret = ath11k_qmi_alloc_target_mem_chunk(ab);
2988		if (ret) {
2989			ath11k_warn(ab, "failed to allocate qmi target memory: %d\n",
2990				    ret);
2991			return;
2992		}
2993	}
2994
2995	ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_REQUEST_MEM, NULL);
2996}
2997
2998static void ath11k_qmi_msg_mem_ready_cb(struct qmi_handle *qmi_hdl,
2999					struct sockaddr_qrtr *sq,
3000					struct qmi_txn *txn,
3001					const void *decoded)
3002{
3003	struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3004	struct ath11k_base *ab = qmi->ab;
3005
3006	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware memory ready indication\n");
3007	ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_MEM_READY, NULL);
3008}
3009
3010static void ath11k_qmi_msg_fw_ready_cb(struct qmi_handle *qmi_hdl,
3011				       struct sockaddr_qrtr *sq,
3012				       struct qmi_txn *txn,
3013				       const void *decoded)
3014{
3015	struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3016	struct ath11k_base *ab = qmi->ab;
3017
3018	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware ready\n");
3019
3020	if (!ab->qmi.cal_done) {
3021		ab->qmi.cal_done = 1;
3022		wake_up(&ab->qmi.cold_boot_waitq);
3023	}
3024
3025	ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_READY, NULL);
3026}
3027
3028static void ath11k_qmi_msg_cold_boot_cal_done_cb(struct qmi_handle *qmi_hdl,
3029						 struct sockaddr_qrtr *sq,
3030						 struct qmi_txn *txn,
3031						 const void *decoded)
3032{
3033	struct ath11k_qmi *qmi = container_of(qmi_hdl,
3034					      struct ath11k_qmi, handle);
3035	struct ath11k_base *ab = qmi->ab;
3036
3037	ab->qmi.cal_done = 1;
3038	wake_up(&ab->qmi.cold_boot_waitq);
3039	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi cold boot calibration done\n");
3040}
3041
3042static void ath11k_qmi_msg_fw_init_done_cb(struct qmi_handle *qmi_hdl,
3043					   struct sockaddr_qrtr *sq,
3044					   struct qmi_txn *txn,
3045					   const void *decoded)
3046{
3047	struct ath11k_qmi *qmi = container_of(qmi_hdl,
3048					      struct ath11k_qmi, handle);
3049	struct ath11k_base *ab = qmi->ab;
3050
3051	ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_FW_INIT_DONE, NULL);
3052	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi firmware init done\n");
3053}
3054
3055static const struct qmi_msg_handler ath11k_qmi_msg_handlers[] = {
3056	{
3057		.type = QMI_INDICATION,
3058		.msg_id = QMI_WLFW_REQUEST_MEM_IND_V01,
3059		.ei = qmi_wlanfw_request_mem_ind_msg_v01_ei,
3060		.decoded_size = sizeof(struct qmi_wlanfw_request_mem_ind_msg_v01),
3061		.fn = ath11k_qmi_msg_mem_request_cb,
3062	},
3063	{
3064		.type = QMI_INDICATION,
3065		.msg_id = QMI_WLFW_FW_MEM_READY_IND_V01,
3066		.ei = qmi_wlanfw_mem_ready_ind_msg_v01_ei,
3067		.decoded_size = sizeof(struct qmi_wlanfw_fw_mem_ready_ind_msg_v01),
3068		.fn = ath11k_qmi_msg_mem_ready_cb,
3069	},
3070	{
3071		.type = QMI_INDICATION,
3072		.msg_id = QMI_WLFW_FW_READY_IND_V01,
3073		.ei = qmi_wlanfw_fw_ready_ind_msg_v01_ei,
3074		.decoded_size = sizeof(struct qmi_wlanfw_fw_ready_ind_msg_v01),
3075		.fn = ath11k_qmi_msg_fw_ready_cb,
3076	},
3077	{
3078		.type = QMI_INDICATION,
3079		.msg_id = QMI_WLFW_COLD_BOOT_CAL_DONE_IND_V01,
3080		.ei = qmi_wlanfw_cold_boot_cal_done_ind_msg_v01_ei,
3081		.decoded_size =
3082			sizeof(struct qmi_wlanfw_fw_cold_cal_done_ind_msg_v01),
3083		.fn = ath11k_qmi_msg_cold_boot_cal_done_cb,
3084	},
3085	{
3086		.type = QMI_INDICATION,
3087		.msg_id = QMI_WLFW_FW_INIT_DONE_IND_V01,
3088		.ei = qmi_wlfw_fw_init_done_ind_msg_v01_ei,
3089		.decoded_size =
3090			sizeof(struct qmi_wlfw_fw_init_done_ind_msg_v01),
3091		.fn = ath11k_qmi_msg_fw_init_done_cb,
3092	},
3093
3094	/* end of list */
3095	{},
3096};
3097
3098static int ath11k_qmi_ops_new_server(struct qmi_handle *qmi_hdl,
3099				     struct qmi_service *service)
3100{
3101	struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3102	struct ath11k_base *ab = qmi->ab;
3103	struct sockaddr_qrtr *sq = &qmi->sq;
3104	int ret;
3105
3106	sq->sq_family = AF_QIPCRTR;
3107	sq->sq_node = service->node;
3108	sq->sq_port = service->port;
3109
3110	ret = kernel_connect(qmi_hdl->sock, (struct sockaddr *)sq,
3111			     sizeof(*sq), 0);
3112	if (ret) {
3113		ath11k_warn(ab, "failed to connect to qmi remote service: %d\n", ret);
3114		return ret;
3115	}
3116
3117	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wifi fw qmi service connected\n");
3118	ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_ARRIVE, NULL);
3119
3120	return ret;
3121}
3122
3123static void ath11k_qmi_ops_del_server(struct qmi_handle *qmi_hdl,
3124				      struct qmi_service *service)
3125{
3126	struct ath11k_qmi *qmi = container_of(qmi_hdl, struct ath11k_qmi, handle);
3127	struct ath11k_base *ab = qmi->ab;
3128
3129	ath11k_dbg(ab, ATH11K_DBG_QMI, "qmi wifi fw del server\n");
3130	ath11k_qmi_driver_event_post(qmi, ATH11K_QMI_EVENT_SERVER_EXIT, NULL);
3131}
3132
3133static const struct qmi_ops ath11k_qmi_ops = {
3134	.new_server = ath11k_qmi_ops_new_server,
3135	.del_server = ath11k_qmi_ops_del_server,
3136};
3137
3138static void ath11k_qmi_driver_event_work(struct work_struct *work)
3139{
3140	struct ath11k_qmi *qmi = container_of(work, struct ath11k_qmi,
3141					      event_work);
3142	struct ath11k_qmi_driver_event *event;
3143	struct ath11k_base *ab = qmi->ab;
3144	int ret;
3145
3146	spin_lock(&qmi->event_lock);
3147	while (!list_empty(&qmi->event_list)) {
3148		event = list_first_entry(&qmi->event_list,
3149					 struct ath11k_qmi_driver_event, list);
3150		list_del(&event->list);
3151		spin_unlock(&qmi->event_lock);
3152
3153		if (test_bit(ATH11K_FLAG_UNREGISTERING, &ab->dev_flags)) {
3154			kfree(event);
3155			return;
3156		}
3157
3158		switch (event->type) {
3159		case ATH11K_QMI_EVENT_SERVER_ARRIVE:
3160			ret = ath11k_qmi_event_server_arrive(qmi);
3161			if (ret < 0)
3162				set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3163			break;
3164		case ATH11K_QMI_EVENT_SERVER_EXIT:
3165			set_bit(ATH11K_FLAG_CRASH_FLUSH, &ab->dev_flags);
3166			set_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
3167
3168			if (!ab->is_reset)
3169				ath11k_core_pre_reconfigure_recovery(ab);
3170			break;
3171		case ATH11K_QMI_EVENT_REQUEST_MEM:
3172			ret = ath11k_qmi_event_mem_request(qmi);
3173			if (ret < 0)
3174				set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3175			break;
3176		case ATH11K_QMI_EVENT_FW_MEM_READY:
3177			ret = ath11k_qmi_event_load_bdf(qmi);
3178			if (ret < 0) {
3179				set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3180				break;
3181			}
3182
3183			ret = ath11k_qmi_wlanfw_m3_info_send(ab);
3184			if (ret < 0) {
3185				ath11k_warn(ab,
3186					    "failed to send qmi m3 info req: %d\n", ret);
3187				set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3188			}
3189
3190			break;
3191		case ATH11K_QMI_EVENT_FW_INIT_DONE:
3192			clear_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3193			if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) {
3194				ath11k_hal_dump_srng_stats(ab);
3195				queue_work(ab->workqueue, &ab->restart_work);
3196				break;
3197			}
3198
3199			if (ath11k_cold_boot_cal && ab->qmi.cal_done == 0 &&
3200			    ab->hw_params.cold_boot_calib) {
3201				ath11k_qmi_process_coldboot_calibration(ab);
3202			} else {
3203				clear_bit(ATH11K_FLAG_CRASH_FLUSH,
3204					  &ab->dev_flags);
3205				clear_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
3206				ret = ath11k_core_qmi_firmware_ready(ab);
3207				if (ret) {
3208					set_bit(ATH11K_FLAG_QMI_FAIL, &ab->dev_flags);
3209					break;
3210				}
3211				set_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags);
3212			}
3213
3214			break;
3215		case ATH11K_QMI_EVENT_FW_READY:
3216			/* For targets requiring a FW restart upon cold
3217			 * boot completion, there is no need to process
3218			 * FW ready; such targets will receive FW init
3219			 * done message after FW restart.
3220			 */
3221			if (ab->hw_params.cbcal_restart_fw)
3222				break;
3223
3224			clear_bit(ATH11K_FLAG_CRASH_FLUSH,
3225				  &ab->dev_flags);
3226			clear_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
3227			ath11k_core_qmi_firmware_ready(ab);
3228			set_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags);
3229
3230			break;
3231		case ATH11K_QMI_EVENT_COLD_BOOT_CAL_DONE:
3232			break;
3233		default:
3234			ath11k_warn(ab, "invalid qmi event type: %d", event->type);
3235			break;
3236		}
3237		kfree(event);
3238		spin_lock(&qmi->event_lock);
3239	}
3240	spin_unlock(&qmi->event_lock);
3241}
3242
3243int ath11k_qmi_init_service(struct ath11k_base *ab)
3244{
3245	int ret;
3246
3247	memset(&ab->qmi.target, 0, sizeof(struct target_info));
3248	memset(&ab->qmi.target_mem, 0, sizeof(struct target_mem_chunk));
3249	ab->qmi.ab = ab;
3250
3251	ab->qmi.target_mem_mode = ab->hw_params.fw_mem_mode;
3252	ret = qmi_handle_init(&ab->qmi.handle, ATH11K_QMI_RESP_LEN_MAX,
3253			      &ath11k_qmi_ops, ath11k_qmi_msg_handlers);
3254	if (ret < 0) {
3255		ath11k_warn(ab, "failed to initialize qmi handle: %d\n", ret);
3256		return ret;
3257	}
3258
3259	ab->qmi.event_wq = alloc_workqueue("ath11k_qmi_driver_event",
3260					   WQ_UNBOUND, 1);
3261	if (!ab->qmi.event_wq) {
3262		ath11k_err(ab, "failed to allocate workqueue\n");
3263		return -EFAULT;
3264	}
3265
3266	INIT_LIST_HEAD(&ab->qmi.event_list);
3267	spin_lock_init(&ab->qmi.event_lock);
3268	INIT_WORK(&ab->qmi.event_work, ath11k_qmi_driver_event_work);
3269
3270	ret = qmi_add_lookup(&ab->qmi.handle, ATH11K_QMI_WLFW_SERVICE_ID_V01,
3271			     ATH11K_QMI_WLFW_SERVICE_VERS_V01,
3272			     ab->qmi.service_ins_id);
3273	if (ret < 0) {
3274		ath11k_warn(ab, "failed to add qmi lookup: %d\n", ret);
3275		destroy_workqueue(ab->qmi.event_wq);
3276		return ret;
3277	}
3278
3279	return ret;
3280}
3281
3282void ath11k_qmi_deinit_service(struct ath11k_base *ab)
3283{
3284	qmi_handle_release(&ab->qmi.handle);
3285	cancel_work_sync(&ab->qmi.event_work);
3286	destroy_workqueue(ab->qmi.event_wq);
3287	ath11k_qmi_m3_free(ab);
3288	ath11k_qmi_free_target_mem_chunk(ab);
3289}
3290EXPORT_SYMBOL(ath11k_qmi_deinit_service);
3291
3292void ath11k_qmi_free_resource(struct ath11k_base *ab)
3293{
3294	ath11k_qmi_free_target_mem_chunk(ab);
3295	ath11k_qmi_m3_free(ab);
3296}