Merge "net: cnss2: Update CNSS2 driver" (8f4fbfd6) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/net/wireless/cnss2/bus.c

+79 −0

Original line number	Diff line number	Diff line
		@@ -186,6 +186,36 @@ int cnss_bus_force_fw_assert_hdlr(struct cnss_plat_data *plat_priv)
		}
		}

		int cnss_bus_qmi_send_get(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_qmi_send_get(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		int cnss_bus_qmi_send_put(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_qmi_send_put(plat_priv->bus_priv);
		default:
		cnss_pr_err("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return -EINVAL;
		}
		}

		void cnss_bus_fw_boot_timeout_hdlr(struct timer_list *t)
		{
		struct cnss_plat_data *plat_priv =
		@@ -372,3 +402,52 @@ int cnss_bus_update_status(struct cnss_plat_data *plat_priv,
		return -EINVAL;
		}
		}

		int cnss_bus_is_device_down(struct cnss_plat_data *plat_priv)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pcie_is_device_down(plat_priv->bus_priv);
		default:
		cnss_pr_dbg("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return 0;
		}
		}

		int cnss_bus_debug_reg_read(struct cnss_plat_data *plat_priv, u32 offset,
		u32 *val)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_debug_reg_read(plat_priv->bus_priv, offset,
		val);
		default:
		cnss_pr_dbg("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return 0;
		}
		}

		int cnss_bus_debug_reg_write(struct cnss_plat_data *plat_priv, u32 offset,
		u32 val)
		{
		if (!plat_priv)
		return -ENODEV;

		switch (plat_priv->bus_type) {
		case CNSS_BUS_PCI:
		return cnss_pci_debug_reg_write(plat_priv->bus_priv, offset,
		val);
		default:
		cnss_pr_dbg("Unsupported bus type: %d\n",
		plat_priv->bus_type);
		return 0;
		}
		}

drivers/net/wireless/cnss2/bus.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -30,6 +30,8 @@ int cnss_bus_alloc_qdss_mem(struct cnss_plat_data *plat_priv);
		void cnss_bus_free_qdss_mem(struct cnss_plat_data *plat_priv);
		u32 cnss_bus_get_wake_irq(struct cnss_plat_data *plat_priv);
		int cnss_bus_force_fw_assert_hdlr(struct cnss_plat_data *plat_priv);
		int cnss_bus_qmi_send_get(struct cnss_plat_data *plat_priv);
		int cnss_bus_qmi_send_put(struct cnss_plat_data *plat_priv);
		void cnss_bus_fw_boot_timeout_hdlr(struct timer_list *t);
		void cnss_bus_collect_dump_info(struct cnss_plat_data *plat_priv,
		bool in_panic);
		@@ -45,5 +47,10 @@ int cnss_bus_call_driver_modem_status(struct cnss_plat_data *plat_priv,
		int modem_current_status);
		int cnss_bus_update_status(struct cnss_plat_data *plat_priv,
		enum cnss_driver_status status);
		int cnss_bus_is_device_down(struct cnss_plat_data *plat_priv);
		int cnss_bus_debug_reg_read(struct cnss_plat_data *plat_priv, u32 offset,
		u32 *val);
		int cnss_bus_debug_reg_write(struct cnss_plat_data *plat_priv, u32 offset,
		u32 val);

		#endif /* _CNSS_BUS_H */

drivers/net/wireless/cnss2/debug.c

+59 −13

