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
  32 unsigned int ath10k_debug_mask;
  33 static bool uart_print;
  34 static unsigned int ath10k_p2p;
  35 static bool skip_otp;
  36
  37 module_param_named(debug_mask, ath10k_debug_mask, uint, 0644);
  38 module_param(uart_print, bool, 0644);
  39 module_param_named(p2p, ath10k_p2p, uint, 0644);
  40 module_param(skip_otp, bool, 0644);
  41
  42 MODULE_PARM_DESC(debug_mask, "Debugging mask");
  43 MODULE_PARM_DESC(uart_print, "Uart target debugging");
  44 MODULE_PARM_DESC(p2p, "Enable ath10k P2P support");
  45 MODULE_PARM_DESC(skip_otp, "Skip otp failure for calibration in testmode");
  46
  47 static const struct ath10k_hw_params ath10k_hw_params_list[] = {
  48         {
  49                 .id = QCA988X_HW_2_0_VERSION,
  50                 .name = "qca988x hw2.0",
  51                 .patch_load_addr = QCA988X_HW_2_0_PATCH_LOAD_ADDR,
  52                 .uart_pin = 7,
  53                 .fw = {
  54                         .dir = QCA988X_HW_2_0_FW_DIR,
  55                         .fw = QCA988X_HW_2_0_FW_FILE,
  56                         .otp = QCA988X_HW_2_0_OTP_FILE,
  57                         .board = QCA988X_HW_2_0_BOARD_DATA_FILE,
  58                         .board_size = QCA988X_BOARD_DATA_SZ,
  59                         .board_ext_size = QCA988X_BOARD_EXT_DATA_SZ,
  60                 },
  61         },
  62 };
  63
  64 static void ath10k_send_suspend_complete(struct ath10k *ar)
  65 {
  66         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot suspend complete\n");
  67
  68         complete(&ar->target_suspend);
  69 }
  70
  71 static int ath10k_init_configure_target(struct ath10k *ar)
  72 {
  73         u32 param_host;
  74         int ret;
  75
  76         /* tell target which HTC version it is used*/
  77         ret = ath10k_bmi_write32(ar, hi_app_host_interest,
  78                                  HTC_PROTOCOL_VERSION);
  79         if (ret) {
  80                 ath10k_err(ar, "settings HTC version failed\n");
  81                 return ret;
  82         }
  83
  84         /* set the firmware mode to STA/IBSS/AP */
  85         ret = ath10k_bmi_read32(ar, hi_option_flag, &param_host);
  86         if (ret) {
  87                 ath10k_err(ar, "setting firmware mode (1/2) failed\n");
  88                 return ret;
  89         }
  90
  91         /* TODO following parameters need to be re-visited. */
  92         /* num_device */
  93         param_host |= (1 << HI_OPTION_NUM_DEV_SHIFT);
  94         /* Firmware mode */
  95         /* FIXME: Why FW_MODE_AP ??.*/
  96         param_host |= (HI_OPTION_FW_MODE_AP << HI_OPTION_FW_MODE_SHIFT);
  97         /* mac_addr_method */
  98         param_host |= (1 << HI_OPTION_MAC_ADDR_METHOD_SHIFT);
  99         /* firmware_bridge */
 100         param_host |= (0 << HI_OPTION_FW_BRIDGE_SHIFT);
 101         /* fwsubmode */
 102         param_host |= (0 << HI_OPTION_FW_SUBMODE_SHIFT);
 103
 104         ret = ath10k_bmi_write32(ar, hi_option_flag, param_host);
 105         if (ret) {
 106                 ath10k_err(ar, "setting firmware mode (2/2) failed\n");
 107                 return ret;
 108         }
 109
 110         /* We do all byte-swapping on the host */
 111         ret = ath10k_bmi_write32(ar, hi_be, 0);
 112         if (ret) {
 113                 ath10k_err(ar, "setting host CPU BE mode failed\n");
 114                 return ret;
 115         }
 116
 117         /* FW descriptor/Data swap flags */
 118         ret = ath10k_bmi_write32(ar, hi_fw_swap, 0);
 119
 120         if (ret) {
 121                 ath10k_err(ar, "setting FW data/desc swap flags failed\n");
 122                 return ret;
 123         }
 124
 125         return 0;
 126 }
 127
 128 static const struct firmware *ath10k_fetch_fw_file(struct ath10k *ar,
 129                                                    const char *dir,
 130                                                    const char *file)
 131 {
 132         char filename[100];
 133         const struct firmware *fw;
 134         int ret;
 135
 136         if (file == NULL)
 137                 return ERR_PTR(-ENOENT);
 138
 139         if (dir == NULL)
 140                 dir = ".";
 141
 142         snprintf(filename, sizeof(filename), "%s/%s", dir, file);
 143         ret = request_firmware(&fw, filename, ar->dev);
 144         if (ret)
 145                 return ERR_PTR(ret);
 146
 147         return fw;
 148 }
 149
 150 static int ath10k_push_board_ext_data(struct ath10k *ar, const void *data,
 151                                       size_t data_len)
 152 {
 153         u32 board_data_size = ar->hw_params.fw.board_size;
 154         u32 board_ext_data_size = ar->hw_params.fw.board_ext_size;
 155         u32 board_ext_data_addr;
 156         int ret;
 157
 158         ret = ath10k_bmi_read32(ar, hi_board_ext_data, &board_ext_data_addr);
 159         if (ret) {
 160                 ath10k_err(ar, "could not read board ext data addr (%d)\n",
 161                            ret);
 162                 return ret;
 163         }
 164
 165         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 166                    "boot push board extended data addr 0x%x\n",
 167                    board_ext_data_addr);
 168
 169         if (board_ext_data_addr == 0)
 170                 return 0;
 171
 172         if (data_len != (board_data_size + board_ext_data_size)) {
 173                 ath10k_err(ar, "invalid board (ext) data sizes %zu != %d+%d\n",
 174                            data_len, board_data_size, board_ext_data_size);
 175                 return -EINVAL;
 176         }
 177
 178         ret = ath10k_bmi_write_memory(ar, board_ext_data_addr,
 179                                       data + board_data_size,
 180                                       board_ext_data_size);
 181         if (ret) {
 182                 ath10k_err(ar, "could not write board ext data (%d)\n", ret);
 183                 return ret;
 184         }
 185
 186         ret = ath10k_bmi_write32(ar, hi_board_ext_data_config,
 187                                  (board_ext_data_size << 16) | 1);
 188         if (ret) {
 189                 ath10k_err(ar, "could not write board ext data bit (%d)\n",
 190                            ret);
 191                 return ret;
 192         }
 193
 194         return 0;
 195 }
 196
 197 static int ath10k_download_board_data(struct ath10k *ar, const void *data,
 198                                       size_t data_len)
 199 {
 200         u32 board_data_size = ar->hw_params.fw.board_size;
 201         u32 address;
 202         int ret;
 203
 204         ret = ath10k_push_board_ext_data(ar, data, data_len);
 205         if (ret) {
 206                 ath10k_err(ar, "could not push board ext data (%d)\n", ret);
 207                 goto exit;
 208         }
 209
 210         ret = ath10k_bmi_read32(ar, hi_board_data, &address);
 211         if (ret) {
 212                 ath10k_err(ar, "could not read board data addr (%d)\n", ret);
 213                 goto exit;
 214         }
 215
 216         ret = ath10k_bmi_write_memory(ar, address, data,
 217                                       min_t(u32, board_data_size,
 218                                             data_len));
 219         if (ret) {
 220                 ath10k_err(ar, "could not write board data (%d)\n", ret);
 221                 goto exit;
 222         }
 223
 224         ret = ath10k_bmi_write32(ar, hi_board_data_initialized, 1);
 225         if (ret) {
 226                 ath10k_err(ar, "could not write board data bit (%d)\n", ret);
 227                 goto exit;
 228         }
 229
 230 exit:
 231         return ret;
 232 }
 233
 234 static int ath10k_download_cal_file(struct ath10k *ar)
 235 {
 236         int ret;
 237
 238         if (!ar->cal_file)
 239                 return -ENOENT;
 240
 241         if (IS_ERR(ar->cal_file))
 242                 return PTR_ERR(ar->cal_file);
 243
 244         ret = ath10k_download_board_data(ar, ar->cal_file->data,
 245                                          ar->cal_file->size);
 246         if (ret) {
 247                 ath10k_err(ar, "failed to download cal_file data: %d\n", ret);
 248                 return ret;
 249         }
 250
 251         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot cal file downloaded\n");
 252
 253         return 0;
 254 }
 255
 256 static int ath10k_download_cal_dt(struct ath10k *ar)
 257 {
 258         struct device_node *node;
 259         int data_len;
 260         void *data;
 261         int ret;
 262
 263         node = ar->dev->of_node;
 264         if (!node)
 265                 /* Device Tree is optional, don't print any warnings if
 266                  * there's no node for ath10k.
 267                  */
 268                 return -ENOENT;
 269
 270         if (!of_get_property(node, "qcom,ath10k-calibration-data",
 271                              &data_len)) {
 272                 /* The calibration data node is optional */
 273                 return -ENOENT;
 274         }
 275
 276         if (data_len != QCA988X_CAL_DATA_LEN) {
 277                 ath10k_warn(ar, "invalid calibration data length in DT: %d\n",
 278                             data_len);
 279                 ret = -EMSGSIZE;
 280                 goto out;
 281         }
 282
 283         data = kmalloc(data_len, GFP_KERNEL);
 284         if (!data) {
 285                 ret = -ENOMEM;
 286                 goto out;
 287         }
 288
 289         ret = of_property_read_u8_array(node, "qcom,ath10k-calibration-data",
 290                                         data, data_len);
 291         if (ret) {
 292                 ath10k_warn(ar, "failed to read calibration data from DT: %d\n",
 293                             ret);
 294                 goto out_free;
 295         }
 296
 297         ret = ath10k_download_board_data(ar, data, data_len);
 298         if (ret) {
 299                 ath10k_warn(ar, "failed to download calibration data from Device Tree: %d\n",
 300                             ret);
 301                 goto out_free;
 302         }
 303
 304         ret = 0;
 305
 306 out_free:
 307         kfree(data);
 308
 309 out:
 310         return ret;
 311 }
 312
 313 static int ath10k_download_and_run_otp(struct ath10k *ar)
 314 {
 315         u32 result, address = ar->hw_params.patch_load_addr;
 316         int ret;
 317
 318         ret = ath10k_download_board_data(ar, ar->board_data, ar->board_len);
 319         if (ret) {
 320                 ath10k_err(ar, "failed to download board data: %d\n", ret);
 321                 return ret;
 322         }
 323
 324         /* OTP is optional */
 325
 326         if (!ar->otp_data || !ar->otp_len) {
 327                 ath10k_warn(ar, "Not running otp, calibration will be incorrect (otp-data %p otp_len %zd)!\n",
 328                             ar->otp_data, ar->otp_len);
 329                 return 0;
 330         }
 331
 332         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot upload otp to 0x%x len %zd\n",
 333                    address, ar->otp_len);
 334
 335         ret = ath10k_bmi_fast_download(ar, address, ar->otp_data, ar->otp_len);
 336         if (ret) {
 337                 ath10k_err(ar, "could not write otp (%d)\n", ret);
 338                 return ret;
 339         }
 340
 341         ret = ath10k_bmi_execute(ar, address, 0, &result);
 342         if (ret) {
 343                 ath10k_err(ar, "could not execute otp (%d)\n", ret);
 344                 return ret;
 345         }
 346
 347         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot otp execute result %d\n", result);
 348
 349         if (!skip_otp && result != 0) {
 350                 ath10k_err(ar, "otp calibration failed: %d", result);
 351                 return -EINVAL;
 352         }
 353
 354         return 0;
 355 }
 356
 357 static int ath10k_download_fw(struct ath10k *ar, enum ath10k_firmware_mode mode)
 358 {
 359         u32 address, data_len;
 360         const char *mode_name;
 361         const void *data;
 362         int ret;
 363
 364         address = ar->hw_params.patch_load_addr;
 365
 366         switch (mode) {
 367         case ATH10K_FIRMWARE_MODE_NORMAL:
 368                 data = ar->firmware_data;
 369                 data_len = ar->firmware_len;
 370                 mode_name = "normal";
 371                 break;
 372         case ATH10K_FIRMWARE_MODE_UTF:
 373                 data = ar->testmode.utf->data;
 374                 data_len = ar->testmode.utf->size;
 375                 mode_name = "utf";
 376                 break;
 377         default:
 378                 ath10k_err(ar, "unknown firmware mode: %d\n", mode);
 379                 return -EINVAL;
 380         }
 381
 382         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 383                    "boot uploading firmware image %p len %d mode %s\n",
 384                    data, data_len, mode_name);
 385
 386         ret = ath10k_bmi_fast_download(ar, address, data, data_len);
 387         if (ret) {
 388                 ath10k_err(ar, "failed to download %s firmware: %d\n",
 389                            mode_name, ret);
 390                 return ret;
 391         }
 392
 393         return ret;
 394 }
 395
 396 static void ath10k_core_free_firmware_files(struct ath10k *ar)
 397 {
 398         if (ar->board && !IS_ERR(ar->board))
 399                 release_firmware(ar->board);
 400
 401         if (ar->otp && !IS_ERR(ar->otp))
 402                 release_firmware(ar->otp);
 403
 404         if (ar->firmware && !IS_ERR(ar->firmware))
 405                 release_firmware(ar->firmware);
 406
 407         if (ar->cal_file && !IS_ERR(ar->cal_file))
 408                 release_firmware(ar->cal_file);
 409
 410         ar->board = NULL;
 411         ar->board_data = NULL;
 412         ar->board_len = 0;
 413
 414         ar->otp = NULL;
 415         ar->otp_data = NULL;
 416         ar->otp_len = 0;
 417
 418         ar->firmware = NULL;
 419         ar->firmware_data = NULL;
 420         ar->firmware_len = 0;
 421
 422         ar->cal_file = NULL;
 423 }
 424
 425 static int ath10k_fetch_cal_file(struct ath10k *ar)
 426 {
 427         char filename[100];
 428
 429         /* cal-<bus>-<id>.bin */
 430         scnprintf(filename, sizeof(filename), "cal-%s-%s.bin",
 431                   ath10k_bus_str(ar->hif.bus), dev_name(ar->dev));
 432
 433         ar->cal_file = ath10k_fetch_fw_file(ar, ATH10K_FW_DIR, filename);
 434         if (IS_ERR(ar->cal_file))
 435                 /* calibration file is optional, don't print any warnings */
 436                 return PTR_ERR(ar->cal_file);
 437
 438         ath10k_dbg(ar, ATH10K_DBG_BOOT, "found calibration file %s/%s\n",
 439                    ATH10K_FW_DIR, filename);
 440
 441         return 0;
 442 }
 443
 444 static int ath10k_core_fetch_firmware_api_1(struct ath10k *ar)
 445 {
 446         int ret = 0;
 447
 448         if (ar->hw_params.fw.fw == NULL) {
 449                 ath10k_err(ar, "firmware file not defined\n");
 450                 return -EINVAL;
 451         }
 452
 453         if (ar->hw_params.fw.board == NULL) {
 454                 ath10k_err(ar, "board data file not defined");
 455                 return -EINVAL;
 456         }
 457
 458         ar->board = ath10k_fetch_fw_file(ar,
 459                                          ar->hw_params.fw.dir,
 460                                          ar->hw_params.fw.board);
 461         if (IS_ERR(ar->board)) {
 462                 ret = PTR_ERR(ar->board);
 463                 ath10k_err(ar, "could not fetch board data (%d)\n", ret);
 464                 goto err;
 465         }
 466
 467         ar->board_data = ar->board->data;
 468         ar->board_len = ar->board->size;
 469
 470         ar->firmware = ath10k_fetch_fw_file(ar,
 471                                             ar->hw_params.fw.dir,
 472                                             ar->hw_params.fw.fw);
 473         if (IS_ERR(ar->firmware)) {
 474                 ret = PTR_ERR(ar->firmware);
 475                 ath10k_err(ar, "could not fetch firmware (%d)\n", ret);
 476                 goto err;
 477         }
 478
 479         ar->firmware_data = ar->firmware->data;
 480         ar->firmware_len = ar->firmware->size;
 481
 482         /* OTP may be undefined. If so, don't fetch it at all */
 483         if (ar->hw_params.fw.otp == NULL)
 484                 return 0;
 485
 486         ar->otp = ath10k_fetch_fw_file(ar,
 487                                        ar->hw_params.fw.dir,
 488                                        ar->hw_params.fw.otp);
 489         if (IS_ERR(ar->otp)) {
 490                 ret = PTR_ERR(ar->otp);
 491                 ath10k_err(ar, "could not fetch otp (%d)\n", ret);
 492                 goto err;
 493         }
 494
 495         ar->otp_data = ar->otp->data;
 496         ar->otp_len = ar->otp->size;
 497
 498         return 0;
 499
 500 err:
 501         ath10k_core_free_firmware_files(ar);
 502         return ret;
 503 }
 504
 505 static int ath10k_core_fetch_firmware_api_n(struct ath10k *ar, const char *name)
 506 {
 507         size_t magic_len, len, ie_len;
 508         int ie_id, i, index, bit, ret;
 509         struct ath10k_fw_ie *hdr;
 510         const u8 *data;
 511         __le32 *timestamp;
 512
 513         /* first fetch the firmware file (firmware-*.bin) */
 514         ar->firmware = ath10k_fetch_fw_file(ar, ar->hw_params.fw.dir, name);
 515         if (IS_ERR(ar->firmware)) {
 516                 ath10k_err(ar, "could not fetch firmware file '%s/%s': %ld\n",
 517                            ar->hw_params.fw.dir, name, PTR_ERR(ar->firmware));
 518                 return PTR_ERR(ar->firmware);
 519         }
 520
 521         data = ar->firmware->data;
 522         len = ar->firmware->size;
 523
 524         /* magic also includes the null byte, check that as well */
 525         magic_len = strlen(ATH10K_FIRMWARE_MAGIC) + 1;
 526
 527         if (len < magic_len) {
 528                 ath10k_err(ar, "firmware file '%s/%s' too small to contain magic: %zu\n",
 529                            ar->hw_params.fw.dir, name, len);
 530                 ret = -EINVAL;
 531                 goto err;
 532         }
 533
 534         if (memcmp(data, ATH10K_FIRMWARE_MAGIC, magic_len) != 0) {
 535                 ath10k_err(ar, "invalid firmware magic\n");
 536                 ret = -EINVAL;
 537                 goto err;
 538         }
 539
 540         /* jump over the padding */
 541         magic_len = ALIGN(magic_len, 4);
 542
 543         len -= magic_len;
 544         data += magic_len;
 545
 546         /* loop elements */
 547         while (len > sizeof(struct ath10k_fw_ie)) {
 548                 hdr = (struct ath10k_fw_ie *)data;
 549
 550                 ie_id = le32_to_cpu(hdr->id);
 551                 ie_len = le32_to_cpu(hdr->len);
 552
 553                 len -= sizeof(*hdr);
 554                 data += sizeof(*hdr);
 555
 556                 if (len < ie_len) {
 557                         ath10k_err(ar, "invalid length for FW IE %d (%zu < %zu)\n",
 558                                    ie_id, len, ie_len);
 559                         ret = -EINVAL;
 560                         goto err;
 561                 }
 562
 563                 switch (ie_id) {
 564                 case ATH10K_FW_IE_FW_VERSION:
 565                         if (ie_len > sizeof(ar->hw->wiphy->fw_version) - 1)
 566                                 break;
 567
 568                         memcpy(ar->hw->wiphy->fw_version, data, ie_len);
 569                         ar->hw->wiphy->fw_version[ie_len] = '\0';
 570
 571                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 572                                    "found fw version %s\n",
 573                                     ar->hw->wiphy->fw_version);
 574                         break;
 575                 case ATH10K_FW_IE_TIMESTAMP:
 576                         if (ie_len != sizeof(u32))
 577                                 break;
 578
 579                         timestamp = (__le32 *)data;
 580
 581                         ath10k_dbg(ar, ATH10K_DBG_BOOT, "found fw timestamp %d\n",
 582                                    le32_to_cpup(timestamp));
 583                         break;
 584                 case ATH10K_FW_IE_FEATURES:
 585                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 586                                    "found firmware features ie (%zd B)\n",
 587                                    ie_len);
 588
 589                         for (i = 0; i < ATH10K_FW_FEATURE_COUNT; i++) {
 590                                 index = i / 8;
 591                                 bit = i % 8;
 592
 593                                 if (index == ie_len)
 594                                         break;
 595
 596                                 if (data[index] & (1 << bit)) {
 597                                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 598                                                    "Enabling feature bit: %i\n",
 599                                                    i);
 600                                         __set_bit(i, ar->fw_features);
 601                                 }
 602                         }
 603
 604                         ath10k_dbg_dump(ar, ATH10K_DBG_BOOT, "features", "",
 605                                         ar->fw_features,
 606                                         sizeof(ar->fw_features));
 607                         break;
 608                 case ATH10K_FW_IE_FW_IMAGE:
 609                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 610                                    "found fw image ie (%zd B)\n",
 611                                    ie_len);
 612
 613                         ar->firmware_data = data;
 614                         ar->firmware_len = ie_len;
 615
 616                         break;
 617                 case ATH10K_FW_IE_OTP_IMAGE:
 618                         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 619                                    "found otp image ie (%zd B)\n",
 620                                    ie_len);
 621
 622                         ar->otp_data = data;
 623                         ar->otp_len = ie_len;
 624
 625                         break;
 626                 default:
 627                         ath10k_warn(ar, "Unknown FW IE: %u\n",
 628                                     le32_to_cpu(hdr->id));
 629                         break;
 630                 }
 631
 632                 /* jump over the padding */
 633                 ie_len = ALIGN(ie_len, 4);
 634
 635                 len -= ie_len;
 636                 data += ie_len;
 637         }
 638
 639         if (!ar->firmware_data || !ar->firmware_len) {
 640                 ath10k_warn(ar, "No ATH10K_FW_IE_FW_IMAGE found from '%s/%s', skipping\n",
 641                             ar->hw_params.fw.dir, name);
 642                 ret = -ENOMEDIUM;
 643                 goto err;
 644         }
 645
 646         /* now fetch the board file */
 647         if (ar->hw_params.fw.board == NULL) {
 648                 ath10k_err(ar, "board data file not defined");
 649                 ret = -EINVAL;
 650                 goto err;
 651         }
 652
 653         ar->board = ath10k_fetch_fw_file(ar,
 654                                          ar->hw_params.fw.dir,
 655                                          ar->hw_params.fw.board);
 656         if (IS_ERR(ar->board)) {
 657                 ret = PTR_ERR(ar->board);
 658                 ath10k_err(ar, "could not fetch board data '%s/%s' (%d)\n",
 659                            ar->hw_params.fw.dir, ar->hw_params.fw.board,
 660                            ret);
 661                 goto err;
 662         }
 663
 664         ar->board_data = ar->board->data;
 665         ar->board_len = ar->board->size;
 666
 667         return 0;
 668
 669 err:
 670         ath10k_core_free_firmware_files(ar);
 671         return ret;
 672 }
 673
 674 static int ath10k_core_fetch_firmware_files(struct ath10k *ar)
 675 {
 676         int ret;
 677
 678         /* calibration file is optional, don't check for any errors */
 679         ath10k_fetch_cal_file(ar);
 680
 681         ar->fw_api = 3;
 682         ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
 683
 684         ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API3_FILE);
 685         if (ret == 0)
 686                 goto success;
 687
 688         ar->fw_api = 2;
 689         ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
 690
 691         ret = ath10k_core_fetch_firmware_api_n(ar, ATH10K_FW_API2_FILE);
 692         if (ret == 0)
 693                 goto success;
 694
 695         ar->fw_api = 1;
 696         ath10k_dbg(ar, ATH10K_DBG_BOOT, "trying fw api %d\n", ar->fw_api);
 697
 698         ret = ath10k_core_fetch_firmware_api_1(ar);
 699         if (ret)
 700                 return ret;
 701
 702 success:
 703         ath10k_dbg(ar, ATH10K_DBG_BOOT, "using fw api %d\n", ar->fw_api);
 704
 705         return 0;
 706 }
 707
 708 static int ath10k_download_cal_data(struct ath10k *ar)
 709 {
 710         int ret;
 711
 712         ret = ath10k_download_cal_file(ar);
 713         if (ret == 0) {
 714                 ar->cal_mode = ATH10K_CAL_MODE_FILE;
 715                 goto done;
 716         }
 717
 718         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 719                    "boot did not find a calibration file, try DT next: %d\n",
 720                    ret);
 721
 722         ret = ath10k_download_cal_dt(ar);
 723         if (ret == 0) {
 724                 ar->cal_mode = ATH10K_CAL_MODE_DT;
 725                 goto done;
 726         }
 727
 728         ath10k_dbg(ar, ATH10K_DBG_BOOT,
 729                    "boot did not find DT entry, try OTP next: %d\n",
 730                    ret);
 731
 732         ret = ath10k_download_and_run_otp(ar);
 733         if (ret) {
 734                 ath10k_err(ar, "failed to run otp: %d\n", ret);
 735                 return ret;
 736         }
 737
 738         ar->cal_mode = ATH10K_CAL_MODE_OTP;
 739
 740 done:
 741         ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot using calibration mode %s\n",
 742                    ath10k_cal_mode_str(ar->cal_mode));
 743         return 0;
 744 }
 745
 746 static int ath10k_init_uart(struct ath10k *ar)
 747 {
 748         int ret;
 749
 750         /*
 751          * Explicitly setting UART prints to zero as target turns it on
 752          * based on scratch registers.
 753          */
 754         ret = ath10k_bmi_write32(ar, hi_serial_enable, 0);
 755         if (ret) {
 756                 ath10k_warn(ar, "could not disable UART prints (%d)\n", ret);
 757                 return ret;
 758         }
 759
 760         if (!uart_print)
 761                 return 0;
 762
 763         ret = ath10k_bmi_write32(ar, hi_dbg_uart_txpin, ar->hw_params.uart_pin);
 764         if (ret) {
 765                 ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
 766                 return ret;
 767         }
 768
 769         ret = ath10k_bmi_write32(ar, hi_serial_enable, 1);
 770         if (ret) {
 771                 ath10k_warn(ar, "could not enable UART prints (%d)\n", ret);
 772                 return ret;
 773         }
 774
 775         /* Set the UART baud rate to 19200. */
 776         ret = ath10k_bmi_write32(ar, hi_desired_baud_rate, 19200);
 777         if (ret) {
 778                 ath10k_warn(ar, "could not set the baud rate (%d)\n", ret);
 779                 return ret;
 780         }
 781
 782         ath10k_info(ar, "UART prints enabled\n");
 783         return 0;
 784 }
 785
 786 static int ath10k_init_hw_params(struct ath10k *ar)
 787 {
 788         const struct ath10k_hw_params *uninitialized_var(hw_params);
 789         int i;
 790
 791         for (i = 0; i < ARRAY_SIZE(ath10k_hw_params_list); i++) {
 792                 hw_params = &ath10k_hw_params_list[i];
 793
 794                 if (hw_params->id == ar->target_version)
 795                         break;
 796         }
 797
 798         if (i == ARRAY_SIZE(ath10k_hw_params_list)) {
 799                 ath10k_err(ar, "Unsupported hardware version: 0x%x\n",
 800                            ar->target_version);
 801                 return -EINVAL;
 802         }
 803
 804         ar->hw_params = *hw_params;
 805
 806         ath10k_dbg(ar, ATH10K_DBG_BOOT, "Hardware name %s version 0x%x\n",
 807                    ar->hw_params.name, ar->target_version);
 808
 809         return 0;
 810 }
 811
 812 static void ath10k_core_restart(struct work_struct *work)
 813 {
 814         struct ath10k *ar = container_of(work, struct ath10k, restart_work);
 815
 816         set_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags);
 817
 818         /* Place a barrier to make sure the compiler doesn't reorder
 819          * CRASH_FLUSH and calling other functions.
 820          */
 821         barrier();
 822
 823         ieee80211_stop_queues(ar->hw);
 824         ath10k_drain_tx(ar);
 825         complete_all(&ar->scan.started);
 826         complete_all(&ar->scan.completed);
 827         complete_all(&ar->scan.on_channel);
 828         complete_all(&ar->offchan_tx_completed);
 829         complete_all(&ar->install_key_done);
 830         complete_all(&ar->vdev_setup_done);
 831         wake_up(&ar->htt.empty_tx_wq);
 832         wake_up(&ar->wmi.tx_credits_wq);
 833         wake_up(&ar->peer_mapping_wq);
 834
 835         mutex_lock(&ar->conf_mutex);
 836
 837         switch (ar->state) {
 838         case ATH10K_STATE_ON:
 839                 ar->state = ATH10K_STATE_RESTARTING;
 840                 ath10k_hif_stop(ar);
 841                 ath10k_scan_finish(ar);
 842                 ieee80211_restart_hw(ar->hw);
 843                 break;
 844         case ATH10K_STATE_OFF:
 845                 /* this can happen if driver is being unloaded
 846                  * or if the crash happens during FW probing */
 847                 ath10k_warn(ar, "cannot restart a device that hasn't been started\n");
 848                 break;
 849         case ATH10K_STATE_RESTARTING:
 850                 /* hw restart might be requested from multiple places */
 851                 break;
 852         case ATH10K_STATE_RESTARTED:
 853                 ar->state = ATH10K_STATE_WEDGED;
 854                 /* fall through */
 855         case ATH10K_STATE_WEDGED:
 856                 ath10k_warn(ar, "device is wedged, will not restart\n");
 857                 break;
 858         case ATH10K_STATE_UTF:
 859                 ath10k_warn(ar, "firmware restart in UTF mode not supported\n");
 860                 break;
 861         }
 862
 863         mutex_unlock(&ar->conf_mutex);
 864 }
 865
 866 static int ath10k_core_init_firmware_features(struct ath10k *ar)
 867 {
 868         if (test_bit(ATH10K_FW_FEATURE_WMI_10_2, ar->fw_features) &&
 869             !test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
 870                 ath10k_err(ar, "feature bits corrupted: 10.2 feature requires 10.x feature to be set as well");
 871                 return -EINVAL;
 872         }
 873
 874         if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
 875                 ar->max_num_peers = TARGET_10X_NUM_PEERS;
 876                 ar->max_num_stations = TARGET_10X_NUM_STATIONS;
 877         } else {
 878                 ar->max_num_peers = TARGET_NUM_PEERS;
 879                 ar->max_num_stations = TARGET_NUM_STATIONS;
 880         }
 881
 882         return 0;
 883 }
 884
 885 int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode)
 886 {
 887         int status;
 888
 889         lockdep_assert_held(&ar->conf_mutex);
 890
 891         clear_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags);
 892
 893         ath10k_bmi_start(ar);
 894
 895         if (ath10k_init_configure_target(ar)) {
 896                 status = -EINVAL;
 897                 goto err;
 898         }
 899
 900         status = ath10k_download_cal_data(ar);
 901         if (status)
 902                 goto err;
 903
 904         status = ath10k_download_fw(ar, mode);
 905         if (status)
 906                 goto err;
 907
 908         status = ath10k_init_uart(ar);
 909         if (status)
 910                 goto err;
 911
 912         ar->htc.htc_ops.target_send_suspend_complete =
 913                 ath10k_send_suspend_complete;
 914
 915         status = ath10k_htc_init(ar);
 916         if (status) {
 917                 ath10k_err(ar, "could not init HTC (%d)\n", status);
 918                 goto err;
 919         }
 920
 921         status = ath10k_bmi_done(ar);
 922         if (status)
 923                 goto err;
 924
 925         status = ath10k_wmi_attach(ar);
 926         if (status) {
 927                 ath10k_err(ar, "WMI attach failed: %d\n", status);
 928                 goto err;
 929         }
 930
 931         status = ath10k_htt_init(ar);
 932         if (status) {
 933                 ath10k_err(ar, "failed to init htt: %d\n", status);
 934                 goto err_wmi_detach;
 935         }
 936
 937         status = ath10k_htt_tx_alloc(&ar->htt);
 938         if (status) {
 939                 ath10k_err(ar, "failed to alloc htt tx: %d\n", status);
 940                 goto err_wmi_detach;
 941         }
 942
 943         status = ath10k_htt_rx_alloc(&ar->htt);
 944         if (status) {
 945                 ath10k_err(ar, "failed to alloc htt rx: %d\n", status);
 946                 goto err_htt_tx_detach;
 947         }
 948
 949         status = ath10k_hif_start(ar);
 950         if (status) {
 951                 ath10k_err(ar, "could not start HIF: %d\n", status);
 952                 goto err_htt_rx_detach;
 953         }
 954
 955         status = ath10k_htc_wait_target(&ar->htc);
 956         if (status) {
 957                 ath10k_err(ar, "failed to connect to HTC: %d\n", status);
 958                 goto err_hif_stop;
 959         }
 960
 961         if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
 962                 status = ath10k_htt_connect(&ar->htt);
 963                 if (status) {
 964                         ath10k_err(ar, "failed to connect htt (%d)\n", status);
 965                         goto err_hif_stop;
 966                 }
 967         }
 968
 969         status = ath10k_wmi_connect(ar);
 970         if (status) {
 971                 ath10k_err(ar, "could not connect wmi: %d\n", status);
 972                 goto err_hif_stop;
 973         }
 974
 975         status = ath10k_htc_start(&ar->htc);
 976         if (status) {
 977                 ath10k_err(ar, "failed to start htc: %d\n", status);
 978                 goto err_hif_stop;
 979         }
 980
 981         if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
 982                 status = ath10k_wmi_wait_for_service_ready(ar);
 983                 if (status <= 0) {
 984                         ath10k_warn(ar, "wmi service ready event not received");
 985                         status = -ETIMEDOUT;
 986                         goto err_hif_stop;
 987                 }
 988         }
 989
 990         ath10k_dbg(ar, ATH10K_DBG_BOOT, "firmware %s booted\n",
 991                    ar->hw->wiphy->fw_version);
 992
 993         status = ath10k_wmi_cmd_init(ar);
 994         if (status) {
 995                 ath10k_err(ar, "could not send WMI init command (%d)\n",
 996                            status);
 997                 goto err_hif_stop;
 998         }
 999
