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

   1 // SPDX-License-Identifier: BSD-3-Clause-Clear
   2 /*
   3  * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
   4  */
   5
   6 #include <linux/module.h>
   7 #include <linux/slab.h>
   8 #include <linux/remoteproc.h>
   9 #include <linux/firmware.h>
  10 #include <linux/of.h>
  11 #include "core.h"
  12 #include "dp_tx.h"
  13 #include "dp_rx.h"
  14 #include "debug.h"
  15 #include "hif.h"
  16 #include "wow.h"
  17
  18 unsigned int ath11k_debug_mask;
  19 EXPORT_SYMBOL(ath11k_debug_mask);
  20 module_param_named(debug_mask, ath11k_debug_mask, uint, 0644);
  21 MODULE_PARM_DESC(debug_mask, "Debugging mask");
  22
  23 static unsigned int ath11k_crypto_mode;
  24 module_param_named(crypto_mode, ath11k_crypto_mode, uint, 0644);
  25 MODULE_PARM_DESC(crypto_mode, "crypto mode: 0-hardware, 1-software");
  26
  27 /* frame mode values are mapped as per enum ath11k_hw_txrx_mode */
  28 unsigned int ath11k_frame_mode = ATH11K_HW_TXRX_NATIVE_WIFI;
  29 module_param_named(frame_mode, ath11k_frame_mode, uint, 0644);
  30 MODULE_PARM_DESC(frame_mode,
  31                  "Datapath frame mode (0: raw, 1: native wifi (default), 2: ethernet)");
  32
  33 static const struct ath11k_hw_params ath11k_hw_params[] = {
  34         {
  35                 .hw_rev = ATH11K_HW_IPQ8074,
  36                 .name = "ipq8074 hw2.0",
  37                 .fw = {
  38                         .dir = "IPQ8074/hw2.0",
  39                         .board_size = 256 * 1024,
  40                         .cal_size = 256 * 1024,
  41                 },
  42                 .max_radios = 3,
  43                 .bdf_addr = 0x4B0C0000,
  44                 .hw_ops = &ipq8074_ops,
  45                 .ring_mask = &ath11k_hw_ring_mask_ipq8074,
  46                 .internal_sleep_clock = false,
  47                 .regs = &ipq8074_regs,
  48                 .host_ce_config = ath11k_host_ce_config_ipq8074,
  49                 .ce_count = 12,
  50                 .target_ce_config = ath11k_target_ce_config_wlan_ipq8074,
  51                 .target_ce_count = 11,
  52                 .svc_to_ce_map = ath11k_target_service_to_ce_map_wlan_ipq8074,
  53                 .svc_to_ce_map_len = 21,
  54                 .single_pdev_only = false,
  55                 .rxdma1_enable = true,
  56                 .num_rxmda_per_pdev = 1,
  57                 .rx_mac_buf_ring = false,
  58                 .vdev_start_delay = false,
  59                 .htt_peer_map_v2 = true,
  60                 .tcl_0_only = false,
  61                 .spectral_fft_sz = 2,
  62
  63                 .interface_modes = BIT(NL80211_IFTYPE_STATION) |
  64                                         BIT(NL80211_IFTYPE_AP) |
  65                                         BIT(NL80211_IFTYPE_MESH_POINT),
  66                 .supports_monitor = true,
  67                 .supports_shadow_regs = false,
  68                 .idle_ps = false,
  69                 .cold_boot_calib = true,
  70                 .supports_suspend = false,
  71         },
  72         {
  73                 .hw_rev = ATH11K_HW_IPQ6018_HW10,
  74                 .name = "ipq6018 hw1.0",
  75                 .fw = {
  76                         .dir = "IPQ6018/hw1.0",
  77                         .board_size = 256 * 1024,
  78                         .cal_size = 256 * 1024,
  79                 },
  80                 .max_radios = 2,
  81                 .bdf_addr = 0x4ABC0000,
  82                 .hw_ops = &ipq6018_ops,
  83                 .ring_mask = &ath11k_hw_ring_mask_ipq8074,
  84                 .internal_sleep_clock = false,
  85                 .regs = &ipq8074_regs,
  86                 .host_ce_config = ath11k_host_ce_config_ipq8074,
  87                 .ce_count = 12,
  88                 .target_ce_config = ath11k_target_ce_config_wlan_ipq8074,
  89                 .target_ce_count = 11,
  90                 .svc_to_ce_map = ath11k_target_service_to_ce_map_wlan_ipq6018,
  91                 .svc_to_ce_map_len = 19,
  92                 .single_pdev_only = false,
  93                 .rxdma1_enable = true,
  94                 .num_rxmda_per_pdev = 1,
  95                 .rx_mac_buf_ring = false,
  96                 .vdev_start_delay = false,
  97                 .htt_peer_map_v2 = true,
  98                 .tcl_0_only = false,
  99                 .spectral_fft_sz = 4,
 100
 101                 .interface_modes = BIT(NL80211_IFTYPE_STATION) |
 102                                         BIT(NL80211_IFTYPE_AP) |
 103                                         BIT(NL80211_IFTYPE_MESH_POINT),
 104                 .supports_monitor = true,
 105                 .supports_shadow_regs = false,
 106                 .idle_ps = false,
 107                 .cold_boot_calib = true,
 108                 .supports_suspend = false,
 109         },
 110         {
 111                 .name = "qca6390 hw2.0",
 112                 .hw_rev = ATH11K_HW_QCA6390_HW20,
 113                 .fw = {
 114                         .dir = "QCA6390/hw2.0",
 115                         .board_size = 256 * 1024,
 116                         .cal_size = 256 * 1024,
 117                 },
 118                 .max_radios = 3,
 119                 .bdf_addr = 0x4B0C0000,
 120                 .hw_ops = &qca6390_ops,
 121                 .ring_mask = &ath11k_hw_ring_mask_qca6390,
 122                 .internal_sleep_clock = true,
 123                 .regs = &qca6390_regs,
 124                 .host_ce_config = ath11k_host_ce_config_qca6390,
 125                 .ce_count = 9,
 126                 .target_ce_config = ath11k_target_ce_config_wlan_qca6390,
 127                 .target_ce_count = 9,
 128                 .svc_to_ce_map = ath11k_target_service_to_ce_map_wlan_qca6390,
 129                 .svc_to_ce_map_len = 14,
 130                 .single_pdev_only = true,
 131                 .rxdma1_enable = false,
 132                 .num_rxmda_per_pdev = 2,
 133                 .rx_mac_buf_ring = true,
 134                 .vdev_start_delay = true,
 135                 .htt_peer_map_v2 = false,
 136                 .tcl_0_only = true,
 137                 .spectral_fft_sz = 0,
 138
 139                 .interface_modes = BIT(NL80211_IFTYPE_STATION) |
 140                                         BIT(NL80211_IFTYPE_AP),
 141                 .supports_monitor = false,
 142                 .supports_shadow_regs = true,
 143                 .idle_ps = true,
 144                 .cold_boot_calib = false,
 145                 .supports_suspend = true,
 146         },
 147 };
 148
 149 int ath11k_core_suspend(struct ath11k_base *ab)
 150 {
 151         int ret;
 152
 153         if (!ab->hw_params.supports_suspend)
 154                 return -EOPNOTSUPP;
 155
 156         /* TODO: there can frames in queues so for now add delay as a hack.
 157          * Need to implement to handle and remove this delay.
 158          */
 159         msleep(500);
 160
 161         ret = ath11k_dp_rx_pktlog_stop(ab, true);
 162         if (ret) {
 163                 ath11k_warn(ab, "failed to stop dp rx (and timer) pktlog during suspend: %d\n",
 164                             ret);
 165                 return ret;
 166         }
 167
 168         ret = ath11k_wow_enable(ab);
 169         if (ret) {
 170                 ath11k_warn(ab, "failed to enable wow during suspend: %d\n", ret);
 171                 return ret;
 172         }
 173
 174         ret = ath11k_dp_rx_pktlog_stop(ab, false);
 175         if (ret) {
 176                 ath11k_warn(ab, "failed to stop dp rx pktlog during suspend: %d\n",
 177                             ret);
 178                 return ret;
 179         }
 180
 181         ath11k_ce_stop_shadow_timers(ab);
 182         ath11k_dp_stop_shadow_timers(ab);
 183
 184         ath11k_hif_irq_disable(ab);
 185         ath11k_hif_ce_irq_disable(ab);
 186
 187         ret = ath11k_hif_suspend(ab);
 188         if (ret) {
 189                 ath11k_warn(ab, "failed to suspend hif: %d\n", ret);
 190                 return ret;
 191         }
 192
 193         return 0;
 194 }
 195 EXPORT_SYMBOL(ath11k_core_suspend);
 196
 197 int ath11k_core_resume(struct ath11k_base *ab)
 198 {
 199         int ret;
 200
 201         if (!ab->hw_params.supports_suspend)
 202                 return -EOPNOTSUPP;
 203
 204         ret = ath11k_hif_resume(ab);
 205         if (ret) {
 206                 ath11k_warn(ab, "failed to resume hif during resume: %d\n", ret);
 207                 return ret;
 208         }
 209
 210         ath11k_hif_ce_irq_enable(ab);
 211         ath11k_hif_irq_enable(ab);
 212
 213         ret = ath11k_dp_rx_pktlog_start(ab);
 214         if (ret) {
 215                 ath11k_warn(ab, "failed to start rx pktlog during resume: %d\n",
 216                             ret);
 217                 return ret;
 218         }
 219
 220         ret = ath11k_wow_wakeup(ab);
 221         if (ret) {
 222                 ath11k_warn(ab, "failed to wakeup wow during resume: %d\n", ret);
 223                 return ret;
 224         }
 225
 226         return 0;
 227 }
 228 EXPORT_SYMBOL(ath11k_core_resume);
 229
 230 int ath11k_core_check_dt(struct ath11k_base *ab)
 231 {
 232         size_t max_len = sizeof(ab->qmi.target.bdf_ext);
 233         const char *variant = NULL;
 234         struct device_node *node;
 235
 236         node = ab->dev->of_node;
 237         if (!node)
 238                 return -ENOENT;
 239
 240         of_property_read_string(node, "qcom,ath11k-calibration-variant",
 241                                 &variant);
 242         if (!variant)
 243                 return -ENODATA;
 244
 245         if (strscpy(ab->qmi.target.bdf_ext, variant, max_len) < 0)
 246                 ath11k_dbg(ab, ATH11K_DBG_BOOT,
 247                            "bdf variant string is longer than the buffer can accommodate (variant: %s)\n",
 248                             variant);
 249
 250         return 0;
 251 }
 252
 253 static int ath11k_core_create_board_name(struct ath11k_base *ab, char *name,
 254                                          size_t name_len)
 255 {
 256         /* strlen(',variant=') + strlen(ab->qmi.target.bdf_ext) */
 257         char variant[9 + ATH11K_QMI_BDF_EXT_STR_LENGTH] = { 0 };
 258
 259         if (ab->qmi.target.bdf_ext[0] != '\0')
 260                 scnprintf(variant, sizeof(variant), ",variant=%s",
 261                           ab->qmi.target.bdf_ext);
 262
 263         scnprintf(name, name_len,
 264                   "bus=%s,qmi-chip-id=%d,qmi-board-id=%d%s",
 265                   ath11k_bus_str(ab->hif.bus),
 266                   ab->qmi.target.chip_id,
 267                   ab->qmi.target.board_id, variant);
 268
 269         ath11k_dbg(ab, ATH11K_DBG_BOOT, "boot using board name '%s'\n", name);
 270
 271         return 0;
 272 }
 273
 274 const struct firmware *ath11k_core_firmware_request(struct ath11k_base *ab,
 275                                                     const char *file)
 276 {
 277         const struct firmware *fw;
 278         char path[100];
 279         int ret;
 280
 281         if (file == NULL)
 282                 return ERR_PTR(-ENOENT);
 283
 284         ath11k_core_create_firmware_path(ab, file, path, sizeof(path));
 285
 286         ret = firmware_request_nowarn(&fw, path, ab->dev);
 287         if (ret)
 288                 return ERR_PTR(ret);
 289
 290         ath11k_dbg(ab, ATH11K_DBG_BOOT, "boot firmware request %s size %zu\n",
 291                    path, fw->size);
 292
 293         return fw;
 294 }
 295
 296 void ath11k_core_free_bdf(struct ath11k_base *ab, struct ath11k_board_data *bd)
 297 {
 298         if (!IS_ERR(bd->fw))
 299                 release_firmware(bd->fw);
 300
 301         memset(bd, 0, sizeof(*bd));
 302 }
 303
 304 static int ath11k_core_parse_bd_ie_board(struct ath11k_base *ab,
 305                                          struct ath11k_board_data *bd,
 306                                          const void *buf, size_t buf_len,
 307                                          const char *boardname,
 308                                          int bd_ie_type)
 309 {
 310         const struct ath11k_fw_ie *hdr;
 311         bool name_match_found;
 312         int ret, board_ie_id;
 313         size_t board_ie_len;
 314         const void *board_ie_data;
 315
 316         name_match_found = false;
 317
 318         /* go through ATH11K_BD_IE_BOARD_ elements */
 319         while (buf_len > sizeof(struct ath11k_fw_ie)) {
 320                 hdr = buf;
 321                 board_ie_id = le32_to_cpu(hdr->id);
 322                 board_ie_len = le32_to_cpu(hdr->len);
 323                 board_ie_data = hdr->data;
 324
 325                 buf_len -= sizeof(*hdr);
 326                 buf += sizeof(*hdr);
 327
 328                 if (buf_len < ALIGN(board_ie_len, 4)) {
 329                         ath11k_err(ab, "invalid ATH11K_BD_IE_BOARD length: %zu < %zu\n",
 330                                    buf_len, ALIGN(board_ie_len, 4));
 331                         ret = -EINVAL;
 332                         goto out;
 333                 }
 334
 335                 switch (board_ie_id) {
 336                 case ATH11K_BD_IE_BOARD_NAME:
 337                         ath11k_dbg_dump(ab, ATH11K_DBG_BOOT, "board name", "",
 338                                         board_ie_data, board_ie_len);
 339
 340                         if (board_ie_len != strlen(boardname))
 341                                 break;
 342
 343                         ret = memcmp(board_ie_data, boardname, strlen(boardname));
 344                         if (ret)
 345                                 break;
 346
 347                         name_match_found = true;
 348                         ath11k_dbg(ab, ATH11K_DBG_BOOT,
 349                                    "boot found match for name '%s'",
 350                                    boardname);
 351                         break;
 352                 case ATH11K_BD_IE_BOARD_DATA:
 353                         if (!name_match_found)
 354                                 /* no match found */
 355                                 break;
 356
 357                         ath11k_dbg(ab, ATH11K_DBG_BOOT,
 358                                    "boot found board data for '%s'", boardname);
 359
 360                         bd->data = board_ie_data;
 361                         bd->len = board_ie_len;
 362
 363                         ret = 0;
 364                         goto out;
 365                 default:
 366                         ath11k_warn(ab, "unknown ATH11K_BD_IE_BOARD found: %d\n",
 367                                     board_ie_id);
 368                         break;
 369                 }
 370
 371                 /* jump over the padding */
 372                 board_ie_len = ALIGN(board_ie_len, 4);
 373
 374                 buf_len -= board_ie_len;
 375                 buf += board_ie_len;
 376         }
 377
 378         /* no match found */
 379         ret = -ENOENT;
 380
 381 out:
 382         return ret;
 383 }
 384
 385 static int ath11k_core_fetch_board_data_api_n(struct ath11k_base *ab,
 386                                               struct ath11k_board_data *bd,
 387                                               const char *boardname)
 388 {
 389         size_t len, magic_len;
 390         const u8 *data;
 391         char *filename, filepath[100];
 392         size_t ie_len;
 393         struct ath11k_fw_ie *hdr;
 394         int ret, ie_id;
 395
 396         filename = ATH11K_BOARD_API2_FILE;
 397
 398         if (!bd->fw)
 399                 bd->fw = ath11k_core_firmware_request(ab, filename);
 400
 401         if (IS_ERR(bd->fw))
 402                 return PTR_ERR(bd->fw);
 403
 404         data = bd->fw->data;
 405         len = bd->fw->size;
 406
 407         ath11k_core_create_firmware_path(ab, filename,
 408                                          filepath, sizeof(filepath));
 409
 410         /* magic has extra null byte padded */
 411         magic_len = strlen(ATH11K_BOARD_MAGIC) + 1;
 412         if (len < magic_len) {
 413                 ath11k_err(ab, "failed to find magic value in %s, file too short: %zu\n",
 414                            filepath, len);
 415                 ret = -EINVAL;
 416                 goto err;
 417         }
 418
 419         if (memcmp(data, ATH11K_BOARD_MAGIC, magic_len)) {
 420                 ath11k_err(ab, "found invalid board magic\n");
 421                 ret = -EINVAL;
 422                 goto err;
 423         }
 424
 425         /* magic is padded to 4 bytes */
 426         magic_len = ALIGN(magic_len, 4);
 427         if (len < magic_len) {
 428                 ath11k_err(ab, "failed: %s too small to contain board data, len: %zu\n",
 429                            filepath, len);
 430                 ret = -EINVAL;
 431                 goto err;
 432         }
 433
 434         data += magic_len;
 435         len -= magic_len;
 436
 437         while (len > sizeof(struct ath11k_fw_ie)) {
 438                 hdr = (struct ath11k_fw_ie *)data;
 439                 ie_id = le32_to_cpu(hdr->id);
 440                 ie_len = le32_to_cpu(hdr->len);
 441
 442                 len -= sizeof(*hdr);
 443                 data = hdr->data;
 444
 445                 if (len < ALIGN(ie_len, 4)) {
 446                         ath11k_err(ab, "invalid length for board ie_id %d ie_len %zu len %zu\n",
 447                                    ie_id, ie_len, len);
 448                         return -EINVAL;
 449                 }
 450
 451                 switch (ie_id) {
 452                 case ATH11K_BD_IE_BOARD:
 453                         ret = ath11k_core_parse_bd_ie_board(ab, bd, data,
 454                                                             ie_len,
 455                                                             boardname,
 456                                                             ATH11K_BD_IE_BOARD);
 457                         if (ret == -ENOENT)
 458                                 /* no match found, continue */
 459                                 break;
 460                         else if (ret)
 461                                 /* there was an error, bail out */
 462                                 goto err;
 463                         /* either found or error, so stop searching */
 464                         goto out;
 465                 }
 466
 467                 /* jump over the padding */
 468                 ie_len = ALIGN(ie_len, 4);
 469
 470                 len -= ie_len;
 471                 data += ie_len;
 472         }
 473
 474 out:
 475         if (!bd->data || !bd->len) {
 476                 ath11k_err(ab,
 477                            "failed to fetch board data for %s from %s\n",
 478                            boardname, filepath);
 479                 ret = -ENODATA;
 480                 goto err;
 481         }
 482
 483         return 0;
 484
 485 err:
 486         ath11k_core_free_bdf(ab, bd);
 487         return ret;
 488 }
 489
 490 static int ath11k_core_fetch_board_data_api_1(struct ath11k_base *ab,
 491                                               struct ath11k_board_data *bd)
 492 {
 493         bd->fw = ath11k_core_firmware_request(ab, ATH11K_DEFAULT_BOARD_FILE);
 494         if (IS_ERR(bd->fw))
 495                 return PTR_ERR(bd->fw);
 496
 497         bd->data = bd->fw->data;
 498         bd->len = bd->fw->size;
 499
 500         return 0;
 501 }
 502
 503 #define BOARD_NAME_SIZE 100
 504 int ath11k_core_fetch_bdf(struct ath11k_base *ab, struct ath11k_board_data *bd)
 505 {
 506         char boardname[BOARD_NAME_SIZE];
 507         int ret;
 508
 509         ret = ath11k_core_create_board_name(ab, boardname, BOARD_NAME_SIZE);
 510         if (ret) {
 511                 ath11k_err(ab, "failed to create board name: %d", ret);
 512                 return ret;
 513         }
 514
 515         ab->bd_api = 2;
 516         ret = ath11k_core_fetch_board_data_api_n(ab, bd, boardname);
 517         if (!ret)
 518                 goto success;
 519
 520         ab->bd_api = 1;
 521         ret = ath11k_core_fetch_board_data_api_1(ab, bd);
 522         if (ret) {
 523                 ath11k_err(ab, "failed to fetch board-2.bin or board.bin from %s\n",
 524                            ab->hw_params.fw.dir);
 525                 return ret;
 526         }
 527
 528 success:
 529         ath11k_dbg(ab, ATH11K_DBG_BOOT, "using board api %d\n", ab->bd_api);
 530         return 0;
 531 }
 532
 533 static void ath11k_core_stop(struct ath11k_base *ab)
 534 {
 535         if (!test_bit(ATH11K_FLAG_CRASH_FLUSH, &ab->dev_flags))
 536                 ath11k_qmi_firmware_stop(ab);
 537
 538         ath11k_hif_stop(ab);
 539         ath11k_wmi_detach(ab);
 540         ath11k_dp_pdev_reo_cleanup(ab);
 541
 542         /* De-Init of components as needed */
 543 }
 544
 545 static int ath11k_core_soc_create(struct ath11k_base *ab)
 546 {
 547         int ret;
 548
 549         ret = ath11k_qmi_init_service(ab);
 550         if (ret) {
 551                 ath11k_err(ab, "failed to initialize qmi :%d\n", ret);
 552                 return ret;
 553         }
 554
 555         ret = ath11k_debugfs_soc_create(ab);
 556         if (ret) {
 557                 ath11k_err(ab, "failed to create ath11k debugfs\n");
 558                 goto err_qmi_deinit;
 559         }
 560
 561         ret = ath11k_hif_power_up(ab);
 562         if (ret) {
 563                 ath11k_err(ab, "failed to power up :%d\n", ret);
 564                 goto err_debugfs_reg;
 565         }
 566
 567         return 0;
 568
 569 err_debugfs_reg:
 570         ath11k_debugfs_soc_destroy(ab);
 571 err_qmi_deinit:
 572         ath11k_qmi_deinit_service(ab);
 573         return ret;
 574 }
 575
 576 static void ath11k_core_soc_destroy(struct ath11k_base *ab)
 577 {
 578         ath11k_debugfs_soc_destroy(ab);
 579         ath11k_dp_free(ab);
 580         ath11k_reg_free(ab);
 581         ath11k_qmi_deinit_service(ab);
 582 }
 583
 584 static int ath11k_core_pdev_create(struct ath11k_base *ab)
 585 {
 586         int ret;
 587
 588         ret = ath11k_debugfs_pdev_create(ab);
 589         if (ret) {
 590                 ath11k_err(ab, "failed to create core pdev debugfs: %d\n", ret);
 591                 return ret;
 592         }
 593
 594         ret = ath11k_mac_register(ab);
 595         if (ret) {
 596                 ath11k_err(ab, "failed register the radio with mac80211: %d\n", ret);
 597                 goto err_pdev_debug;
 598         }
 599
 600         ret = ath11k_dp_pdev_alloc(ab);
 601         if (ret) {
 602                 ath11k_err(ab, "failed to attach DP pdev: %d\n", ret);
 603                 goto err_mac_unregister;
 604         }
 605
 606         ret = ath11k_thermal_register(ab);
 607         if (ret) {
 608                 ath11k_err(ab, "could not register thermal device: %d\n",
 609                            ret);
 610                 goto err_dp_pdev_free;
 611         }
 612
 613         ret = ath11k_spectral_init(ab);
 614         if (ret) {
 615                 ath11k_err(ab, "failed to init spectral %d\n", ret);
 616                 goto err_thermal_unregister;
 617         }
 618
 619         return 0;
 620
 621 err_thermal_unregister:
 622         ath11k_thermal_unregister(ab);
 623 err_dp_pdev_free:
 624         ath11k_dp_pdev_free(ab);
 625 err_mac_unregister:
 626         ath11k_mac_unregister(ab);
 627 err_pdev_debug:
 628         ath11k_debugfs_pdev_destroy(ab);
 629
 630         return ret;
 631 }
 632
 633 static void ath11k_core_pdev_destroy(struct ath11k_base *ab)
 634 {
 635         ath11k_spectral_deinit(ab);
 636         ath11k_thermal_unregister(ab);
 637         ath11k_mac_unregister(ab);
 638         ath11k_hif_irq_disable(ab);
 639         ath11k_dp_pdev_free(ab);
 640         ath11k_debugfs_pdev_destroy(ab);
 641 }
 642
 643 static int ath11k_core_start(struct ath11k_base *ab,
 644                              enum ath11k_firmware_mode mode)
 645 {
 646         int ret;
 647
 648         ret = ath11k_qmi_firmware_start(ab, mode);
 649         if (ret) {
 650                 ath11k_err(ab, "failed to attach wmi: %d\n", ret);
 651                 return ret;
 652         }
 653
 654         ret = ath11k_wmi_attach(ab);
 655         if (ret) {
 656                 ath11k_err(ab, "failed to attach wmi: %d\n", ret);
 657                 goto err_firmware_stop;
 658         }
 659
 660         ret = ath11k_htc_init(ab);
 661         if (ret) {
 662                 ath11k_err(ab, "failed to init htc: %d\n", ret);
 663                 goto err_wmi_detach;
 664         }
 665
 666         ret = ath11k_hif_start(ab);
 667         if (ret) {
 668                 ath11k_err(ab, "failed to start HIF: %d\n", ret);
 669                 goto err_wmi_detach;
 670         }
 671
 672         ret = ath11k_htc_wait_target(&ab->htc);
 673         if (ret) {
 674                 ath11k_err(ab, "failed to connect to HTC: %d\n", ret);
 675                 goto err_hif_stop;
 676         }
 677
 678         ret = ath11k_dp_htt_connect(&ab->dp);
 679         if (ret) {
 680                 ath11k_err(ab, "failed to connect to HTT: %d\n", ret);
 681                 goto err_hif_stop;
 682         }
 683
 684         ret = ath11k_wmi_connect(ab);
 685         if (ret) {
 686                 ath11k_err(ab, "failed to connect wmi: %d\n", ret);
 687                 goto err_hif_stop;
 688         }
 689
 690         ret = ath11k_htc_start(&ab->htc);
 691         if (ret) {
 692                 ath11k_err(ab, "failed to start HTC: %d\n", ret);
 693                 goto err_hif_stop;
 694         }
 695
 696         ret = ath11k_wmi_wait_for_service_ready(ab);
 697         if (ret) {
 698                 ath11k_err(ab, "failed to receive wmi service ready event: %d\n",
 699                            ret);
 700                 goto err_hif_stop;
 701         }
 702
 703         ret = ath11k_mac_allocate(ab);
 704         if (ret) {
 705                 ath11k_err(ab, "failed to create new hw device with mac80211 :%d\n",
 706                            ret);
 707                 goto err_hif_stop;
 708         }
 709
 710         ath11k_dp_pdev_pre_alloc(ab);
 711
 712         ret = ath11k_dp_pdev_reo_setup(ab);
 713         if (ret) {
 714                 ath11k_err(ab, "failed to initialize reo destination rings: %d\n", ret);
 715                 goto err_mac_destroy;
 716         }
 717
 718         ret = ath11k_wmi_cmd_init(ab);
 719         if (ret) {
 720                 ath11k_err(ab, "failed to send wmi init cmd: %d\n", ret);
 721                 goto err_reo_cleanup;
 722         }
 723
 724         ret = ath11k_wmi_wait_for_unified_ready(ab);
 725         if (ret) {
 726                 ath11k_err(ab, "failed to receive wmi unified ready event: %d\n",
 727                            ret);
 728                 goto err_reo_cleanup;
 729         }
 730
 731         /* put hardware to DBS mode */
 732         if (ab->hw_params.single_pdev_only) {
 733                 ret = ath11k_wmi_set_hw_mode(ab, WMI_HOST_HW_MODE_DBS);
 734                 if (ret) {
 735                         ath11k_err(ab, "failed to send dbs mode: %d\n", ret);
 736                         goto err_hif_stop;
 737                 }
 738         }
 739
 740         ret = ath11k_dp_tx_htt_h2t_ver_req_msg(ab);
 741         if (ret) {
 742                 ath11k_err(ab, "failed to send htt version request message: %d\n",
 743                            ret);
 744                 goto err_reo_cleanup;
 745         }
 746
 747         return 0;
 748
 749 err_reo_cleanup:
 750         ath11k_dp_pdev_reo_cleanup(ab);
 751 err_mac_destroy:
 752         ath11k_mac_destroy(ab);
 753 err_hif_stop:
 754         ath11k_hif_stop(ab);
 755 err_wmi_detach:
 756         ath11k_wmi_detach(ab);
 757 err_firmware_stop:
 758         ath11k_qmi_firmware_stop(ab);
 759
 760         return ret;
 761 }
 762
 763 int ath11k_core_qmi_firmware_ready(struct ath11k_base *ab)
 764 {
 765         int ret;
 766
 767         ret = ath11k_ce_init_pipes(ab);
 768         if (ret) {
 769                 ath11k_err(ab, "failed to initialize CE: %d\n", ret);
 770                 return ret;
 771         }
 772
 773         ret = ath11k_dp_alloc(ab);
 774         if (ret) {
 775                 ath11k_err(ab, "failed to init DP: %d\n", ret);
 776                 return ret;
 777         }
 778
 779         switch (ath11k_crypto_mode) {
 780         case ATH11K_CRYPT_MODE_SW:
 781                 set_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ab->dev_flags);
 782                 set_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags);
 783                 break;
 784         case ATH11K_CRYPT_MODE_HW:
 785                 clear_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ab->dev_flags);
 786                 clear_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags);
 787                 break;
 788         default:
 789                 ath11k_info(ab, "invalid crypto_mode: %d\n", ath11k_crypto_mode);
 790                 return -EINVAL;
 791         }
 792
 793         if (ath11k_frame_mode == ATH11K_HW_TXRX_RAW)
 794                 set_bit(ATH11K_FLAG_RAW_MODE, &ab->dev_flags);
 795
 796         mutex_lock(&ab->core_lock);
 797         ret = ath11k_core_start(ab, ATH11K_FIRMWARE_MODE_NORMAL);
 798         if (ret) {
 799                 ath11k_err(ab, "failed to start core: %d\n", ret);
 800                 goto err_dp_free;
 801         }
 802
 803         ret = ath11k_core_pdev_create(ab);
 804         if (ret) {
 805                 ath11k_err(ab, "failed to create pdev core: %d\n", ret);
 806                 goto err_core_stop;
 807         }
 808         ath11k_hif_irq_enable(ab);
 809         mutex_unlock(&ab->core_lock);
 810
 811         return 0;
 812
 813 err_core_stop:
 814         ath11k_core_stop(ab);
 815         ath11k_mac_destroy(ab);
 816 err_dp_free:
 817         ath11k_dp_free(ab);
 818         mutex_unlock(&ab->core_lock);
 819         return ret;
 820 }
 821
 822 static int ath11k_core_reconfigure_on_crash(struct ath11k_base *ab)
 823 {
 824         int ret;
 825
 826         mutex_lock(&ab->core_lock);
 827         ath11k_thermal_unregister(ab);
 828         ath11k_hif_irq_disable(ab);
 829         ath11k_dp_pdev_free(ab);
 830         ath11k_spectral_deinit(ab);
 831         ath11k_hif_stop(ab);
 832         ath11k_wmi_detach(ab);
 833         ath11k_dp_pdev_reo_cleanup(ab);
 834         mutex_unlock(&ab->core_lock);
 835
 836         ath11k_dp_free(ab);
 837         ath11k_hal_srng_deinit(ab);
 838
 839         ab->free_vdev_map = (1LL << (ab->num_radios * TARGET_NUM_VDEVS)) - 1;
 840
 841         ret = ath11k_hal_srng_init(ab);
 842         if (ret)
 843                 return ret;
 844
 845         clear_bit(ATH11K_FLAG_CRASH_FLUSH, &ab->dev_flags);
 846
 847         ret = ath11k_core_qmi_firmware_ready(ab);
 848         if (ret)
 849                 goto err_hal_srng_deinit;
 850
 851         clear_bit(ATH11K_FLAG_RECOVERY, &ab->dev_flags);
 852
 853         return 0;
 854
 855 err_hal_srng_deinit:
 856         ath11k_hal_srng_deinit(ab);
 857         return ret;
 858 }
 859
 860 void ath11k_core_halt(struct ath11k *ar)
 861 {
 862         struct ath11k_base *ab = ar->ab;
 863
 864         lockdep_assert_held(&ar->conf_mutex);
 865
 866         ar->num_created_vdevs = 0;
 867         ar->allocated_vdev_map = 0;
 868
 869         ath11k_mac_scan_finish(ar);
 870         ath11k_mac_peer_cleanup_all(ar);
 871         cancel_delayed_work_sync(&ar->scan.timeout);
 872         cancel_work_sync(&ar->regd_update_work);
 873
 874         rcu_assign_pointer(ab->pdevs_active[ar->pdev_idx], NULL);
 875         synchronize_rcu();
 876         INIT_LIST_HEAD(&ar->arvifs);
 877         idr_init(&ar->txmgmt_idr);
 878 }
 879
 880 static void ath11k_core_restart(struct work_struct *work)
 881 {
 882         struct ath11k_base *ab = container_of(work, struct ath11k_base, restart_work);
 883         struct ath11k *ar;
 884         struct ath11k_pdev *pdev;
 885         int i, ret = 0;
 886
 887         spin_lock_bh(&ab->base_lock);
 888         ab->stats.fw_crash_counter++;
 889         spin_unlock_bh(&ab->base_lock);
 890
 891         for (i = 0; i < ab->num_radios; i++) {
 892                 pdev = &ab->pdevs[i];
 893                 ar = pdev->ar;
 894                 if (!ar || ar->state == ATH11K_STATE_OFF)
 895                         continue;
 896
 897                 ieee80211_stop_queues(ar->hw);
 898                 ath11k_mac_drain_tx(ar);
 899                 complete(&ar->scan.started);
 900                 complete(&ar->scan.completed);
 901                 complete(&ar->peer_assoc_done);
 902                 complete(&ar->peer_delete_done);
 903                 complete(&ar->install_key_done);
 904                 complete(&ar->vdev_setup_done);
 905                 complete(&ar->vdev_delete_done);
 906                 complete(&ar->bss_survey_done);
 907                 complete(&ar->thermal.wmi_sync);
 908
 909                 wake_up(&ar->dp.tx_empty_waitq);
 910                 idr_for_each(&ar->txmgmt_idr,
 911                              ath11k_mac_tx_mgmt_pending_free, ar);
 912                 idr_destroy(&ar->txmgmt_idr);
 913         }
 914
 915         wake_up(&ab->wmi_ab.tx_credits_wq);
 916         wake_up(&ab->peer_mapping_wq);
 917
 918         ret = ath11k_core_reconfigure_on_crash(ab);
 919         if (ret) {
 920                 ath11k_err(ab, "failed to reconfigure driver on crash recovery\n");
 921                 return;
 922         }
 923
 924         for (i = 0; i < ab->num_radios; i++) {
 925                 pdev = &ab->pdevs[i];
 926                 ar = pdev->ar;
 927                 if (!ar || ar->state == ATH11K_STATE_OFF)
 928                         continue;
 929
 930                 mutex_lock(&ar->conf_mutex);
 931
 932                 switch (ar->state) {
 933                 case ATH11K_STATE_ON:
 934                         ar->state = ATH11K_STATE_RESTARTING;
 935                         ath11k_core_halt(ar);
 936                         ieee80211_restart_hw(ar->hw);
 937                         break;
 938                 case ATH11K_STATE_OFF:
 939                         ath11k_warn(ab,
 940                                     "cannot restart radio %d that hasn't been started\n",
 941                                     i);
 942                         break;
 943                 case ATH11K_STATE_RESTARTING:
 944                         break;
 945                 case ATH11K_STATE_RESTARTED:
 946                         ar->state = ATH11K_STATE_WEDGED;
 947                         fallthrough;
 948                 case ATH11K_STATE_WEDGED:
 949                         ath11k_warn(ab,
 950                                     "device is wedged, will not restart radio %d\n", i);
 951                         break;
 952                 }
 953                 mutex_unlock(&ar->conf_mutex);
 954         }
 955         complete(&ab->driver_recovery);
 956 }
 957
 958 static int ath11k_init_hw_params(struct ath11k_base *ab)
 959 {
 960         const struct ath11k_hw_params *hw_params = NULL;
 961         int i;
 962
 963         for (i = 0; i < ARRAY_SIZE(ath11k_hw_params); i++) {
 964                 hw_params = &ath11k_hw_params[i];
 965
 966                 if (hw_params->hw_rev == ab->hw_rev)
 967                         break;
 968         }
 969
 970         if (i == ARRAY_SIZE(ath11k_hw_params)) {
 971                 ath11k_err(ab, "Unsupported hardware version: 0x%x\n", ab->hw_rev);
 972                 return -EINVAL;
 973         }
 974
 975         ab->hw_params = *hw_params;
 976
 977         ath11k_dbg(ab, ATH11K_DBG_BOOT, "Hardware name %s\n", ab->hw_params.name);
 978
 979         return 0;
 980 }
 981
 982 int ath11k_core_pre_init(struct ath11k_base *ab)
 983 {
 984         int ret;
 985
 986         ret = ath11k_init_hw_params(ab);
 987         if (ret) {
 988                 ath11k_err(ab, "failed to get hw params: %d\n", ret);
 989                 return ret;
 990         }
 991
 992         return 0;
 993 }
 994 EXPORT_SYMBOL(ath11k_core_pre_init);
 995
 996 int ath11k_core_init(struct ath11k_base *ab)
 997 {
 998         int ret;
 999
1000         ret = ath11k_core_soc_create(ab);
1001         if (ret) {
1002                 ath11k_err(ab, "failed to create soc core: %d\n", ret);
1003                 return ret;
1004         }
1005
1006         return 0;
1007 }
1008 EXPORT_SYMBOL(ath11k_core_init);
1009
1010 void ath11k_core_deinit(struct ath11k_base *ab)
1011 {
1012         mutex_lock(&ab->core_lock);
1013
1014         ath11k_core_pdev_destroy(ab);
1015         ath11k_core_stop(ab);
1016
1017         mutex_unlock(&ab->core_lock);
1018
1019         ath11k_hif_power_down(ab);
1020         ath11k_mac_destroy(ab);
1021         ath11k_core_soc_destroy(ab);
1022 }
1023 EXPORT_SYMBOL(ath11k_core_deinit);
1024
1025 void ath11k_core_free(struct ath11k_base *ab)
1026 {
1027         kfree(ab);
1028 }
1029 EXPORT_SYMBOL(ath11k_core_free);
1030
1031 struct ath11k_base *ath11k_core_alloc(struct device *dev, size_t priv_size,
1032                                       enum ath11k_bus bus,
1033                                       const struct ath11k_bus_params *bus_params)
1034 {
1035         struct ath11k_base *ab;
1036
1037         ab = kzalloc(sizeof(*ab) + priv_size, GFP_KERNEL);
1038         if (!ab)
1039                 return NULL;
1040
1041         init_completion(&ab->driver_recovery);
1042
1043         ab->workqueue = create_singlethread_workqueue("ath11k_wq");
1044         if (!ab->workqueue)
1045                 goto err_sc_free;
1046
1047         mutex_init(&ab->core_lock);
1048         spin_lock_init(&ab->base_lock);
1049
1050         INIT_LIST_HEAD(&ab->peers);
1051         init_waitqueue_head(&ab->peer_mapping_wq);
1052         init_waitqueue_head(&ab->wmi_ab.tx_credits_wq);
1053         init_waitqueue_head(&ab->qmi.cold_boot_waitq);
1054         INIT_WORK(&ab->restart_work, ath11k_core_restart);
1055         timer_setup(&ab->rx_replenish_retry, ath11k_ce_rx_replenish_retry, 0);
1056         init_completion(&ab->htc_suspend);
1057         init_completion(&ab->wow.wakeup_completed);
1058
1059         ab->dev = dev;
1060         ab->bus_params = *bus_params;
1061         ab->hif.bus = bus;
1062
1063         return ab;
1064
1065 err_sc_free:
1066         kfree(ab);
1067         return NULL;
1068 }
1069 EXPORT_SYMBOL(ath11k_core_alloc);
1070
1071 MODULE_DESCRIPTION("Core module for Qualcomm Atheros 802.11ax wireless LAN cards.");
1072 MODULE_LICENSE("Dual BSD/GPL");