drivers/net/wireless/ath/ath10k/core.c

   1 /*
   2  * Copyright (c) 2005-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/firmware.h>
  20 #include <linux/of.h>
  21 #include <asm/byteorder.h>
  22
  23 #include "core.h"
  24 #include "mac.h"
  25 #include "htc.h"
  26 #include "hif.h"
  27 #include "wmi.h"
  28 #include "bmi.h"
  29 #include "debug.h"
  30 #include "htt.h"
  31 #include "testmode.h"
  32 #include "wmi-ops.h"
  33
  34 unsigned int ath10k_debug_mask;
  35 static unsigned int ath10k_cryptmode_param;
  36 static bool uart_print;
  37 static bool skip_otp;
  38 static bool rawmode;
  39
  40 module_param_named(debug_mask, ath10k_debug_mask, uint, 0644);
  41 module_param_named(cryptmode, ath10k_cryptmode_param, uint, 0644);
  42 module_param(uart_print, bool, 0644);
  43 module_param(skip_otp, bool, 0644);
  44 module_param(rawmode, bool, 0644);
  45
  46 MODULE_PARM_DESC(debug_mask, "Debugging mask");
  47 MODULE_PARM_DESC(uart_print, "Uart target debugging");
  48 MODULE_PARM_DESC(skip_otp, "Skip otp failure for calibration in testmode");
  49 MODULE_PARM_DESC(cryptmode, "Crypto mode: 0-hardware, 1-software");
  50 MODULE_PARM_DESC(rawmode, "Use raw 802.11 frame datapath");
  51
  52 static const struct ath10k_hw_params ath10k_hw_params_list[] = {
  53         {
  54                 .id = QCA988X_HW_2_0_VERSION,
  55                 .dev_id = QCA988X_2_0_DEVICE_ID,
  56                 .name = "qca988x hw2.0",
  57                 .patch_load_addr = QCA988X_HW_2_0_PATCH_LOAD_ADDR,
  58                 .uart_pin = 7,
  59                 .cc_wraparound_type = ATH10K_HW_CC_WRAP_SHIFTED_ALL,
  60                 .otp_exe_param = 0,
  61                 .channel_counters_freq_hz = 88000,
  62                 .max_probe_resp_desc_thres = 0,
  63                 .cal_data_len = 2116,
  64                 .fw = {
  65                         .dir = QCA988X_HW_2_0_FW_DIR,
  66                         .board = QCA988X_HW_2_0_BOARD_DATA_FILE,
  67                         .board_size = QCA988X_BOARD_DATA_SZ,
  68                         .board_ext_size = QCA988X_BOARD_EXT_DATA_SZ,
  69                 },
  70                 .hw_ops = &qca988x_ops,
  71                 .decap_align_bytes = 4,
  72         },
  73         {
  74                 .id = QCA9887_HW_1_0_VERSION,
  75                 .dev_id = QCA9887_1_0_DEVICE_ID,
  76                 .name = "qca9887 hw1.0",
  77                 .patch_load_addr = QCA9887_HW_1_0_PATCH_LOAD_ADDR,
  78                 .uart_pin = 7,
  79                 .cc_wraparound_type = ATH10K_HW_CC_WRAP_SHIFTED_ALL,
  80                 .otp_exe_param = 0,
  81                 .channel_counters_freq_hz = 88000,
  82                 .max_probe_resp_desc_thres = 0,
  83                 .cal_data_len = 2116,
  84                 .fw = {
  85                         .dir = QCA9887_HW_1_0_FW_DIR,
  86                         .board = QCA9887_HW_1_0_BOARD_DATA_FILE,
  87                         .board_size = QCA9887_BOARD_DATA_SZ,
  88                         .board_ext_size = QCA9887_BOARD_EXT_DATA_SZ,
  89                 },
  90                 .hw_ops = &qca988x_ops,
  91                 .decap_align_bytes = 4,
  92         },
  93         {
  94                 .id = QCA6174_HW_2_1_VERSION,
  95                 .dev_id = QCA6164_2_1_DEVICE_ID,
  96                 .name = "qca6164 hw2.1",
  97                 .patch_load_addr = QCA6174_HW_2_1_PATCH_LOAD_ADDR,
  98                 .uart_pin = 6,
  99                 .otp_exe_param = 0,
 100                 .channel_counters_freq_hz = 88000,
 101                 .max_probe_resp_desc_thres = 0,
 102                 .cal_data_len = 8124,
 103                 .fw = {
 104                         .dir = QCA6174_HW_2_1_FW_DIR,
 105                         .board = QCA6174_HW_2_1_BOARD_DATA_FILE,
 106                         .board_size = QCA6174_BOARD_DATA_SZ,
 107                         .board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
 108                 },
 109                 .hw_ops = &qca988x_ops,
 110                 .decap_align_bytes = 4,
 111         },
 112         {
 113                 .id = QCA6174_HW_2_1_VERSION,
 114                 .dev_id = QCA6174_2_1_DEVICE_ID,
 115                 .name = "qca6174 hw2.1",
 116                 .patch_load_addr = QCA6174_HW_2_1_PATCH_LOAD_ADDR,
 117                 .uart_pin = 6,
 118                 .otp_exe_param = 0,
 119                 .channel_counters_freq_hz = 88000,
 120                 .max_probe_resp_desc_thres = 0,
 121                 .cal_data_len = 8124,
 122                 .fw = {
 123                         .dir = QCA6174_HW_2_1_FW_DIR,
 124                         .board = QCA6174_HW_2_1_BOARD_DATA_FILE,
 125                         .board_size = QCA6174_BOARD_DATA_SZ,
 126                         .board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
 127                 },
 128                 .hw_ops = &qca988x_ops,
 129                 .decap_align_bytes = 4,
 130         },
 131         {
 132                 .id = QCA6174_HW_3_0_VERSION,
 133                 .dev_id = QCA6174_2_1_DEVICE_ID,
 134                 .name = "qca6174 hw3.0",
 135                 .patch_load_addr = QCA6174_HW_3_0_PATCH_LOAD_ADDR,
 136                 .uart_pin = 6,
 137                 .otp_exe_param = 0,
 138                 .channel_counters_freq_hz = 88000,
 139                 .max_probe_resp_desc_thres = 0,
 140                 .cal_data_len = 8124,
 141                 .fw = {
 142                         .dir = QCA6174_HW_3_0_FW_DIR,
 143                         .board = QCA6174_HW_3_0_BOARD_DATA_FILE,
 144                         .board_size = QCA6174_BOARD_DATA_SZ,
 145                         .board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
 146                 },
 147                 .hw_ops = &qca988x_ops,
 148                 .decap_align_bytes = 4,
 149         },
 150         {
 151                 .id = QCA6174_HW_3_2_VERSION,
 152                 .dev_id = QCA6174_2_1_DEVICE_ID,
 153                 .name = "qca6174 hw3.2",
 154                 .patch_load_addr = QCA6174_HW_3_0_PATCH_LOAD_ADDR,
 155                 .uart_pin = 6,
 156                 .otp_exe_param = 0,
 157                 .channel_counters_freq_hz = 88000,
 158                 .max_probe_resp_desc_thres = 0,
 159                 .cal_data_len = 8124,
 160                 .fw = {
 161                         /* uses same binaries as hw3.0 */
 162                         .dir = QCA6174_HW_3_0_FW_DIR,
 163                         .board = QCA6174_HW_3_0_BOARD_DATA_FILE,
 164                         .board_size = QCA6174_BOARD_DATA_SZ,
 165                         .board_ext_size = QCA6174_BOARD_EXT_DATA_SZ,
 166                 },
 167                 .hw_ops = &qca988x_ops,
 168                 .decap_align_bytes = 4,
 169         },
 170         {
 171                 .id = QCA99X0_HW_2_0_DEV_VERSION,
 172                 .dev_id = QCA99X0_2_0_DEVICE_ID,
 173                 .name = "qca99x0 hw2.0",
 174                 .patch_load_addr = QCA99X0_HW_2_0_PATCH_LOAD_ADDR,
 175                 .uart_pin = 7,
 176                 .otp_exe_param = 0x00000700,
 177                 .continuous_frag_desc = true,
 178                 .cck_rate_map_rev2 = true,
 179                 .channel_counters_freq_hz = 150000,
 180                 .max_probe_resp_desc_thres = 24,
 181                 .tx_chain_mask = 0xf,
 182                 .rx_chain_mask = 0xf,
 183                 .max_spatial_stream = 4,
 184                 .cal_data_len = 12064,
 185                 .fw = {
 186                         .dir = QCA99X0_HW_2_0_FW_DIR,
 187                         .board = QCA99X0_HW_2_0_BOARD_DATA_FILE,
 188                         .board_size = QCA99X0_BOARD_DATA_SZ,
 189                         .board_ext_size = QCA99X0_BOARD_EXT_DATA_SZ,
 190                 },
 191                 .sw_decrypt_mcast_mgmt = true,
 192                 .hw_ops = &qca99x0_ops,
 193                 .decap_align_bytes = 1,
 194         },
 195         {
 196                 .id = QCA9984_HW_1_0_DEV_VERSION,
 197                 .dev_id = QCA9984_1_0_DEVICE_ID,
 198                 .name = "qca9984/qca9994 hw1.0",
 199                 .patch_load_addr = QCA9984_HW_1_0_PATCH_LOAD_ADDR,
 200                 .uart_pin = 7,
 201                 .otp_exe_param = 0x00000700,
 202                 .continuous_frag_desc = true,
 203                 .cck_rate_map_rev2 = true,
 204                 .channel_counters_freq_hz = 150000,
 205                 .max_probe_resp_desc_thres = 24,
 206                 .tx_chain_mask = 0xf,
 207                 .rx_chain_mask = 0xf,
 208                 .max_spatial_stream = 4,
 209                 .cal_data_len = 12064,
 210                 .fw = {
 211                         .dir = QCA9984_HW_1_0_FW_DIR,
 212                         .board = QCA9984_HW_1_0_BOARD_DATA_FILE,
 213                         .board_size = QCA99X0_BOARD_DATA_SZ,
 214                         .board_ext_size = QCA99X0_BOARD_EXT_DATA_SZ,
 215                 },
 216                 .sw_decrypt_mcast_mgmt = true,
 217                 .hw_ops = &qca99x0_ops,
 218                 .decap_align_bytes = 1,
 219         },
 220         {
 221                 .id = QCA9888_HW_2_0_DEV_VERSION,
 222                 .dev_id = QCA9888_2_0_DEVICE_ID,
 223                 .name = "qca9888 hw2.0",
 224                 .patch_load_addr = QCA9888_HW_2_0_PATCH_LOAD_ADDR,
 225                 .uart_pin = 7,
 226                 .otp_exe_param = 0x00000700,
 227                 .continuous_frag_desc = true,
 228                 .channel_counters_freq_hz = 150000,
 229                 .max_probe_resp_desc_thres = 24,
 230                 .tx_chain_mask = 3,
 231                 .rx_chain_mask = 3,
 232                 .max_spatial_stream = 2,
 233                 .cal_data_len = 12064,
 234                 .fw = {
 235                         .dir = QCA9888_HW_2_0_FW_DIR,
 236                         .board = QCA9888_HW_2_0_BOARD_DATA_FILE,
 237                         .board_size = QCA99X0_BOARD_DATA_SZ,
 238                         .board_ext_size = QCA99X0_BOARD_EXT_DATA_SZ,
 239                 },
 240                 .sw_decrypt_mcast_mgmt = true,
 241                 .hw_ops = &qca99x0_ops,
 242                 .decap_align_bytes = 1,
 243         },
 244         {
 245                 .id = QCA9377_HW_1_0_DEV_VERSION,
 246                 .dev_id = QCA9377_1_0_DEVICE_ID,
 247                 .name = "qca9377 hw1.0",
 248                 .patch_load_addr = QCA9377_HW_1_0_PATCH_LOAD_ADDR,
 249                 .uart_pin = 6,
 250                 .otp_exe_param = 0,
 251                 .channel_counters_freq_hz = 88000,
 252                 .max_probe_resp_desc_thres = 0,
 253                 .cal_data_len = 8124,
 254                 .fw = {
 255                         .dir = QCA9377_HW_1_0_FW_DIR,
 256                         .board = QCA9377_HW_1_0_BOARD_DATA_FILE,
 257                         .board_size = QCA9377_BOARD_DATA_SZ,
 258                         .board_ext_size = QCA9377_BOARD_EXT_DATA_SZ,
 259                 },
 260                 .hw_ops = &qca988x_ops,
 261                 .decap_align_bytes = 4,
 262         },
 263         {
 264                 .id = QCA9377_HW_1_1_DEV_VERSION,
 265                 .dev_id = QCA9377_1_0_DEVICE_ID,
 266                 .name = "qca9377 hw1.1",
 267                 .patch_load_addr = QCA9377_HW_1_0_PATCH_LOAD_ADDR,
 268                 .uart_pin = 6,
 269                 .otp_exe_param = 0,
 270                 .channel_counters_freq_hz = 88000,
 271                 .max_probe_resp_desc_thres = 0,
 272                 .cal_data_len = 8124,
 273                 .fw = {
 274                         .dir = QCA9377_HW_1_0_FW_DIR,
 275                         .board = QCA9377_HW_1_0_BOARD_DATA_FILE,
 276                         .board_size = QCA9377_BOARD_DATA_SZ,
 277                         .board_ext_size = QCA9377_BOARD_EXT_DATA_SZ,
 278                 },
 279                 .hw_ops = &qca988x_ops,
 280                 .decap_align_bytes = 4,
 281         },
 282         {
 283                 .id = QCA4019_HW_1_0_DEV_VERSION,
 284                 .dev_id = 0,
 285                 .name = "qca4019 hw1.0",
 286                 .patch_load_addr = QCA4019_HW_1_0_PATCH_LOAD_ADDR,
 287                 .uart_pin = 7,
 288                 .cc_wraparound_type = ATH10K_HW_CC_WRAP_SHIFTED_EACH,
 289                 .otp_exe_param = 0x0010000,
 290                 .continuous_frag_desc = true,
 291                 .cck_rate_map_rev2 = true,
 292                 .channel_counters_freq_hz = 125000,
 293                 .max_probe_resp_desc_thres = 24,
 294                 .tx_chain_mask = 0x3,
 295                 .rx_chain_mask = 0x3,
 296                 .max_spatial_stream = 2,
 297                 .cal_data_len = 12064,
 298                 .fw = {
 299                         .dir = QCA4019_HW_1_0_FW_DIR,
 300                         .board = QCA4019_HW_1_0_BOARD_DATA_FILE,
 301                         .board_size = QCA4019_BOARD_DATA_SZ,
 302                         .board_ext_size = QCA4019_BOARD_EXT_DATA_SZ,
 303                 },
 304                 .sw_decrypt_mcast_mgmt = true,
 305                 .hw_ops = &qca99x0_ops,
 306                 .decap_align_bytes = 1,
 307         },
 308 };
 309
 310 static const char *const ath10k_core_fw_feature_str[] = {
 311         [ATH10K_FW_FEATURE_EXT_WMI_MGMT_RX] = "wmi-mgmt-rx",
 312         [ATH10K_FW_FEATURE_WMI_10X] = "wmi-10.x",
 313         [ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX] = "has-wmi-mgmt-tx",
 314         [ATH10K_FW_FEATURE_NO_P2P] = "no-p2p",
 315         [ATH10K_FW_FEATURE_WMI_10_2] = "wmi-10.2",
 316         [ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT] = "multi-vif-ps",
 317         [ATH10K_FW_FEATURE_WOWLAN_SUPPORT] = "wowlan",
 318         [ATH10K_FW_FEATURE_IGNORE_OTP_RESULT] = "ignore-otp",
 319         [ATH10K_FW_FEATURE_NO_NWIFI_DECAP_4ADDR_PADDING] = "no-4addr-pad",
 320         [ATH10K_FW_FEATURE_SUPPORTS_SKIP_CLOCK_INIT] = "skip-clock-init",
 321         [ATH10K_FW_FEATURE_RAW_MODE_SUPPORT] = "raw-mode",
 322         [ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA] = "adaptive-cca",
 323         [ATH10K_FW_FEATURE_MFP_SUPPORT] = "mfp",
 324         [ATH10K_FW_FEATURE_PEER_FLOW_CONTROL] = "peer-flow-ctrl",
 325         [ATH10K_FW_FEATURE_BTCOEX_PARAM] = "btcoex-param",
 326         [ATH10K_FW_FEATURE_SKIP_NULL_FUNC_WAR] = "skip-null-func-war",
 327 };
 328
 329 static unsigned int ath10k_core_get_fw_feature_str(char *buf,
 330                                                    size_t buf_len,
 331                                                    enum ath10k_fw_features feat)
 332 {
 333         /* make sure that ath10k_core_fw_feature_str[] gets updated */
 334         BUILD_BUG_ON(ARRAY_SIZE(ath10k_core_fw_feature_str) !=
 335                      ATH10K_FW_FEATURE_COUNT);
 336
 337         if (feat >= ARRAY_SIZE(ath10k_core_fw_feature_str) ||
 338             WARN_ON(!ath10k_core_fw_feature_str[feat])) {
 339                 return scnprintf(buf, buf_len, "bit%d", feat);
 340         }
 341
 342         return scnprintf(buf, buf_len, "%s", ath10k_core_fw_feature_str[feat]);
 343 }
 344
 345 void ath10k_core_get_fw_features_str(struct ath10k *ar,
 346                                      char *buf,
 347                                      size_t buf_len)
 348 {
 349         unsigned int len = 0;
 350         int i;
 351
 352         for (i = 0; i < ATH10K_FW_FEATURE_COUNT; i++) {
 353                 if (test_bit(i, ar->normal_mode_fw.fw_file.fw_features)) {
 354                         if (len > 0)
 355                                 len += scnprintf(buf + len, buf_len - len, ",");
 356
 357                         len += ath10k_core_get_fw_feature_str(buf + len,
 358                                                               buf_len - len,
 359                                                               i);
 360                 }
 361         }
 362 }
 363
 364 static void ath10k_send_suspend_complete(struct ath10k *ar)
 365 {
 366         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot suspend complete\n");
 367
 368         complete(&ar->target_suspend);
 369 }
 370
 371 static int ath10k_init_configure_target(struct ath10k *ar)
 372 {
 373         u32 param_host;
 374         int ret;
 375
 376         /* tell target which HTC version it is used*/
 377         ret = ath10k_bmi_write32(ar, hi_app_host_interest,
 378                                  HTC_PROTOCOL_VERSION);
 379         if (ret) {
 380                 ath10k_err(ar, "settings HTC version failed\n");
 381                 return ret;
 382         }
 383
 384         /* set the firmware mode to STA/IBSS/AP */
 385         ret = ath10k_bmi_read32(ar, hi_option_flag, &param_host);
 386         if (ret) {
 387                 ath10k_err(ar, "setting firmware mode (1/2) failed\n");
 388                 return ret;
 389         }
 390
 391         /* TODO following parameters need to be re-visited. */
 392         /* num_device */
 393         param_host |= (1 << HI_OPTION_NUM_DEV_SHIFT);
 394         /* Firmware mode */
 395         /* FIXME: Why FW_MODE_AP ??.*/
 396         param_host |= (HI_OPTION_FW_MODE_AP << HI_OPTION_FW_MODE_SHIFT);
 397         /* mac_addr_method */
 398         param_host |= (1 << HI_OPTION_MAC_ADDR_METHOD_SHIFT);
 399         /* firmware_bridge */
 400         param_host |= (0 << HI_OPTION_FW_BRIDGE_SHIFT);
 401         /* fwsubmode */
 402         param_host |= (0 << HI_OPTION_FW_SUBMODE_SHIFT);
 403
 404         ret = ath10k_bmi_write32(ar, hi_option_flag, param_host);
 405         if (ret) {
 406                 ath10k_err(ar, "setting firmware mode (2/2) failed\n");
 407                 return ret;
 408         }
 409
 410         /* We do all byte-swapping on the host */
 411         ret = ath10k_bmi_write32(ar, hi_be, 0);
 412         if (ret) {
 413                 ath10k_err(ar, "setting host CPU BE mode failed\n");
 414                 return ret;
 415         }
 416
 417         /* FW descriptor/Data swap flags */
 418         ret = ath10k_bmi_write32(ar, hi_fw_swap, 0);
 419
 420         if (ret) {
 421                 ath10k_err(ar, "setting FW data/desc swap flags failed\n");
 422                 return ret;
 423         }
 424
 425         /* Some devices have a special sanity check that verifies the PCI
 426          * Device ID is written to this host interest var. It is known to be
 427          * required to boot QCA6164.
 428          */
 429         ret = ath10k_bmi_write32(ar, hi_hci_uart_pwr_mgmt_params_ext,
 430                                  ar->dev_id);
 431         if (ret) {
 432                 ath10k_err(ar, "failed to set pwr_mgmt_params: %d\n", ret);
 433                 return ret;
 434         }
 435
 436         return 0;
 437 }
 438
 439 static const struct firmware *ath10k_fetch_fw_file(struct ath10k *ar,
 440                                                    const char *dir,
 441                                                    const char *file)
 442 {
 443         char filename[100];
 444         const struct firmware *fw;
 445         int ret;
 446
 447         if (file == NULL)
 448                 return ERR_PTR(-ENOENT);
 449
 450         if (dir == NULL)
 451                 dir = ".";
 452
 453         snprintf(filename, sizeof(filename), "%s/%s", dir, file);
 454         ret = reject_firmware(&fw, filename, ar->dev);
 455         if (ret)
 456                 return ERR_PTR(ret);
 457
 458         return fw;
 459 }
 460
 461 static int ath10k_push_board_ext_data(struct ath10k *ar, const void *data,
 462                                       size_t data_len)
 463 {
 464         u32 board_data_size = ar->hw_params.fw.board_size;
 465         u32 board_ext_data_size = ar->hw_params.fw.board_ext_size;
 466         u32 board_ext_data_addr;
 467         int ret;
 468
 469         ret = ath10k_bmi_read32(ar, hi_board_ext_data, &board_ext_data_addr);
 470         if (ret) {
 471                 ath10k_err(ar, "could not read board ext data addr (%d)\n",
 472                            ret);
 473                 return ret;
 474         }
 475
 476         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 477                    "boot push board extended data addr 0x%x\n",
 478                    board_ext_data_addr);
 479
 480         if (board_ext_data_addr == 0)
 481                 return 0;
 482
 483         if (data_len != (board_data_size + board_ext_data_size)) {
 484                 ath10k_err(ar, "invalid board (ext) data sizes %zu != %d+%d\n",
 485                            data_len, board_data_size, board_ext_data_size);
 486                 return -EINVAL;
 487         }
 488
 489         ret = ath10k_bmi_write_memory(ar, board_ext_data_addr,
 490                                       data + board_data_size,
 491                                       board_ext_data_size);
 492         if (ret) {
 493                 ath10k_err(ar, "could not write board ext data (%d)\n", ret);
 494                 return ret;
 495         }
 496
 497         ret = ath10k_bmi_write32(ar, hi_board_ext_data_config,
 498                                  (board_ext_data_size << 16) | 1);
 499         if (ret) {
 500                 ath10k_err(ar, "could not write board ext data bit (%d)\n",
 501                            ret);
 502                 return ret;
 503         }
 504
 505         return 0;
 506 }
 507
 508 static int ath10k_download_board_data(struct ath10k *ar, const void *data,
 509                                       size_t data_len)
 510 {
 511         u32 board_data_size = ar->hw_params.fw.board_size;
 512         u32 address;
 513         int ret;
 514
 515         ret = ath10k_push_board_ext_data(ar, data, data_len);
 516         if (ret) {
 517                 ath10k_err(ar, "could not push board ext data (%d)\n", ret);
 518                 goto exit;
 519         }
 520
 521         ret = ath10k_bmi_read32(ar, hi_board_data, &address);
 522         if (ret) {
 523                 ath10k_err(ar, "could not read board data addr (%d)\n", ret);
 524                 goto exit;
 525         }
 526
 527         ret = ath10k_bmi_write_memory(ar, address, data,
 528                                       min_t(u32, board_data_size,
 529                                             data_len));
 530         if (ret) {
 531                 ath10k_err(ar, "could not write board data (%d)\n", ret);
 532                 goto exit;
 533         }
 534
 535         ret = ath10k_bmi_write32(ar, hi_board_data_initialized, 1);
 536         if (ret) {
 537                 ath10k_err(ar, "could not write board data bit (%d)\n", ret);
 538                 goto exit;
 539         }
 540
 541 exit:
 542         return ret;
 543 }
 544
 545 static int ath10k_download_cal_file(struct ath10k *ar,
 546                                     const struct firmware *file)
 547 {
 548         int ret;
 549
 550         if (!file)
 551                 return -ENOENT;
 552
 553         if (IS_ERR(file))
 554                 return PTR_ERR(file);
 555
 556         ret = ath10k_download_board_data(ar, file->data, file->size);
 557         if (ret) {
 558                 ath10k_err(ar, "failed to download cal_file data: %d\n", ret);
 559                 return ret;
 560         }
 561
 562         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cal file downloaded\n");
 563
 564         return 0;
 565 }
 566
 567 static int ath10k_download_cal_dt(struct ath10k *ar, const char *dt_name)
 568 {
 569         struct device_node *node;
 570         int data_len;
 571         void *data;
 572         int ret;
 573
 574         node = ar->dev->of_node;
 575         if (!node)
 576                 /* Device Tree is optional, don't print any warnings if
 577                  * there's no node for ath10k.
 578                  */
 579                 return -ENOENT;
 580
 581         if (!of_get_property(node, dt_name, &data_len)) {
 582                 /* The calibration data node is optional */
 583                 return -ENOENT;
 584         }
 585
 586         if (data_len != ar->hw_params.cal_data_len) {
 587                 ath10k_warn(ar, "invalid calibration data length in DT: %d\n",
 588                             data_len);
 589                 ret = -EMSGSIZE;
 590                 goto out;
 591         }
 592
 593         data = kmalloc(data_len, GFP_KERNEL);
 594         if (!data) {
 595                 ret = -ENOMEM;
 596                 goto out;
 597         }
 598
 599         ret = of_property_read_u8_array(node, dt_name, data, data_len);
 600         if (ret) {
 601                 ath10k_warn(ar, "failed to read calibration data from DT: %d\n",
 602                             ret);
 603                 goto out_free;
 604         }
 605
 606         ret = ath10k_download_board_data(ar, data, data_len);
 607         if (ret) {
 608                 ath10k_warn(ar, "failed to download calibration data from Device Tree: %d\n",
 609                             ret);
 610                 goto out_free;
 611         }
 612
 613         ret = 0;
 614
 615 out_free:
 616         kfree(data);
 617
 618 out:
 619         return ret;
 620 }
 621
 622 static int ath10k_download_cal_eeprom(struct ath10k *ar)
 623 {
 624         size_t data_len;
 625         void *data = NULL;
 626         int ret;
 627
 628         ret = ath10k_hif_fetch_cal_eeprom(ar, &data, &data_len);
 629         if (ret) {
 630                 if (ret != -EOPNOTSUPP)
 631                         ath10k_warn(ar, "failed to read calibration data from EEPROM: %d\n",
 632                                     ret);
 633                 goto out_free;
 634         }
 635
 636         ret = ath10k_download_board_data(ar, data, data_len);
 637         if (ret) {
 638                 ath10k_warn(ar, "failed to download calibration data from EEPROM: %d\n",
 639                             ret);
 640                 goto out_free;
 641         }
 642
 643         ret = 0;
 644
 645 out_free:
 646         kfree(data);
 647
 648         return ret;
 649 }
 650
 651 static int ath10k_core_get_board_id_from_otp(struct ath10k *ar)
 652 {
 653         u32 result, address;
 654         u8 board_id, chip_id;
 655         int ret, bmi_board_id_param;
 656
 657         address = ar->hw_params.patch_load_addr;
 658
 659         if (!ar->normal_mode_fw.fw_file.otp_data ||
 660             !ar->normal_mode_fw.fw_file.otp_len) {
 661                 ath10k_warn(ar,
 662                             "failed to retrieve board id because of invalid otp\n");
 663                 return -ENODATA;
 664         }
 665
 666         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 667                    "boot upload otp to 0x%x len %zd for board id\n",
 668                    address, ar->normal_mode_fw.fw_file.otp_len);
 669
 670         ret = ath10k_bmi_fast_download(ar, address,
 671                                        ar->normal_mode_fw.fw_file.otp_data,
 672                                        ar->normal_mode_fw.fw_file.otp_len);
 673         if (ret) {
 674                 ath10k_err(ar, "could not write otp for board id check: %d\n",
 675                            ret);
 676                 return ret;
 677         }
 678
 679         if (ar->cal_mode == ATH10K_PRE_CAL_MODE_DT ||
 680             ar->cal_mode == ATH10K_PRE_CAL_MODE_FILE)
 681                 bmi_board_id_param = BMI_PARAM_GET_FLASH_BOARD_ID;
 682         else
 683                 bmi_board_id_param = BMI_PARAM_GET_EEPROM_BOARD_ID;
 684
 685         ret = ath10k_bmi_execute(ar, address, bmi_board_id_param, &result);
 686         if (ret) {
 687                 ath10k_err(ar, "could not execute otp for board id check: %d\n",
 688                            ret);
 689                 return ret;
 690         }
 691
 692         board_id = MS(result, ATH10K_BMI_BOARD_ID_FROM_OTP);
 693         chip_id = MS(result, ATH10K_BMI_CHIP_ID_FROM_OTP);
 694
 695         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 696                    "boot get otp board id result 0x%08x board_id %d chip_id %d\n",
 697                    result, board_id, chip_id);
 698
 699         if ((result & ATH10K_BMI_BOARD_ID_STATUS_MASK) != 0 ||
 700             (board_id == 0)) {
 701                 ath10k_dbg(ar, ATH10K_DBG_BOOT,
 702                            "board id does not exist in otp, ignore it\n");
 703                 return -EOPNOTSUPP;
 704         }
 705
 706         ar->id.bmi_ids_valid = true;
 707         ar->id.bmi_board_id = board_id;
 708         ar->id.bmi_chip_id = chip_id;
 709
 710         return 0;
 711 }
 712
 713 static int ath10k_download_and_run_otp(struct ath10k *ar)
 714 {
 715         u32 result, address = ar->hw_params.patch_load_addr;
 716         u32 bmi_otp_exe_param = ar->hw_params.otp_exe_param;
 717         int ret;
 718
 719         ret = ath10k_download_board_data(ar,
 720                                          ar->running_fw->board_data,
 721                                          ar->running_fw->board_len);
 722         if (ret) {
 723                 ath10k_err(ar, "failed to download board data: %d\n", ret);
 724                 return ret;
 725         }
 726
 727         /* OTP is optional */
 728
 729         if (!ar->running_fw->fw_file.otp_data ||
 730             !ar->running_fw->fw_file.otp_len) {
 731                 ath10k_warn(ar, "Not running otp, calibration will be incorrect (otp-data %pK otp_len %zd)!\n",
 732                             ar->running_fw->fw_file.otp_data,
 733                             ar->running_fw->fw_file.otp_len);
 734                 return 0;
 735         }
 736
 737         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot upload otp to 0x%x len %zd\n",
 738                    address, ar->running_fw->fw_file.otp_len);
 739
 740         ret = ath10k_bmi_fast_download(ar, address,
 741                                        ar->running_fw->fw_file.otp_data,
 742                                        ar->running_fw->fw_file.otp_len);
 743         if (ret) {
 744                 ath10k_err(ar, "could not write otp (%d)\n", ret);
 745                 return ret;
 746         }
 747
 748         /* As of now pre-cal is valid for 10_4 variants */
 749         if (ar->cal_mode == ATH10K_PRE_CAL_MODE_DT ||
 750             ar->cal_mode == ATH10K_PRE_CAL_MODE_FILE)
 751                 bmi_otp_exe_param = BMI_PARAM_FLASH_SECTION_ALL;
 752
 753         ret = ath10k_bmi_execute(ar, address, bmi_otp_exe_param, &result);
 754         if (ret) {
 755                 ath10k_err(ar, "could not execute otp (%d)\n", ret);
 756                 return ret;
 757         }
 758
 759         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot otp execute result %d\n", result);
 760
 761         if (!(skip_otp || test_bit(ATH10K_FW_FEATURE_IGNORE_OTP_RESULT,
 762                                    ar->running_fw->fw_file.fw_features)) &&
 763             result != 0) {
 764                 ath10k_err(ar, "otp calibration failed: %d", result);
 765                 return -EINVAL;
 766         }
 767
 768         return 0;
 769 }
 770
 771 static int ath10k_download_fw(struct ath10k *ar)
 772 {
 773         u32 address, data_len;
 774         const void *data;
 775         int ret;
 776
 777         address = ar->hw_params.patch_load_addr;
 778
 779         data = ar->running_fw->fw_file.firmware_data;
 780         data_len = ar->running_fw->fw_file.firmware_len;
 781
 782         ret = ath10k_swap_code_seg_configure(ar, &ar->running_fw->fw_file);
 783         if (ret) {
 784                 ath10k_err(ar, "failed to configure fw code swap: %d\n",
 785                            ret);
 786                 return ret;
 787         }
 788
 789         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 790                    "boot uploading firmware image %pK len %d\n",
 791                    data, data_len);
 792
 793         ret = ath10k_bmi_fast_download(ar, address, data, data_len);
 794         if (ret) {
 795                 ath10k_err(ar, "failed to download firmware: %d\n",
 796                            ret);
 797                 return ret;
 798         }
 799
 800         return ret;
 801 }
 802
 803 static void ath10k_core_free_board_files(struct ath10k *ar)
 804 {
 805         if (!IS_ERR(ar->normal_mode_fw.board))
 806                 release_firmware(ar->normal_mode_fw.board);
 807
 808         ar->normal_mode_fw.board = NULL;
 809         ar->normal_mode_fw.board_data = NULL;
 810         ar->normal_mode_fw.board_len = 0;
 811 }
 812
 813 static void ath10k_core_free_firmware_files(struct ath10k *ar)
 814 {
 815         if (!IS_ERR(ar->normal_mode_fw.fw_file.firmware))
 816                 release_firmware(ar->normal_mode_fw.fw_file.firmware);
 817
 818         if (!IS_ERR(ar->cal_file))
 819                 release_firmware(ar->cal_file);
 820
 821         if (!IS_ERR(ar->pre_cal_file))
 822                 release_firmware(ar->pre_cal_file);
 823
 824         ath10k_swap_code_seg_release(ar, &ar->normal_mode_fw.fw_file);
 825
 826         ar->normal_mode_fw.fw_file.otp_data = NULL;
 827         ar->normal_mode_fw.fw_file.otp_len = 0;
 828
 829         ar->normal_mode_fw.fw_file.firmware = NULL;
 830         ar->normal_mode_fw.fw_file.firmware_data = NULL;
 831         ar->normal_mode_fw.fw_file.firmware_len = 0;
 832
 833         ar->cal_file = NULL;
 834         ar->pre_cal_file = NULL;
 835 }
 836
 837 static int ath10k_fetch_cal_file(struct ath10k *ar)
 838 {
 839         char filename[100];
 840
 841         /* pre-cal-<bus>-<id>.bin */
 842         scnprintf(filename, sizeof(filename), "/*(DEBLOBBED)*/",
 843                   ath10k_bus_str(ar->hif.bus), dev_name(ar->dev));
 844
 845         ar->pre_cal_file = ath10k_fetch_fw_file(ar, ATH10K_FW_DIR, filename);
 846         if (!IS_ERR(ar->pre_cal_file))
 847                 goto success;
 848
 849         /*(DEBLOBBED)*/
 850         scnprintf(filename, sizeof(filename), "/*(DEBLOBBED)*/",
 851                   ath10k_bus_str(ar->hif.bus), dev_name(ar->dev));
 852
 853         ar->cal_file = ath10k_fetch_fw_file(ar, ATH10K_FW_DIR, filename);
 854         if (IS_ERR(ar->cal_file))
 855                 /* calibration file is optional, don't print any warnings */
 856                 return PTR_ERR(ar->cal_file);
 857 success:
 858         ath10k_dbg(ar, ATH10K_DBG_BOOT, "found calibration file %s/%s\n",
 859                    ATH10K_FW_DIR, filename);
 860
 861         return 0;
 862 }
 863
 864 static int ath10k_core_fetch_board_data_api_1(struct ath10k *ar)
 865 {
 866         if (!ar->hw_params.fw.board) {
 867                 ath10k_err(ar, "failed to find board file fw entry\n");
 868                 return -EINVAL;
 869         }
 870
 871         ar->normal_mode_fw.board = ath10k_fetch_fw_file(ar,
 872                                                         ar->hw_params.fw.dir,
 873                                                         ar->hw_params.fw.board);
 874         if (IS_ERR(ar->normal_mode_fw.board))
 875                 return PTR_ERR(ar->normal_mode_fw.board);
 876
 877         ar->normal_mode_fw.board_data = ar->normal_mode_fw.board->data;
 878         ar->normal_mode_fw.board_len = ar->normal_mode_fw.board->size;
 879
 880         return 0;
 881 }
 882
 883 static int ath10k_core_parse_bd_ie_board(struct ath10k *ar,
 884                                          const void *buf, size_t buf_len,
 885                                          const char *boardname)
 886 {
 887         const struct ath10k_fw_ie *hdr;
 888         bool name_match_found;
 889         int ret, board_ie_id;
 890         size_t board_ie_len;
 891         const void *board_ie_data;
 892
 893         name_match_found = false;
 894
 895         /* go through ATH10K_BD_IE_BOARD_ elements */
 896         while (buf_len > sizeof(struct ath10k_fw_ie)) {
 897                 hdr = buf;
 898                 board_ie_id = le32_to_cpu(hdr->id);
 899                 board_ie_len = le32_to_cpu(hdr->len);
 900                 board_ie_data = hdr->data;
 901
 902                 buf_len -= sizeof(*hdr);
 903                 buf += sizeof(*hdr);
 904
 905                 if (buf_len < ALIGN(board_ie_len, 4)) {
 906                         ath10k_err(ar, "invalid ATH10K_BD_IE_BOARD length: %zu < %zu\n",
 907                                    buf_len, ALIGN(board_ie_len, 4));
 908                         ret = -EINVAL;
 909                         goto out;
 910                 }
 911
 912                 switch (board_ie_id) {
 913                 case ATH10K_BD_IE_BOARD_NAME:
 914                         ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "board name", "",
 915                                         board_ie_data, board_ie_len);
 916
 917                         if (board_ie_len != strlen(boardname))
 918                                 break;
 919
 920                         ret = memcmp(board_ie_data, boardname, strlen(boardname));
 921                         if (ret)
 922                                 break;
 923
 924                         name_match_found = true;
 925                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 926                                    "boot found match for name '%s'",
 927                                    boardname);
 928                         break;
 929                 case ATH10K_BD_IE_BOARD_DATA:
 930                         if (!name_match_found)
 931                                 /* no match found */
 932                                 break;
 933
 934                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 935                                    "boot found board data for '%s'",
 936                                    boardname);
 937
 938                         ar->normal_mode_fw.board_data = board_ie_data;
 939                         ar->normal_mode_fw.board_len = board_ie_len;
 940
 941                         ret = 0;
 942                         goto out;
 943                 default:
 944                         ath10k_warn(ar, "unknown ATH10K_BD_IE_BOARD found: %d\n",
 945                                     board_ie_id);
 946                         break;
 947                 }
 948
 949                 /* jump over the padding */
 950                 board_ie_len = ALIGN(board_ie_len, 4);
 951
 952                 buf_len -= board_ie_len;
 953                 buf += board_ie_len;
 954         }
 955
 956         /* no match found */
 957         ret = -ENOENT;
 958
 959 out:
 960         return ret;
 961 }
 962
 963 static int ath10k_core_fetch_board_data_api_n(struct ath10k *ar,
 964                                               const char *boardname,
 965                                               const char *filename)
 966 {
 967         size_t len, magic_len, ie_len;
 968         struct ath10k_fw_ie *hdr;
 969         const u8 *data;
 970         int ret, ie_id;
 971
 972         ar->normal_mode_fw.board = ath10k_fetch_fw_file(ar,
 973                                                         ar->hw_params.fw.dir,
 974                                                         filename);
 975         if (IS_ERR(ar->normal_mode_fw.board))
 976                 return PTR_ERR(ar->normal_mode_fw.board);
 977
 978         data = ar->normal_mode_fw.board->data;
 979         len = ar->normal_mode_fw.board->size;
 980
 981         /* magic has extra null byte padded */
 982         magic_len = strlen(ATH10K_BOARD_MAGIC) + 1;
 983         if (len < magic_len) {
 984                 ath10k_err(ar, "failed to find magic value in %s/%s, file too short: %zu\n",
 985                            ar->hw_params.fw.dir, filename, len);
 986                 ret = -EINVAL;
 987                 goto err;
 988         }
 989
 990         if (memcmp(data, ATH10K_BOARD_MAGIC, magic_len)) {
 991                 ath10k_err(ar, "found invalid board magic\n");
 992                 ret = -EINVAL;
 993                 goto err;
 994         }
 995
 996         /* magic is padded to 4 bytes */
 997         magic_len = ALIGN(magic_len, 4);
 998         if (len < magic_len) {
 999                 ath10k_err(ar, "failed: %s/%s too small to contain board data, len: %zu\n",
1000                            ar->hw_params.fw.dir, filename, len);
1001                 ret = -EINVAL;
1002                 goto err;
1003         }
1004
1005         data += magic_len;
1006         len -= magic_len;
1007
1008         while (len > sizeof(struct ath10k_fw_ie)) {
1009                 hdr = (struct ath10k_fw_ie *)data;
1010                 ie_id = le32_to_cpu(hdr->id);
1011                 ie_len = le32_to_cpu(hdr->len);
1012
1013                 len -= sizeof(*hdr);
1014                 data = hdr->data;
1015
1016                 if (len < ALIGN(ie_len, 4)) {
1017                         ath10k_err(ar, "invalid length for board ie_id %d ie_len %zu len %zu\n",
1018                                    ie_id, ie_len, len);
1019                         ret = -EINVAL;
1020                         goto err;
1021                 }
1022
1023                 switch (ie_id) {
1024                 case ATH10K_BD_IE_BOARD:
1025                         ret = ath10k_core_parse_bd_ie_board(ar, data, ie_len,
1026                                                             boardname);
1027                         if (ret == -ENOENT)
1028                                 /* no match found, continue */
1029                                 break;
1030                         else if (ret)
1031                                 /* there was an error, bail out */
1032                                 goto err;
1033
1034                         /* board data found */
1035                         goto out;
1036                 }
1037
1038                 /* jump over the padding */
1039                 ie_len = ALIGN(ie_len, 4);
1040
1041                 len -= ie_len;
1042                 data += ie_len;
1043         }
1044
1045 out:
1046         if (!ar->normal_mode_fw.board_data || !ar->normal_mode_fw.board_len) {
1047                 ath10k_err(ar,
1048                            "failed to fetch board data for %s from %s/%s\n",
1049                            boardname, ar->hw_params.fw.dir, filename);
1050                 ret = -ENODATA;
1051                 goto err;
1052         }
1053
1054         return 0;
1055
1056 err:
1057         ath10k_core_free_board_files(ar);
1058         return ret;
1059 }
1060
1061 static int ath10k_core_create_board_name(struct ath10k *ar, char *name,
1062                                          size_t name_len)
1063 {
1064         if (ar->id.bmi_ids_valid) {
1065                 scnprintf(name, name_len,
1066                           "bus=%s,bmi-chip-id=%d,bmi-board-id=%d",
1067                           ath10k_bus_str(ar->hif.bus),
1068                           ar->id.bmi_chip_id,
1069                           ar->id.bmi_board_id);
1070                 goto out;
1071         }
1072
1073         scnprintf(name, name_len,
1074                   "bus=%s,vendor=%04x,device=%04x,subsystem-vendor=%04x,subsystem-device=%04x",
1075                   ath10k_bus_str(ar->hif.bus),
1076                   ar->id.vendor, ar->id.device,
1077                   ar->id.subsystem_vendor, ar->id.subsystem_device);
1078
1079 out:
1080         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot using board name '%s'\n", name);
1081
1082         return 0;
1083 }
1084
1085 static int ath10k_core_fetch_board_file(struct ath10k *ar)
1086 {
1087         char boardname[100];
1088         int ret;
1089
1090         ret = ath10k_core_create_board_name(ar, boardname, sizeof(boardname));
1091         if (ret) {
1092                 ath10k_err(ar, "failed to create board name: %d", ret);
1093                 return ret;
1094         }
1095
1096         ar->bd_api = 2;
1097         ret = ath10k_core_fetch_board_data_api_n(ar, boardname,
1098                                                  ATH10K_BOARD_API2_FILE);
1099         if (!ret)
1100                 goto success;
1101
1102         ar->bd_api = 1;
1103         ret = ath10k_core_fetch_board_data_api_1(ar);
1104         if (ret) {
1105                 ath10k_err(ar, "failed to fetch board data\n");
1106                 return ret;
1107         }
1108
1109 success:
1110         ath10k_dbg(ar, ATH10K_DBG_BOOT, "using board api %d\n", ar->bd_api);
1111         return 0;
1112 }
1113
1114 int ath10k_core_fetch_firmware_api_n(struct ath10k *ar, const char *name,
1115                                      struct ath10k_fw_file *fw_file)
1116 {
1117         size_t magic_len, len, ie_len;
1118         int ie_id, i, index, bit, ret;
1119         struct ath10k_fw_ie *hdr;
1120         const u8 *data;
1121         __le32 *timestamp, *version;
1122
1123         /* first fetch the firmware file (firmware-*.bin) */
1124         fw_file->firmware = ath10k_fetch_fw_file(ar, ar->hw_params.fw.dir,
1125                                                  name);
1126         if (IS_ERR(fw_file->firmware)) {
1127                 ath10k_err(ar, "could not fetch firmware file '%s/%s': %ld\n",
1128                            ar->hw_params.fw.dir, name,
1129                            PTR_ERR(fw_file->firmware));
1130                 return PTR_ERR(fw_file->firmware);
1131         }
1132
1133         data = fw_file->firmware->data;
1134         len = fw_file->firmware->size;
1135
1136         /* magic also includes the null byte, check that as well */
1137         magic_len = strlen(ATH10K_FIRMWARE_MAGIC) + 1;
1138
1139         if (len < magic_len) {
1140                 ath10k_err(ar, "firmware file '%s/%s' too small to contain magic: %zu\n",
1141                            ar->hw_params.fw.dir, name, len);
1142                 ret = -EINVAL;
1143                 goto err;
1144         }
1145
1146         if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
1147                 ath10k_err(ar, "invalid firmware magic\n");
1148                 ret = -EINVAL;
1149                 goto err;
1150         }
1151
1152         /* jump over the padding */
1153         magic_len = ALIGN(magic_len, 4);
1154
1155         len -= magic_len;
1156         data += magic_len;
1157
1158         /* loop elements */
1159         while (len > sizeof(struct ath10k_fw_ie)) {
1160                 hdr = (struct ath10k_fw_ie *)data;
1161
1162                 ie_id = le32_to_cpu(hdr->id);
1163                 ie_len = le32_to_cpu(hdr->len);
1164
1165                 len -= sizeof(*hdr);
1166                 data += sizeof(*hdr);
1167
1168                 if (len < ie_len) {
1169                         ath10k_err(ar, "invalid length for FW IE %d (%zu < %zu)\n",
1170                                    ie_id, len, ie_len);
1171                         ret = -EINVAL;
1172                         goto err;
1173                 }
1174
1175                 switch (ie_id) {
1176                 case ATH10K_FW_IE_FW_VERSION:
1177                         if (ie_len > sizeof(fw_file->fw_version) - 1)
1178                                 break;
1179
1180                         memcpy(fw_file->fw_version, data, ie_len);
1181                         fw_file->fw_version[ie_len] = '\0';
1182
1183                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1184                                    "found fw version %s\n",
1185                                     fw_file->fw_version);
1186                         break;
1187                 case ATH10K_FW_IE_TIMESTAMP:
1188                         if (ie_len != sizeof(u32))
1189                                 break;
1190
1191                         timestamp = (__le32 *)data;
1192
1193                         ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw timestamp %d\n",
1194                                    le32_to_cpup(timestamp));
1195                         break;
1196                 case ATH10K_FW_IE_FEATURES:
1197                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1198                                    "found firmware features ie (%zd B)\n",
1199                                    ie_len);
1200
1201                         for (i = 0; i < ATH10K_FW_FEATURE_COUNT; i++) {
1202                                 index = i / 8;
1203                                 bit = i % 8;
1204
1205                                 if (index == ie_len)
1206                                         break;
1207
1208                                 if (data[index] & (1 << bit)) {
1209                                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1210                                                    "Enabling feature bit: %i\n",
1211                                                    i);
1212                                         __set_bit(i, fw_file->fw_features);
1213                                 }
1214                         }
1215
1216                         ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "features", "",
1217                                         fw_file->fw_features,
1218                                         sizeof(fw_file->fw_features));
1219                         break;
1220                 case ATH10K_FW_IE_FW_IMAGE:
1221                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1222                                    "found fw image ie (%zd B)\n",
1223                                    ie_len);
1224
1225                         fw_file->firmware_data = data;
1226                         fw_file->firmware_len = ie_len;
1227
1228                         break;
1229                 case ATH10K_FW_IE_OTP_IMAGE:
1230                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1231                                    "found otp image ie (%zd B)\n",
1232                                    ie_len);
1233
1234                         fw_file->otp_data = data;
1235                         fw_file->otp_len = ie_len;
1236
1237                         break;
1238                 case ATH10K_FW_IE_WMI_OP_VERSION:
1239                         if (ie_len != sizeof(u32))
1240                                 break;
1241
1242                         version = (__le32 *)data;
1243
1244                         fw_file->wmi_op_version = le32_to_cpup(version);
1245
1246                         ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw ie wmi op version %d\n",
1247                                    fw_file->wmi_op_version);
1248                         break;
1249                 case ATH10K_FW_IE_HTT_OP_VERSION:
1250                         if (ie_len != sizeof(u32))
1251                                 break;
1252
1253                         version = (__le32 *)data;
1254
1255                         fw_file->htt_op_version = le32_to_cpup(version);
1256
1257                         ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw ie htt op version %d\n",
1258                                    fw_file->htt_op_version);
1259                         break;
1260                 case ATH10K_FW_IE_FW_CODE_SWAP_IMAGE:
1261                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1262                                    "found fw code swap image ie (%zd B)\n",
1263                                    ie_len);
1264                         fw_file->codeswap_data = data;
1265                         fw_file->codeswap_len = ie_len;
1266                         break;
1267                 default:
1268                         ath10k_warn(ar, "Unknown FW IE: %u\n",
1269                                     le32_to_cpu(hdr->id));
1270                         break;
1271                 }
1272
1273                 /* jump over the padding */
1274                 ie_len = ALIGN(ie_len, 4);
1275
1276                 len -= ie_len;
1277                 data += ie_len;
1278         }
1279
1280         if (!fw_file->firmware_data ||
1281             !fw_file->firmware_len) {
1282                 ath10k_warn(ar, "No ATH10K_FW_IE_FW_IMAGE found from '%s/%s', skipping\n",
1283                             ar->hw_params.fw.dir, name);
1284                 ret = -ENOMEDIUM;
1285                 goto err;
1286         }
1287
1288         return 0;
1289
1290 err:
1291         ath10k_core_free_firmware_files(ar);
1292         return ret;
1293 }
1294
1295 static int ath10k_core_fetch_firmware_files(struct ath10k *ar)
1296 {
1297         int ret;
1298
1299         /* calibration file is optional, don't check for any errors */
1300         ath10k_fetch_cal_file(ar);
1301
1302         ar->fw_api = 5;
1303         ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
1304
1305         ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API5_FILE,
1306                                                &ar->normal_mode_fw.fw_file);
1307         if (ret == 0)
1308                 goto success;
1309
1310         ar->fw_api = 4;
1311         ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
1312
1313         ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API4_FILE,
1314                                                &ar->normal_mode_fw.fw_file);
1315         if (ret == 0)
1316                 goto success;
1317
1318         ar->fw_api = 3;
1319         ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
1320
1321         ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API3_FILE,
1322                                                &ar->normal_mode_fw.fw_file);
1323         if (ret == 0)
1324                 goto success;
1325
1326         ar->fw_api = 2;
1327         ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
1328
1329         ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API2_FILE,
1330                                                &ar->normal_mode_fw.fw_file);
1331         if (ret)
1332                 return ret;
1333
1334 success:
1335         ath10k_dbg(ar, ATH10K_DBG_BOOT, "using fw api %d\n", ar->fw_api);
1336
1337         return 0;
1338 }
1339
1340 static int ath10k_core_pre_cal_download(struct ath10k *ar)
1341 {
1342         int ret;
1343
1344         ret = ath10k_download_cal_file(ar, ar->pre_cal_file);
1345         if (ret == 0) {
1346                 ar->cal_mode = ATH10K_PRE_CAL_MODE_FILE;
1347                 goto success;
1348         }
1349
1350         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1351                    "boot did not find a pre calibration file, try DT next: %d\n",
1352                    ret);
1353
1354         ret = ath10k_download_cal_dt(ar, "qcom,ath10k-pre-calibration-data");
1355         if (ret) {
1356                 ath10k_dbg(ar, ATH10K_DBG_BOOT,
1357                            "unable to load pre cal data from DT: %d\n", ret);
1358                 return ret;
1359         }
1360         ar->cal_mode = ATH10K_PRE_CAL_MODE_DT;
1361
1362 success:
1363         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot using calibration mode %s\n",
1364                    ath10k_cal_mode_str(ar->cal_mode));
1365
1366         return 0;
1367 }
1368
1369 static int ath10k_core_pre_cal_config(struct ath10k *ar)
1370 {
1371         int ret;
1372
1373         ret = ath10k_core_pre_cal_download(ar);
1374         if (ret) {
1375                 ath10k_dbg(ar, ATH10K_DBG_BOOT,
1376                            "failed to load pre cal data: %d\n", ret);
1377                 return ret;
1378         }
1379
1380         ret = ath10k_core_get_board_id_from_otp(ar);
1381         if (ret) {
1382                 ath10k_err(ar, "failed to get board id: %d\n", ret);
1383                 return ret;
1384         }
1385
1386         ret = ath10k_download_and_run_otp(ar);
1387         if (ret) {
1388                 ath10k_err(ar, "failed to run otp: %d\n", ret);
1389                 return ret;
1390         }
1391
1392         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1393                    "pre cal configuration done successfully\n");
1394
1395         return 0;
1396 }
1397
1398 static int ath10k_download_cal_data(struct ath10k *ar)
1399 {
1400         int ret;
1401
1402         ret = ath10k_core_pre_cal_config(ar);
1403         if (ret == 0)
1404                 return 0;
1405
1406         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1407                    "pre cal download procedure failed, try cal file: %d\n",
1408                    ret);
1409
1410         ret = ath10k_download_cal_file(ar, ar->cal_file);
1411         if (ret == 0) {
1412                 ar->cal_mode = ATH10K_CAL_MODE_FILE;
1413                 goto done;
1414         }
1415
1416         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1417                    "boot did not find a calibration file, try DT next: %d\n",
1418                    ret);
1419
1420         ret = ath10k_download_cal_dt(ar, "qcom,ath10k-calibration-data");
1421         if (ret == 0) {
1422                 ar->cal_mode = ATH10K_CAL_MODE_DT;
1423                 goto done;
1424         }
1425
1426         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1427                    "boot did not find DT entry, try target EEPROM next: %d\n",
1428                    ret);
1429
1430         ret = ath10k_download_cal_eeprom(ar);
1431         if (ret == 0) {
1432                 ar->cal_mode = ATH10K_CAL_MODE_EEPROM;
1433                 goto done;
1434         }
1435
1436         ath10k_dbg(ar, ATH10K_DBG_BOOT,
1437                    "boot did not find target EEPROM entry, try OTP next: %d\n",
1438                    ret);
1439
1440         ret = ath10k_download_and_run_otp(ar);
1441         if (ret) {
1442                 ath10k_err(ar, "failed to run otp: %d\n", ret);
1443                 return ret;
1444         }
1445
1446         ar->cal_mode = ATH10K_CAL_MODE_OTP;
1447
1448 done:
1449         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot using calibration mode %s\n",
1450                    ath10k_cal_mode_str(ar->cal_mode));
1451         return 0;
1452 }
1453
1454 static int ath10k_init_uart(struct ath10k *ar)
1455 {
1456         int ret;
1457
1458         /*
1459          * Explicitly setting UART prints to zero as target turns it on
1460          * based on scratch registers.
1461          */
1462         ret = ath10k_bmi_write32(ar, hi_serial_enable, 0);
1463         if (ret) {
1464                 ath10k_warn(ar, "could not disable UART prints (%d)\n", ret);
1465                 return ret;
1466         }
1467
1468         if (!uart_print)
1469                 return 0;
1470
1471         ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, ar->hw_params.uart_pin);
1472         if (ret) {
1473                 ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
1474                 return ret;
1475         }
1476
1477         ret = ath10k_bmi_write32(ar, hi_serial_enable, 1);
1478         if (ret) {
1479                 ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
1480                 return ret;
1481         }
1482
1483         /* Set the UART baud rate to 19200. */
1484         ret = ath10k_bmi_write32(ar, hi_desired_baud_rate, 19200);
1485         if (ret) {
1486                 ath10k_warn(ar, "could not set the baud rate (%d)\n", ret);
1487                 return ret;
1488         }
1489
1490         ath10k_info(ar, "UART prints enabled\n");
1491         return 0;
1492 }
1493
1494 static int ath10k_init_hw_params(struct ath10k *ar)
1495 {
1496         const struct ath10k_hw_params *uninitialized_var(hw_params);
1497         int i;
1498
1499         for (i = 0; i < ARRAY_SIZE(ath10k_hw_params_list); i++) {
1500                 hw_params = &ath10k_hw_params_list[i];
1501
1502                 if (hw_params->id == ar->target_version &&
1503                     hw_params->dev_id == ar->dev_id)
1504                         break;
1505         }
1506
1507         if (i == ARRAY_SIZE(ath10k_hw_params_list)) {
1508                 ath10k_err(ar, "Unsupported hardware version: 0x%x\n",
1509                            ar->target_version);
1510                 return -EINVAL;
1511         }
1512
1513         ar->hw_params = *hw_params;
1514
1515         ath10k_dbg(ar, ATH10K_DBG_BOOT, "Hardware name %s version 0x%x\n",
1516                    ar->hw_params.name, ar->target_version);
1517
1518         return 0;
1519 }
1520
1521 static void ath10k_core_restart(struct work_struct *work)
1522 {
1523         struct ath10k *ar = container_of(work, struct ath10k, restart_work);
1524
1525         set_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags);
1526
1527         /* Place a barrier to make sure the compiler doesn't reorder
1528          * CRASH_FLUSH and calling other functions.
1529          */
1530         barrier();
1531
1532         ieee80211_stop_queues(ar->hw);
1533         ath10k_drain_tx(ar);
1534         complete(&ar->scan.started);
1535         complete(&ar->scan.completed);
1536         complete(&ar->scan.on_channel);
1537         complete(&ar->offchan_tx_completed);
1538         complete(&ar->install_key_done);
1539         complete(&ar->vdev_setup_done);
1540         complete(&ar->thermal.wmi_sync);
1541         complete(&ar->bss_survey_done);
1542         wake_up(&ar->htt.empty_tx_wq);
1543         wake_up(&ar->wmi.tx_credits_wq);
1544         wake_up(&ar->peer_mapping_wq);
1545
1546         mutex_lock(&ar->conf_mutex);
1547
1548         switch (ar->state) {
1549         case ATH10K_STATE_ON:
1550                 ar->state = ATH10K_STATE_RESTARTING;
1551                 ath10k_halt(ar);
1552                 ath10k_scan_finish(ar);
1553                 ieee80211_restart_hw(ar->hw);
1554                 break;
1555         case ATH10K_STATE_OFF:
1556                 /* this can happen if driver is being unloaded
1557                  * or if the crash happens during FW probing */
1558                 ath10k_warn(ar, "cannot restart a device that hasn't been started\n");
1559                 break;
1560         case ATH10K_STATE_RESTARTING:
1561                 /* hw restart might be requested from multiple places */
1562                 break;
1563         case ATH10K_STATE_RESTARTED:
1564                 ar->state = ATH10K_STATE_WEDGED;
1565                 /* fall through */
1566         case ATH10K_STATE_WEDGED:
1567                 ath10k_warn(ar, "device is wedged, will not restart\n");
1568                 break;
1569         case ATH10K_STATE_UTF:
1570                 ath10k_warn(ar, "firmware restart in UTF mode not supported\n");
1571                 break;
1572         }
1573
1574         mutex_unlock(&ar->conf_mutex);
1575 }
1576
1577 static int ath10k_core_init_firmware_features(struct ath10k *ar)
1578 {
1579         struct ath10k_fw_file *fw_file = &ar->normal_mode_fw.fw_file;
1580
1581         if (test_bit(ATH10K_FW_FEATURE_WMI_10_2, fw_file->fw_features) &&
1582             !test_bit(ATH10K_FW_FEATURE_WMI_10X, fw_file->fw_features)) {
1583                 ath10k_err(ar, "feature bits corrupted: 10.2 feature requires 10.x feature to be set as well");
1584                 return -EINVAL;
1585         }
1586
1587         if (fw_file->wmi_op_version >= ATH10K_FW_WMI_OP_VERSION_MAX) {
1588                 ath10k_err(ar, "unsupported WMI OP version (max %d): %d\n",
1589                            ATH10K_FW_WMI_OP_VERSION_MAX, fw_file->wmi_op_version);
1590                 return -EINVAL;
1591         }
1592
1593         ar->wmi.rx_decap_mode = ATH10K_HW_TXRX_NATIVE_WIFI;
1594         switch (ath10k_cryptmode_param) {
1595         case ATH10K_CRYPT_MODE_HW:
1596                 clear_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags);
1597                 clear_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags);
1598                 break;
1599         case ATH10K_CRYPT_MODE_SW:
1600                 if (!test_bit(ATH10K_FW_FEATURE_RAW_MODE_SUPPORT,
1601                               fw_file->fw_features)) {
1602                         ath10k_err(ar, "cryptmode > 0 requires raw mode support from firmware");
1603                         return -EINVAL;
1604                 }
1605
1606                 set_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags);
1607                 set_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags);
1608                 break;
1609         default:
1610                 ath10k_info(ar, "invalid cryptmode: %d\n",
1611                             ath10k_cryptmode_param);
1612                 return -EINVAL;
1613         }
1614
1615         ar->htt.max_num_amsdu = ATH10K_HTT_MAX_NUM_AMSDU_DEFAULT;
1616         ar->htt.max_num_ampdu = ATH10K_HTT_MAX_NUM_AMPDU_DEFAULT;
1617
1618         if (rawmode) {
1619                 if (!test_bit(ATH10K_FW_FEATURE_RAW_MODE_SUPPORT,
1620                               fw_file->fw_features)) {
1621                         ath10k_err(ar, "rawmode = 1 requires support from firmware");
1622                         return -EINVAL;
1623                 }
1624                 set_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags);
1625         }
1626
1627         if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
1628                 ar->wmi.rx_decap_mode = ATH10K_HW_TXRX_RAW;
1629
1630                 /* Workaround:
1631                  *
1632                  * Firmware A-MSDU aggregation breaks with RAW Tx encap mode
1633                  * and causes enormous performance issues (malformed frames,
1634                  * etc).
1635                  *
1636                  * Disabling A-MSDU makes RAW mode stable with heavy traffic
1637                  * albeit a bit slower compared to regular operation.
1638                  */
1639                 ar->htt.max_num_amsdu = 1;
1640         }
1641
1642         /* Backwards compatibility for firmwares without
1643          * ATH10K_FW_IE_WMI_OP_VERSION.
1644          */
1645         if (fw_file->wmi_op_version == ATH10K_FW_WMI_OP_VERSION_UNSET) {
1646                 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, fw_file->fw_features)) {
1647                         if (test_bit(ATH10K_FW_FEATURE_WMI_10_2,
1648                                      fw_file->fw_features))
1649                                 fw_file->wmi_op_version = ATH10K_FW_WMI_OP_VERSION_10_2;
1650                         else
1651                                 fw_file->wmi_op_version = ATH10K_FW_WMI_OP_VERSION_10_1;
1652                 } else {
1653                         fw_file->wmi_op_version = ATH10K_FW_WMI_OP_VERSION_MAIN;
1654                 }
1655         }
1656
1657         switch (fw_file->wmi_op_version) {
1658         case ATH10K_FW_WMI_OP_VERSION_MAIN:
1659                 ar->max_num_peers = TARGET_NUM_PEERS;
1660                 ar->max_num_stations = TARGET_NUM_STATIONS;
1661                 ar->max_num_vdevs = TARGET_NUM_VDEVS;
1662                 ar->htt.max_num_pending_tx = TARGET_NUM_MSDU_DESC;
1663                 ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
1664                         WMI_STAT_PEER;
1665                 ar->max_spatial_stream = WMI_MAX_SPATIAL_STREAM;
1666                 break;
1667         case ATH10K_FW_WMI_OP_VERSION_10_1:
1668         case ATH10K_FW_WMI_OP_VERSION_10_2:
1669         case ATH10K_FW_WMI_OP_VERSION_10_2_4:
1670                 if (ath10k_peer_stats_enabled(ar)) {
1671                         ar->max_num_peers = TARGET_10X_TX_STATS_NUM_PEERS;
1672                         ar->max_num_stations = TARGET_10X_TX_STATS_NUM_STATIONS;
1673                 } else {
1674                         ar->max_num_peers = TARGET_10X_NUM_PEERS;
1675                         ar->max_num_stations = TARGET_10X_NUM_STATIONS;
1676                 }
1677                 ar->max_num_vdevs = TARGET_10X_NUM_VDEVS;
1678                 ar->htt.max_num_pending_tx = TARGET_10X_NUM_MSDU_DESC;
1679                 ar->fw_stats_req_mask = WMI_STAT_PEER;
1680                 ar->max_spatial_stream = WMI_MAX_SPATIAL_STREAM;
1681                 break;
1682         case ATH10K_FW_WMI_OP_VERSION_TLV:
1683                 ar->max_num_peers = TARGET_TLV_NUM_PEERS;
1684                 ar->max_num_stations = TARGET_TLV_NUM_STATIONS;
1685                 ar->max_num_vdevs = TARGET_TLV_NUM_VDEVS;
1686                 ar->max_num_tdls_vdevs = TARGET_TLV_NUM_TDLS_VDEVS;
1687                 ar->htt.max_num_pending_tx = TARGET_TLV_NUM_MSDU_DESC;
1688                 ar->wow.max_num_patterns = TARGET_TLV_NUM_WOW_PATTERNS;
1689                 ar->fw_stats_req_mask = WMI_STAT_PDEV | WMI_STAT_VDEV |
1690                         WMI_STAT_PEER;
1691                 ar->max_spatial_stream = WMI_MAX_SPATIAL_STREAM;
1692                 break;
1693         case ATH10K_FW_WMI_OP_VERSION_10_4:
1694                 ar->max_num_peers = TARGET_10_4_NUM_PEERS;
1695                 ar->max_num_stations = TARGET_10_4_NUM_STATIONS;
1696                 ar->num_active_peers = TARGET_10_4_ACTIVE_PEERS;
1697                 ar->max_num_vdevs = TARGET_10_4_NUM_VDEVS;
1698                 ar->num_tids = TARGET_10_4_TGT_NUM_TIDS;
1699                 ar->fw_stats_req_mask = WMI_10_4_STAT_PEER |
1700                                         WMI_10_4_STAT_PEER_EXTD;
1701                 ar->max_spatial_stream = ar->hw_params.max_spatial_stream;
1702
1703                 if (test_bit(ATH10K_FW_FEATURE_PEER_FLOW_CONTROL,
1704                              fw_file->fw_features))
1705                         ar->htt.max_num_pending_tx = TARGET_10_4_NUM_MSDU_DESC_PFC;
1706                 else
1707                         ar->htt.max_num_pending_tx = TARGET_10_4_NUM_MSDU_DESC;
1708                 break;
1709         case ATH10K_FW_WMI_OP_VERSION_UNSET:
1710         case ATH10K_FW_WMI_OP_VERSION_MAX:
1711                 WARN_ON(1);
1712                 return -EINVAL;
1713         }
1714
1715         /* Backwards compatibility for firmwares without
1716          * ATH10K_FW_IE_HTT_OP_VERSION.
1717          */
1718         if (fw_file->htt_op_version == ATH10K_FW_HTT_OP_VERSION_UNSET) {
1719                 switch (fw_file->wmi_op_version) {
1720                 case ATH10K_FW_WMI_OP_VERSION_MAIN:
1721                         fw_file->htt_op_version = ATH10K_FW_HTT_OP_VERSION_MAIN;
1722                         break;
1723                 case ATH10K_FW_WMI_OP_VERSION_10_1:
1724                 case ATH10K_FW_WMI_OP_VERSION_10_2:
1725                 case ATH10K_FW_WMI_OP_VERSION_10_2_4:
1726                         fw_file->htt_op_version = ATH10K_FW_HTT_OP_VERSION_10_1;
1727                         break;
1728                 case ATH10K_FW_WMI_OP_VERSION_TLV:
1729                         fw_file->htt_op_version = ATH10K_FW_HTT_OP_VERSION_TLV;
1730                         break;
1731                 case ATH10K_FW_WMI_OP_VERSION_10_4:
1732                 case ATH10K_FW_WMI_OP_VERSION_UNSET:
1733                 case ATH10K_FW_WMI_OP_VERSION_MAX:
1734                         ath10k_err(ar, "htt op version not found from fw meta data");
1735                         return -EINVAL;
1736                 }
1737         }
1738
1739         return 0;
1740 }
1741
1742 static int ath10k_core_reset_rx_filter(struct ath10k *ar)
1743 {
1744         int ret;
1745         int vdev_id;
1746         int vdev_type;
1747         int vdev_subtype;
1748         const u8 *vdev_addr;
1749
1750         vdev_id = 0;
1751         vdev_type = WMI_VDEV_TYPE_STA;
1752         vdev_subtype = ath10k_wmi_get_vdev_subtype(ar, WMI_VDEV_SUBTYPE_NONE);
1753         vdev_addr = ar->mac_addr;
1754
1755         ret = ath10k_wmi_vdev_create(ar, vdev_id, vdev_type, vdev_subtype,
1756                                      vdev_addr);
1757         if (ret) {
1758                 ath10k_err(ar, "failed to create dummy vdev: %d\n", ret);
1759                 return ret;
1760         }
1761
1762         ret = ath10k_wmi_vdev_delete(ar, vdev_id);
1763         if (ret) {
1764                 ath10k_err(ar, "failed to delete dummy vdev: %d\n", ret);
1765                 return ret;
1766         }
1767
1768         /* WMI and HTT may use separate HIF pipes and are not guaranteed to be
1769          * serialized properly implicitly.
1770          *
1771          * Moreover (most) WMI commands have no explicit acknowledges. It is
1772          * possible to infer it implicitly by poking firmware with echo
1773          * command - getting a reply means all preceding comments have been
1774          * (mostly) processed.
1775          *
1776          * In case of vdev create/delete this is sufficient.
1777          *
1778          * Without this it's possible to end up with a race when HTT Rx ring is
1779          * started before vdev create/delete hack is complete allowing a short
1780          * window of opportunity to receive (and Tx ACK) a bunch of frames.
1781          */
1782         ret = ath10k_wmi_barrier(ar);
1783         if (ret) {
1784                 ath10k_err(ar, "failed to ping firmware: %d\n", ret);
1785                 return ret;
1786         }
1787
1788         return 0;
1789 }
1790
1791 int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode,
1792                       const struct ath10k_fw_components *fw)
1793 {
1794         int status;
1795         u32 val;
1796
1797         lockdep_assert_held(&ar->conf_mutex);
1798
1799         clear_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags);
1800
1801         ar->running_fw = fw;
1802
1803         ath10k_bmi_start(ar);
1804
1805         if (ath10k_init_configure_target(ar)) {
1806                 status = -EINVAL;
1807                 goto err;
1808         }
1809
1810         status = ath10k_download_cal_data(ar);
1811         if (status)
1812                 goto err;
1813
1814         /* Some of of qca988x solutions are having global reset issue
1815          * during target initialization. Bypassing PLL setting before
1816          * downloading firmware and letting the SoC run on REF_CLK is
1817          * fixing the problem. Corresponding firmware change is also needed
1818          * to set the clock source once the target is initialized.
1819          */
1820         if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_SKIP_CLOCK_INIT,
1821                      ar->running_fw->fw_file.fw_features)) {
1822                 status = ath10k_bmi_write32(ar, hi_skip_clock_init, 1);
1823                 if (status) {
1824                         ath10k_err(ar, "could not write to skip_clock_init: %d\n",
1825                                    status);
1826                         goto err;
1827                 }
1828         }
1829
1830         status = ath10k_download_fw(ar);
1831         if (status)
1832                 goto err;
1833
1834         status = ath10k_init_uart(ar);
1835         if (status)
1836                 goto err;
1837
1838         ar->htc.htc_ops.target_send_suspend_complete =
1839                 ath10k_send_suspend_complete;
1840
1841         status = ath10k_htc_init(ar);
1842         if (status) {
1843                 ath10k_err(ar, "could not init HTC (%d)\n", status);
1844                 goto err;
1845         }
1846
1847         status = ath10k_bmi_done(ar);
1848         if (status)
1849                 goto err;
1850
1851         status = ath10k_wmi_attach(ar);
1852         if (status) {
1853                 ath10k_err(ar, "WMI attach failed: %d\n", status);
1854                 goto err;
1855         }
1856
1857         status = ath10k_htt_init(ar);
1858         if (status) {
1859                 ath10k_err(ar, "failed to init htt: %d\n", status);
1860                 goto err_wmi_detach;
1861         }
1862
1863         status = ath10k_htt_tx_alloc(&ar->htt);
1864         if (status) {
1865                 ath10k_err(ar, "failed to alloc htt tx: %d\n", status);
1866                 goto err_wmi_detach;
1867         }
1868
1869         /* If firmware indicates Full Rx Reorder support it must be used in a
1870          * slightly different manner. Let HTT code know.
1871          */
1872         ar->htt.rx_ring.in_ord_rx = !!(test_bit(WMI_SERVICE_RX_FULL_REORDER,
1873                                                 ar->wmi.svc_map));
1874
1875         status = ath10k_htt_rx_alloc(&ar->htt);
1876         if (status) {
1877                 ath10k_err(ar, "failed to alloc htt rx: %d\n", status);
1878                 goto err_htt_tx_detach;
1879         }
1880
1881         status = ath10k_hif_start(ar);
1882         if (status) {
1883                 ath10k_err(ar, "could not start HIF: %d\n", status);
1884                 goto err_htt_rx_detach;
1885         }
1886
1887         status = ath10k_htc_wait_target(&ar->htc);
1888         if (status) {
1889                 ath10k_err(ar, "failed to connect to HTC: %d\n", status);
1890                 goto err_hif_stop;
1891         }
1892
1893         if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
1894                 status = ath10k_htt_connect(&ar->htt);
1895                 if (status) {
1896                         ath10k_err(ar, "failed to connect htt (%d)\n", status);
1897                         goto err_hif_stop;
1898                 }
1899         }
1900
1901         status = ath10k_wmi_connect(ar);
1902         if (status) {
1903                 ath10k_err(ar, "could not connect wmi: %d\n", status);
1904                 goto err_hif_stop;
1905         }
1906
1907         status = ath10k_htc_start(&ar->htc);
1908         if (status) {
1909                 ath10k_err(ar, "failed to start htc: %d\n", status);
1910                 goto err_hif_stop;
1911         }
1912
1913         if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
1914                 status = ath10k_wmi_wait_for_service_ready(ar);
1915                 if (status) {
1916                         ath10k_warn(ar, "wmi service ready event not received");
1917                         goto err_hif_stop;
1918                 }
1919         }
1920
1921         ath10k_dbg(ar, ATH10K_DBG_BOOT, "firmware %s booted\n",
1922                    ar->hw->wiphy->fw_version);
1923
1924         if (test_bit(WMI_SERVICE_EXT_RES_CFG_SUPPORT, ar->wmi.svc_map) &&
1925             mode == ATH10K_FIRMWARE_MODE_NORMAL) {
1926                 val = 0;
1927                 if (ath10k_peer_stats_enabled(ar))
1928                         val = WMI_10_4_PEER_STATS;
1929
1930                 if (test_bit(WMI_SERVICE_BSS_CHANNEL_INFO_64, ar->wmi.svc_map))
1931                         val |= WMI_10_4_BSS_CHANNEL_INFO_64;
1932
1933                 /* 10.4 firmware supports BT-Coex without reloading firmware
1934                  * via pdev param. To support Bluetooth coexistence pdev param,
1935                  * WMI_COEX_GPIO_SUPPORT of extended resource config should be
1936                  * enabled always.
1937                  */
1938                 if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map) &&
1939                     test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM,
1940                              ar->running_fw->fw_file.fw_features))
1941                         val |= WMI_10_4_COEX_GPIO_SUPPORT;
1942
1943                 status = ath10k_mac_ext_resource_config(ar, val);
1944                 if (status) {
1945                         ath10k_err(ar,
1946                                    "failed to send ext resource cfg command : %d\n",
1947                                    status);
1948                         goto err_hif_stop;
1949                 }
1950         }
1951
1952         status = ath10k_wmi_cmd_init(ar);
1953         if (status) {
1954                 ath10k_err(ar, "could not send WMI init command (%d)\n",
1955                            status);
1956                 goto err_hif_stop;
1957         }
1958
1959         status = ath10k_wmi_wait_for_unified_ready(ar);
1960         if (status) {
1961                 ath10k_err(ar, "wmi unified ready event not received\n");
1962                 goto err_hif_stop;
1963         }
1964
1965         /* Some firmware revisions do not properly set up hardware rx filter
1966          * registers.
1967          *
1968          * A known example from QCA9880 and 10.2.4 is that MAC_PCU_ADDR1_MASK
1969          * is filled with 0s instead of 1s allowing HW to respond with ACKs to
1970          * any frames that matches MAC_PCU_RX_FILTER which is also
1971          * misconfigured to accept anything.
1972          *
1973          * The ADDR1 is programmed using internal firmware structure field and
1974          * can't be (easily/sanely) reached from the driver explicitly. It is
1975          * possible to implicitly make it correct by creating a dummy vdev and
1976          * then deleting it.
1977          */
1978         if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
1979                 status = ath10k_core_reset_rx_filter(ar);
1980                 if (status) {
1981                         ath10k_err(ar,
1982                                    "failed to reset rx filter: %d\n", status);
1983                         goto err_hif_stop;
1984                 }
1985         }
1986
1987         status = ath10k_htt_rx_ring_refill(ar);
1988         if (status) {
1989                 ath10k_err(ar, "failed to refill htt rx ring: %d\n", status);
1990                 goto err_hif_stop;
1991         }
1992
1993         if (ar->max_num_vdevs >= 64)
1994                 ar->free_vdev_map = 0xFFFFFFFFFFFFFFFFLL;
1995         else
1996                 ar->free_vdev_map = (1LL << ar->max_num_vdevs) - 1;
1997
1998         INIT_LIST_HEAD(&ar->arvifs);
1999
2000         /* we don't care about HTT in UTF mode */
2001         if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
2002                 status = ath10k_htt_setup(&ar->htt);
2003                 if (status) {
2004                         ath10k_err(ar, "failed to setup htt: %d\n", status);
2005                         goto err_hif_stop;
2006                 }
2007         }
2008
2009         status = ath10k_debug_start(ar);
2010         if (status)
2011                 goto err_hif_stop;
2012
2013         return 0;
2014
2015 err_hif_stop:
2016         ath10k_hif_stop(ar);
2017 err_htt_rx_detach:
2018         ath10k_htt_rx_free(&ar->htt);
2019 err_htt_tx_detach:
2020         ath10k_htt_tx_free(&ar->htt);
2021 err_wmi_detach:
2022         ath10k_wmi_detach(ar);
2023 err:
2024         return status;
2025 }
2026 EXPORT_SYMBOL(ath10k_core_start);
2027
2028 int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt)
2029 {
2030         int ret;
2031         unsigned long time_left;
2032
2033         reinit_completion(&ar->target_suspend);
2034
2035         ret = ath10k_wmi_pdev_suspend_target(ar, suspend_opt);
2036         if (ret) {
2037                 ath10k_warn(ar, "could not suspend target (%d)\n", ret);
2038                 return ret;
2039         }
2040
2041         time_left = wait_for_completion_timeout(&ar->target_suspend, 1 * HZ);
2042
2043         if (!time_left) {
2044                 ath10k_warn(ar, "suspend timed out - target pause event never came\n");
2045                 return -ETIMEDOUT;
2046         }
2047
2048         return 0;
2049 }
2050
2051 void ath10k_core_stop(struct ath10k *ar)
2052 {
2053         lockdep_assert_held(&ar->conf_mutex);
2054         ath10k_debug_stop(ar);
2055
2056         /* try to suspend target */
2057         if (ar->state != ATH10K_STATE_RESTARTING &&
2058             ar->state != ATH10K_STATE_UTF)
2059                 ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND_AND_DISABLE_INTR);
2060
2061         ath10k_hif_stop(ar);
2062         ath10k_htt_tx_free(&ar->htt);
2063         ath10k_htt_rx_free(&ar->htt);
2064         ath10k_wmi_detach(ar);
2065 }
2066 EXPORT_SYMBOL(ath10k_core_stop);
2067
2068 /* mac80211 manages fw/hw initialization through start/stop hooks. However in
2069  * order to know what hw capabilities should be advertised to mac80211 it is
2070  * necessary to load the firmware (and tear it down immediately since start
2071  * hook will try to init it again) before registering */
2072 static int ath10k_core_probe_fw(struct ath10k *ar)
2073 {
2074         struct bmi_target_info target_info;
2075         int ret = 0;
2076
2077         ret = ath10k_hif_power_up(ar);
2078         if (ret) {
2079                 ath10k_err(ar, "could not start pci hif (%d)\n", ret);
2080                 return ret;
2081         }
2082
2083         memset(&target_info, 0, sizeof(target_info));
2084         ret = ath10k_bmi_get_target_info(ar, &target_info);
2085         if (ret) {
2086                 ath10k_err(ar, "could not get target info (%d)\n", ret);
2087                 goto err_power_down;
2088         }
2089
2090         ar->target_version = target_info.version;
2091         ar->hw->wiphy->hw_version = target_info.version;
2092
2093         ret = ath10k_init_hw_params(ar);
2094         if (ret) {
2095                 ath10k_err(ar, "could not get hw params (%d)\n", ret);
2096                 goto err_power_down;
2097         }
2098
2099         ret = ath10k_core_fetch_firmware_files(ar);
2100         if (ret) {
2101                 ath10k_err(ar, "could not fetch firmware files (%d)\n", ret);
2102                 goto err_power_down;
2103         }
2104
2105         BUILD_BUG_ON(sizeof(ar->hw->wiphy->fw_version) !=
2106                      sizeof(ar->normal_mode_fw.fw_file.fw_version));
2107         memcpy(ar->hw->wiphy->fw_version, ar->normal_mode_fw.fw_file.fw_version,
2108                sizeof(ar->hw->wiphy->fw_version));
2109
2110         ath10k_debug_print_hwfw_info(ar);
2111
2112         ret = ath10k_core_pre_cal_download(ar);
2113         if (ret) {
2114                 /* pre calibration data download is not necessary
2115                  * for all the chipsets. Ignore failures and continue.
2116                  */
2117                 ath10k_dbg(ar, ATH10K_DBG_BOOT,
2118                            "could not load pre cal data: %d\n", ret);
2119         }
2120
2121         ret = ath10k_core_get_board_id_from_otp(ar);
2122         if (ret && ret != -EOPNOTSUPP) {
2123                 ath10k_err(ar, "failed to get board id from otp: %d\n",
2124                            ret);
2125                 goto err_free_firmware_files;
2126         }
2127
2128         ret = ath10k_core_fetch_board_file(ar);
2129         if (ret) {
2130                 ath10k_err(ar, "failed to fetch board file: %d\n", ret);
2131                 goto err_free_firmware_files;
2132         }
2133
2134         ath10k_debug_print_board_info(ar);
2135
2136         ret = ath10k_core_init_firmware_features(ar);
2137         if (ret) {
2138                 ath10k_err(ar, "fatal problem with firmware features: %d\n",
2139                            ret);
2140                 goto err_free_firmware_files;
2141         }
2142
2143         ret = ath10k_swap_code_seg_init(ar, &ar->normal_mode_fw.fw_file);
2144         if (ret) {
2145                 ath10k_err(ar, "failed to initialize code swap segment: %d\n",
2146                            ret);
2147                 goto err_free_firmware_files;
2148         }
2149
2150         mutex_lock(&ar->conf_mutex);
2151
2152         ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL,
2153                                 &ar->normal_mode_fw);
2154         if (ret) {
2155                 ath10k_err(ar, "could not init core (%d)\n", ret);
2156                 goto err_unlock;
2157         }
2158
2159         ath10k_debug_print_boot_info(ar);
2160         ath10k_core_stop(ar);
2161
2162         mutex_unlock(&ar->conf_mutex);
2163
2164         ath10k_hif_power_down(ar);
2165         return 0;
2166
2167 err_unlock:
2168         mutex_unlock(&ar->conf_mutex);
2169
2170 err_free_firmware_files:
2171         ath10k_core_free_firmware_files(ar);
2172
2173 err_power_down:
2174         ath10k_hif_power_down(ar);
2175
2176         return ret;
2177 }
2178
2179 static void ath10k_core_register_work(struct work_struct *work)
2180 {
2181         struct ath10k *ar = container_of(work, struct ath10k, register_work);
2182         int status;
2183
2184         /* peer stats are enabled by default */
2185         set_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags);
2186
2187         status = ath10k_core_probe_fw(ar);
2188         if (status) {
2189                 ath10k_err(ar, "could not probe fw (%d)\n", status);
2190                 goto err;
2191         }
2192
2193         status = ath10k_mac_register(ar);
2194         if (status) {
2195                 ath10k_err(ar, "could not register to mac80211 (%d)\n", status);
2196                 goto err_release_fw;
2197         }
2198
2199         status = ath10k_debug_register(ar);
2200         if (status) {
2201                 ath10k_err(ar, "unable to initialize debugfs\n");
2202                 goto err_unregister_mac;
2203         }
2204
2205         status = ath10k_spectral_create(ar);
2206         if (status) {
2207                 ath10k_err(ar, "failed to initialize spectral\n");
2208                 goto err_debug_destroy;
2209         }
2210
2211         status = ath10k_thermal_register(ar);
2212         if (status) {
2213                 ath10k_err(ar, "could not register thermal device: %d\n",
2214                            status);
2215                 goto err_spectral_destroy;
2216         }
2217
2218         set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);
2219         return;
2220
2221 err_spectral_destroy:
2222         ath10k_spectral_destroy(ar);
2223 err_debug_destroy:
2224         ath10k_debug_destroy(ar);
2225 err_unregister_mac:
2226         ath10k_mac_unregister(ar);
2227 err_release_fw:
2228         ath10k_core_free_firmware_files(ar);
2229 err:
2230         /* TODO: It's probably a good idea to release device from the driver
2231          * but calling device_release_driver() here will cause a deadlock.
2232          */
2233         return;
2234 }
2235
2236 int ath10k_core_register(struct ath10k *ar, u32 chip_id)
2237 {
2238         ar->chip_id = chip_id;
2239         queue_work(ar->workqueue, &ar->register_work);
2240
2241         return 0;
2242 }
2243 EXPORT_SYMBOL(ath10k_core_register);
2244
2245 void ath10k_core_unregister(struct ath10k *ar)
2246 {
2247         cancel_work_sync(&ar->register_work);
2248
2249         if (!test_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags))
2250                 return;
2251
2252         ath10k_thermal_unregister(ar);
2253         /* Stop spectral before unregistering from mac80211 to remove the
2254          * relayfs debugfs file cleanly. Otherwise the parent debugfs tree
2255          * would be already be free'd recursively, leading to a double free.
2256          */
2257         ath10k_spectral_destroy(ar);
2258
2259         /* We must unregister from mac80211 before we stop HTC and HIF.
2260          * Otherwise we will fail to submit commands to FW and mac80211 will be
2261          * unhappy about callback failures. */
2262         ath10k_mac_unregister(ar);
2263
2264         ath10k_testmode_destroy(ar);
2265
2266         ath10k_core_free_firmware_files(ar);
2267         ath10k_core_free_board_files(ar);
2268
2269         ath10k_debug_unregister(ar);
2270 }
2271 EXPORT_SYMBOL(ath10k_core_unregister);
2272
2273 struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
2274                                   enum ath10k_bus bus,
2275                                   enum ath10k_hw_rev hw_rev,
2276                                   const struct ath10k_hif_ops *hif_ops)
2277 {
2278         struct ath10k *ar;
2279         int ret;
2280
2281         ar = ath10k_mac_create(priv_size);
2282         if (!ar)
2283                 return NULL;
2284
2285         ar->ath_common.priv = ar;
2286         ar->ath_common.hw = ar->hw;
2287         ar->dev = dev;
2288         ar->hw_rev = hw_rev;
2289         ar->hif.ops = hif_ops;
2290         ar->hif.bus = bus;
2291
2292         switch (hw_rev) {
2293         case ATH10K_HW_QCA988X:
2294         case ATH10K_HW_QCA9887:
2295                 ar->regs = &qca988x_regs;
2296                 ar->hw_values = &qca988x_values;
2297                 break;
2298         case ATH10K_HW_QCA6174:
2299         case ATH10K_HW_QCA9377:
2300                 ar->regs = &qca6174_regs;
2301                 ar->hw_values = &qca6174_values;
2302                 break;
2303         case ATH10K_HW_QCA99X0:
2304         case ATH10K_HW_QCA9984:
2305                 ar->regs = &qca99x0_regs;
2306                 ar->hw_values = &qca99x0_values;
2307                 break;
2308         case ATH10K_HW_QCA9888:
2309                 ar->regs = &qca99x0_regs;
2310                 ar->hw_values = &qca9888_values;
2311                 break;
2312         case ATH10K_HW_QCA4019:
2313                 ar->regs = &qca4019_regs;
2314                 ar->hw_values = &qca4019_values;
2315                 break;
2316         default:
2317                 ath10k_err(ar, "unsupported core hardware revision %d\n",
2318                            hw_rev);
2319                 ret = -ENOTSUPP;
2320                 goto err_free_mac;
2321         }
2322
2323         init_completion(&ar->scan.started);
2324         init_completion(&ar->scan.completed);
2325         init_completion(&ar->scan.on_channel);
2326         init_completion(&ar->target_suspend);
2327         init_completion(&ar->wow.wakeup_completed);
2328
2329         init_completion(&ar->install_key_done);
2330         init_completion(&ar->vdev_setup_done);
2331         init_completion(&ar->thermal.wmi_sync);
2332         init_completion(&ar->bss_survey_done);
2333
2334         INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
2335
2336         ar->workqueue = create_singlethread_workqueue("ath10k_wq");
2337         if (!ar->workqueue)
2338                 goto err_free_mac;
2339
2340         ar->workqueue_aux = create_singlethread_workqueue("ath10k_aux_wq");
2341         if (!ar->workqueue_aux)
2342                 goto err_free_wq;
2343
2344         mutex_init(&ar->conf_mutex);
2345         spin_lock_init(&ar->data_lock);
2346         spin_lock_init(&ar->txqs_lock);
2347
2348         INIT_LIST_HEAD(&ar->txqs);
2349         INIT_LIST_HEAD(&ar->peers);
2350         init_waitqueue_head(&ar->peer_mapping_wq);
2351         init_waitqueue_head(&ar->htt.empty_tx_wq);
2352         init_waitqueue_head(&ar->wmi.tx_credits_wq);
2353
2354         init_completion(&ar->offchan_tx_completed);
2355         INIT_WORK(&ar->offchan_tx_work, ath10k_offchan_tx_work);
2356         skb_queue_head_init(&ar->offchan_tx_queue);
2357
2358         INIT_WORK(&ar->wmi_mgmt_tx_work, ath10k_mgmt_over_wmi_tx_work);
2359         skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
2360
2361         INIT_WORK(&ar->register_work, ath10k_core_register_work);
2362         INIT_WORK(&ar->restart_work, ath10k_core_restart);
2363
2364         init_dummy_netdev(&ar->napi_dev);
2365
2366         ret = ath10k_debug_create(ar);
2367         if (ret)
2368                 goto err_free_aux_wq;
2369
2370         return ar;
2371
2372 err_free_aux_wq:
2373         destroy_workqueue(ar->workqueue_aux);
2374 err_free_wq:
2375         destroy_workqueue(ar->workqueue);
2376
2377 err_free_mac:
2378         ath10k_mac_destroy(ar);
2379
2380         return NULL;
2381 }
2382 EXPORT_SYMBOL(ath10k_core_create);
2383
2384 void ath10k_core_destroy(struct ath10k *ar)
2385 {
2386         flush_workqueue(ar->workqueue);
2387         destroy_workqueue(ar->workqueue);
2388
2389         flush_workqueue(ar->workqueue_aux);
2390         destroy_workqueue(ar->workqueue_aux);
2391
2392         ath10k_debug_destroy(ar);
2393         ath10k_wmi_free_host_mem(ar);
2394         ath10k_mac_destroy(ar);
2395 }
2396 EXPORT_SYMBOL(ath10k_core_destroy);
2397
2398 MODULE_AUTHOR("Qualcomm Atheros");
2399 MODULE_DESCRIPTION("Core module for Qualcomm Atheros 802.11ac wireless LAN cards.");
2400 MODULE_LICENSE("Dual BSD/GPL");