1000         status = ath10k_wmi_wait_for_unified_ready(ar);
1001         if (status <= 0) {
1002                 ath10k_err(ar, "wmi unified ready event not received\n");
1003                 status = -ETIMEDOUT;
1004                 goto err_hif_stop;
1005         }
1006
1007         /* we don't care about HTT in UTF mode */
1008         if (mode == ATH10K_FIRMWARE_MODE_NORMAL) {
1009                 status = ath10k_htt_setup(&ar->htt);
1010                 if (status) {
1011                         ath10k_err(ar, "failed to setup htt: %d\n", status);
1012                         goto err_hif_stop;
1013                 }
1014         }
1015
1016         status = ath10k_debug_start(ar);
1017         if (status)
1018                 goto err_hif_stop;
1019
1020         if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
1021                 ar->free_vdev_map = (1LL << TARGET_10X_NUM_VDEVS) - 1;
1022         else
1023                 ar->free_vdev_map = (1LL << TARGET_NUM_VDEVS) - 1;
1024
1025         INIT_LIST_HEAD(&ar->arvifs);
1026
1027         return 0;
1028
1029 err_hif_stop:
1030         ath10k_hif_stop(ar);
1031 err_htt_rx_detach:
1032         ath10k_htt_rx_free(&ar->htt);
1033 err_htt_tx_detach:
1034         ath10k_htt_tx_free(&ar->htt);
1035 err_wmi_detach:
1036         ath10k_wmi_detach(ar);
1037 err:
1038         return status;
1039 }
1040 EXPORT_SYMBOL(ath10k_core_start);
1041
1042 int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt)
1043 {
1044         int ret;
1045
1046         reinit_completion(&ar->target_suspend);
1047
1048         ret = ath10k_wmi_pdev_suspend_target(ar, suspend_opt);
1049         if (ret) {
1050                 ath10k_warn(ar, "could not suspend target (%d)\n", ret);
1051                 return ret;
1052         }
1053
1054         ret = wait_for_completion_timeout(&ar->target_suspend, 1 * HZ);
1055
1056         if (ret == 0) {
1057                 ath10k_warn(ar, "suspend timed out - target pause event never came\n");
1058                 return -ETIMEDOUT;
1059         }
1060
1061         return 0;
1062 }
1063
1064 void ath10k_core_stop(struct ath10k *ar)
1065 {
1066         lockdep_assert_held(&ar->conf_mutex);
1067
1068         /* try to suspend target */
1069         if (ar->state != ATH10K_STATE_RESTARTING &&
1070             ar->state != ATH10K_STATE_UTF)
1071                 ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND_AND_DISABLE_INTR);
1072
1073         ath10k_debug_stop(ar);
1074         ath10k_hif_stop(ar);
1075         ath10k_htt_tx_free(&ar->htt);
1076         ath10k_htt_rx_free(&ar->htt);
1077         ath10k_wmi_detach(ar);
1078 }
1079 EXPORT_SYMBOL(ath10k_core_stop);
1080
1081 /* mac80211 manages fw/hw initialization through start/stop hooks. However in
1082  * order to know what hw capabilities should be advertised to mac80211 it is
1083  * necessary to load the firmware (and tear it down immediately since start
1084  * hook will try to init it again) before registering */
1085 static int ath10k_core_probe_fw(struct ath10k *ar)
1086 {
1087         struct bmi_target_info target_info;
1088         int ret = 0;
1089
1090         ret = ath10k_hif_power_up(ar);
1091         if (ret) {
1092                 ath10k_err(ar, "could not start pci hif (%d)\n", ret);
1093                 return ret;
1094         }
1095
1096         memset(&target_info, 0, sizeof(target_info));
1097         ret = ath10k_bmi_get_target_info(ar, &target_info);
1098         if (ret) {
1099                 ath10k_err(ar, "could not get target info (%d)\n", ret);
1100                 goto err_power_down;
1101         }
1102
1103         ar->target_version = target_info.version;
1104         ar->hw->wiphy->hw_version = target_info.version;
1105
1106         ret = ath10k_init_hw_params(ar);
1107         if (ret) {
1108                 ath10k_err(ar, "could not get hw params (%d)\n", ret);
1109                 goto err_power_down;
1110         }
1111
1112         ret = ath10k_core_fetch_firmware_files(ar);
1113         if (ret) {
1114                 ath10k_err(ar, "could not fetch firmware files (%d)\n", ret);
1115                 goto err_power_down;
1116         }
1117
1118         ret = ath10k_core_init_firmware_features(ar);
1119         if (ret) {
1120                 ath10k_err(ar, "fatal problem with firmware features: %d\n",
1121                            ret);
1122                 goto err_free_firmware_files;
1123         }
1124
1125         mutex_lock(&ar->conf_mutex);
1126
1127         ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
1128         if (ret) {
1129                 ath10k_err(ar, "could not init core (%d)\n", ret);
1130                 goto err_unlock;
1131         }
1132
1133         ath10k_print_driver_info(ar);
1134         ath10k_core_stop(ar);
1135
1136         mutex_unlock(&ar->conf_mutex);
1137
1138         ath10k_hif_power_down(ar);
1139         return 0;
1140
1141 err_unlock:
1142         mutex_unlock(&ar->conf_mutex);
1143
1144 err_free_firmware_files:
1145         ath10k_core_free_firmware_files(ar);
1146
1147 err_power_down:
1148         ath10k_hif_power_down(ar);
1149
1150         return ret;
1151 }
1152
1153 static void ath10k_core_register_work(struct work_struct *work)
1154 {
1155         struct ath10k *ar = container_of(work, struct ath10k, register_work);
1156         int status;
1157
1158         status = ath10k_core_probe_fw(ar);
1159         if (status) {
1160                 ath10k_err(ar, "could not probe fw (%d)\n", status);
1161                 goto err;
1162         }
1163
1164         status = ath10k_mac_register(ar);
1165         if (status) {
1166                 ath10k_err(ar, "could not register to mac80211 (%d)\n", status);
1167                 goto err_release_fw;
1168         }
1169
1170         status = ath10k_debug_register(ar);
1171         if (status) {
1172                 ath10k_err(ar, "unable to initialize debugfs\n");
1173                 goto err_unregister_mac;
1174         }
1175
1176         status = ath10k_spectral_create(ar);
1177         if (status) {
1178                 ath10k_err(ar, "failed to initialize spectral\n");
1179                 goto err_debug_destroy;
1180         }
1181
1182         set_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags);
1183         return;
1184
1185 err_debug_destroy:
1186         ath10k_debug_destroy(ar);
1187 err_unregister_mac:
1188         ath10k_mac_unregister(ar);
1189 err_release_fw:
1190         ath10k_core_free_firmware_files(ar);
1191 err:
1192         /* TODO: It's probably a good idea to release device from the driver
1193          * but calling device_release_driver() here will cause a deadlock.
1194          */
1195         return;
1196 }
1197
1198 int ath10k_core_register(struct ath10k *ar, u32 chip_id)
1199 {
1200         ar->chip_id = chip_id;
1201         queue_work(ar->workqueue, &ar->register_work);
1202
1203         return 0;
1204 }
1205 EXPORT_SYMBOL(ath10k_core_register);
1206
1207 void ath10k_core_unregister(struct ath10k *ar)
1208 {
1209         cancel_work_sync(&ar->register_work);
1210
1211         if (!test_bit(ATH10K_FLAG_CORE_REGISTERED, &ar->dev_flags))
1212                 return;
1213
1214         /* Stop spectral before unregistering from mac80211 to remove the
1215          * relayfs debugfs file cleanly. Otherwise the parent debugfs tree
1216          * would be already be free'd recursively, leading to a double free.
1217          */
1218         ath10k_spectral_destroy(ar);
1219
1220         /* We must unregister from mac80211 before we stop HTC and HIF.
1221          * Otherwise we will fail to submit commands to FW and mac80211 will be
1222          * unhappy about callback failures. */
1223         ath10k_mac_unregister(ar);
1224
1225         ath10k_testmode_destroy(ar);
1226
1227         ath10k_core_free_firmware_files(ar);
1228
1229         ath10k_debug_unregister(ar);
1230 }
1231 EXPORT_SYMBOL(ath10k_core_unregister);
1232
1233 struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
1234                                   enum ath10k_bus bus,
1235                                   const struct ath10k_hif_ops *hif_ops)
1236 {
1237         struct ath10k *ar;
1238         int ret;
1239
1240         ar = ath10k_mac_create(priv_size);
1241         if (!ar)
1242                 return NULL;
1243
1244         ar->ath_common.priv = ar;
1245         ar->ath_common.hw = ar->hw;
1246
1247         ar->p2p = !!ath10k_p2p;
1248         ar->dev = dev;
1249
1250         ar->hif.ops = hif_ops;
1251         ar->hif.bus = bus;
1252
1253         init_completion(&ar->scan.started);
1254         init_completion(&ar->scan.completed);
1255         init_completion(&ar->scan.on_channel);
1256         init_completion(&ar->target_suspend);
1257
1258         init_completion(&ar->install_key_done);
1259         init_completion(&ar->vdev_setup_done);
1260
1261         INIT_DELAYED_WORK(&ar->scan.timeout, ath10k_scan_timeout_work);
1262
1263         ar->workqueue = create_singlethread_workqueue("ath10k_wq");
1264         if (!ar->workqueue)
1265                 goto err_free_mac;
1266
1267         mutex_init(&ar->conf_mutex);
1268         spin_lock_init(&ar->data_lock);
1269
1270         INIT_LIST_HEAD(&ar->peers);
1271         init_waitqueue_head(&ar->peer_mapping_wq);
1272         init_waitqueue_head(&ar->htt.empty_tx_wq);
1273         init_waitqueue_head(&ar->wmi.tx_credits_wq);
1274
1275         init_completion(&ar->offchan_tx_completed);
1276         INIT_WORK(&ar->offchan_tx_work, ath10k_offchan_tx_work);
1277         skb_queue_head_init(&ar->offchan_tx_queue);
1278
1279         INIT_WORK(&ar->wmi_mgmt_tx_work, ath10k_mgmt_over_wmi_tx_work);
1280         skb_queue_head_init(&ar->wmi_mgmt_tx_queue);
1281
1282         INIT_WORK(&ar->register_work, ath10k_core_register_work);
1283         INIT_WORK(&ar->restart_work, ath10k_core_restart);
1284
1285         ret = ath10k_debug_create(ar);
1286         if (ret)
1287                 goto err_free_wq;
1288
1289         return ar;
1290
1291 err_free_wq:
1292         destroy_workqueue(ar->workqueue);
1293
1294 err_free_mac:
1295         ath10k_mac_destroy(ar);
1296
1297         return NULL;
1298 }
1299 EXPORT_SYMBOL(ath10k_core_create);
1300
1301 void ath10k_core_destroy(struct ath10k *ar)
1302 {
1303         flush_workqueue(ar->workqueue);
1304         destroy_workqueue(ar->workqueue);
1305
1306         ath10k_debug_destroy(ar);
1307         ath10k_mac_destroy(ar);
1308 }
1309 EXPORT_SYMBOL(ath10k_core_destroy);
1310
1311 MODULE_AUTHOR("Qualcomm Atheros");
1312 MODULE_DESCRIPTION("Core module for QCA988X PCIe devices.");
1313 MODULE_LICENSE("Dual BSD/GPL");