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