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