drivers/net/wireless/cnss2/main.c

   1 /* Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License version 2 and
   5  * only version 2 as published by the Free Software Foundation.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  */
  12
  13 #include <linux/delay.h>
  14 #include <linux/jiffies.h>
  15 #include <linux/module.h>
  16 #include <linux/of.h>
  17 #include <linux/of_device.h>
  18 #include <linux/pm_wakeup.h>
  19 #include <linux/rwsem.h>
  20 #include <linux/suspend.h>
  21 #include <linux/timer.h>
  22 #include <soc/qcom/ramdump.h>
  23 #include <soc/qcom/subsystem_notif.h>
  24
  25 #include "main.h"
  26 #include "bus.h"
  27 #include "debug.h"
  28
  29 #define CNSS_DUMP_FORMAT_VER            0x11
  30 #define CNSS_DUMP_FORMAT_VER_V2         0x22
  31 #define CNSS_DUMP_MAGIC_VER_V2          0x42445953
  32 #define CNSS_DUMP_NAME                  "CNSS_WLAN"
  33 #define CNSS_DUMP_DESC_SIZE             0x1000
  34 #define CNSS_DUMP_SEG_VER               0x1
  35 #define WLAN_RECOVERY_DELAY             1000
  36 #define FILE_SYSTEM_READY               1
  37 #define FW_READY_TIMEOUT                20000
  38 #define FW_ASSERT_TIMEOUT               5000
  39 #define CNSS_EVENT_PENDING              2989
  40 #define CE_MSI_NAME                     "CE"
  41
  42 static struct cnss_plat_data *plat_env;
  43
  44 static DECLARE_RWSEM(cnss_pm_sem);
  45
  46 static bool qmi_bypass;
  47 #ifdef CONFIG_CNSS2_DEBUG
  48 module_param(qmi_bypass, bool, 0600);
  49 MODULE_PARM_DESC(qmi_bypass, "Bypass QMI from platform driver");
  50 #endif
  51
  52 static bool enable_waltest;
  53 #ifdef CONFIG_CNSS2_DEBUG
  54 module_param(enable_waltest, bool, 0600);
  55 MODULE_PARM_DESC(enable_waltest, "Enable to handle firmware waltest");
  56 #endif
  57
  58 unsigned long quirks;
  59 #ifdef CONFIG_CNSS2_DEBUG
  60 module_param(quirks, ulong, 0600);
  61 MODULE_PARM_DESC(quirks, "Debug quirks for the driver");
  62 #endif
  63
  64 static unsigned int wow_wake_gpionum;
  65 #ifdef CONFIG_CNSS2_DEBUG
  66 module_param(wow_wake_gpionum, uint, 0600);
  67 MODULE_PARM_DESC(wow_wake_gpionum, "configure gpio number for wow wake");
  68 #endif
  69
  70 static unsigned int wow_wake_enable;
  71 int cnss_enable_wow_wake(const char *val, const struct kernel_param *kp)
  72 {
  73         int ret;
  74         unsigned int prev_val;
  75
  76         prev_val = *(unsigned int *)kp->arg;
  77         ret = param_set_uint(val, kp);
  78         if (ret || prev_val == wow_wake_enable) {
  79                 cnss_pr_err("failed set new wow_enable ret = %d", ret);
  80                 return ret;
  81         }
  82         if (wow_wake_enable) {
  83                 if (!wow_wake_gpionum)
  84                         wow_wake_gpionum = HOST_WAKE_GPIO_IN;
  85                 cnss_set_wlan_chip_to_host_wakeup(wow_wake_gpionum);
  86         }
  87         return 0;
  88 }
  89
  90 static const struct kernel_param_ops cnss_param_ops_uint = {
  91         .set = &cnss_enable_wow_wake,
  92         .get = &param_get_uint
  93 };
  94
  95 module_param_cb(wow_wake_enable, &cnss_param_ops_uint,
  96                 &wow_wake_enable, 0600);
  97
  98 static struct cnss_fw_files FW_FILES_QCA6174_FW_3_0 = {
  99         "qwlan30.bin", "bdwlan30.bin", "otp30.bin", "utf30.bin",
 100         "utfbd30.bin", "epping30.bin", "evicted30.bin"
 101 };
 102
 103 static struct cnss_fw_files FW_FILES_DEFAULT = {
 104         "qwlan.bin", "bdwlan.bin", "otp.bin", "utf.bin",
 105         "utfbd.bin", "epping.bin", "evicted.bin"
 106 };
 107
 108 struct cnss_driver_event {
 109         struct list_head list;
 110         enum cnss_driver_event_type type;
 111         bool sync;
 112         struct completion complete;
 113         int ret;
 114         void *data;
 115 };
 116
 117 static void cnss_set_plat_priv(struct platform_device *plat_dev,
 118                                struct cnss_plat_data *plat_priv)
 119 {
 120         plat_env = plat_priv;
 121 }
 122
 123 struct cnss_plat_data *cnss_get_plat_priv(struct platform_device *plat_dev)
 124 {
 125         return plat_env;
 126 }
 127
 128 static int cnss_pm_notify(struct notifier_block *b,
 129                           unsigned long event, void *p)
 130 {
 131         switch (event) {
 132         case PM_SUSPEND_PREPARE:
 133                 down_write(&cnss_pm_sem);
 134                 break;
 135         case PM_POST_SUSPEND:
 136                 up_write(&cnss_pm_sem);
 137                 break;
 138         }
 139
 140         return NOTIFY_DONE;
 141 }
 142
 143 static struct notifier_block cnss_pm_notifier = {
 144         .notifier_call = cnss_pm_notify,
 145 };
 146
 147 static void cnss_pm_stay_awake(struct cnss_plat_data *plat_priv)
 148 {
 149         if (atomic_inc_return(&plat_priv->pm_count) != 1)
 150                 return;
 151
 152         cnss_pr_dbg("PM stay awake, state: 0x%lx, count: %d\n",
 153                     plat_priv->driver_state,
 154                     atomic_read(&plat_priv->pm_count));
 155         pm_stay_awake(&plat_priv->plat_dev->dev);
 156 }
 157
 158 static void cnss_pm_relax(struct cnss_plat_data *plat_priv)
 159 {
 160         int r = atomic_dec_return(&plat_priv->pm_count);
 161
 162         WARN_ON(r < 0);
 163
 164         if (r != 0)
 165                 return;
 166
 167         cnss_pr_dbg("PM relax, state: 0x%lx, count: %d\n",
 168                     plat_priv->driver_state,
 169                     atomic_read(&plat_priv->pm_count));
 170         pm_relax(&plat_priv->plat_dev->dev);
 171 }
 172
 173 void cnss_lock_pm_sem(struct device *dev)
 174 {
 175         down_read(&cnss_pm_sem);
 176 }
 177 EXPORT_SYMBOL(cnss_lock_pm_sem);
 178
 179 void cnss_release_pm_sem(struct device *dev)
 180 {
 181         up_read(&cnss_pm_sem);
 182 }
 183 EXPORT_SYMBOL(cnss_release_pm_sem);
 184
 185 int cnss_get_fw_files_for_target(struct device *dev,
 186                                  struct cnss_fw_files *pfw_files,
 187                                  u32 target_type, u32 target_version)
 188 {
 189         if (!pfw_files)
 190                 return -ENODEV;
 191
 192         switch (target_version) {
 193         case QCA6174_REV3_VERSION:
 194         case QCA6174_REV3_2_VERSION:
 195                 memcpy(pfw_files, &FW_FILES_QCA6174_FW_3_0, sizeof(*pfw_files));
 196                 break;
 197         default:
 198                 memcpy(pfw_files, &FW_FILES_DEFAULT, sizeof(*pfw_files));
 199                 cnss_pr_err("Unknown target version, type: 0x%X, version: 0x%X",
 200                             target_type, target_version);
 201                 break;
 202         }
 203
 204         return 0;
 205 }
 206 EXPORT_SYMBOL(cnss_get_fw_files_for_target);
 207
 208 int cnss_request_bus_bandwidth(struct device *dev, int bandwidth)
 209 {
 210         int ret = 0;
 211         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
 212         struct cnss_bus_bw_info *bus_bw_info;
 213
 214         if (!plat_priv)
 215                 return -ENODEV;
 216
 217         bus_bw_info = &plat_priv->bus_bw_info;
 218         if (!bus_bw_info->bus_client)
 219                 return -EINVAL;
 220
 221         switch (bandwidth) {
 222         case CNSS_BUS_WIDTH_NONE:
 223         case CNSS_BUS_WIDTH_LOW:
 224         case CNSS_BUS_WIDTH_MEDIUM:
 225         case CNSS_BUS_WIDTH_HIGH:
 226                 ret = msm_bus_scale_client_update_request(
 227                         bus_bw_info->bus_client, bandwidth);
 228                 if (!ret)
 229                         bus_bw_info->current_bw_vote = bandwidth;
 230                 else
 231                         cnss_pr_err("Could not set bus bandwidth: %d, err = %d\n",
 232                                     bandwidth, ret);
 233                 break;
 234         default:
 235                 cnss_pr_err("Invalid bus bandwidth: %d", bandwidth);
 236                 ret = -EINVAL;
 237         }
 238
 239         return ret;
 240 }
 241 EXPORT_SYMBOL(cnss_request_bus_bandwidth);
 242
 243 int cnss_get_platform_cap(struct device *dev, struct cnss_platform_cap *cap)
 244 {
 245         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
 246
 247         if (!plat_priv)
 248                 return -ENODEV;
 249
 250         if (cap)
 251                 *cap = plat_priv->cap;
 252
 253         return 0;
 254 }
 255 EXPORT_SYMBOL(cnss_get_platform_cap);
 256
 257 void cnss_request_pm_qos(struct device *dev, u32 qos_val)
 258 {
 259         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
 260
 261         if (!plat_priv)
 262                 return;
 263
 264         pm_qos_add_request(&plat_priv->qos_request, PM_QOS_CPU_DMA_LATENCY,
 265                            qos_val);
 266 }
 267 EXPORT_SYMBOL(cnss_request_pm_qos);
 268
 269 void cnss_remove_pm_qos(struct device *dev)
 270 {
 271         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
 272
 273         if (!plat_priv)
 274                 return;
 275
 276         pm_qos_remove_request(&plat_priv->qos_request);
 277 }
 278 EXPORT_SYMBOL(cnss_remove_pm_qos);
 279
 280 int cnss_wlan_enable(struct device *dev,
 281                      struct cnss_wlan_enable_cfg *config,
 282                      enum cnss_driver_mode mode,
 283                      const char *host_version)
 284 {
 285         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(NULL);
 286         struct wlfw_wlan_cfg_req_msg_v01 req;
 287         u32 i, ce_id, num_vectors, user_base_data, base_vector;
 288         int ret = 0;
 289
 290         if (plat_priv->device_id == QCA6174_DEVICE_ID)
 291                 return 0;
 292
 293         if (qmi_bypass)
 294                 return 0;
 295
 296         if (plat_priv->bus_type == CNSS_BUS_USB ||
 297             plat_priv->bus_type == CNSS_BUS_SDIO)
 298                 goto skip_cfg;
 299
 300         if (!config || !host_version) {
 301                 cnss_pr_err("Invalid config or host_version pointer\n");
 302                 return -EINVAL;
 303         }
 304
 305         cnss_pr_dbg("Mode: %d, config: %pK, host_version: %s\n",
 306                     mode, config, host_version);
 307
 308         if (mode == CNSS_WALTEST || mode == CNSS_CCPM)
 309                 goto skip_cfg;
 310
 311         memset(&req, 0, sizeof(req));
 312
 313         req.host_version_valid = 1;
 314         strlcpy(req.host_version, host_version,
 315                 QMI_WLFW_MAX_STR_LEN_V01 + 1);
 316
 317         req.tgt_cfg_valid = 1;
 318         if (config->num_ce_tgt_cfg > QMI_WLFW_MAX_NUM_CE_V01)
 319                 req.tgt_cfg_len = QMI_WLFW_MAX_NUM_CE_V01;
 320         else
 321                 req.tgt_cfg_len = config->num_ce_tgt_cfg;
 322         for (i = 0; i < req.tgt_cfg_len; i++) {
 323                 req.tgt_cfg[i].pipe_num = config->ce_tgt_cfg[i].pipe_num;
 324                 req.tgt_cfg[i].pipe_dir = config->ce_tgt_cfg[i].pipe_dir;
 325                 req.tgt_cfg[i].nentries = config->ce_tgt_cfg[i].nentries;
 326                 req.tgt_cfg[i].nbytes_max = config->ce_tgt_cfg[i].nbytes_max;
 327                 req.tgt_cfg[i].flags = config->ce_tgt_cfg[i].flags;
 328         }
 329
 330         req.svc_cfg_valid = 1;
 331         if (config->num_ce_svc_pipe_cfg > QMI_WLFW_MAX_NUM_SVC_V01)
 332                 req.svc_cfg_len = QMI_WLFW_MAX_NUM_SVC_V01;
 333         else
 334                 req.svc_cfg_len = config->num_ce_svc_pipe_cfg;
 335         for (i = 0; i < req.svc_cfg_len; i++) {
 336                 req.svc_cfg[i].service_id = config->ce_svc_cfg[i].service_id;
 337                 req.svc_cfg[i].pipe_dir = config->ce_svc_cfg[i].pipe_dir;
 338                 req.svc_cfg[i].pipe_num = config->ce_svc_cfg[i].pipe_num;
 339         }
 340
 341         if (config->num_shadow_reg_cfg) {
 342                 req.shadow_reg_valid = 1;
 343
 344                 if (config->num_shadow_reg_cfg >
 345                     QMI_WLFW_MAX_NUM_SHADOW_REG_V01)
 346                         req.shadow_reg_len = QMI_WLFW_MAX_NUM_SHADOW_REG_V01;
 347                 else
 348                         req.shadow_reg_len = config->num_shadow_reg_cfg;
 349                 memcpy(req.shadow_reg, config->shadow_reg_cfg,
 350                        sizeof(struct wlfw_shadow_reg_cfg_s_v01)
 351                        * req.shadow_reg_len);
 352         }
 353
 354         req.shadow_reg_v2_valid = 1;
 355         if (config->num_shadow_reg_v2_cfg >
 356             QMI_WLFW_MAX_NUM_SHADOW_REG_V2_V01)
 357                 req.shadow_reg_v2_len = QMI_WLFW_MAX_NUM_SHADOW_REG_V2_V01;
 358         else
 359                 req.shadow_reg_v2_len = config->num_shadow_reg_v2_cfg;
 360
 361         memcpy(req.shadow_reg_v2, config->shadow_reg_v2_cfg,
 362                sizeof(struct wlfw_shadow_reg_v2_cfg_s_v01)
 363                * req.shadow_reg_v2_len);
 364
 365         if (config->rri_over_ddr_cfg_valid) {
 366                 req.rri_over_ddr_cfg_valid = 1;
 367                 req.rri_over_ddr_cfg.base_addr_low =
 368                         config->rri_over_ddr_cfg.base_addr_low;
 369                 req.rri_over_ddr_cfg.base_addr_high =
 370                         config->rri_over_ddr_cfg.base_addr_high;
 371         }
 372
 373         if (plat_priv->device_id == QCN7605_DEVICE_ID) {
 374                 ret = cnss_get_user_msi_assignment(dev, CE_MSI_NAME,
 375                                                    &num_vectors,
 376                                                    &user_base_data,
 377                                                    &base_vector);
 378                 if (!ret) {
 379                         req.msi_cfg_valid = 1;
 380                         req.msi_cfg_len = QMI_WLFW_MAX_NUM_CE_V01;
 381                         for (ce_id = 0; ce_id < QMI_WLFW_MAX_NUM_CE_V01;
 382                                 ce_id++) {
 383                                 req.msi_cfg[ce_id].ce_id = ce_id;
 384                                 req.msi_cfg[ce_id].msi_vector =
 385                                         (ce_id % num_vectors) + base_vector;
 386                         }
 387                 }
 388         }
 389         ret = cnss_wlfw_wlan_cfg_send_sync(plat_priv, &req);
 390         if (ret)
 391                 goto out;
 392
 393 skip_cfg:
 394         ret = cnss_wlfw_wlan_mode_send_sync(plat_priv, mode);
 395 out:
 396         return ret;
 397 }
 398 EXPORT_SYMBOL(cnss_wlan_enable);
 399
 400 int cnss_wlan_disable(struct device *dev, enum cnss_driver_mode mode)
 401 {
 402         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(NULL);
 403
 404         if (plat_priv->device_id == QCA6174_DEVICE_ID)
 405                 return 0;
 406
 407         if (qmi_bypass)
 408                 return 0;
 409
 410         return cnss_wlfw_wlan_mode_send_sync(plat_priv, QMI_WLFW_OFF_V01);
 411 }
 412 EXPORT_SYMBOL(cnss_wlan_disable);
 413
 414 #ifdef CONFIG_CNSS2_DEBUG
 415 int cnss_athdiag_read(struct device *dev, u32 offset, u32 mem_type,
 416                       u32 data_len, u8 *output)
 417 {
 418         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
 419         int ret = 0;
 420
 421         if (!plat_priv) {
 422                 cnss_pr_err("plat_priv is NULL!\n");
 423                 return -EINVAL;
 424         }
 425
 426         if (plat_priv->device_id == QCA6174_DEVICE_ID)
 427                 return 0;
 428
 429         if (!output || data_len == 0 || data_len > QMI_WLFW_MAX_DATA_SIZE_V01) {
 430                 cnss_pr_err("Invalid parameters for athdiag read: output %p, data_len %u\n",
 431                             output, data_len);
 432                 ret = -EINVAL;
 433                 goto out;
 434         }
 435
 436         if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
 437                 cnss_pr_err("Invalid state for athdiag read: 0x%lx\n",
 438                             plat_priv->driver_state);
 439                 ret = -EINVAL;
 440                 goto out;
 441         }
 442
 443         ret = cnss_wlfw_athdiag_read_send_sync(plat_priv, offset, mem_type,
 444                                                data_len, output);
 445
 446 out:
 447         return ret;
 448 }
 449 EXPORT_SYMBOL(cnss_athdiag_read);
 450
 451 int cnss_athdiag_write(struct device *dev, u32 offset, u32 mem_type,
 452                        u32 data_len, u8 *input)
 453 {
 454         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
 455         int ret = 0;
 456
 457         if (!plat_priv) {
 458                 cnss_pr_err("plat_priv is NULL!\n");
 459                 return -EINVAL;
 460         }
 461
 462         if (plat_priv->device_id == QCA6174_DEVICE_ID)
 463                 return 0;
 464
 465         if (!input || data_len == 0 || data_len > QMI_WLFW_MAX_DATA_SIZE_V01) {
 466                 cnss_pr_err("Invalid parameters for athdiag write: input %p, data_len %u\n",
 467                             input, data_len);
 468                 ret = -EINVAL;
 469                 goto out;
 470         }
 471
 472         if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
 473                 cnss_pr_err("Invalid state for athdiag write: 0x%lx\n",
 474                             plat_priv->driver_state);
 475                 ret = -EINVAL;
 476                 goto out;
 477         }
 478
 479         ret = cnss_wlfw_athdiag_write_send_sync(plat_priv, offset, mem_type,
 480                                                 data_len, input);
 481
 482 out:
 483         return ret;
 484 }
 485 EXPORT_SYMBOL(cnss_athdiag_write);
 486 #else
 487 int cnss_athdiag_read(struct device *dev, u32 offset, u32 mem_type,
 488                       u32 data_len, u8 *output)
 489 {
 490         return -EPERM;
 491 }
 492 EXPORT_SYMBOL(cnss_athdiag_read);
 493
 494 int cnss_athdiag_write(struct device *dev, u32 offset, u32 mem_type,
 495                        u32 data_len, u8 *input)
 496 {
 497         return -EPERM;
 498 }
 499 EXPORT_SYMBOL(cnss_athdiag_write);
 500 #endif
 501
 502 int cnss_set_fw_log_mode(struct device *dev, u8 fw_log_mode)
 503 {
 504         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
 505
 506         if (plat_priv->device_id == QCA6174_DEVICE_ID)
 507                 return 0;
 508
 509         return cnss_wlfw_ini_send_sync(plat_priv, fw_log_mode);
 510 }
 511 EXPORT_SYMBOL(cnss_set_fw_log_mode);
 512
 513 unsigned long *cnss_get_debug_quirks(void)
 514 {
 515         return &quirks;
 516 }
 517
 518 bool *cnss_get_qmi_bypass(void)
 519 {
 520         return &qmi_bypass;
 521 }
 522
 523 static int cnss_fw_mem_ready_hdlr(struct cnss_plat_data *plat_priv)
 524 {
 525         int ret = 0;
 526
 527         if (!plat_priv)
 528                 return -ENODEV;
 529
 530         set_bit(CNSS_FW_MEM_READY, &plat_priv->driver_state);
 531
 532         ret = cnss_wlfw_tgt_cap_send_sync(plat_priv);
 533         if (ret)
 534                 goto out;
 535
 536         ret = cnss_wlfw_bdf_dnld_send_sync(plat_priv);
 537         if (ret)
 538                 goto out;
 539
 540         if (plat_priv->device_id == QCN7605_DEVICE_ID)
 541                 goto skip_m3_dnld;
 542         ret = cnss_bus_load_m3(plat_priv);
 543         if (ret)
 544                 goto out;
 545
 546         ret = cnss_wlfw_m3_dnld_send_sync(plat_priv);
 547         if (ret)
 548                 goto out;
 549 skip_m3_dnld:
 550         return 0;
 551 out:
 552         return ret;
 553 }
 554
 555 static int cnss_fw_ready_hdlr(struct cnss_plat_data *plat_priv)
 556 {
 557         int ret = 0;
 558
 559         if (!plat_priv)
 560                 return -ENODEV;
 561
 562         del_timer(&plat_priv->fw_boot_timer);
 563         set_bit(CNSS_FW_READY, &plat_priv->driver_state);
 564
 565         if (test_bit(CNSS_FW_BOOT_RECOVERY, &plat_priv->driver_state)) {
 566                 clear_bit(CNSS_FW_BOOT_RECOVERY, &plat_priv->driver_state);
 567                 clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
 568         }
 569
 570         if (enable_waltest) {
 571                 ret = cnss_wlfw_wlan_mode_send_sync(plat_priv,
 572                                                     QMI_WLFW_WALTEST_V01);
 573         } else if (test_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state)) {
 574                 ret = cnss_wlfw_wlan_mode_send_sync(plat_priv,
 575                                                     QMI_WLFW_CALIBRATION_V01);
 576         } else if (test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state) ||
 577                    test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {
 578                 ret = cnss_bus_call_driver_probe(plat_priv);
 579         } else {
 580                 complete(&plat_priv->power_up_complete);
 581         }
 582
 583         if (ret && test_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state))
 584                 goto out;
 585         else if (ret)
 586                 goto shutdown;
 587
 588         return 0;
 589
 590 shutdown:
 591         cnss_bus_dev_shutdown(plat_priv);
 592
 593         clear_bit(CNSS_FW_READY, &plat_priv->driver_state);
 594         clear_bit(CNSS_FW_MEM_READY, &plat_priv->driver_state);
 595
 596 out:
 597         return ret;
 598 }
 599
 600 static int caldb_mem_bounds_check(struct cnss_plat_data *plat_priv, void *data)
 601 {
 602         int ret = 0;
 603         struct cnss_cal_data *cal_data = data;
 604         u8 *end_ptr, *cal_data_ptr;
 605         u32 total_size;
 606
 607         end_ptr = (u8 *)plat_priv->caldb_mem + QCN7605_CALDB_SIZE;
 608         cal_data_ptr = (u8 *)plat_priv->caldb_mem + cal_data->index;
 609         total_size = cal_data->total_size;
 610
 611         if (cal_data_ptr >= end_ptr || (cal_data_ptr + total_size) >= end_ptr) {
 612                 cnss_pr_err("caldb data offset or size error\n");
 613                 ret = -EINVAL;
 614         }
 615
 616         return ret;
 617 }
 618
 619 static int cnss_cal_update_hdlr(struct cnss_plat_data *plat_priv, void *data)
 620 {
 621         int ret = 0;
 622
 623         ret  = caldb_mem_bounds_check(plat_priv, data);
 624         if (ret)
 625                 CNSS_ASSERT(0);
 626         else
 627                 cnss_wlfw_cal_update_req_send_sync(plat_priv, data);
 628
 629         return ret;
 630 }
 631
 632 static int cnss_cal_download_hdlr(struct cnss_plat_data *plat_priv, void *data)
 633 {
 634         int ret = 0;
 635
 636         ret = caldb_mem_bounds_check(plat_priv, data);
 637         if (ret)
 638                 CNSS_ASSERT(0);
 639         else
 640                 cnss_wlfw_cal_download_req_send_sync(plat_priv, data);
 641
 642         return ret;
 643 }
 644
 645 static char *cnss_driver_event_to_str(enum cnss_driver_event_type type)
 646 {
 647         switch (type) {
 648         case CNSS_DRIVER_EVENT_SERVER_ARRIVE:
 649                 return "SERVER_ARRIVE";
 650         case CNSS_DRIVER_EVENT_SERVER_EXIT:
 651                 return "SERVER_EXIT";
 652         case CNSS_DRIVER_EVENT_REQUEST_MEM:
 653                 return "REQUEST_MEM";
 654         case CNSS_DRIVER_EVENT_FW_MEM_READY:
 655                 return "FW_MEM_READY";
 656         case CNSS_DRIVER_EVENT_FW_READY:
 657                 return "FW_READY";
 658         case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START:
 659                 return "COLD_BOOT_CAL_START";
 660         case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_DONE:
 661                 return "COLD_BOOT_CAL_DONE";
 662         case CNSS_DRIVER_EVENT_CAL_UPDATE:
 663                 return "COLD_BOOT_CAL_DATA_UPDATE";
 664         case CNSS_DRIVER_EVENT_CAL_DOWNLOAD:
 665                 return "COLD_BOOT_CAL_DATA_DOWNLOAD";
 666         case CNSS_DRIVER_EVENT_REGISTER_DRIVER:
 667                 return "REGISTER_DRIVER";
 668         case CNSS_DRIVER_EVENT_UNREGISTER_DRIVER:
 669                 return "UNREGISTER_DRIVER";
 670         case CNSS_DRIVER_EVENT_RECOVERY:
 671                 return "RECOVERY";
 672         case CNSS_DRIVER_EVENT_FORCE_FW_ASSERT:
 673                 return "FORCE_FW_ASSERT";
 674         case CNSS_DRIVER_EVENT_POWER_UP:
 675                 return "POWER_UP";
 676         case CNSS_DRIVER_EVENT_POWER_DOWN:
 677                 return "POWER_DOWN";
 678         case CNSS_DRIVER_EVENT_MAX:
 679                 return "EVENT_MAX";
 680         }
 681
 682         return "UNKNOWN";
 683 };
 684
 685 int cnss_driver_event_post(struct cnss_plat_data *plat_priv,
 686                            enum cnss_driver_event_type type,
 687                            u32 flags, void *data)
 688 {
 689         struct cnss_driver_event *event;
 690         unsigned long irq_flags;
 691         int gfp = GFP_KERNEL;
 692         int ret = 0;
 693
 694         if (!plat_priv)
 695                 return -ENODEV;
 696
 697         cnss_pr_dbg("Posting event: %s(%d)%s, state: 0x%lx flags: 0x%0x\n",
 698                     cnss_driver_event_to_str(type), type,
 699                     flags ? "-sync" : "", plat_priv->driver_state, flags);
 700
 701         if (type >= CNSS_DRIVER_EVENT_MAX) {
 702                 cnss_pr_err("Invalid Event type: %d, can't post", type);
 703                 return -EINVAL;
 704         }
 705
 706         if (in_interrupt() || irqs_disabled())
 707                 gfp = GFP_ATOMIC;
 708
 709         event = kzalloc(sizeof(*event), gfp);
 710         if (!event)
 711                 return -ENOMEM;
 712
 713         cnss_pm_stay_awake(plat_priv);
 714
 715         event->type = type;
 716         event->data = data;
 717         init_completion(&event->complete);
 718         event->ret = CNSS_EVENT_PENDING;
 719         event->sync = !!(flags & CNSS_EVENT_SYNC);
 720
 721         spin_lock_irqsave(&plat_priv->event_lock, irq_flags);
 722         list_add_tail(&event->list, &plat_priv->event_list);
 723         spin_unlock_irqrestore(&plat_priv->event_lock, irq_flags);
 724
 725         queue_work(plat_priv->event_wq, &plat_priv->event_work);
 726
 727         if (!(flags & CNSS_EVENT_SYNC))
 728                 goto out;
 729
 730         if (flags & CNSS_EVENT_UNINTERRUPTIBLE)
 731                 wait_for_completion(&event->complete);
 732         else
 733                 ret = wait_for_completion_interruptible(&event->complete);
 734
 735         cnss_pr_dbg("Completed event: %s(%d), state: 0x%lx, ret: %d/%d\n",
 736                     cnss_driver_event_to_str(type), type,
 737                     plat_priv->driver_state, ret, event->ret);
 738         spin_lock_irqsave(&plat_priv->event_lock, irq_flags);
 739         if (ret == -ERESTARTSYS && event->ret == CNSS_EVENT_PENDING) {
 740                 event->sync = false;
 741                 spin_unlock_irqrestore(&plat_priv->event_lock, irq_flags);
 742                 ret = -EINTR;
 743                 goto out;
 744         }
 745         spin_unlock_irqrestore(&plat_priv->event_lock, irq_flags);
 746
 747         ret = event->ret;
 748         kfree(event);
 749
 750 out:
 751         cnss_pm_relax(plat_priv);
 752         return ret;
 753 }
 754
 755 int cnss_power_up(struct device *dev)
 756 {
 757         int ret = 0;
 758         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
 759         unsigned int timeout;
 760
 761         if (!plat_priv) {
 762                 cnss_pr_err("plat_priv is NULL\n");
 763                 return -ENODEV;
 764         }
 765
 766         cnss_pr_dbg("Powering up device\n");
 767
 768         ret = cnss_driver_event_post(plat_priv,
 769                                      CNSS_DRIVER_EVENT_POWER_UP,
 770                                      CNSS_EVENT_SYNC, NULL);
 771         if (ret)
 772                 goto out;
 773
 774         if (plat_priv->device_id == QCA6174_DEVICE_ID)
 775                 goto out;
 776
 777         timeout = cnss_get_qmi_timeout();
 778
 779         reinit_completion(&plat_priv->power_up_complete);
 780         ret = wait_for_completion_timeout(&plat_priv->power_up_complete,
 781                                           msecs_to_jiffies(timeout) << 2);
 782         if (!ret) {
 783                 cnss_pr_err("Timeout waiting for power up to complete\n");
 784                 ret = -EAGAIN;
 785                 goto out;
 786         }
 787
 788         return 0;
 789
 790 out:
 791         return ret;
 792 }
 793 EXPORT_SYMBOL(cnss_power_up);
 794
 795 int cnss_power_down(struct device *dev)
 796 {
 797         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
 798
 799         if (!plat_priv) {
 800                 cnss_pr_err("plat_priv is NULL\n");
 801                 return -ENODEV;
 802         }
 803
 804         cnss_pr_dbg("Powering down device\n");
 805
 806         return cnss_driver_event_post(plat_priv,
 807                                       CNSS_DRIVER_EVENT_POWER_DOWN,
 808                                       CNSS_EVENT_SYNC, NULL);
 809 }
 810 EXPORT_SYMBOL(cnss_power_down);
 811
 812 int cnss_idle_restart(struct device *dev)
 813 {
 814         return 0;
 815 }
 816 EXPORT_SYMBOL(cnss_idle_restart);
 817
 818 int cnss_idle_shutdown(struct device *dev)
 819 {
 820         return 0;
 821 }
 822 EXPORT_SYMBOL(cnss_idle_shutdown);
 823
 824 static int cnss_get_resources(struct cnss_plat_data *plat_priv)
 825 {
 826         int ret = 0;
 827
 828         ret = cnss_get_vreg(plat_priv);
 829         if (ret) {
 830                 cnss_pr_err("Failed to get vreg, err = %d\n", ret);
 831                 goto out;
 832         }
 833
 834         ret = cnss_get_pinctrl(plat_priv);
 835         if (ret) {
 836                 cnss_pr_err("Failed to get pinctrl, err = %d\n", ret);
 837                 goto out;
 838         }
 839
 840         return 0;
 841 out:
 842         return ret;
 843 }
 844
 845 static void cnss_put_resources(struct cnss_plat_data *plat_priv)
 846 {
 847 }
 848
 849 static int cnss_modem_notifier_nb(struct notifier_block *nb,
 850                                   unsigned long code,
 851                                   void *ss_handle)
 852 {
 853         struct cnss_plat_data *plat_priv =
 854                 container_of(nb, struct cnss_plat_data, modem_nb);
 855         struct cnss_esoc_info *esoc_info;
 856
 857         cnss_pr_dbg("Modem notifier: event %lu\n", code);
 858
 859         if (!plat_priv)
 860                 return NOTIFY_DONE;
 861
 862         esoc_info = &plat_priv->esoc_info;
 863
 864         if (code == SUBSYS_AFTER_POWERUP)
 865                 esoc_info->modem_current_status = 1;
 866         else if (code == SUBSYS_BEFORE_SHUTDOWN)
 867                 esoc_info->modem_current_status = 0;
 868         else
 869                 return NOTIFY_DONE;
 870
 871         if (!cnss_bus_call_driver_modem_status(plat_priv,
 872                                                esoc_info->modem_current_status))
 873                 return NOTIFY_DONE;
 874
 875         return NOTIFY_OK;
 876 }
 877
 878 static int cnss_register_esoc(struct cnss_plat_data *plat_priv)
 879 {
 880         int ret = 0;
 881         struct device *dev;
 882         struct cnss_esoc_info *esoc_info;
 883         struct esoc_desc *esoc_desc;
 884         const char *client_desc;
 885
 886         dev = &plat_priv->plat_dev->dev;
 887         esoc_info = &plat_priv->esoc_info;
 888
 889         esoc_info->notify_modem_status =
 890                 of_property_read_bool(dev->of_node,
 891                                       "qcom,notify-modem-status");
 892
 893         if (esoc_info->notify_modem_status)
 894                 goto out;
 895
 896         ret = of_property_read_string_index(dev->of_node, "esoc-names", 0,
 897                                             &client_desc);
 898         if (ret) {
 899                 cnss_pr_dbg("esoc-names is not defined in DT, skip!\n");
 900         } else {
 901                 esoc_desc = devm_register_esoc_client(dev, client_desc);
 902                 if (IS_ERR_OR_NULL(esoc_desc)) {
 903                         ret = PTR_RET(esoc_desc);
 904                         cnss_pr_err("Failed to register esoc_desc, err = %d\n",
 905                                     ret);
 906                         goto out;
 907                 }
 908                 esoc_info->esoc_desc = esoc_desc;
 909         }
 910
 911         plat_priv->modem_nb.notifier_call = cnss_modem_notifier_nb;
 912         esoc_info->modem_current_status = 0;
 913         esoc_info->modem_notify_handler =
 914                 subsys_notif_register_notifier(esoc_info->esoc_desc ?
 915                                                esoc_info->esoc_desc->name :
 916                                                "modem", &plat_priv->modem_nb);
 917         if (IS_ERR(esoc_info->modem_notify_handler)) {
 918                 ret = PTR_ERR(esoc_info->modem_notify_handler);
 919                 cnss_pr_err("Failed to register esoc notifier, err = %d\n",
 920                             ret);
 921                 goto unreg_esoc;
 922         }
 923
 924         return 0;
 925 unreg_esoc:
 926         if (esoc_info->esoc_desc)
 927                 devm_unregister_esoc_client(dev, esoc_info->esoc_desc);
 928 out:
 929         return ret;
 930 }
 931
 932 static void cnss_unregister_esoc(struct cnss_plat_data *plat_priv)
 933 {
 934         struct device *dev;
 935         struct cnss_esoc_info *esoc_info;
 936
 937         dev = &plat_priv->plat_dev->dev;
 938         esoc_info = &plat_priv->esoc_info;
 939
 940         if (esoc_info->notify_modem_status)
 941                 subsys_notif_unregister_notifier(esoc_info->
 942                                                  modem_notify_handler,
 943                                                  &plat_priv->modem_nb);
 944         if (esoc_info->esoc_desc)
 945                 devm_unregister_esoc_client(dev, esoc_info->esoc_desc);
 946 }
 947
 948 static int cnss_subsys_powerup(const struct subsys_desc *subsys_desc)
 949 {
 950         struct cnss_plat_data *plat_priv;
 951
 952         if (!subsys_desc->dev) {
 953                 cnss_pr_err("dev from subsys_desc is NULL\n");
 954                 return -ENODEV;
 955         }
 956
 957         plat_priv = dev_get_drvdata(subsys_desc->dev);
 958         if (!plat_priv) {
 959                 cnss_pr_err("plat_priv is NULL\n");
 960                 return -ENODEV;
 961         }
 962
 963         if (!plat_priv->driver_state) {
 964                 cnss_pr_dbg("Powerup is ignored\n");
 965                 return 0;
 966         }
 967
 968         return cnss_bus_dev_powerup(plat_priv);
 969 }
 970
 971 static int cnss_subsys_shutdown(const struct subsys_desc *subsys_desc,
 972                                 bool force_stop)
 973 {
 974         struct cnss_plat_data *plat_priv;
 975
 976         if (!subsys_desc->dev) {
 977                 cnss_pr_err("dev from subsys_desc is NULL\n");
 978                 return -ENODEV;
 979         }
 980
 981         plat_priv = dev_get_drvdata(subsys_desc->dev);
 982         if (!plat_priv) {
 983                 cnss_pr_err("plat_priv is NULL\n");
 984                 return -ENODEV;
 985         }
 986
 987         if (!plat_priv->driver_state) {
 988                 cnss_pr_dbg("shutdown is ignored\n");
 989                 return 0;
 990         }
 991
 992         return cnss_bus_dev_shutdown(plat_priv);
 993 }
 994
 995 static int cnss_subsys_ramdump(int enable,
 996                                const struct subsys_desc *subsys_desc)
 997 {
 998         struct cnss_plat_data *plat_priv = dev_get_drvdata(subsys_desc->dev);
 999
1000         if (!plat_priv) {
1001                 cnss_pr_err("plat_priv is NULL!\n");
1002                 return -ENODEV;
1003         }
1004
1005         if (!enable)
1006                 return 0;
1007
1008         return cnss_bus_dev_ramdump(plat_priv);
1009 }
1010
1011 void *cnss_get_virt_ramdump_mem(struct device *dev, unsigned long *size)
1012 {
1013         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
1014         struct cnss_ramdump_info *ramdump_info;
1015
1016         if (!plat_priv)
1017                 return NULL;
1018
1019         ramdump_info = &plat_priv->ramdump_info;
1020         *size = ramdump_info->ramdump_size;
1021
1022         return ramdump_info->ramdump_va;
1023 }
1024 EXPORT_SYMBOL(cnss_get_virt_ramdump_mem);
1025
1026 void cnss_device_crashed(struct device *dev)
1027 {
1028         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
1029         struct cnss_subsys_info *subsys_info;
1030
1031         if (!plat_priv)
1032                 return;
1033
1034         subsys_info = &plat_priv->subsys_info;
1035         if (subsys_info->subsys_device) {
1036                 set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
1037                 subsys_set_crash_status(subsys_info->subsys_device, true);
1038                 subsystem_restart_dev(subsys_info->subsys_device);
1039         }
1040 }
1041 EXPORT_SYMBOL(cnss_device_crashed);
1042
1043 static void cnss_subsys_crash_shutdown(const struct subsys_desc *subsys_desc)
1044 {
1045         struct cnss_plat_data *plat_priv = dev_get_drvdata(subsys_desc->dev);
1046
1047         if (!plat_priv) {
1048                 cnss_pr_err("plat_priv is NULL!\n");
1049                 return;
1050         }
1051         cnss_bus_dev_crash_shutdown(plat_priv);
1052 }
1053
1054 static const char *cnss_recovery_reason_to_str(enum cnss_recovery_reason reason)
1055 {
1056         switch (reason) {
1057         case CNSS_REASON_DEFAULT:
1058                 return "DEFAULT";
1059         case CNSS_REASON_LINK_DOWN:
1060                 return "LINK_DOWN";
1061         case CNSS_REASON_RDDM:
1062                 return "RDDM";
1063         case CNSS_REASON_TIMEOUT:
1064                 return "TIMEOUT";
1065         }
1066
1067         return "UNKNOWN";
1068 };
1069
1070 static int cnss_do_recovery(struct cnss_plat_data *plat_priv,
1071                             enum cnss_recovery_reason reason)
1072 {
1073         struct cnss_subsys_info *subsys_info =
1074                 &plat_priv->subsys_info;
1075
1076         plat_priv->recovery_count++;
1077
1078         if (plat_priv->device_id == QCA6174_DEVICE_ID)
1079                 goto self_recovery;
1080
1081         cnss_bus_recovery_update_status(plat_priv);
1082
1083         if (test_bit(SKIP_RECOVERY, &quirks)) {
1084                 cnss_pr_dbg("Skip device recovery\n");
1085                 return 0;
1086         }
1087
1088         switch (reason) {
1089         case CNSS_REASON_LINK_DOWN:
1090                 if (test_bit(LINK_DOWN_SELF_RECOVERY, &quirks))
1091                         goto self_recovery;
1092                 break;
1093         case CNSS_REASON_RDDM:
1094                 cnss_bus_collect_dump_info(plat_priv);
1095                 clear_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state);
1096                 break;
1097         case CNSS_REASON_DEFAULT:
1098         case CNSS_REASON_TIMEOUT:
1099                 break;
1100         default:
1101                 cnss_pr_err("Unsupported recovery reason: %s(%d)\n",
1102                             cnss_recovery_reason_to_str(reason), reason);
1103                 break;
1104         }
1105
1106         if (!subsys_info->subsys_device)
1107                 return 0;
1108
1109         subsys_set_crash_status(subsys_info->subsys_device, true);
1110         subsystem_restart_dev(subsys_info->subsys_device);
1111
1112         return 0;
1113
1114 self_recovery:
1115         cnss_bus_dev_shutdown(plat_priv);
1116         cnss_bus_dev_powerup(plat_priv);
1117
1118         return 0;
1119 }
1120
1121 static int cnss_driver_recovery_hdlr(struct cnss_plat_data *plat_priv,
1122                                      void *data)
1123 {
1124         struct cnss_recovery_data *recovery_data = data;
1125         int ret = 0;
1126
1127         cnss_pr_dbg("Driver recovery is triggered with reason: %s(%d)\n",
1128                     cnss_recovery_reason_to_str(recovery_data->reason),
1129                     recovery_data->reason);
1130
1131         if (!plat_priv->driver_state) {
1132                 cnss_pr_err("Improper driver state, ignore recovery\n");
1133                 ret = -EINVAL;
1134                 goto out;
1135         }
1136
1137         if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {
1138                 cnss_pr_err("Recovery is already in progress\n");
1139                 ret = -EINVAL;
1140                 goto out;
1141         }
1142
1143         if (test_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state)) {
1144                 cnss_pr_err("Driver unload is in progress, ignore recovery\n");
1145                 ret = -EINVAL;
1146                 goto out;
1147         }
1148
1149         switch (plat_priv->device_id) {
1150         case QCA6174_DEVICE_ID:
1151                 if (test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state)) {
1152                         cnss_pr_err("Driver load is in progress, ignore recovery\n");
1153                         ret = -EINVAL;
1154                         goto out;
1155                 }
1156                 break;
1157         default:
1158                 if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
1159                         set_bit(CNSS_FW_BOOT_RECOVERY,
1160                                 &plat_priv->driver_state);
1161                 }
1162                 break;
1163         }
1164
1165         set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);
1166         ret = cnss_do_recovery(plat_priv, recovery_data->reason);
1167
1168 out:
1169         kfree(data);
1170         return ret;
1171 }
1172
1173 int cnss_self_recovery(struct device *dev,
1174                        enum cnss_recovery_reason reason)
1175 {
1176         cnss_schedule_recovery(dev, reason);
1177         return 0;
1178 }
1179 EXPORT_SYMBOL(cnss_self_recovery);
1180
1181 void cnss_schedule_recovery(struct device *dev,
1182                             enum cnss_recovery_reason reason)
1183 {
1184         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
1185         struct cnss_recovery_data *data;
1186         int gfp = GFP_KERNEL;
1187
1188         if (in_interrupt() || irqs_disabled())
1189                 gfp = GFP_ATOMIC;
1190
1191         data = kzalloc(sizeof(*data), gfp);
1192         if (!data)
1193                 return;
1194
1195         data->reason = reason;
1196         cnss_driver_event_post(plat_priv,
1197                                CNSS_DRIVER_EVENT_RECOVERY,
1198                                0, data);
1199 }
1200 EXPORT_SYMBOL(cnss_schedule_recovery);
1201
1202 int cnss_force_fw_assert(struct device *dev)
1203 {
1204         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
1205
1206         if (!plat_priv) {
1207                 cnss_pr_err("plat_priv is NULL\n");
1208                 return -ENODEV;
1209         }
1210
1211         if (plat_priv->device_id == QCA6174_DEVICE_ID) {
1212                 cnss_pr_info("Forced FW assert is not supported\n");
1213                 return -EOPNOTSUPP;
1214         }
1215
1216         if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {
1217                 cnss_pr_info("Recovery is already in progress, ignore forced FW assert\n");
1218                 return 0;
1219         }
1220
1221         cnss_driver_event_post(plat_priv,
1222                                CNSS_DRIVER_EVENT_FORCE_FW_ASSERT,
1223                                0, NULL);
1224
1225         return 0;
1226 }
1227 EXPORT_SYMBOL(cnss_force_fw_assert);
1228
1229 int cnss_force_collect_rddm(struct device *dev)
1230 {
1231         struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
1232         int ret = 0;
1233
1234         if (!plat_priv) {
1235                 cnss_pr_err("plat_priv is NULL\n");
1236                 return -ENODEV;
1237         }
1238
1239         if (plat_priv->device_id == QCA6174_DEVICE_ID) {
1240                 cnss_pr_info("Force collect rddm is not supported\n");
1241                 return -EOPNOTSUPP;
1242         }
1243
1244         if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {
1245                 cnss_pr_info("Recovery is already in progress, ignore forced collect rddm\n");
1246                 return 0;
1247         }
1248
1249         cnss_driver_event_post(plat_priv,
1250                                CNSS_DRIVER_EVENT_FORCE_FW_ASSERT,
1251                                0, NULL);
1252
1253         reinit_completion(&plat_priv->rddm_complete);
1254         ret = wait_for_completion_timeout
1255                 (&plat_priv->rddm_complete,
1256                  msecs_to_jiffies(CNSS_RDDM_TIMEOUT_MS));
1257         if (!ret)
1258                 ret = -ETIMEDOUT;
1259
1260         return ret;
1261 }
1262 EXPORT_SYMBOL(cnss_force_collect_rddm);
1263
1264 int cnss_qmi_send_get(struct device *dev)
1265 {
1266         return 0;
1267 }
1268 EXPORT_SYMBOL(cnss_qmi_send_get);
1269
1270 int cnss_qmi_send_put(struct device *dev)
1271 {
1272         return 0;
1273 }
1274 EXPORT_SYMBOL(cnss_qmi_send_put);
1275
1276 int cnss_qmi_send(struct device *dev, int type, void *cmd,
1277                   int cmd_len, void *cb_ctx,
1278                   int (*cb)(void *ctx, void *event, int event_len))
1279 {
1280         return -EINVAL;
1281 }
1282 EXPORT_SYMBOL(cnss_qmi_send);
1283
1284 static int cnss_wlfw_server_arrive_hdlr(struct cnss_plat_data *plat_priv)
1285 {
1286         int ret;
1287
1288         ret = cnss_wlfw_server_arrive(plat_priv);
1289         if (ret)
1290                 goto out;
1291
1292         if (plat_priv->bus_type == CNSS_BUS_USB ||
1293             plat_priv->bus_type == CNSS_BUS_SDIO) {
1294                 ret = cnss_wlfw_tgt_cap_send_sync(plat_priv);
1295                 if (ret)
1296                         goto out;
1297
1298                 ret = cnss_wlfw_bdf_dnld_send_sync(plat_priv);
1299         }
1300 out:
1301         return ret;
1302 }
1303
1304 static int cnss_cold_boot_cal_start_hdlr(struct cnss_plat_data *plat_priv)
1305 {
1306         int ret = 0;
1307         bool pwr_up_reqd = false;
1308
1309         set_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state);
1310         if (test_bit(CNSS_DEV_REMOVED, &plat_priv->driver_state))
1311                 pwr_up_reqd = true;
1312
1313         if (pwr_up_reqd || plat_priv->bus_type == CNSS_BUS_PCI)
1314                 ret = cnss_bus_dev_powerup(plat_priv);
1315
1316         if (ret)
1317                 clear_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state);
1318
1319         return ret;
1320 }
1321
1322 static int cnss_cold_boot_cal_done_hdlr(struct cnss_plat_data *plat_priv)
1323 {
1324         plat_priv->cal_done = true;
1325         cnss_wlfw_wlan_mode_send_sync(plat_priv, QMI_WLFW_OFF_V01);
1326         if (plat_priv->device_id == QCN7605_DEVICE_ID ||
1327             plat_priv->bus_type == CNSS_BUS_USB)
1328                 goto skip_shutdown;
1329         cnss_bus_dev_shutdown(plat_priv);
1330
1331 skip_shutdown:
1332         clear_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state);
1333         return 0;
1334 }
1335
1336 static int cnss_power_up_hdlr(struct cnss_plat_data *plat_priv)
1337 {
1338         return cnss_bus_dev_powerup(plat_priv);
1339 }
1340
1341 static int cnss_power_down_hdlr(struct cnss_plat_data *plat_priv)
1342 {
1343         cnss_bus_dev_shutdown(plat_priv);
1344
1345         return 0;
1346 }
1347
1348 static void cnss_driver_event_work(struct work_struct *work)
1349 {
1350         struct cnss_plat_data *plat_priv =
1351                 container_of(work, struct cnss_plat_data, event_work);
1352         struct cnss_driver_event *event;
1353         unsigned long flags;
1354         int ret = 0;
1355
1356         if (!plat_priv) {
1357                 cnss_pr_err("plat_priv is NULL!\n");
1358                 return;
1359         }
1360
1361         cnss_pm_stay_awake(plat_priv);
1362
1363         spin_lock_irqsave(&plat_priv->event_lock, flags);
1364
1365         while (!list_empty(&plat_priv->event_list)) {
1366                 event = list_first_entry(&plat_priv->event_list,
1367                                          struct cnss_driver_event, list);
1368                 list_del(&event->list);
1369                 spin_unlock_irqrestore(&plat_priv->event_lock, flags);
1370
1371                 cnss_pr_dbg("Processing driver event: %s%s(%d), state: 0x%lx\n",
1372                             cnss_driver_event_to_str(event->type),
1373                             event->sync ? "-sync" : "", event->type,
1374                             plat_priv->driver_state);
1375
1376                 switch (event->type) {
1377                 case CNSS_DRIVER_EVENT_SERVER_ARRIVE:
1378                         ret = cnss_wlfw_server_arrive_hdlr(plat_priv);
1379                         break;
1380                 case CNSS_DRIVER_EVENT_SERVER_EXIT:
1381                         ret = cnss_wlfw_server_exit(plat_priv);
1382                         break;
1383                 case CNSS_DRIVER_EVENT_REQUEST_MEM:
1384                         ret = cnss_bus_alloc_fw_mem(plat_priv);
1385                         if (ret)
1386                                 break;
1387                         ret = cnss_wlfw_respond_mem_send_sync(plat_priv);
1388                         break;
1389                 case CNSS_DRIVER_EVENT_FW_MEM_READY:
1390                         ret = cnss_fw_mem_ready_hdlr(plat_priv);
1391                         break;
1392                 case CNSS_DRIVER_EVENT_FW_READY:
1393                         ret = cnss_fw_ready_hdlr(plat_priv);
1394                         break;
1395                 case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START:
1396                         ret = cnss_cold_boot_cal_start_hdlr(plat_priv);
1397                         break;
1398                 case CNSS_DRIVER_EVENT_CAL_UPDATE:
1399                         ret = cnss_cal_update_hdlr(plat_priv, event->data);
1400                         break;
1401                 case CNSS_DRIVER_EVENT_CAL_DOWNLOAD:
1402                         ret = cnss_cal_download_hdlr(plat_priv, event->data);
1403                         break;
1404                 case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_DONE:
1405                         ret = cnss_cold_boot_cal_done_hdlr(plat_priv);
1406                         break;
1407                 case CNSS_DRIVER_EVENT_REGISTER_DRIVER:
1408                         ret = cnss_bus_register_driver_hdlr(plat_priv,
1409                                                             event->data);
1410                         break;
1411                 case CNSS_DRIVER_EVENT_UNREGISTER_DRIVER:
1412                         ret = cnss_bus_unregister_driver_hdlr(plat_priv);
1413                         break;
1414                 case CNSS_DRIVER_EVENT_RECOVERY:
1415                         ret = cnss_driver_recovery_hdlr(plat_priv,
1416                                                         event->data);
1417                         break;
1418                 case CNSS_DRIVER_EVENT_FORCE_FW_ASSERT:
1419                         ret = cnss_bus_force_fw_assert_hdlr(plat_priv);
1420                         break;
1421                 case CNSS_DRIVER_EVENT_POWER_UP:
1422                         ret = cnss_power_up_hdlr(plat_priv);
1423                         break;
1424                 case CNSS_DRIVER_EVENT_POWER_DOWN:
1425                         ret = cnss_power_down_hdlr(plat_priv);
1426                         break;
1427                 default:
1428                         cnss_pr_err("Invalid driver event type: %d",
1429                                     event->type);
1430                         kfree(event);
1431                         spin_lock_irqsave(&plat_priv->event_lock, flags);
1432                         continue;
1433                 }
1434
1435                 spin_lock_irqsave(&plat_priv->event_lock, flags);
1436                 if (event->sync) {
1437                         event->ret = ret;
1438                         complete(&event->complete);
1439                         continue;
1440                 }
1441                 spin_unlock_irqrestore(&plat_priv->event_lock, flags);
1442
1443                 kfree(event);
1444
1445                 spin_lock_irqsave(&plat_priv->event_lock, flags);
1446         }
1447         spin_unlock_irqrestore(&plat_priv->event_lock, flags);
1448
1449         cnss_pm_relax(plat_priv);
1450 }
1451
1452 int cnss_register_subsys(struct cnss_plat_data *plat_priv)
1453 {
1454         int ret = 0;
1455         struct cnss_subsys_info *subsys_info;
1456
1457         subsys_info = &plat_priv->subsys_info;
1458
1459         switch (plat_priv->device_id) {
1460         case QCA6174_DEVICE_ID:
1461                 subsys_info->subsys_desc.name = "AR6320";
1462                 break;
1463         case QCA6290_EMULATION_DEVICE_ID:
1464         case QCA6290_DEVICE_ID:
1465                 subsys_info->subsys_desc.name = "QCA6290";
1466                 break;
1467         case QCN7605_DEVICE_ID:
1468         case QCN7605_STANDALONE_DEVICE_ID:
1469         case QCN7605_COMPOSITE_DEVICE_ID:
1470         case QCN7605_VER20_STANDALONE_DEVICE_ID:
1471         case QCN7605_VER20_COMPOSITE_DEVICE_ID:
1472         case QCN7605_SDIO_DEVICE_ID:
1473                 subsys_info->subsys_desc.name = "QCN7605";
1474                 break;
1475         default:
1476                 cnss_pr_err("Unknown device ID: 0x%lx\n", plat_priv->device_id);
1477                 ret = -ENODEV;
1478                 goto out;
1479         }
1480
1481         subsys_info->subsys_desc.owner = THIS_MODULE;
1482         subsys_info->subsys_desc.powerup = cnss_subsys_powerup;
1483         subsys_info->subsys_desc.shutdown = cnss_subsys_shutdown;
1484         subsys_info->subsys_desc.ramdump = cnss_subsys_ramdump;
1485         subsys_info->subsys_desc.crash_shutdown = cnss_subsys_crash_shutdown;
1486         subsys_info->subsys_desc.dev = &plat_priv->plat_dev->dev;
1487
1488         subsys_info->subsys_device = subsys_register(&subsys_info->subsys_desc);
1489         if (IS_ERR(subsys_info->subsys_device)) {
1490                 ret = PTR_ERR(subsys_info->subsys_device);
1491                 cnss_pr_err("Failed to register subsys, err = %d\n", ret);
1492                 goto out;
1493         }
1494
1495         subsys_info->subsys_handle =
1496                 subsystem_get(subsys_info->subsys_desc.name);
1497         if (!subsys_info->subsys_handle) {
1498                 cnss_pr_err("Failed to get subsys_handle!\n");
1499                 ret = -EINVAL;
1500                 goto unregister_subsys;
1501         } else if (IS_ERR(subsys_info->subsys_handle)) {
1502                 ret = PTR_ERR(subsys_info->subsys_handle);
1503                 cnss_pr_err("Failed to do subsystem_get, err = %d\n", ret);
1504                 goto unregister_subsys;
1505         }
1506
1507         return 0;
1508
1509 unregister_subsys:
1510         subsys_unregister(subsys_info->subsys_device);
1511 out:
1512         return ret;
1513 }
1514
1515 void cnss_unregister_subsys(struct cnss_plat_data *plat_priv)
1516 {
1517         struct cnss_subsys_info *subsys_info;
1518
1519         subsys_info = &plat_priv->subsys_info;
1520         subsystem_put(subsys_info->subsys_handle);
1521         subsys_unregister(subsys_info->subsys_device);
1522 }
1523
1524 static int cnss_init_dump_entry(struct cnss_plat_data *plat_priv)
1525 {
1526         struct cnss_ramdump_info *ramdump_info;
1527         struct msm_dump_entry dump_entry;
1528
1529         ramdump_info = &plat_priv->ramdump_info;
1530         ramdump_info->dump_data.addr = ramdump_info->ramdump_pa;
1531         ramdump_info->dump_data.len = ramdump_info->ramdump_size;
1532         ramdump_info->dump_data.version = CNSS_DUMP_FORMAT_VER;
1533         ramdump_info->dump_data.magic = CNSS_DUMP_MAGIC_VER_V2;
1534         strlcpy(ramdump_info->dump_data.name, CNSS_DUMP_NAME,
1535                 sizeof(ramdump_info->dump_data.name));
1536         dump_entry.id = MSM_DUMP_DATA_CNSS_WLAN;
1537         dump_entry.addr = virt_to_phys(&ramdump_info->dump_data);
1538
1539         return msm_dump_data_register(MSM_DUMP_TABLE_APPS, &dump_entry);
1540 }
1541
1542 static int cnss_register_ramdump_v1(struct cnss_plat_data *plat_priv)
1543 {
1544         int ret = 0;
1545         struct device *dev;
1546         struct cnss_subsys_info *subsys_info;
1547         struct cnss_ramdump_info *ramdump_info;
1548         u32 ramdump_size = 0;
1549
1550         dev = &plat_priv->plat_dev->dev;
1551         subsys_info = &plat_priv->subsys_info;
1552         ramdump_info = &plat_priv->ramdump_info;
1553
1554         if (of_property_read_u32(dev->of_node, "qcom,wlan-ramdump-dynamic",
1555                                  &ramdump_size) == 0) {
1556                 ramdump_info->ramdump_va = dma_alloc_coherent(dev, ramdump_size,
1557                         &ramdump_info->ramdump_pa, GFP_KERNEL);
1558
1559                 if (ramdump_info->ramdump_va)
1560                         ramdump_info->ramdump_size = ramdump_size;
1561         }
1562
1563         cnss_pr_dbg("ramdump va: %pK, pa: %pa\n",
1564                     ramdump_info->ramdump_va, &ramdump_info->ramdump_pa);
1565
1566         if (ramdump_info->ramdump_size == 0) {
1567                 cnss_pr_info("Ramdump will not be collected");
1568                 goto out;
1569         }
1570
1571         ret = cnss_init_dump_entry(plat_priv);
1572         if (ret) {
1573                 cnss_pr_err("Failed to setup dump table, err = %d\n", ret);
1574                 goto free_ramdump;
1575         }
1576
1577         ramdump_info->ramdump_dev = create_ramdump_device(
1578                 subsys_info->subsys_desc.name, subsys_info->subsys_desc.dev);
1579         if (!ramdump_info->ramdump_dev) {
1580                 cnss_pr_err("Failed to create ramdump device!");
1581                 ret = -ENOMEM;
1582                 goto free_ramdump;
1583         }
1584
1585         return 0;
1586 free_ramdump:
1587         dma_free_coherent(dev, ramdump_info->ramdump_size,
1588                           ramdump_info->ramdump_va, ramdump_info->ramdump_pa);
1589 out:
1590         return ret;
1591 }
1592
1593 static void cnss_unregister_ramdump_v1(struct cnss_plat_data *plat_priv)
1594 {
1595         struct device *dev;
1596         struct cnss_ramdump_info *ramdump_info;
1597
1598         dev = &plat_priv->plat_dev->dev;
1599         ramdump_info = &plat_priv->ramdump_info;
1600
1601         if (ramdump_info->ramdump_dev)
1602                 destroy_ramdump_device(ramdump_info->ramdump_dev);
1603
1604         if (ramdump_info->ramdump_va)
1605                 dma_free_coherent(dev, ramdump_info->ramdump_size,
1606                                   ramdump_info->ramdump_va,
1607                                   ramdump_info->ramdump_pa);
1608 }
1609
1610 static int cnss_register_ramdump_v2(struct cnss_plat_data *plat_priv)
1611 {
1612         int ret = 0;
1613         struct cnss_subsys_info *subsys_info;
1614         struct cnss_ramdump_info_v2 *info_v2;
1615         struct cnss_dump_data *dump_data;
1616         struct msm_dump_entry dump_entry;
1617         struct device *dev = &plat_priv->plat_dev->dev;
1618         u32 ramdump_size = 0;
1619
1620         subsys_info = &plat_priv->subsys_info;
1621         info_v2 = &plat_priv->ramdump_info_v2;
1622         dump_data = &info_v2->dump_data;
1623
1624         if (of_property_read_u32(dev->of_node, "qcom,wlan-ramdump-dynamic",
1625                                  &ramdump_size) == 0)
1626                 info_v2->ramdump_size = ramdump_size;
1627
1628         cnss_pr_dbg("Ramdump size 0x%lx\n", info_v2->ramdump_size);
1629
1630         info_v2->dump_data_vaddr = kzalloc(CNSS_DUMP_DESC_SIZE, GFP_KERNEL);
1631         if (!info_v2->dump_data_vaddr)
1632                 return -ENOMEM;
1633
1634         dump_data->paddr = virt_to_phys(info_v2->dump_data_vaddr);
1635         dump_data->version = CNSS_DUMP_FORMAT_VER_V2;
1636         dump_data->magic = CNSS_DUMP_MAGIC_VER_V2;
1637         dump_data->seg_version = CNSS_DUMP_SEG_VER;
1638         strlcpy(dump_data->name, CNSS_DUMP_NAME,
1639                 sizeof(dump_data->name));
1640         dump_entry.id = MSM_DUMP_DATA_CNSS_WLAN;
1641         dump_entry.addr = virt_to_phys(dump_data);
1642
1643         ret = msm_dump_data_register(MSM_DUMP_TABLE_APPS, &dump_entry);
1644         if (ret) {
1645                 cnss_pr_err("Failed to setup dump table, err = %d\n", ret);
1646                 goto free_ramdump;
1647         }
1648
1649         info_v2->ramdump_dev =
1650                 create_ramdump_device(subsys_info->subsys_desc.name,
1651                                       subsys_info->subsys_desc.dev);
1652         if (!info_v2->ramdump_dev) {
1653                 cnss_pr_err("Failed to create ramdump device!\n");
1654                 ret = -ENOMEM;
1655                 goto free_ramdump;
1656         }
1657
1658         return 0;
1659
1660 free_ramdump:
1661         kfree(info_v2->dump_data_vaddr);
1662         info_v2->dump_data_vaddr = NULL;
1663         return ret;
1664 }
1665
1666 static void cnss_unregister_ramdump_v2(struct cnss_plat_data *plat_priv)
1667 {
1668         struct cnss_ramdump_info_v2 *info_v2;
1669
1670         info_v2 = &plat_priv->ramdump_info_v2;
1671
1672         if (info_v2->ramdump_dev)
1673                 destroy_ramdump_device(info_v2->ramdump_dev);
1674
1675         kfree(info_v2->dump_data_vaddr);
1676         info_v2->dump_data_vaddr = NULL;
1677         info_v2->dump_data_valid = false;
1678 }
1679
1680 int cnss_register_ramdump(struct cnss_plat_data *plat_priv)
1681 {
1682         int ret = 0;
1683
1684         switch (plat_priv->device_id) {
1685         case QCA6174_DEVICE_ID:
1686                 ret = cnss_register_ramdump_v1(plat_priv);
1687                 break;
1688         case QCA6290_EMULATION_DEVICE_ID:
1689         case QCA6290_DEVICE_ID:
1690         case QCN7605_DEVICE_ID:
1691                 ret = cnss_register_ramdump_v2(plat_priv);
1692                 break;
1693         case QCN7605_COMPOSITE_DEVICE_ID:
1694         case QCN7605_STANDALONE_DEVICE_ID:
1695         case QCN7605_VER20_STANDALONE_DEVICE_ID:
1696         case QCN7605_VER20_COMPOSITE_DEVICE_ID:
1697                 break;
1698
1699         default:
1700                 cnss_pr_err("Unknown device ID: 0x%lx\n", plat_priv->device_id);
1701                 ret = -ENODEV;
1702                 break;
1703         }
1704         return ret;
1705 }
1706
1707 void cnss_unregister_ramdump(struct cnss_plat_data *plat_priv)
1708 {
1709         switch (plat_priv->device_id) {
1710         case QCA6174_DEVICE_ID:
1711                 cnss_unregister_ramdump_v1(plat_priv);
1712                 break;
1713         case QCA6290_EMULATION_DEVICE_ID:
1714         case QCA6290_DEVICE_ID:
1715                 cnss_unregister_ramdump_v2(plat_priv);
1716                 break;
1717         case QCN7605_COMPOSITE_DEVICE_ID:
1718         case QCN7605_STANDALONE_DEVICE_ID:
1719         case QCN7605_VER20_STANDALONE_DEVICE_ID:
1720         case QCN7605_VER20_COMPOSITE_DEVICE_ID:
1721                 break;
1722         default:
1723                 cnss_pr_err("Unknown device ID: 0x%lx\n", plat_priv->device_id);
1724                 break;
1725         }
1726 }
1727
1728 static int cnss_register_bus_scale(struct cnss_plat_data *plat_priv)
1729 {
1730         int ret = 0;
1731         struct cnss_bus_bw_info *bus_bw_info;
1732
1733         bus_bw_info = &plat_priv->bus_bw_info;
1734
1735         bus_bw_info->bus_scale_table =
1736                 msm_bus_cl_get_pdata(plat_priv->plat_dev);
1737         if (bus_bw_info->bus_scale_table)  {
1738                 bus_bw_info->bus_client =
1739                         msm_bus_scale_register_client(
1740                                 bus_bw_info->bus_scale_table);
1741                 if (!bus_bw_info->bus_client) {
1742                         cnss_pr_err("Failed to register bus scale client!\n");
1743                         ret = -EINVAL;
1744                         goto out;
1745                 }
1746         }
1747
1748         return 0;
1749 out:
1750         return ret;
1751 }
1752
1753 static void cnss_unregister_bus_scale(struct cnss_plat_data *plat_priv)
1754 {
1755         struct cnss_bus_bw_info *bus_bw_info;
1756
1757         bus_bw_info = &plat_priv->bus_bw_info;
1758
1759         if (bus_bw_info->bus_client)
1760                 msm_bus_scale_unregister_client(bus_bw_info->bus_client);
1761 }
1762
1763 static ssize_t cnss_fs_ready_store(struct device *dev,
1764                                    struct device_attribute *attr,
1765                                    const char *buf,
1766                                    size_t count)
1767 {
1768         int fs_ready = 0;
1769         struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
1770
1771         if (sscanf(buf, "%du", &fs_ready) != 1)
1772                 return -EINVAL;
1773
1774         cnss_pr_dbg("File system is ready, fs_ready is %d, count is %zu\n",
1775                     fs_ready, count);
1776
1777         if (qmi_bypass) {
1778                 cnss_pr_dbg("QMI is bypassed.\n");
1779                 return count;
1780         }
1781
1782         if (!plat_priv) {
1783                 cnss_pr_err("plat_priv is NULL!\n");
1784                 return count;
1785         }
1786
1787         switch (plat_priv->device_id) {
1788         case QCA6290_EMULATION_DEVICE_ID:
1789         case QCA6290_DEVICE_ID:
1790         case QCN7605_DEVICE_ID:
1791         case QCN7605_COMPOSITE_DEVICE_ID:
1792         case QCN7605_STANDALONE_DEVICE_ID:
1793                 break;
1794         default:
1795                 cnss_pr_err("Not supported for device ID 0x%lx\n",
1796                             plat_priv->device_id);
1797                 return count;
1798         }
1799
1800         if (fs_ready == FILE_SYSTEM_READY) {
1801                 cnss_driver_event_post(plat_priv,
1802                                        CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START,
1803                                        CNSS_EVENT_SYNC, NULL);
1804         }
1805
1806         return count;
1807 }
1808
1809 #ifdef CONFIG_SDIO_QCN
1810 static void cnss_set_card_state(bool state)
1811 {
1812         qcn_sdio_card_state(state);
1813 }
1814 #else
1815 static void cnss_set_card_state(bool state)
1816 {
1817         /* no op */
1818 }
1819 #endif
1820
1821 static DEVICE_ATTR(fs_ready, 0220, NULL, cnss_fs_ready_store);
1822
1823 static ssize_t cnss_wl_pwr_on(struct device *dev,
1824                               struct device_attribute *attr,
1825                               const char *buf,
1826                               size_t count)
1827 {
1828         int pwr_state = 0;
1829         struct cnss_plat_data *plat_priv = dev_get_drvdata(dev);
1830         unsigned int timeout;
1831
1832         if (sscanf(buf, "%du", &pwr_state) != 1)
1833                 return -EINVAL;
1834
1835         cnss_pr_dbg("vreg-wlan-en state change %d, count %zu", pwr_state,
1836                     count);
1837
1838         timeout = cnss_get_qmi_timeout();
1839         if (pwr_state) {
1840                 cnss_power_on_device(plat_priv);
1841                 cnss_set_card_state(true);
1842                 if (timeout) {
1843                         mod_timer(&plat_priv->fw_boot_timer,
1844                                   jiffies + msecs_to_jiffies(timeout));
1845                 }
1846         } else {
1847                 cnss_power_off_device(plat_priv);
1848                 cnss_set_card_state(false);
1849                 del_timer(&plat_priv->fw_boot_timer);
1850         }
1851         return count;
1852 }
1853
1854 static DEVICE_ATTR(wl_pwr_on, 0220, NULL, cnss_wl_pwr_on);
1855
1856 static int cnss_create_sysfs(struct cnss_plat_data *plat_priv)
1857 {
1858         int ret = 0;
1859
1860         ret = device_create_file(&plat_priv->plat_dev->dev, &dev_attr_fs_ready);
1861         if (ret) {
1862                 cnss_pr_err("Failed to create device file, err = %d\n", ret);
1863                 goto out;
1864         }
1865
1866         return 0;
1867 out:
1868         return ret;
1869 }
1870
1871 static void cnss_remove_sysfs(struct cnss_plat_data *plat_priv)
1872 {
1873         device_remove_file(&plat_priv->plat_dev->dev, &dev_attr_fs_ready);
1874 }
1875
1876 static int cnss_create_sysfs_wl_pwr(struct cnss_plat_data *plat_priv)
1877 {
1878         int ret = 0;
1879
1880         ret = device_create_file(&plat_priv->plat_dev->dev,
1881                                  &dev_attr_wl_pwr_on);
1882         if (ret) {
1883                 cnss_pr_err("Failed to create device file, err = %d\n", ret);
1884                 goto out;
1885         }
1886         cnss_pr_dbg("created sysfs for vreg-wlan-en control\n");
1887         return 0;
1888 out:
1889         return ret;
1890 }
1891
1892 static void cnss_remove_sysfs_wl_pwr(struct cnss_plat_data *plat_priv)
1893 {
1894         device_remove_file(&plat_priv->plat_dev->dev, &dev_attr_wl_pwr_on);
1895 }
1896
1897 static int cnss_event_work_init(struct cnss_plat_data *plat_priv)
1898 {
1899         spin_lock_init(&plat_priv->event_lock);
1900         plat_priv->event_wq = alloc_workqueue("cnss_driver_event",
1901                                               WQ_UNBOUND, 1);
1902         if (!plat_priv->event_wq) {
1903                 cnss_pr_err("Failed to create event workqueue!\n");
1904                 return -EFAULT;
1905         }
1906
1907         INIT_WORK(&plat_priv->event_work, cnss_driver_event_work);
1908         INIT_LIST_HEAD(&plat_priv->event_list);
1909
1910         return 0;
1911 }
1912
1913 static void cnss_event_work_deinit(struct cnss_plat_data *plat_priv)
1914 {
1915         destroy_workqueue(plat_priv->event_wq);
1916 }
1917
1918 static int cnss_alloc_caldb_mem(struct cnss_plat_data *plat_priv)
1919 {
1920         int ret = 0;
1921
1922         plat_priv->caldb_mem = vzalloc(QCN7605_CALDB_SIZE);
1923         if (plat_priv->caldb_mem)
1924                 cnss_pr_dbg("600KB cal db alloc done caldb_mem %pK\n",
1925                             plat_priv->caldb_mem);
1926         else
1927                 ret = -ENOMEM;
1928
1929         return ret;
1930 }
1931
1932 static void cnss_free_caldb_mem(struct cnss_plat_data *plat_priv)
1933 {
1934         vfree(plat_priv->caldb_mem);
1935 }
1936
1937 static const struct platform_device_id cnss_platform_id_table[] = {
1938         { .name = "qca6174", .driver_data = QCA6174_DEVICE_ID, },
1939         { .name = "qca6290", .driver_data = QCA6290_DEVICE_ID, },
1940         { .name = "qcn7605", .driver_data = QCN7605_DEVICE_ID, },
1941         { .name = "qcn7605_sdio", .driver_data = QCN7605_SDIO_DEVICE_ID, },
1942 };
1943
1944 static const struct of_device_id cnss_of_match_table[] = {
1945         {
1946                 .compatible = "qcom,cnss",
1947                 .data = (void *)&cnss_platform_id_table[0]},
1948         {
1949                 .compatible = "qcom,cnss-qca6290",
1950                 .data = (void *)&cnss_platform_id_table[1]},
1951         {
1952                 .compatible = "qcom,cnss",
1953                 .data = (void *)&cnss_platform_id_table[2]},
1954         {
1955                 .compatible = "qcom,cnss-sdio",
1956                 .data = (void *)&cnss_platform_id_table[3]},
1957         { },
1958 };
1959 MODULE_DEVICE_TABLE(of, cnss_of_match_table);
1960
1961 static int cnss_probe(struct platform_device *plat_dev)
1962 {
1963         int ret = 0;
1964         struct cnss_plat_data *plat_priv;
1965         const struct of_device_id *of_id;
1966         const struct platform_device_id *device_id;
1967
1968         if (cnss_get_plat_priv(plat_dev)) {
1969                 cnss_pr_err("Driver is already initialized!\n");
1970                 ret = -EEXIST;
1971                 goto out;
1972         }
1973
1974         of_id = of_match_device(cnss_of_match_table, &plat_dev->dev);
1975         if (!of_id || !of_id->data) {
1976                 cnss_pr_err("Failed to find of match device!\n");
1977                 ret = -ENODEV;
1978                 goto out;
1979         }
1980
1981         device_id = of_id->data;
1982
1983         plat_priv = devm_kzalloc(&plat_dev->dev, sizeof(*plat_priv),
1984                                  GFP_KERNEL);
1985         if (!plat_priv) {
1986                 ret = -ENOMEM;
1987                 goto out;
1988         }
1989
1990         plat_priv->plat_dev = plat_dev;
1991         plat_priv->device_id = device_id->driver_data;
1992         plat_priv->bus_type = cnss_get_bus_type(plat_priv->device_id);
1993         cnss_pr_dbg("bus type selected  %d\n", plat_priv->bus_type);
1994         cnss_set_plat_priv(plat_dev, plat_priv);
1995         platform_set_drvdata(plat_dev, plat_priv);
1996
1997         ret = cnss_get_resources(plat_priv);
1998         if (ret)
1999                 goto reset_ctx;
2000
2001         if (!test_bit(SKIP_DEVICE_BOOT, &quirks)) {
2002                 ret = cnss_power_on_device(plat_priv);
2003                 if (ret)
2004                         goto free_res;
2005
2006                 ret = cnss_bus_init(plat_priv);
2007                 if (ret == -EPROBE_DEFER)
2008                         goto free_res;
2009                 else if (ret)
2010                         goto power_off;
2011         }
2012
2013         ret = cnss_register_esoc(plat_priv);
2014         if (ret)
2015                 goto deinit_bus;
2016
2017         ret = cnss_register_bus_scale(plat_priv);
2018         if (ret)
2019                 goto unreg_esoc;
2020
2021         ret = cnss_create_sysfs(plat_priv);
2022         if (ret)
2023                 goto unreg_bus_scale;
2024
2025         ret = cnss_create_sysfs_wl_pwr(plat_priv);
2026         if (ret)
2027                 goto remove_sysfs;
2028
2029         ret = cnss_event_work_init(plat_priv);
2030         if (ret)
2031                 goto remove_sysfs_pwr;
2032
2033         ret = cnss_qmi_init(plat_priv);
2034         if (ret)
2035                 goto deinit_event_work;
2036
2037         ret = cnss_debugfs_create(plat_priv);
2038         if (ret)
2039                 goto deinit_qmi;
2040
2041         if (plat_priv->bus_type == CNSS_BUS_USB)        {
2042                 ret = cnss_alloc_caldb_mem(plat_priv);
2043                 if (ret)
2044                         goto remove_debugfs;
2045         }
2046
2047         setup_timer(&plat_priv->fw_boot_timer,
2048                     cnss_bus_fw_boot_timeout_hdlr, (unsigned long)plat_priv);
2049
2050         register_pm_notifier(&cnss_pm_notifier);
2051
2052         ret = device_init_wakeup(&plat_dev->dev, true);
2053         if (ret)
2054                 cnss_pr_err("Failed to init platform device wakeup source, err = %d\n",
2055                             ret);
2056
2057         init_completion(&plat_priv->power_up_complete);
2058         init_completion(&plat_priv->rddm_complete);
2059         mutex_init(&plat_priv->dev_lock);
2060
2061         cnss_pr_info("Platform driver probed successfully.\n");
2062
2063         return 0;
2064
2065 remove_debugfs:
2066         cnss_debugfs_destroy(plat_priv);
2067 deinit_qmi:
2068         cnss_qmi_deinit(plat_priv);
2069 deinit_event_work:
2070         cnss_event_work_deinit(plat_priv);
2071 remove_sysfs:
2072         cnss_remove_sysfs(plat_priv);
2073 remove_sysfs_pwr:
2074         cnss_remove_sysfs_wl_pwr(plat_priv);
2075 unreg_bus_scale:
2076         cnss_unregister_bus_scale(plat_priv);
2077 unreg_esoc:
2078         cnss_unregister_esoc(plat_priv);
2079 deinit_bus:
2080         if (!test_bit(SKIP_DEVICE_BOOT, &quirks))
2081                 cnss_bus_deinit(plat_priv);
2082 power_off:
2083         if (!test_bit(SKIP_DEVICE_BOOT, &quirks))
2084                 cnss_power_off_device(plat_priv);
2085 free_res:
2086         cnss_put_resources(plat_priv);
2087 reset_ctx:
2088         platform_set_drvdata(plat_dev, NULL);
2089         cnss_set_plat_priv(plat_dev, NULL);
2090 out:
2091         return ret;
2092 }
2093
2094 static int cnss_remove(struct platform_device *plat_dev)
2095 {
2096         struct cnss_plat_data *plat_priv = platform_get_drvdata(plat_dev);
2097
2098         complete_all(&plat_priv->rddm_complete);
2099         complete_all(&plat_priv->power_up_complete);
2100         device_init_wakeup(&plat_dev->dev, false);
2101         unregister_pm_notifier(&cnss_pm_notifier);
2102         del_timer(&plat_priv->fw_boot_timer);
2103         cnss_free_caldb_mem(plat_priv);
2104         cnss_debugfs_destroy(plat_priv);
2105         cnss_qmi_deinit(plat_priv);
2106         cnss_event_work_deinit(plat_priv);
2107         cnss_remove_sysfs(plat_priv);
2108         cnss_unregister_bus_scale(plat_priv);
2109         cnss_unregister_esoc(plat_priv);
2110         cnss_bus_deinit(plat_priv);
2111         cnss_put_resources(plat_priv);
2112         platform_set_drvdata(plat_dev, NULL);
2113         plat_env = NULL;
2114
2115         return 0;
2116 }
2117
2118 static struct platform_driver cnss_platform_driver = {
2119         .probe  = cnss_probe,
2120         .remove = cnss_remove,
2121         .driver = {
2122                 .name = "cnss2",
2123                 .owner = THIS_MODULE,
2124                 .of_match_table = cnss_of_match_table,
2125 #ifdef CONFIG_CNSS_ASYNC
2126                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
2127 #endif
2128         },
2129 };
2130
2131 static int __init cnss_initialize(void)
2132 {
2133         int ret = 0;
2134
2135         cnss_debug_init();
2136         ret = platform_driver_register(&cnss_platform_driver);
2137         if (ret)
2138                 cnss_debug_deinit();
2139
2140         return ret;
2141 }
2142
2143 static void __exit cnss_exit(void)
2144 {
2145         platform_driver_unregister(&cnss_platform_driver);
2146         cnss_debug_deinit();
2147 }
2148
2149 module_init(cnss_initialize);
2150 module_exit(cnss_exit);
2151
2152 MODULE_LICENSE("GPL v2");
2153 MODULE_DESCRIPTION("CNSS2 Platform Driver");