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