Original line number	Diff line number	Diff line
		@@ -5,9 +5,12 @@
		#include <linux/seq_file.h>
		#include <linux/debugfs.h>
		#include "main.h"
		#include "bus.h"
		#include "debug.h"
		#include "pci.h"

		#define MMIO_REG_ACCESS_MEM_TYPE 0xFF

		void *cnss_ipc_log_context;
		void *cnss_ipc_log_long_context;

		@@ -107,6 +110,9 @@ static int cnss_stats_show_state(struct seq_file *s,
		case CNSS_IN_SUSPEND_RESUME:
		seq_puts(s, "IN_SUSPEND_RESUME");
		continue;
		case CNSS_IN_REBOOT:
		seq_puts(s, "IN_REBOOT");
		continue;
		}

		seq_printf(s, "UNKNOWN-%d", i);
		@@ -194,7 +200,7 @@ static ssize_t cnss_dev_boot_debug_write(struct file *fp,
		ret = -EINVAL;
		}

		if (ret)
		if (ret < 0)
		return ret;

		return count;
		@@ -238,6 +244,8 @@ static int cnss_reg_read_debug_show(struct seq_file s, void data)
		mutex_lock(&plat_priv->dev_lock);
		if (!plat_priv->diag_reg_read_buf) {
		seq_puts(s, "\nUsage: echo <mem_type> <offset> <data_len> > <debugfs_path>/cnss/reg_read\n");
		seq_puts(s, "Use mem_type = 0xff for register read by IO access, data_len will be ignored\n");
		seq_puts(s, "Use other mem_type for register read by QMI\n");
		mutex_unlock(&plat_priv->dev_lock);
		return 0;
		}
		@@ -269,16 +277,11 @@ static ssize_t cnss_reg_read_debug_write(struct file *fp,
		char sptr, token;
		unsigned int len = 0;
		u32 reg_offset, mem_type;
		u32 data_len = 0;
		u32 data_len = 0, reg_val = 0;
		u8 *reg_buf = NULL;
		const char *delim = " ";
		int ret = 0;

		if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
		cnss_pr_err("Firmware is not ready yet\n");
		return -EINVAL;
		}

		len = min(count, sizeof(buf) - 1);
		if (copy_from_user(buf, user_buf, len))
		return -EFAULT;
		@@ -313,6 +316,20 @@ static ssize_t cnss_reg_read_debug_write(struct file *fp,
		if (kstrtou32(token, 0, &data_len))
		return -EINVAL;

		if (mem_type == MMIO_REG_ACCESS_MEM_TYPE) {
		ret = cnss_bus_debug_reg_read(plat_priv, reg_offset, &reg_val);
		if (ret)
		return ret;
		cnss_pr_dbg("Read 0x%x from register offset 0x%x\n", reg_val,
		reg_offset);
		return count;
		}

		if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
		cnss_pr_err("Firmware is not ready yet\n");
		return -EINVAL;
		}

		mutex_lock(&plat_priv->dev_lock);
		kfree(plat_priv->diag_reg_read_buf);
		plat_priv->diag_reg_read_buf = NULL;
		@@ -357,6 +374,8 @@ static const struct file_operations cnss_reg_read_debug_fops = {
		static int cnss_reg_write_debug_show(struct seq_file s, void data)
		{
		seq_puts(s, "\nUsage: echo <mem_type> <offset> <reg_val> > <debugfs_path>/cnss/reg_write\n");
		seq_puts(s, "Use mem_type = 0xff for register write by IO access\n");
		seq_puts(s, "Use other mem_type for register write by QMI\n");

		return 0;
		}
		@@ -374,11 +393,6 @@ static ssize_t cnss_reg_write_debug_write(struct file *fp,
		const char *delim = " ";
		int ret = 0;

		if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
		cnss_pr_err("Firmware is not ready yet\n");
		return -EINVAL;
		}

		len = min(count, sizeof(buf) - 1);
		if (copy_from_user(buf, user_buf, len))
		return -EFAULT;
		@@ -413,6 +427,20 @@ static ssize_t cnss_reg_write_debug_write(struct file *fp,
		if (kstrtou32(token, 0, &reg_val))
		return -EINVAL;

		if (mem_type == MMIO_REG_ACCESS_MEM_TYPE) {
		ret = cnss_bus_debug_reg_write(plat_priv, reg_offset, reg_val);
		if (ret)
		return ret;
		cnss_pr_dbg("Wrote 0x%x to register offset 0x%x\n", reg_val,
		reg_offset);
		return count;
		}

		if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) {
		cnss_pr_err("Firmware is not ready yet\n");
		return -EINVAL;
		}

		ret = cnss_wlfw_athdiag_write_send_sync(plat_priv, reg_offset, mem_type,
		sizeof(u32),
		(u8 *)&reg_val);
		@@ -477,12 +505,16 @@ static ssize_t cnss_runtime_pm_debug_write(struct file *fp,
		cnss_pci_pm_runtime_put_noidle(pci_priv);
		} else if (sysfs_streq(cmd, "mark_last_busy")) {
		cnss_pci_pm_runtime_mark_last_busy(pci_priv);
		} else if (sysfs_streq(cmd, "resume_bus")) {
		cnss_pci_resume_bus(pci_priv);
		} else if (sysfs_streq(cmd, "suspend_bus")) {
		cnss_pci_suspend_bus(pci_priv);
		} else {
		cnss_pr_err("Runtime PM debugfs command is invalid\n");
		ret = -EINVAL;
		}

		if (ret)
		if (ret < 0)
		return ret;

		return count;
		@@ -493,11 +525,15 @@ static int cnss_runtime_pm_debug_show(struct seq_file s, void data)
		seq_puts(s, "\nUsage: echo <action> > <debugfs_path>/cnss/runtime_pm\n");
		seq_puts(s, "<action> can be one of below:\n");
		seq_puts(s, "usage_count: get runtime PM usage count\n");
		seq_puts(s, "reques_resume: do async runtime PM resume\n");
		seq_puts(s, "resume: do sync runtime PM resume\n");
		seq_puts(s, "get: do runtime PM get\n");
		seq_puts(s, "get_noresume: do runtime PM get noresume\n");
		seq_puts(s, "put_noidle: do runtime PM put noidle\n");
		seq_puts(s, "put_autosuspend: do runtime PM put autosuspend\n");
		seq_puts(s, "mark_last_busy: do runtime PM mark last busy\n");
		seq_puts(s, "resume_bus: do bus resume only\n");
		seq_puts(s, "suspend_bus: do bus suspend only\n");

		return 0;
		}
		@@ -555,6 +591,8 @@ static ssize_t cnss_control_params_debug_write(struct file *fp,
		plat_priv->ctrl_params.quirks = val;
		else if (strcmp(cmd, "mhi_timeout") == 0)
		plat_priv->ctrl_params.mhi_timeout = val;
		else if (strcmp(cmd, "mhi_m2_timeout") == 0)
		plat_priv->ctrl_params.mhi_m2_timeout = val;
		else if (strcmp(cmd, "qmi_timeout") == 0)
		plat_priv->ctrl_params.qmi_timeout = val;
		else if (strcmp(cmd, "bdf_type") == 0)
		@@ -613,6 +651,12 @@ static int cnss_show_quirks_state(struct seq_file *s,
		case DISABLE_DRV:
		seq_puts(s, "DISABLE_DRV");
		continue;
		case DISABLE_IO_COHERENCY:
		seq_puts(s, "DISABLE_IO_COHERENCY");
		continue;
		case IGNORE_PCI_LINK_FAILURE:
		seq_puts(s, "IGNORE_PCI_LINK_FAILURE");
		continue;
		}

		seq_printf(s, "UNKNOWN-%d", i);
		@@ -636,6 +680,8 @@ static int cnss_control_params_debug_show(struct seq_file s, void data)
		seq_puts(s, "\nCurrent value:\n");
		cnss_show_quirks_state(s, cnss_priv);
		seq_printf(s, "mhi_timeout: %u\n", cnss_priv->ctrl_params.mhi_timeout);
		seq_printf(s, "mhi_m2_timeout: %u\n",
		cnss_priv->ctrl_params.mhi_m2_timeout);
		seq_printf(s, "qmi_timeout: %u\n", cnss_priv->ctrl_params.qmi_timeout);
		seq_printf(s, "bdf_type: %u\n", cnss_priv->ctrl_params.bdf_type);
		seq_printf(s, "time_sync_period: %u\n",

drivers/net/wireless/cnss2/genl.c

+12 −2

Original line number	Diff line number	Diff line
		@@ -5,6 +5,7 @@

		#include <linux/err.h>
		#include <linux/module.h>
		#include <linux/delay.h>
		#include <net/netlink.h>
		#include <net/genetlink.h>

		@@ -161,6 +162,7 @@ int cnss_genl_send_msg(void buff, u8 type, char file_name, u32 total_size)
		u32 seg_id = 0;
		u32 data_len = 0;
		u8 end = 0;
		u8 retry;

		cnss_pr_dbg("type: %u, total_size: %x\n", type, total_size);

		@@ -171,8 +173,16 @@ int cnss_genl_send_msg(void buff, u8 type, char file_name, u32 total_size)
		data_len = remaining;
		end = 1;
		}

		for (retry = 0; retry < 2; retry++) {
		ret = cnss_genl_send_data(type, file_name, total_size,
		seg_id, end, data_len, msg_buff);
		seg_id, end, data_len,
		msg_buff);
		if (ret >= 0)
		break;
		msleep(100);
		}

		if (ret < 0) {
		cnss_pr_err("fail to send genl data, ret %d\n", ret);
		return ret;

drivers/net/wireless/cnss2/main.c

+193 −6

Original line number	Diff line number	Diff line
		@@ -7,9 +7,11 @@
		#include <linux/of.h>
		#include <linux/of_device.h>
		#include <linux/pm_wakeup.h>
		#include <linux/reboot.h>
		#include <linux/rwsem.h>
		#include <linux/suspend.h>
		#include <linux/timer.h>
		#include <soc/qcom/minidump.h>
		#include <soc/qcom/ramdump.h>
		#include <soc/qcom/subsystem_notif.h>

		@@ -29,13 +31,15 @@
		#define FW_READY_TIMEOUT 20000
		#define FW_ASSERT_TIMEOUT 5000
		#define CNSS_EVENT_PENDING 2989
		#define COLD_BOOT_CAL_SHUTDOWN_DELAY_MS 50

		#define CNSS_QUIRKS_DEFAULT 0
		#define CNSS_QUIRKS_DEFAULT BIT(DISABLE_IO_COHERENCY)
		#ifdef CONFIG_CNSS_EMULATION
		#define CNSS_MHI_TIMEOUT_DEFAULT 90000
		#else
		#define CNSS_MHI_TIMEOUT_DEFAULT 0
		#endif
		#define CNSS_MHI_M2_TIMEOUT_DEFAULT 25
		#define CNSS_QMI_TIMEOUT_DEFAULT 10000
		#define CNSS_BDF_TYPE_DEFAULT CNSS_BDF_ELF
		#define CNSS_TIME_SYNC_PERIOD_DEFAULT 900000
		@@ -283,6 +287,7 @@ EXPORT_SYMBOL(cnss_wlan_enable);
		int cnss_wlan_disable(struct device *dev, enum cnss_driver_mode mode)
		{
		struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
		int ret = 0;

		if (plat_priv->device_id == QCA6174_DEVICE_ID)
		return 0;
		@@ -290,7 +295,10 @@ int cnss_wlan_disable(struct device *dev, enum cnss_driver_mode mode)
		if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks))
		return 0;

		return cnss_wlfw_wlan_mode_send_sync(plat_priv, CNSS_OFF);
		ret = cnss_wlfw_wlan_mode_send_sync(plat_priv, CNSS_OFF);
		cnss_bus_free_qdss_mem(plat_priv);

		return ret;
		}
		EXPORT_SYMBOL(cnss_wlan_disable);

		@@ -1063,6 +1071,12 @@ static int cnss_driver_recovery_hdlr(struct cnss_plat_data *plat_priv,
		goto out;
		}

		if (test_bit(CNSS_IN_REBOOT, &plat_priv->driver_state)) {
		cnss_pr_err("Reboot is in progress, ignore recovery\n");
		ret = -EINVAL;
		goto out;
		}

		if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {
		cnss_pr_err("Recovery is already in progress\n");
		ret = -EINVAL;
		@@ -1153,7 +1167,7 @@ int cnss_force_fw_assert(struct device *dev)
		return -EOPNOTSUPP;
		}

		if (cnss_pci_is_device_down(dev)) {
		if (cnss_bus_is_device_down(plat_priv)) {
		cnss_pr_info("Device is already in bad state, ignore force assert\n");
		return 0;
		}
		@@ -1189,7 +1203,7 @@ int cnss_force_collect_rddm(struct device *dev)
		return -EOPNOTSUPP;
		}

		if (cnss_pci_is_device_down(dev)) {
		if (cnss_bus_is_device_down(plat_priv)) {
		cnss_pr_info("Device is already in bad state, ignore force collect rddm\n");
		return 0;
		}
		@@ -1222,6 +1236,54 @@ int cnss_force_collect_rddm(struct device *dev)
		}
		EXPORT_SYMBOL(cnss_force_collect_rddm);

		int cnss_qmi_send_get(struct device *dev)
		{
		struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);

		if (!test_bit(CNSS_QMI_WLFW_CONNECTED, &plat_priv->driver_state))
		return 0;

		return cnss_bus_qmi_send_get(plat_priv);
		}
		EXPORT_SYMBOL(cnss_qmi_send_get);

		int cnss_qmi_send_put(struct device *dev)
		{
		struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);

		if (!test_bit(CNSS_QMI_WLFW_CONNECTED, &plat_priv->driver_state))
		return 0;

		return cnss_bus_qmi_send_put(plat_priv);
		}
		EXPORT_SYMBOL(cnss_qmi_send_put);

		int cnss_qmi_send(struct device dev, int type, void cmd,
		int cmd_len, void *cb_ctx,
		int (cb)(void ctx, void *event, int event_len))
		{
		struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);
		int ret;

		if (!plat_priv)
		return -ENODEV;

		if (!test_bit(CNSS_QMI_WLFW_CONNECTED, &plat_priv->driver_state))
		return -EINVAL;

		plat_priv->get_info_cb = cb;
		plat_priv->get_info_cb_ctx = cb_ctx;

		ret = cnss_wlfw_get_info_send_sync(plat_priv, type, cmd, cmd_len);
		if (ret) {
		plat_priv->get_info_cb = NULL;
		plat_priv->get_info_cb_ctx = NULL;
		}

		return ret;
		}
		EXPORT_SYMBOL(cnss_qmi_send);

		static int cnss_cold_boot_cal_start_hdlr(struct cnss_plat_data *plat_priv)
		{
		int ret = 0;
		@@ -1268,8 +1330,10 @@ static int cnss_cold_boot_cal_done_hdlr(struct cnss_plat_data *plat_priv,
		}

		cnss_wlfw_wlan_mode_send_sync(plat_priv, CNSS_OFF);
		cnss_bus_free_qdss_mem(plat_priv);
		cnss_release_antenna_sharing(plat_priv);
		cnss_bus_dev_shutdown(plat_priv);
		msleep(COLD_BOOT_CAL_SHUTDOWN_DELAY_MS);
		complete(&plat_priv->cal_complete);
		clear_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state);

		@@ -1516,6 +1580,25 @@ static void cnss_driver_event_work(struct work_struct *work)
		cnss_pm_relax(plat_priv);
		}

		int cnss_va_to_pa(struct device dev, size_t size, void va, dma_addr_t dma,
		phys_addr_t *pa, unsigned long attrs)
		{
		struct sg_table sgt;
		int ret;

		ret = dma_get_sgtable_attrs(dev, &sgt, va, dma, size, attrs);
		if (ret) {
		cnss_pr_err("Failed to get sgtable for va: 0x%pK, dma: %pa, size: 0x%zx, attrs: 0x%x\n",
		va, &dma, size, attrs);
		return -EINVAL;
		}

		*pa = page_to_phys(sg_page(sgt.sgl));
		sg_free_table(&sgt);

		return 0;
		}

		int cnss_register_subsys(struct cnss_plat_data *plat_priv)
		{
		int ret = 0;
		@@ -1766,6 +1849,87 @@ void cnss_unregister_ramdump(struct cnss_plat_data *plat_priv)
		}
		}

		int cnss_minidump_add_region(struct cnss_plat_data *plat_priv,
		enum cnss_fw_dump_type type, int seg_no,
		void *va, phys_addr_t pa, size_t size)
		{
		struct md_region md_entry;
		int ret;

		switch (type) {
		case CNSS_FW_IMAGE:
		snprintf(md_entry.name, sizeof(md_entry.name), "FBC_%X",
		seg_no);
		break;
		case CNSS_FW_RDDM:
		snprintf(md_entry.name, sizeof(md_entry.name), "RDDM_%X",
		seg_no);
		break;
		case CNSS_FW_REMOTE_HEAP:
		snprintf(md_entry.name, sizeof(md_entry.name), "RHEAP_%X",
		seg_no);
		break;
		default:
		cnss_pr_err("Unknown dump type ID: %d\n", type);
		return -EINVAL;
		}

		md_entry.phys_addr = pa;
		md_entry.virt_addr = (uintptr_t)va;
		md_entry.size = size;
		md_entry.id = MSM_DUMP_DATA_CNSS_WLAN;

		cnss_pr_dbg("Mini dump region: %s, va: %pK, pa: %pa, size: 0x%zx\n",
		md_entry.name, va, &pa, size);

		ret = msm_minidump_add_region(&md_entry);
		if (ret)
		cnss_pr_err("Failed to add mini dump region, err = %d\n", ret);

		return ret;
		}

		int cnss_minidump_remove_region(struct cnss_plat_data *plat_priv,
		enum cnss_fw_dump_type type, int seg_no,
		void *va, phys_addr_t pa, size_t size)
		{
		struct md_region md_entry;
		int ret;

		switch (type) {
		case CNSS_FW_IMAGE:
		snprintf(md_entry.name, sizeof(md_entry.name), "FBC_%X",
		seg_no);
		break;
		case CNSS_FW_RDDM:
		snprintf(md_entry.name, sizeof(md_entry.name), "RDDM_%X",
		seg_no);
		break;
		case CNSS_FW_REMOTE_HEAP:
		snprintf(md_entry.name, sizeof(md_entry.name), "RHEAP_%X",
		seg_no);
		break;
		default:
		cnss_pr_err("Unknown dump type ID: %d\n", type);
		return -EINVAL;
		}

		md_entry.phys_addr = pa;
		md_entry.virt_addr = (uintptr_t)va;
		md_entry.size = size;
		md_entry.id = MSM_DUMP_DATA_CNSS_WLAN;

		cnss_pr_dbg("Remove mini dump region: %s, va: %pK, pa: %pa, size: 0x%zx\n",
		md_entry.name, va, &pa, size);

		ret = msm_minidump_remove_region(&md_entry);
		if (ret)
		cnss_pr_err("Failed to remove mini dump region, err = %d\n",
		ret);

		return ret;
		}

		static int cnss_register_bus_scale(struct cnss_plat_data *plat_priv)
		{
		int ret = 0;
		@@ -1835,7 +1999,7 @@ static ssize_t fs_ready_store(struct device *dev,
		if (fs_ready == FILE_SYSTEM_READY) {
		cnss_driver_event_post(plat_priv,
		CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START,
		CNSS_EVENT_SYNC, NULL);
		0, NULL);
		}

		return count;
		@@ -1884,6 +2048,19 @@ static void cnss_event_work_deinit(struct cnss_plat_data *plat_priv)
		destroy_workqueue(plat_priv->event_wq);
		}

		static int cnss_reboot_notifier(struct notifier_block *nb,
		unsigned long action,
		void *data)
		{
		struct cnss_plat_data *plat_priv =
		container_of(nb, struct cnss_plat_data, reboot_nb);

		set_bit(CNSS_IN_REBOOT, &plat_priv->driver_state);
		cnss_pr_dbg("Reboot is in progress with action %d\n", action);

		return NOTIFY_DONE;
		}

		static int cnss_misc_init(struct cnss_plat_data *plat_priv)
		{
		int ret;
		@@ -1891,7 +2068,15 @@ static int cnss_misc_init(struct cnss_plat_data *plat_priv)
		timer_setup(&plat_priv->fw_boot_timer,
		cnss_bus_fw_boot_timeout_hdlr, 0);

		register_pm_notifier(&cnss_pm_notifier);
		ret = register_pm_notifier(&cnss_pm_notifier);
		if (ret)
		cnss_pr_err("Failed to register PM notifier, err = %d\n", ret);

		plat_priv->reboot_nb.notifier_call = cnss_reboot_notifier;
		ret = register_reboot_notifier(&plat_priv->reboot_nb);
		if (ret)
		cnss_pr_err("Failed to register reboot notifier, err = %d\n",
		ret);

		ret = device_init_wakeup(&plat_priv->plat_dev->dev, true);
		if (ret)
		@@ -1914,6 +2099,7 @@ static void cnss_misc_deinit(struct cnss_plat_data *plat_priv)
		complete_all(&plat_priv->cal_complete);
		complete_all(&plat_priv->power_up_complete);
		device_init_wakeup(&plat_priv->plat_dev->dev, false);
		unregister_reboot_notifier(&plat_priv->reboot_nb);
		unregister_pm_notifier(&cnss_pm_notifier);
		del_timer(&plat_priv->fw_boot_timer);
		}
		@@ -1922,6 +2108,7 @@ static void cnss_init_control_params(struct cnss_plat_data *plat_priv)
		{
		plat_priv->ctrl_params.quirks = CNSS_QUIRKS_DEFAULT;
		plat_priv->ctrl_params.mhi_timeout = CNSS_MHI_TIMEOUT_DEFAULT;
		plat_priv->ctrl_params.mhi_m2_timeout = CNSS_MHI_M2_TIMEOUT_DEFAULT;
		plat_priv->ctrl_params.qmi_timeout = CNSS_QMI_TIMEOUT_DEFAULT;
		plat_priv->ctrl_params.bdf_type = CNSS_BDF_TYPE_DEFAULT;
		plat_priv->ctrl_params.time_sync_period = CNSS_TIME_SYNC_PERIOD_DEFAULT;