// SPDX-License-Identifier: GPL-2.0-only /* Copyright (c) 2016-2021, The Linux Foundation. All rights reserved. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef OPLUS_BUG_STABILITY //Add for: disable wifi while power off charging because modem img will not mount #include #endif /* OPLUS_BUG_STABILITY */ #ifdef CONFIG_OPLUS_KEVENT_UPLOAD //Add for: pcie self recovery statistics #include #endif /* CONFIG_OPLUS_KEVENT_UPLOAD */ #include "main.h" #include "bus.h" #include "debug.h" #include "genl.h" #define CNSS_DUMP_FORMAT_VER 0x11 #define CNSS_DUMP_FORMAT_VER_V2 0x22 #define CNSS_DUMP_MAGIC_VER_V2 0x42445953 #define CNSS_DUMP_NAME "CNSS_WLAN" #define CNSS_DUMP_DESC_SIZE 0x1000 #define CNSS_DUMP_SEG_VER 0x1 #define RECOVERY_DELAY_MS 100 #define FILE_SYSTEM_READY 1 #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 #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 #define CNSS_MIN_TIME_SYNC_PERIOD 2000 static struct cnss_plat_data *plat_env; static DECLARE_RWSEM(cnss_pm_sem); static struct cnss_fw_files FW_FILES_QCA6174_FW_3_0 = { "qwlan30.bin", "bdwlan30.bin", "otp30.bin", "utf30.bin", "utfbd30.bin", "epping30.bin", "evicted30.bin" }; static struct cnss_fw_files FW_FILES_DEFAULT = { "qwlan.bin", "bdwlan.bin", "otp.bin", "utf.bin", "utfbd.bin", "epping.bin", "evicted.bin" }; struct cnss_driver_event { struct list_head list; enum cnss_driver_event_type type; bool sync; struct completion complete; int ret; void *data; }; #ifdef OPLUS_FEATURE_WIFI_DCS_SWITCH //Add for wifi switch monitor static unsigned int cnssprobestate = 0; #endif /* OPLUS_FEATURE_WIFI_DCS_SWITCH */ #ifdef CONFIG_OPLUS_KEVENT_UPLOAD //Add for: pcie self recovery statistics int cnss_stats_self_recovery(void) { const char* cnss_event_tag = "wifi_fool_proof"; const char* cnss_event_id = "wifi_pci_linkdown"; const char* cnss_event_payload = "cnss_pcie_self_recovery"; struct kernel_packet_info* cnss_event; void *buffer = NULL; int len, size; cnss_pr_err("%s\n", __func__); len = strlen(cnss_event_payload); size = sizeof(struct kernel_packet_info) + len + 1; buffer = kmalloc(size, GFP_KERNEL); if (!buffer) { cnss_pr_err("%s: Allocation failed\n", __func__); return -ENOMEM; } memset(buffer, 0, size); cnss_event = (struct kernel_packet_info *)buffer; cnss_event->type = 1; memcpy(cnss_event->log_tag, cnss_event_tag, strlen(cnss_event_tag) + 1); memcpy(cnss_event->event_id, cnss_event_id, strlen(cnss_event_id) + 1); cnss_event->payload_length = len + 1; memcpy(cnss_event->payload, cnss_event_payload, cnss_event->payload_length); kevent_send_to_user(cnss_event); kfree(buffer); return 0; } #endif /* CONFIG_OPLUS_KEVENT_UPLOAD */ static void cnss_set_plat_priv(struct platform_device *plat_dev, struct cnss_plat_data *plat_priv) { plat_env = plat_priv; } struct cnss_plat_data *cnss_get_plat_priv(struct platform_device *plat_dev) { return plat_env; } static int cnss_pm_notify(struct notifier_block *b, unsigned long event, void *p) { switch (event) { case PM_SUSPEND_PREPARE: down_write(&cnss_pm_sem); break; case PM_POST_SUSPEND: up_write(&cnss_pm_sem); break; } return NOTIFY_DONE; } static struct notifier_block cnss_pm_notifier = { .notifier_call = cnss_pm_notify, }; static void cnss_pm_stay_awake(struct cnss_plat_data *plat_priv) { if (atomic_inc_return(&plat_priv->pm_count) != 1) return; cnss_pr_dbg("PM stay awake, state: 0x%lx, count: %d\n", plat_priv->driver_state, atomic_read(&plat_priv->pm_count)); pm_stay_awake(&plat_priv->plat_dev->dev); } static void cnss_pm_relax(struct cnss_plat_data *plat_priv) { int r = atomic_dec_return(&plat_priv->pm_count); WARN_ON(r < 0); if (r != 0) return; cnss_pr_dbg("PM relax, state: 0x%lx, count: %d\n", plat_priv->driver_state, atomic_read(&plat_priv->pm_count)); pm_relax(&plat_priv->plat_dev->dev); } void cnss_lock_pm_sem(struct device *dev) { down_read(&cnss_pm_sem); } EXPORT_SYMBOL(cnss_lock_pm_sem); void cnss_release_pm_sem(struct device *dev) { up_read(&cnss_pm_sem); } EXPORT_SYMBOL(cnss_release_pm_sem); int cnss_get_fw_files_for_target(struct device *dev, struct cnss_fw_files *pfw_files, u32 target_type, u32 target_version) { if (!pfw_files) return -ENODEV; switch (target_version) { case QCA6174_REV3_VERSION: case QCA6174_REV3_2_VERSION: memcpy(pfw_files, &FW_FILES_QCA6174_FW_3_0, sizeof(*pfw_files)); break; default: memcpy(pfw_files, &FW_FILES_DEFAULT, sizeof(*pfw_files)); cnss_pr_err("Unknown target version, type: 0x%X, version: 0x%X", target_type, target_version); break; } return 0; } EXPORT_SYMBOL(cnss_get_fw_files_for_target); int cnss_request_bus_bandwidth(struct device *dev, int bandwidth) { int ret = 0; struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); struct cnss_bus_bw_info *bus_bw_info; if (!plat_priv) return -ENODEV; bus_bw_info = &plat_priv->bus_bw_info; if (!bus_bw_info->bus_client) return -EINVAL; switch (bandwidth) { case CNSS_BUS_WIDTH_NONE: case CNSS_BUS_WIDTH_IDLE: case CNSS_BUS_WIDTH_LOW: case CNSS_BUS_WIDTH_MEDIUM: case CNSS_BUS_WIDTH_HIGH: case CNSS_BUS_WIDTH_VERY_HIGH: case CNSS_BUS_WIDTH_LOW_LATENCY: ret = msm_bus_scale_client_update_request (bus_bw_info->bus_client, bandwidth); if (!ret) bus_bw_info->current_bw_vote = bandwidth; else cnss_pr_err("Could not set bus bandwidth: %d, err = %d\n", bandwidth, ret); break; default: cnss_pr_err("Invalid bus bandwidth: %d", bandwidth); ret = -EINVAL; } return ret; } EXPORT_SYMBOL(cnss_request_bus_bandwidth); int cnss_get_platform_cap(struct device *dev, struct cnss_platform_cap *cap) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); if (!plat_priv) return -ENODEV; if (!cap) return -EINVAL; *cap = plat_priv->cap; cnss_pr_dbg("Platform cap_flag is 0x%x\n", cap->cap_flag); return 0; } EXPORT_SYMBOL(cnss_get_platform_cap); void cnss_request_pm_qos(struct device *dev, u32 qos_val) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); if (!plat_priv) return; pm_qos_add_request(&plat_priv->qos_request, PM_QOS_CPU_DMA_LATENCY, qos_val); } EXPORT_SYMBOL(cnss_request_pm_qos); void cnss_remove_pm_qos(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); if (!plat_priv) return; pm_qos_remove_request(&plat_priv->qos_request); } EXPORT_SYMBOL(cnss_remove_pm_qos); int cnss_wlan_enable(struct device *dev, struct cnss_wlan_enable_cfg *config, enum cnss_driver_mode mode, const char *host_version) { 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; if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks)) return 0; if (!config || !host_version) { cnss_pr_err("Invalid config or host_version pointer\n"); return -EINVAL; } cnss_pr_dbg("Mode: %d, config: %pK, host_version: %s\n", mode, config, host_version); if (mode == CNSS_WALTEST || mode == CNSS_CCPM) goto skip_cfg; ret = cnss_wlfw_wlan_cfg_send_sync(plat_priv, config, host_version); if (ret) goto out; skip_cfg: ret = cnss_wlfw_wlan_mode_send_sync(plat_priv, mode); out: return ret; } 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; if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks)) return 0; 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); int cnss_athdiag_read(struct device *dev, u32 offset, u32 mem_type, u32 data_len, u8 *output) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); int ret = 0; if (!plat_priv) { cnss_pr_err("plat_priv is NULL!\n"); return -EINVAL; } if (plat_priv->device_id == QCA6174_DEVICE_ID) return 0; if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) { cnss_pr_err("Invalid state for athdiag read: 0x%lx\n", plat_priv->driver_state); ret = -EINVAL; goto out; } ret = cnss_wlfw_athdiag_read_send_sync(plat_priv, offset, mem_type, data_len, output); out: return ret; } EXPORT_SYMBOL(cnss_athdiag_read); int cnss_athdiag_write(struct device *dev, u32 offset, u32 mem_type, u32 data_len, u8 *input) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); int ret = 0; if (!plat_priv) { cnss_pr_err("plat_priv is NULL!\n"); return -EINVAL; } if (plat_priv->device_id == QCA6174_DEVICE_ID) return 0; if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) { cnss_pr_err("Invalid state for athdiag write: 0x%lx\n", plat_priv->driver_state); ret = -EINVAL; goto out; } ret = cnss_wlfw_athdiag_write_send_sync(plat_priv, offset, mem_type, data_len, input); out: return ret; } EXPORT_SYMBOL(cnss_athdiag_write); int cnss_set_fw_log_mode(struct device *dev, u8 fw_log_mode) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); if (plat_priv->device_id == QCA6174_DEVICE_ID) return 0; return cnss_wlfw_ini_send_sync(plat_priv, fw_log_mode); } EXPORT_SYMBOL(cnss_set_fw_log_mode); int cnss_set_pcie_gen_speed(struct device *dev, u8 pcie_gen_speed) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); if (plat_priv->device_id != QCA6490_DEVICE_ID || !plat_priv->fw_pcie_gen_switch) return -ENOTSUPP; if (pcie_gen_speed < QMI_PCIE_GEN_SPEED_1_V01 || pcie_gen_speed > QMI_PCIE_GEN_SPEED_3_V01) return -EINVAL; cnss_pr_dbg("WLAN provided PCIE gen speed: %d\n", pcie_gen_speed); plat_priv->pcie_gen_speed = pcie_gen_speed; return 0; } EXPORT_SYMBOL(cnss_set_pcie_gen_speed); static int cnss_fw_mem_ready_hdlr(struct cnss_plat_data *plat_priv) { int ret = 0; if (!plat_priv) return -ENODEV; set_bit(CNSS_FW_MEM_READY, &plat_priv->driver_state); ret = cnss_wlfw_tgt_cap_send_sync(plat_priv); if (ret) goto out; cnss_wlfw_bdf_dnld_send_sync(plat_priv, CNSS_BDF_REGDB); ret = cnss_wlfw_bdf_dnld_send_sync(plat_priv, plat_priv->ctrl_params.bdf_type); if (ret) goto out; ret = cnss_bus_load_m3(plat_priv); if (ret) goto out; ret = cnss_wlfw_m3_dnld_send_sync(plat_priv); if (ret) goto out; return 0; out: return ret; } static int cnss_request_antenna_sharing(struct cnss_plat_data *plat_priv) { int ret = 0; if (!plat_priv->antenna) { ret = cnss_wlfw_antenna_switch_send_sync(plat_priv); if (ret) goto out; } if (test_bit(CNSS_COEX_CONNECTED, &plat_priv->driver_state)) { ret = coex_antenna_switch_to_wlan_send_sync_msg(plat_priv); if (ret) goto out; } ret = cnss_wlfw_antenna_grant_send_sync(plat_priv); if (ret) goto out; return 0; out: return ret; } static void cnss_release_antenna_sharing(struct cnss_plat_data *plat_priv) { if (test_bit(CNSS_COEX_CONNECTED, &plat_priv->driver_state)) coex_antenna_switch_to_mdm_send_sync_msg(plat_priv); } static int cnss_fw_ready_hdlr(struct cnss_plat_data *plat_priv) { int ret = 0; if (!plat_priv) return -ENODEV; del_timer(&plat_priv->fw_boot_timer); set_bit(CNSS_FW_READY, &plat_priv->driver_state); clear_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state); cnss_wlfw_send_pcie_gen_speed_sync(plat_priv); if (test_bit(CNSS_FW_BOOT_RECOVERY, &plat_priv->driver_state)) { clear_bit(CNSS_FW_BOOT_RECOVERY, &plat_priv->driver_state); clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state); } if (test_bit(ENABLE_WALTEST, &plat_priv->ctrl_params.quirks)) { ret = cnss_wlfw_wlan_mode_send_sync(plat_priv, CNSS_WALTEST); } else if (test_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state)) { cnss_request_antenna_sharing(plat_priv); ret = cnss_wlfw_wlan_mode_send_sync(plat_priv, CNSS_CALIBRATION); } else { ret = cnss_bus_call_driver_probe(plat_priv); } if (ret && test_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state)) goto out; else if (ret) goto shutdown; cnss_vreg_unvote_type(plat_priv, CNSS_VREG_PRIM); return 0; shutdown: cnss_bus_dev_shutdown(plat_priv); clear_bit(CNSS_FW_READY, &plat_priv->driver_state); clear_bit(CNSS_FW_MEM_READY, &plat_priv->driver_state); out: return ret; } static char *cnss_driver_event_to_str(enum cnss_driver_event_type type) { switch (type) { case CNSS_DRIVER_EVENT_SERVER_ARRIVE: return "SERVER_ARRIVE"; case CNSS_DRIVER_EVENT_SERVER_EXIT: return "SERVER_EXIT"; case CNSS_DRIVER_EVENT_REQUEST_MEM: return "REQUEST_MEM"; case CNSS_DRIVER_EVENT_FW_MEM_READY: return "FW_MEM_READY"; case CNSS_DRIVER_EVENT_FW_READY: return "FW_READY"; case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START: return "COLD_BOOT_CAL_START"; case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_DONE: return "COLD_BOOT_CAL_DONE"; case CNSS_DRIVER_EVENT_REGISTER_DRIVER: return "REGISTER_DRIVER"; case CNSS_DRIVER_EVENT_UNREGISTER_DRIVER: return "UNREGISTER_DRIVER"; case CNSS_DRIVER_EVENT_RECOVERY: return "RECOVERY"; case CNSS_DRIVER_EVENT_FORCE_FW_ASSERT: return "FORCE_FW_ASSERT"; case CNSS_DRIVER_EVENT_POWER_UP: return "POWER_UP"; case CNSS_DRIVER_EVENT_POWER_DOWN: return "POWER_DOWN"; case CNSS_DRIVER_EVENT_IDLE_RESTART: return "IDLE_RESTART"; case CNSS_DRIVER_EVENT_IDLE_SHUTDOWN: return "IDLE_SHUTDOWN"; case CNSS_DRIVER_EVENT_QDSS_TRACE_REQ_MEM: return "QDSS_TRACE_REQ_MEM"; case CNSS_DRIVER_EVENT_QDSS_TRACE_SAVE: return "QDSS_TRACE_SAVE"; case CNSS_DRIVER_EVENT_QDSS_TRACE_FREE: return "QDSS_TRACE_FREE"; case CNSS_DRIVER_EVENT_MAX: return "EVENT_MAX"; } return "UNKNOWN"; }; int cnss_driver_event_post(struct cnss_plat_data *plat_priv, enum cnss_driver_event_type type, u32 flags, void *data) { struct cnss_driver_event *event; unsigned long irq_flags; int gfp = GFP_KERNEL; int ret = 0; if (!plat_priv) return -ENODEV; cnss_pr_dbg("Posting event: %s(%d)%s, state: 0x%lx flags: 0x%0x\n", cnss_driver_event_to_str(type), type, flags ? "-sync" : "", plat_priv->driver_state, flags); if (type >= CNSS_DRIVER_EVENT_MAX) { cnss_pr_err("Invalid Event type: %d, can't post", type); return -EINVAL; } if (in_interrupt() || irqs_disabled()) gfp = GFP_ATOMIC; event = kzalloc(sizeof(*event), gfp); if (!event) return -ENOMEM; cnss_pm_stay_awake(plat_priv); event->type = type; event->data = data; init_completion(&event->complete); event->ret = CNSS_EVENT_PENDING; event->sync = !!(flags & CNSS_EVENT_SYNC); spin_lock_irqsave(&plat_priv->event_lock, irq_flags); list_add_tail(&event->list, &plat_priv->event_list); spin_unlock_irqrestore(&plat_priv->event_lock, irq_flags); queue_work(plat_priv->event_wq, &plat_priv->event_work); if (!(flags & CNSS_EVENT_SYNC)) goto out; if (flags & CNSS_EVENT_UNKILLABLE) wait_for_completion(&event->complete); else if (flags & CNSS_EVENT_UNINTERRUPTIBLE) ret = wait_for_completion_killable(&event->complete); else ret = wait_for_completion_interruptible(&event->complete); cnss_pr_dbg("Completed event: %s(%d), state: 0x%lx, ret: %d/%d\n", cnss_driver_event_to_str(type), type, plat_priv->driver_state, ret, event->ret); spin_lock_irqsave(&plat_priv->event_lock, irq_flags); if (ret == -ERESTARTSYS && event->ret == CNSS_EVENT_PENDING) { event->sync = false; spin_unlock_irqrestore(&plat_priv->event_lock, irq_flags); ret = -EINTR; goto out; } spin_unlock_irqrestore(&plat_priv->event_lock, irq_flags); ret = event->ret; kfree(event); out: cnss_pm_relax(plat_priv); return ret; } /** * cnss_get_timeout - Get timeout for corresponding type. * @plat_priv: Pointer to platform driver context. * @cnss_timeout_type: Timeout type. * * Return: Timeout in milliseconds. */ unsigned int cnss_get_timeout(struct cnss_plat_data *plat_priv, enum cnss_timeout_type timeout_type) { unsigned int qmi_timeout = cnss_get_qmi_timeout(plat_priv); switch (timeout_type) { case CNSS_TIMEOUT_QMI: return qmi_timeout; case CNSS_TIMEOUT_POWER_UP: return (qmi_timeout << 2); case CNSS_TIMEOUT_IDLE_RESTART: return ((qmi_timeout << 1) + WLAN_WD_TIMEOUT_MS); case CNSS_TIMEOUT_CALIBRATION: return (qmi_timeout << 2); case CNSS_TIMEOUT_WLAN_WATCHDOG: return ((qmi_timeout << 1) + WLAN_WD_TIMEOUT_MS); case CNSS_TIMEOUT_RDDM: return CNSS_RDDM_TIMEOUT_MS; case CNSS_TIMEOUT_RECOVERY: return RECOVERY_TIMEOUT; default: return qmi_timeout; } } unsigned int cnss_get_boot_timeout(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return 0; } return cnss_get_timeout(plat_priv, CNSS_TIMEOUT_QMI); } EXPORT_SYMBOL(cnss_get_boot_timeout); int cnss_power_up(struct device *dev) { int ret = 0; struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); unsigned int timeout; if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } cnss_pr_dbg("Powering up device\n"); ret = cnss_driver_event_post(plat_priv, CNSS_DRIVER_EVENT_POWER_UP, CNSS_EVENT_SYNC, NULL); if (ret) goto out; if (plat_priv->device_id == QCA6174_DEVICE_ID) goto out; timeout = cnss_get_timeout(plat_priv, CNSS_TIMEOUT_POWER_UP); reinit_completion(&plat_priv->power_up_complete); ret = wait_for_completion_timeout(&plat_priv->power_up_complete, msecs_to_jiffies(timeout)); if (!ret) { cnss_pr_err("Timeout (%ums) waiting for power up to complete\n", timeout); ret = -EAGAIN; goto out; } return 0; out: return ret; } EXPORT_SYMBOL(cnss_power_up); int cnss_power_down(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } cnss_pr_dbg("Powering down device\n"); return cnss_driver_event_post(plat_priv, CNSS_DRIVER_EVENT_POWER_DOWN, CNSS_EVENT_SYNC, NULL); } EXPORT_SYMBOL(cnss_power_down); int cnss_idle_restart(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); unsigned int timeout; int ret = 0; if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } if (!mutex_trylock(&plat_priv->driver_ops_lock)) { cnss_pr_dbg("Another driver operation is in progress, ignore idle restart\n"); return -EBUSY; } cnss_pr_dbg("Doing idle restart\n"); reinit_completion(&plat_priv->power_up_complete); if (test_bit(CNSS_IN_REBOOT, &plat_priv->driver_state)) { cnss_pr_dbg("Reboot or shutdown is in progress, ignore idle restart\n"); ret = -EINVAL; goto out; } ret = cnss_driver_event_post(plat_priv, CNSS_DRIVER_EVENT_IDLE_RESTART, CNSS_EVENT_SYNC_UNINTERRUPTIBLE, NULL); if (ret) goto out; if (plat_priv->device_id == QCA6174_DEVICE_ID) { ret = cnss_bus_call_driver_probe(plat_priv); goto out; } timeout = cnss_get_timeout(plat_priv, CNSS_TIMEOUT_IDLE_RESTART); ret = wait_for_completion_timeout(&plat_priv->power_up_complete, msecs_to_jiffies(timeout)); if (plat_priv->power_up_error) { ret = plat_priv->power_up_error; clear_bit(CNSS_DRIVER_IDLE_RESTART, &plat_priv->driver_state); cnss_pr_dbg("Power up error:%d, exiting\n", plat_priv->power_up_error); goto out; } if (!ret) { cnss_pr_err("Timeout (%ums) waiting for idle restart to complete\n", timeout); ret = -ETIMEDOUT; goto out; } if (test_bit(CNSS_IN_REBOOT, &plat_priv->driver_state)) { cnss_pr_dbg("Reboot or shutdown is in progress, ignore idle restart\n"); del_timer(&plat_priv->fw_boot_timer); ret = -EINVAL; goto out; } mutex_unlock(&plat_priv->driver_ops_lock); return 0; out: mutex_unlock(&plat_priv->driver_ops_lock); return ret; } EXPORT_SYMBOL(cnss_idle_restart); int cnss_idle_shutdown(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); unsigned int timeout; int ret; if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } if (test_bit(CNSS_IN_SUSPEND_RESUME, &plat_priv->driver_state)) { cnss_pr_dbg("System suspend or resume in progress, ignore idle shutdown\n"); return -EAGAIN; } cnss_pr_dbg("Doing idle shutdown\n"); if (!test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state) && !test_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state)) goto skip_wait; reinit_completion(&plat_priv->recovery_complete); timeout = cnss_get_timeout(plat_priv, CNSS_TIMEOUT_RECOVERY); ret = wait_for_completion_timeout(&plat_priv->recovery_complete, msecs_to_jiffies(timeout)); if (!ret) { cnss_pr_err("Timeout (%ums) waiting for recovery to complete\n", timeout); CNSS_ASSERT(0); } skip_wait: return cnss_driver_event_post(plat_priv, CNSS_DRIVER_EVENT_IDLE_SHUTDOWN, CNSS_EVENT_SYNC_UNINTERRUPTIBLE, NULL); } EXPORT_SYMBOL(cnss_idle_shutdown); static int cnss_get_resources(struct cnss_plat_data *plat_priv) { int ret = 0; ret = cnss_get_vreg_type(plat_priv, CNSS_VREG_PRIM); if (ret) { cnss_pr_err("Failed to get vreg, err = %d\n", ret); goto out; } ret = cnss_get_clk(plat_priv); if (ret) { cnss_pr_err("Failed to get clocks, err = %d\n", ret); goto put_vreg; } ret = cnss_get_pinctrl(plat_priv); if (ret) { cnss_pr_err("Failed to get pinctrl, err = %d\n", ret); goto put_clk; } return 0; put_clk: cnss_put_clk(plat_priv); put_vreg: cnss_put_vreg_type(plat_priv, CNSS_VREG_PRIM); out: return ret; } static void cnss_put_resources(struct cnss_plat_data *plat_priv) { cnss_put_clk(plat_priv); cnss_put_vreg_type(plat_priv, CNSS_VREG_PRIM); } #ifdef CONFIG_MSM_SUBSYSTEM_RESTART static int cnss_modem_notifier_nb(struct notifier_block *nb, unsigned long code, void *ss_handle) { struct cnss_plat_data *plat_priv = container_of(nb, struct cnss_plat_data, modem_nb); struct cnss_esoc_info *esoc_info; cnss_pr_dbg("Modem notifier: event %lu\n", code); if (!plat_priv) return NOTIFY_DONE; esoc_info = &plat_priv->esoc_info; if (code == SUBSYS_AFTER_POWERUP) esoc_info->modem_current_status = 1; else if (code == SUBSYS_BEFORE_SHUTDOWN) esoc_info->modem_current_status = 0; else return NOTIFY_DONE; if (!cnss_bus_call_driver_modem_status(plat_priv, esoc_info->modem_current_status)) return NOTIFY_DONE; return NOTIFY_OK; } static int cnss_register_esoc(struct cnss_plat_data *plat_priv) { int ret = 0; struct device *dev; struct cnss_esoc_info *esoc_info; struct esoc_desc *esoc_desc; const char *client_desc; dev = &plat_priv->plat_dev->dev; esoc_info = &plat_priv->esoc_info; esoc_info->notify_modem_status = of_property_read_bool(dev->of_node, "qcom,notify-modem-status"); if (!esoc_info->notify_modem_status) goto out; ret = of_property_read_string_index(dev->of_node, "esoc-names", 0, &client_desc); if (ret) { cnss_pr_dbg("esoc-names is not defined in DT, skip!\n"); } else { esoc_desc = devm_register_esoc_client(dev, client_desc); if (IS_ERR_OR_NULL(esoc_desc)) { ret = PTR_RET(esoc_desc); cnss_pr_err("Failed to register esoc_desc, err = %d\n", ret); goto out; } esoc_info->esoc_desc = esoc_desc; } plat_priv->modem_nb.notifier_call = cnss_modem_notifier_nb; esoc_info->modem_current_status = 0; esoc_info->modem_notify_handler = subsys_notif_register_notifier(esoc_info->esoc_desc ? esoc_info->esoc_desc->name : "modem", &plat_priv->modem_nb); if (IS_ERR(esoc_info->modem_notify_handler)) { ret = PTR_ERR(esoc_info->modem_notify_handler); cnss_pr_err("Failed to register esoc notifier, err = %d\n", ret); goto unreg_esoc; } return 0; unreg_esoc: if (esoc_info->esoc_desc) devm_unregister_esoc_client(dev, esoc_info->esoc_desc); out: return ret; } static void cnss_unregister_esoc(struct cnss_plat_data *plat_priv) { struct device *dev; struct cnss_esoc_info *esoc_info; dev = &plat_priv->plat_dev->dev; esoc_info = &plat_priv->esoc_info; if (esoc_info->notify_modem_status) subsys_notif_unregister_notifier (esoc_info->modem_notify_handler, &plat_priv->modem_nb); if (esoc_info->esoc_desc) devm_unregister_esoc_client(dev, esoc_info->esoc_desc); } static int cnss_subsys_powerup(const struct subsys_desc *subsys_desc) { struct cnss_plat_data *plat_priv; if (!subsys_desc->dev) { cnss_pr_err("dev from subsys_desc is NULL\n"); return -ENODEV; } plat_priv = dev_get_drvdata(subsys_desc->dev); if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } if (!plat_priv->driver_state) { cnss_pr_dbg("Powerup is ignored\n"); return 0; } return cnss_bus_dev_powerup(plat_priv); } static int cnss_subsys_shutdown(const struct subsys_desc *subsys_desc, bool force_stop) { struct cnss_plat_data *plat_priv; if (!subsys_desc->dev) { cnss_pr_err("dev from subsys_desc is NULL\n"); return -ENODEV; } plat_priv = dev_get_drvdata(subsys_desc->dev); if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } if (!plat_priv->driver_state) { cnss_pr_dbg("shutdown is ignored\n"); return 0; } return cnss_bus_dev_shutdown(plat_priv); } void cnss_device_crashed(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); struct cnss_subsys_info *subsys_info; if (!plat_priv) return; subsys_info = &plat_priv->subsys_info; if (subsys_info->subsys_device) { set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state); subsys_set_crash_status(subsys_info->subsys_device, true); subsystem_restart_dev(subsys_info->subsys_device); } } EXPORT_SYMBOL(cnss_device_crashed); static void cnss_subsys_crash_shutdown(const struct subsys_desc *subsys_desc) { struct cnss_plat_data *plat_priv = dev_get_drvdata(subsys_desc->dev); if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return; } cnss_bus_dev_crash_shutdown(plat_priv); } static int cnss_subsys_ramdump(int enable, const struct subsys_desc *subsys_desc) { struct cnss_plat_data *plat_priv = dev_get_drvdata(subsys_desc->dev); if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } if (!enable) return 0; return cnss_bus_dev_ramdump(plat_priv); } static void cnss_recovery_work_handler(struct work_struct *work) { } #else static int cnss_register_esoc(struct cnss_plat_data *plat_priv) { return 0; } static void cnss_unregister_esoc(struct cnss_plat_data *plat_priv) { } static void cnss_recovery_work_handler(struct work_struct *work) { struct cnss_plat_data *plat_priv = container_of(work, struct cnss_plat_data, recovery_work); if (!plat_priv->recovery_enabled) panic("subsys-restart: Resetting the SoC wlan crashed\n"); cnss_bus_dev_shutdown(plat_priv); cnss_bus_dev_ramdump(plat_priv); msleep(RECOVERY_DELAY_MS); cnss_bus_dev_powerup(plat_priv); } void cnss_device_crashed(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); if (!plat_priv) return; set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state); schedule_work(&plat_priv->recovery_work); } EXPORT_SYMBOL(cnss_device_crashed); #endif /* CONFIG_MSM_SUBSYSTEM_RESTART */ void *cnss_get_virt_ramdump_mem(struct device *dev, unsigned long *size) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); struct cnss_ramdump_info *ramdump_info; if (!plat_priv) return NULL; ramdump_info = &plat_priv->ramdump_info; *size = ramdump_info->ramdump_size; return ramdump_info->ramdump_va; } EXPORT_SYMBOL(cnss_get_virt_ramdump_mem); static const char *cnss_recovery_reason_to_str(enum cnss_recovery_reason reason) { switch (reason) { case CNSS_REASON_DEFAULT: return "DEFAULT"; case CNSS_REASON_LINK_DOWN: return "LINK_DOWN"; case CNSS_REASON_RDDM: return "RDDM"; case CNSS_REASON_TIMEOUT: return "TIMEOUT"; } return "UNKNOWN"; }; static int cnss_do_recovery(struct cnss_plat_data *plat_priv, enum cnss_recovery_reason reason) { plat_priv->recovery_count++; if (plat_priv->device_id == QCA6174_DEVICE_ID) goto self_recovery; if (test_bit(SKIP_RECOVERY, &plat_priv->ctrl_params.quirks)) { cnss_pr_dbg("Skip device recovery\n"); return 0; } switch (reason) { case CNSS_REASON_LINK_DOWN: if (!cnss_bus_check_link_status(plat_priv)) { cnss_pr_dbg("Skip link down recovery as link is already up\n"); return 0; } if (test_bit(LINK_DOWN_SELF_RECOVERY, &plat_priv->ctrl_params.quirks)) goto self_recovery; if (!cnss_bus_recover_link_down(plat_priv)) { /* clear recovery bit here to avoid skipping * the recovery work for RDDM later */ clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state); return 0; } break; case CNSS_REASON_RDDM: cnss_bus_collect_dump_info(plat_priv, false); break; case CNSS_REASON_DEFAULT: case CNSS_REASON_TIMEOUT: break; default: cnss_pr_err("Unsupported recovery reason: %s(%d)\n", cnss_recovery_reason_to_str(reason), reason); break; } cnss_bus_device_crashed(plat_priv); return 0; self_recovery: cnss_pr_dbg("Going for self recovery\n"); cnss_bus_dev_shutdown(plat_priv); if (test_bit(LINK_DOWN_SELF_RECOVERY, &plat_priv->ctrl_params.quirks)) clear_bit(LINK_DOWN_SELF_RECOVERY, &plat_priv->ctrl_params.quirks); cnss_bus_dev_powerup(plat_priv); #ifdef CONFIG_OPLUS_KEVENT_UPLOAD //Add for: pcie self recovery statistics cnss_stats_self_recovery(); #endif /* CONFIG_OPLUS_KEVENT_UPLOAD */ return 0; } static int cnss_driver_recovery_hdlr(struct cnss_plat_data *plat_priv, void *data) { struct cnss_recovery_data *recovery_data = data; int ret = 0; cnss_pr_dbg("Driver recovery is triggered with reason: %s(%d)\n", cnss_recovery_reason_to_str(recovery_data->reason), recovery_data->reason); if (!plat_priv->driver_state) { cnss_pr_err("Improper driver state, ignore recovery\n"); ret = -EINVAL; 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"); CNSS_ASSERT(0); ret = -EINVAL; goto out; } if (test_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state) || test_bit(CNSS_DRIVER_IDLE_SHUTDOWN, &plat_priv->driver_state)) { cnss_pr_err("Driver unload or idle shutdown is in progress, ignore recovery\n"); ret = -EINVAL; goto out; } switch (plat_priv->device_id) { case QCA6174_DEVICE_ID: if (test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state) || test_bit(CNSS_DRIVER_IDLE_RESTART, &plat_priv->driver_state)) { cnss_pr_err("Driver load or idle restart is in progress, ignore recovery\n"); ret = -EINVAL; goto out; } break; default: if (!test_bit(CNSS_FW_READY, &plat_priv->driver_state)) { set_bit(CNSS_FW_BOOT_RECOVERY, &plat_priv->driver_state); } break; } set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state); ret = cnss_do_recovery(plat_priv, recovery_data->reason); out: kfree(data); return ret; } int cnss_self_recovery(struct device *dev, enum cnss_recovery_reason reason) { cnss_schedule_recovery(dev, reason); return 0; } EXPORT_SYMBOL(cnss_self_recovery); void cnss_schedule_recovery(struct device *dev, enum cnss_recovery_reason reason) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); struct cnss_recovery_data *data; int gfp = GFP_KERNEL; if (!test_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state) && test_bit(CNSS_QMI_WLFW_CONNECTED, &plat_priv->driver_state)) cnss_bus_update_status(plat_priv, CNSS_FW_DOWN); if (test_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state) || test_bit(CNSS_DRIVER_IDLE_SHUTDOWN, &plat_priv->driver_state)) { cnss_pr_dbg("Driver unload or idle shutdown is in progress, ignore schedule recovery\n"); return; } if (in_interrupt() || irqs_disabled()) gfp = GFP_ATOMIC; data = kzalloc(sizeof(*data), gfp); if (!data) return; data->reason = reason; cnss_driver_event_post(plat_priv, CNSS_DRIVER_EVENT_RECOVERY, 0, data); } EXPORT_SYMBOL(cnss_schedule_recovery); int cnss_force_fw_assert_async(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } if (plat_priv->device_id == QCA6174_DEVICE_ID) { cnss_pr_info("Forced FW assert is not supported\n"); return -EOPNOTSUPP; } if (cnss_bus_is_device_down(plat_priv)) { cnss_pr_info("Device is already in bad state, ignore force assert\n"); return 0; } if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) { cnss_pr_info("Recovery is already in progress, ignore forced FW assert\n"); return 0; } cnss_pr_info("Force assert (async)\n"); cnss_driver_event_post(plat_priv, CNSS_DRIVER_EVENT_FORCE_FW_ASSERT, 0, NULL); return 0; } EXPORT_SYMBOL(cnss_force_fw_assert_async); int cnss_force_fw_assert(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); bool post = (in_interrupt() || irqs_disabled()); if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } if (plat_priv->device_id == QCA6174_DEVICE_ID) { cnss_pr_info("Forced FW assert is not supported\n"); return -EOPNOTSUPP; } if (cnss_bus_is_device_down(plat_priv)) { cnss_pr_info("Device is already in bad state, ignore force assert\n"); return 0; } if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) { cnss_pr_info("Recovery is already in progress, ignore forced FW assert\n"); return 0; } cnss_pr_info("Force assert (%s)\n", post ? "async" : "sync"); if (post) cnss_driver_event_post(plat_priv, CNSS_DRIVER_EVENT_FORCE_FW_ASSERT, 0, NULL); else cnss_bus_force_fw_assert_hdlr(plat_priv); return 0; } EXPORT_SYMBOL(cnss_force_fw_assert); int cnss_force_collect_rddm(struct device *dev) { struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev); unsigned int timeout; int ret = 0; if (!plat_priv) { cnss_pr_err("plat_priv is NULL\n"); return -ENODEV; } if (plat_priv->device_id == QCA6174_DEVICE_ID) { cnss_pr_info("Force collect rddm is not supported\n"); return -EOPNOTSUPP; } if (cnss_bus_is_device_down(plat_priv)) { cnss_pr_info("Device is already in bad state, ignore force collect rddm\n"); return 0; } if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) { cnss_pr_info("Recovery is already in progress, ignore forced collect rddm\n"); return 0; } if (test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state) || test_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state) || test_bit(CNSS_DRIVER_IDLE_RESTART, &plat_priv->driver_state) || test_bit(CNSS_DRIVER_IDLE_SHUTDOWN, &plat_priv->driver_state)) { cnss_pr_info("Loading/Unloading/idle restart/shutdown is in progress, ignore forced collect rddm\n"); return 0; } ret = cnss_bus_force_fw_assert_hdlr(plat_priv); if (ret) return ret; reinit_completion(&plat_priv->rddm_complete); timeout = cnss_get_timeout(plat_priv, CNSS_TIMEOUT_RDDM); ret = wait_for_completion_timeout(&plat_priv->rddm_complete, msecs_to_jiffies(timeout)); if (!ret) { cnss_pr_err("Timeout (%ums) waiting for RDDM to complete\n", timeout); ret = -ETIMEDOUT; } return ret; } 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; if (test_bit(CNSS_FW_READY, &plat_priv->driver_state) || test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state) || test_bit(CNSS_DRIVER_PROBED, &plat_priv->driver_state)) { cnss_pr_dbg("Device is already active, ignore calibration\n"); goto out; } set_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state); reinit_completion(&plat_priv->cal_complete); ret = cnss_bus_dev_powerup(plat_priv); if (ret) { complete(&plat_priv->cal_complete); clear_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state); } out: return ret; } static int cnss_cold_boot_cal_done_hdlr(struct cnss_plat_data *plat_priv, void *data) { struct cnss_cal_info *cal_info = data; if (!test_bit(CNSS_COLD_BOOT_CAL, &plat_priv->driver_state)) goto out; switch (cal_info->cal_status) { case CNSS_CAL_DONE: cnss_pr_dbg("Calibration completed successfully\n"); plat_priv->cal_done = true; break; case CNSS_CAL_TIMEOUT: cnss_pr_dbg("Calibration timed out, force shutdown\n"); break; default: cnss_pr_err("Unknown calibration status: %u\n", cal_info->cal_status); break; } 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); out: kfree(data); return 0; } static int cnss_power_up_hdlr(struct cnss_plat_data *plat_priv) { int ret; ret = cnss_bus_dev_powerup(plat_priv); if (ret) clear_bit(CNSS_DRIVER_IDLE_RESTART, &plat_priv->driver_state); return ret; } static int cnss_power_down_hdlr(struct cnss_plat_data *plat_priv) { cnss_bus_dev_shutdown(plat_priv); return 0; } static int cnss_qdss_trace_req_mem_hdlr(struct cnss_plat_data *plat_priv) { int ret = 0; ret = cnss_bus_alloc_qdss_mem(plat_priv); if (ret < 0) return ret; return cnss_wlfw_qdss_trace_mem_info_send_sync(plat_priv); } static void *cnss_qdss_trace_pa_to_va(struct cnss_plat_data *plat_priv, u64 pa, u32 size, int *seg_id) { int i = 0; struct cnss_fw_mem *qdss_mem = plat_priv->qdss_mem; u64 offset = 0; void *va = NULL; u64 local_pa; u32 local_size; for (i = 0; i < plat_priv->qdss_mem_seg_len; i++) { local_pa = (u64)qdss_mem[i].pa; local_size = (u32)qdss_mem[i].size; if (pa == local_pa && size <= local_size) { va = qdss_mem[i].va; break; } if (pa > local_pa && pa < local_pa + local_size && pa + size <= local_pa + local_size) { offset = pa - local_pa; va = qdss_mem[i].va + offset; break; } } *seg_id = i; return va; } static int cnss_qdss_trace_save_hdlr(struct cnss_plat_data *plat_priv, void *data) { struct cnss_qmi_event_qdss_trace_save_data *event_data = data; struct cnss_fw_mem *qdss_mem = plat_priv->qdss_mem; int ret = 0; int i; void *va = NULL; u64 pa; u32 size; int seg_id = 0; if (!plat_priv->qdss_mem_seg_len) { cnss_pr_err("Memory for QDSS trace is not available\n"); return -ENOMEM; } if (event_data->mem_seg_len == 0) { for (i = 0; i < plat_priv->qdss_mem_seg_len; i++) { ret = cnss_genl_send_msg(qdss_mem[i].va, CNSS_GENL_MSG_TYPE_QDSS, event_data->file_name, qdss_mem[i].size); if (ret < 0) { cnss_pr_err("Fail to save QDSS data: %d\n", ret); break; } } } else { for (i = 0; i < event_data->mem_seg_len; i++) { pa = event_data->mem_seg[i].addr; size = event_data->mem_seg[i].size; va = cnss_qdss_trace_pa_to_va(plat_priv, pa, size, &seg_id); if (!va) { cnss_pr_err("Fail to find matching va for pa %pa\n", &pa); ret = -EINVAL; break; } ret = cnss_genl_send_msg(va, CNSS_GENL_MSG_TYPE_QDSS, event_data->file_name, size); if (ret < 0) { cnss_pr_err("Fail to save QDSS data: %d\n", ret); break; } } } kfree(data); return ret; } static int cnss_qdss_trace_free_hdlr(struct cnss_plat_data *plat_priv) { cnss_bus_free_qdss_mem(plat_priv); return 0; } static void cnss_driver_event_work(struct work_struct *work) { struct cnss_plat_data *plat_priv = container_of(work, struct cnss_plat_data, event_work); struct cnss_driver_event *event; unsigned long flags; int ret = 0; if (!plat_priv) { cnss_pr_err("plat_priv is NULL!\n"); return; } cnss_pm_stay_awake(plat_priv); spin_lock_irqsave(&plat_priv->event_lock, flags); while (!list_empty(&plat_priv->event_list)) { event = list_first_entry(&plat_priv->event_list, struct cnss_driver_event, list); list_del(&event->list); spin_unlock_irqrestore(&plat_priv->event_lock, flags); cnss_pr_dbg("Processing driver event: %s%s(%d), state: 0x%lx\n", cnss_driver_event_to_str(event->type), event->sync ? "-sync" : "", event->type, plat_priv->driver_state); switch (event->type) { case CNSS_DRIVER_EVENT_SERVER_ARRIVE: ret = cnss_wlfw_server_arrive(plat_priv, event->data); break; case CNSS_DRIVER_EVENT_SERVER_EXIT: ret = cnss_wlfw_server_exit(plat_priv); break; case CNSS_DRIVER_EVENT_REQUEST_MEM: ret = cnss_bus_alloc_fw_mem(plat_priv); if (ret) break; ret = cnss_wlfw_respond_mem_send_sync(plat_priv); break; case CNSS_DRIVER_EVENT_FW_MEM_READY: ret = cnss_fw_mem_ready_hdlr(plat_priv); break; case CNSS_DRIVER_EVENT_FW_READY: ret = cnss_fw_ready_hdlr(plat_priv); break; case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START: ret = cnss_cold_boot_cal_start_hdlr(plat_priv); break; case CNSS_DRIVER_EVENT_COLD_BOOT_CAL_DONE: ret = cnss_cold_boot_cal_done_hdlr(plat_priv, event->data); break; case CNSS_DRIVER_EVENT_REGISTER_DRIVER: ret = cnss_bus_register_driver_hdlr(plat_priv, event->data); break; case CNSS_DRIVER_EVENT_UNREGISTER_DRIVER: ret = cnss_bus_unregister_driver_hdlr(plat_priv); break; case CNSS_DRIVER_EVENT_RECOVERY: ret = cnss_driver_recovery_hdlr(plat_priv, event->data); break; case CNSS_DRIVER_EVENT_FORCE_FW_ASSERT: ret = cnss_bus_force_fw_assert_hdlr(plat_priv); break; case CNSS_DRIVER_EVENT_IDLE_RESTART: set_bit(CNSS_DRIVER_IDLE_RESTART, &plat_priv->driver_state); /* fall through */ case CNSS_DRIVER_EVENT_POWER_UP: ret = cnss_power_up_hdlr(plat_priv); break; case CNSS_DRIVER_EVENT_IDLE_SHUTDOWN: set_bit(CNSS_DRIVER_IDLE_SHUTDOWN, &plat_priv->driver_state); /* fall through */ case CNSS_DRIVER_EVENT_POWER_DOWN: ret = cnss_power_down_hdlr(plat_priv); break; case CNSS_DRIVER_EVENT_QDSS_TRACE_REQ_MEM: ret = cnss_qdss_trace_req_mem_hdlr(plat_priv); break; case CNSS_DRIVER_EVENT_QDSS_TRACE_SAVE: ret = cnss_qdss_trace_save_hdlr(plat_priv, event->data); break; case CNSS_DRIVER_EVENT_QDSS_TRACE_FREE: ret = cnss_qdss_trace_free_hdlr(plat_priv); break; default: cnss_pr_err("Invalid driver event type: %d", event->type); kfree(event); spin_lock_irqsave(&plat_priv->event_lock, flags); continue; } spin_lock_irqsave(&plat_priv->event_lock, flags); if (event->sync) { event->ret = ret; complete(&event->complete); continue; } spin_unlock_irqrestore(&plat_priv->event_lock, flags); kfree(event); spin_lock_irqsave(&plat_priv->event_lock, flags); } spin_unlock_irqrestore(&plat_priv->event_lock, flags); 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; } #ifdef CONFIG_MSM_SUBSYSTEM_RESTART int cnss_register_subsys(struct cnss_plat_data *plat_priv) { int ret = 0; struct cnss_subsys_info *subsys_info; subsys_info = &plat_priv->subsys_info; subsys_info->subsys_desc.name = "wlan"; subsys_info->subsys_desc.owner = THIS_MODULE; subsys_info->subsys_desc.powerup = cnss_subsys_powerup; subsys_info->subsys_desc.shutdown = cnss_subsys_shutdown; subsys_info->subsys_desc.ramdump = cnss_subsys_ramdump; subsys_info->subsys_desc.crash_shutdown = cnss_subsys_crash_shutdown; subsys_info->subsys_desc.dev = &plat_priv->plat_dev->dev; subsys_info->subsys_device = subsys_register(&subsys_info->subsys_desc); if (IS_ERR(subsys_info->subsys_device)) { ret = PTR_ERR(subsys_info->subsys_device); cnss_pr_err("Failed to register subsys, err = %d\n", ret); goto out; } subsys_info->subsys_handle = subsystem_get(subsys_info->subsys_desc.name); if (!subsys_info->subsys_handle) { cnss_pr_err("Failed to get subsys_handle!\n"); ret = -EINVAL; goto unregister_subsys; } else if (IS_ERR(subsys_info->subsys_handle)) { ret = PTR_ERR(subsys_info->subsys_handle); cnss_pr_err("Failed to do subsystem_get, err = %d\n", ret); goto unregister_subsys; } return 0; unregister_subsys: subsys_unregister(subsys_info->subsys_device); out: return ret; } void cnss_unregister_subsys(struct cnss_plat_data *plat_priv) { struct cnss_subsys_info *subsys_info; subsys_info = &plat_priv->subsys_info; subsystem_put(subsys_info->subsys_handle); subsys_unregister(subsys_info->subsys_device); } static void *cnss_create_ramdump_device(struct cnss_plat_data *plat_priv) { struct cnss_subsys_info *subsys_info = &plat_priv->subsys_info; return create_ramdump_device(subsys_info->subsys_desc.name, subsys_info->subsys_desc.dev); } static void cnss_destroy_ramdump_device(struct cnss_plat_data *plat_priv, void *ramdump_dev) { destroy_ramdump_device(ramdump_dev); } int cnss_do_ramdump(struct cnss_plat_data *plat_priv) { struct cnss_ramdump_info *ramdump_info = &plat_priv->ramdump_info; struct ramdump_segment segment; memset(&segment, 0, sizeof(segment)); segment.v_address = ramdump_info->ramdump_va; segment.size = ramdump_info->ramdump_size; return do_ramdump(ramdump_info->ramdump_dev, &segment, 1); } int cnss_do_elf_ramdump(struct cnss_plat_data *plat_priv) { struct cnss_ramdump_info_v2 *info_v2 = &plat_priv->ramdump_info_v2; struct cnss_dump_data *dump_data = &info_v2->dump_data; struct cnss_dump_seg *dump_seg = info_v2->dump_data_vaddr; struct ramdump_segment *ramdump_segs, *s; struct cnss_dump_meta_info meta_info = {0}; int i, ret = 0; ramdump_segs = kcalloc(dump_data->nentries + 1, sizeof(*ramdump_segs), GFP_KERNEL); if (!ramdump_segs) return -ENOMEM; s = ramdump_segs + 1; for (i = 0; i < dump_data->nentries; i++) { if (dump_seg->type >= CNSS_FW_DUMP_TYPE_MAX) { cnss_pr_err("Unsupported dump type: %d", dump_seg->type); continue; } if (meta_info.entry[dump_seg->type].entry_start == 0) { meta_info.entry[dump_seg->type].type = dump_seg->type; meta_info.entry[dump_seg->type].entry_start = i + 1; } meta_info.entry[dump_seg->type].entry_num++; s->address = dump_seg->address; s->v_address = dump_seg->v_address; s->size = dump_seg->size; s++; dump_seg++; } meta_info.magic = CNSS_RAMDUMP_MAGIC; meta_info.version = CNSS_RAMDUMP_VERSION; meta_info.chipset = plat_priv->device_id; meta_info.total_entries = CNSS_FW_DUMP_TYPE_MAX; ramdump_segs->v_address = &meta_info; ramdump_segs->size = sizeof(meta_info); ret = do_elf_ramdump(info_v2->ramdump_dev, ramdump_segs, dump_data->nentries + 1); kfree(ramdump_segs); return ret; } #else static int cnss_panic_handler(struct notifier_block *nb, unsigned long action, void *data) { struct cnss_plat_data *plat_priv = container_of(nb, struct cnss_plat_data, panic_nb); cnss_bus_dev_crash_shutdown(plat_priv); return NOTIFY_DONE; } int cnss_register_subsys(struct cnss_plat_data *plat_priv) { int ret; if (!plat_priv) return -ENODEV; plat_priv->panic_nb.notifier_call = cnss_panic_handler; ret = atomic_notifier_chain_register(&panic_notifier_list, &plat_priv->panic_nb); if (ret) { cnss_pr_err("Failed to register panic handler\n"); return -EINVAL; } return 0; } void cnss_unregister_subsys(struct cnss_plat_data *plat_priv) { int ret; ret = atomic_notifier_chain_unregister(&panic_notifier_list, &plat_priv->panic_nb); if (ret) cnss_pr_err("Failed to unregister panic handler\n"); } static void *cnss_create_ramdump_device(struct cnss_plat_data *plat_priv) { return &plat_priv->plat_dev->dev; } static void cnss_destroy_ramdump_device(struct cnss_plat_data *plat_priv, void *ramdump_dev) { } #ifdef CONFIG_SUBSYSTEM_RAMDUMP int cnss_do_ramdump(struct cnss_plat_data *plat_priv) { struct cnss_ramdump_info *ramdump_info = &plat_priv->ramdump_info; struct qcom_dump_segment segment; struct list_head head; INIT_LIST_HEAD(&head); memset(&segment, 0, sizeof(segment)); segment.va = ramdump_info->ramdump_va; segment.size = ramdump_info->ramdump_size; list_add(&segment.node, &head); return do_dump(&head, ramdump_info->ramdump_dev); } int cnss_do_elf_ramdump(struct cnss_plat_data *plat_priv) { struct cnss_ramdump_info_v2 *info_v2 = &plat_priv->ramdump_info_v2; struct cnss_dump_data *dump_data = &info_v2->dump_data; struct cnss_dump_seg *dump_seg = info_v2->dump_data_vaddr; struct qcom_dump_segment *seg; struct cnss_dump_meta_info meta_info = {0}; struct list_head head; int i, ret = 0; INIT_LIST_HEAD(&head); for (i = 0; i < dump_data->nentries; i++) { if (dump_seg->type >= CNSS_FW_DUMP_TYPE_MAX) { cnss_pr_err("Unsupported dump type: %d", dump_seg->type); continue; } if (meta_info.entry[dump_seg->type].entry_start == 0) { meta_info.entry[dump_seg->type].type = dump_seg->type; meta_info.entry[dump_seg->type].entry_start = i + 1; } meta_info.entry[dump_seg->type].entry_num++; seg = kcalloc(1, sizeof(*seg), GFP_KERNEL); seg->da = dump_seg->address; seg->va = dump_seg->v_address; seg->size = dump_seg->size; list_add_tail(&seg->node, &head); dump_seg++; } meta_info.magic = CNSS_RAMDUMP_MAGIC; meta_info.version = CNSS_RAMDUMP_VERSION; meta_info.chipset = plat_priv->device_id; meta_info.total_entries = CNSS_FW_DUMP_TYPE_MAX; seg = kcalloc(1, sizeof(*seg), GFP_KERNEL); seg->va = &meta_info; seg->size = sizeof(meta_info); list_add(&seg->node, &head); ret = do_elf_dump(&head, info_v2->ramdump_dev); while (!list_empty(&head)) { seg = list_first_entry(&head, struct qcom_dump_segment, node); list_del(&seg->node); kfree(seg); } return ret; } #else int cnss_do_ramdump(struct cnss_plat_data *plat_priv) { return 0; } int cnss_do_elf_ramdump(struct cnss_plat_data *plat_priv) { return 0; } #endif /* CONFIG_SUBSYSTEM_RAMDUMP */ #endif /* CONFIG_MSM_SUBSYSTEM_RESTART */ static int cnss_init_dump_entry(struct cnss_plat_data *plat_priv) { struct cnss_ramdump_info *ramdump_info; struct msm_dump_entry dump_entry; ramdump_info = &plat_priv->ramdump_info; ramdump_info->dump_data.addr = ramdump_info->ramdump_pa; ramdump_info->dump_data.len = ramdump_info->ramdump_size; ramdump_info->dump_data.version = CNSS_DUMP_FORMAT_VER; ramdump_info->dump_data.magic = CNSS_DUMP_MAGIC_VER_V2; strlcpy(ramdump_info->dump_data.name, CNSS_DUMP_NAME, sizeof(ramdump_info->dump_data.name)); dump_entry.id = MSM_DUMP_DATA_CNSS_WLAN; dump_entry.addr = virt_to_phys(&ramdump_info->dump_data); return msm_dump_data_register_nominidump(MSM_DUMP_TABLE_APPS, &dump_entry); } static int cnss_register_ramdump_v1(struct cnss_plat_data *plat_priv) { int ret = 0; struct device *dev; struct cnss_ramdump_info *ramdump_info; u32 ramdump_size = 0; dev = &plat_priv->plat_dev->dev; ramdump_info = &plat_priv->ramdump_info; if (of_property_read_u32(dev->of_node, "qcom,wlan-ramdump-dynamic", &ramdump_size) == 0) { ramdump_info->ramdump_va = dma_alloc_coherent(dev, ramdump_size, &ramdump_info->ramdump_pa, GFP_KERNEL); if (ramdump_info->ramdump_va) ramdump_info->ramdump_size = ramdump_size; } cnss_pr_dbg("ramdump va: %pK, pa: %pa\n", ramdump_info->ramdump_va, &ramdump_info->ramdump_pa); if (ramdump_info->ramdump_size == 0) { cnss_pr_info("Ramdump will not be collected"); goto out; } ret = cnss_init_dump_entry(plat_priv); if (ret) { cnss_pr_err("Failed to setup dump table, err = %d\n", ret); goto free_ramdump; } ramdump_info->ramdump_dev = cnss_create_ramdump_device(plat_priv); if (!ramdump_info->ramdump_dev) { cnss_pr_err("Failed to create ramdump device!"); ret = -ENOMEM; goto free_ramdump; } return 0; free_ramdump: dma_free_coherent(dev, ramdump_info->ramdump_size, ramdump_info->ramdump_va, ramdump_info->ramdump_pa); out: return ret; } static void cnss_unregister_ramdump_v1(struct cnss_plat_data *plat_priv) { struct device *dev; struct cnss_ramdump_info *ramdump_info; dev = &plat_priv->plat_dev->dev; ramdump_info = &plat_priv->ramdump_info; if (ramdump_info->ramdump_dev) cnss_destroy_ramdump_device(plat_priv, ramdump_info->ramdump_dev); if (ramdump_info->ramdump_va) dma_free_coherent(dev, ramdump_info->ramdump_size, ramdump_info->ramdump_va, ramdump_info->ramdump_pa); } static int cnss_register_ramdump_v2(struct cnss_plat_data *plat_priv) { int ret = 0; struct cnss_ramdump_info_v2 *info_v2; struct cnss_dump_data *dump_data; struct msm_dump_entry dump_entry; struct device *dev = &plat_priv->plat_dev->dev; u32 ramdump_size = 0; info_v2 = &plat_priv->ramdump_info_v2; dump_data = &info_v2->dump_data; if (of_property_read_u32(dev->of_node, "qcom,wlan-ramdump-dynamic", &ramdump_size) == 0) info_v2->ramdump_size = ramdump_size; cnss_pr_dbg("Ramdump size 0x%lx\n", info_v2->ramdump_size); info_v2->dump_data_vaddr = kzalloc(CNSS_DUMP_DESC_SIZE, GFP_KERNEL); if (!info_v2->dump_data_vaddr) return -ENOMEM; dump_data->paddr = virt_to_phys(info_v2->dump_data_vaddr); dump_data->version = CNSS_DUMP_FORMAT_VER_V2; dump_data->magic = CNSS_DUMP_MAGIC_VER_V2; dump_data->seg_version = CNSS_DUMP_SEG_VER; strlcpy(dump_data->name, CNSS_DUMP_NAME, sizeof(dump_data->name)); dump_entry.id = MSM_DUMP_DATA_CNSS_WLAN; dump_entry.addr = virt_to_phys(dump_data); ret = msm_dump_data_register_nominidump(MSM_DUMP_TABLE_APPS, &dump_entry); if (ret) { cnss_pr_err("Failed to setup dump table, err = %d\n", ret); goto free_ramdump; } info_v2->ramdump_dev = cnss_create_ramdump_device(plat_priv); if (!info_v2->ramdump_dev) { cnss_pr_err("Failed to create ramdump device!\n"); ret = -ENOMEM; goto free_ramdump; } return 0; free_ramdump: kfree(info_v2->dump_data_vaddr); info_v2->dump_data_vaddr = NULL; return ret; } static void cnss_unregister_ramdump_v2(struct cnss_plat_data *plat_priv) { struct cnss_ramdump_info_v2 *info_v2; info_v2 = &plat_priv->ramdump_info_v2; if (info_v2->ramdump_dev) cnss_destroy_ramdump_device(plat_priv, info_v2->ramdump_dev); kfree(info_v2->dump_data_vaddr); info_v2->dump_data_vaddr = NULL; info_v2->dump_data_valid = false; } int cnss_register_ramdump(struct cnss_plat_data *plat_priv) { int ret = 0; switch (plat_priv->device_id) { case QCA6174_DEVICE_ID: ret = cnss_register_ramdump_v1(plat_priv); break; case QCA6290_DEVICE_ID: case QCA6390_DEVICE_ID: case QCA6490_DEVICE_ID: ret = cnss_register_ramdump_v2(plat_priv); break; default: cnss_pr_err("Unknown device ID: 0x%lx\n", plat_priv->device_id); ret = -ENODEV; break; } return ret; } void cnss_unregister_ramdump(struct cnss_plat_data *plat_priv) { switch (plat_priv->device_id) { case QCA6174_DEVICE_ID: cnss_unregister_ramdump_v1(plat_priv); break; case QCA6290_DEVICE_ID: case QCA6390_DEVICE_ID: case QCA6490_DEVICE_ID: cnss_unregister_ramdump_v2(plat_priv); break; default: cnss_pr_err("Unknown device ID: 0x%lx\n", plat_priv->device_id); break; } } 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 < 0) 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; struct cnss_bus_bw_info *bus_bw_info; bus_bw_info = &plat_priv->bus_bw_info; bus_bw_info->bus_scale_table = msm_bus_cl_get_pdata(plat_priv->plat_dev); if (bus_bw_info->bus_scale_table) { bus_bw_info->bus_client = msm_bus_scale_register_client (bus_bw_info->bus_scale_table); if (!bus_bw_info->bus_client) { cnss_pr_err("Failed to register bus scale client!\n"); ret = -EINVAL; goto out; } } return 0; out: return ret; } static void cnss_unregister_bus_scale(struct cnss_plat_data *plat_priv) { struct cnss_bus_bw_info *bus_bw_info; bus_bw_info = &plat_priv->bus_bw_info; if (bus_bw_info->bus_client) msm_bus_scale_unregister_client(bus_bw_info->bus_client); } static ssize_t qtime_sync_period_show(struct device *dev, struct device_attribute *attr, char *buf) { struct cnss_plat_data *plat_priv = dev_get_drvdata(dev); return scnprintf(buf, PAGE_SIZE, "%u\n", plat_priv->ctrl_params.time_sync_period); } static ssize_t qtime_sync_period_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned int qtime_sync_period = 0; if (sscanf(buf, "%du", &qtime_sync_period) != 1) { cnss_pr_err("Invalid qtime sync sysfs command\n"); return -EINVAL; } if (qtime_sync_period >= CNSS_MIN_TIME_SYNC_PERIOD) cnss_pci_update_qtime_sync_period(dev, qtime_sync_period); return count; } static ssize_t recovery_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct cnss_plat_data *plat_priv = dev_get_drvdata(dev); unsigned int recovery = 0; if (!plat_priv) return -ENODEV; if (sscanf(buf, "%du", &recovery) != 1) { cnss_pr_err("Invalid recovery sysfs command\n"); return -EINVAL; } if (recovery) plat_priv->recovery_enabled = true; else plat_priv->recovery_enabled = false; cnss_pr_dbg("%s WLAN recovery, count is %zu\n", plat_priv->recovery_enabled ? "Enable" : "Disable", count); return count; } static ssize_t shutdown_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct cnss_plat_data *plat_priv = dev_get_drvdata(dev); if (plat_priv) { set_bit(CNSS_IN_REBOOT, &plat_priv->driver_state); del_timer(&plat_priv->fw_boot_timer); complete_all(&plat_priv->power_up_complete); complete_all(&plat_priv->cal_complete); } cnss_pr_dbg("Received shutdown notification\n"); return count; } static ssize_t fs_ready_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int fs_ready = 0; struct cnss_plat_data *plat_priv = dev_get_drvdata(dev); if (sscanf(buf, "%du", &fs_ready) != 1) return -EINVAL; cnss_pr_dbg("File system is ready, fs_ready is %d, count is %zu\n", fs_ready, count); if (!plat_priv) { cnss_pr_err("plat_priv is NULL!\n"); return count; } if (test_bit(QMI_BYPASS, &plat_priv->ctrl_params.quirks)) { cnss_pr_dbg("QMI is bypassed.\n"); return count; } switch (plat_priv->device_id) { case QCA6290_DEVICE_ID: case QCA6390_DEVICE_ID: case QCA6490_DEVICE_ID: break; default: cnss_pr_err("Not supported for device ID 0x%lx\n", plat_priv->device_id); return count; } if (fs_ready == FILE_SYSTEM_READY) { cnss_driver_event_post(plat_priv, CNSS_DRIVER_EVENT_COLD_BOOT_CAL_START, 0, NULL); } return count; } static DEVICE_ATTR_WO(fs_ready); static DEVICE_ATTR_WO(shutdown); static DEVICE_ATTR_WO(recovery); static DEVICE_ATTR_RW(qtime_sync_period); static struct attribute *cnss_attrs[] = { &dev_attr_fs_ready.attr, &dev_attr_shutdown.attr, &dev_attr_recovery.attr, &dev_attr_qtime_sync_period.attr, NULL, }; static struct attribute_group cnss_attr_group = { .attrs = cnss_attrs, }; static int cnss_create_sysfs_link(struct cnss_plat_data *plat_priv) { struct device *dev = &plat_priv->plat_dev->dev; int ret; ret = sysfs_create_link(kernel_kobj, &dev->kobj, "cnss"); if (ret) { cnss_pr_err("Failed to create cnss link, err = %d\n", ret); goto out; } /* This is only for backward compatibility. */ ret = sysfs_create_link(kernel_kobj, &dev->kobj, "shutdown_wlan"); if (ret) { cnss_pr_err("Failed to create shutdown_wlan link, err = %d\n", ret); goto rm_cnss_link; } return 0; rm_cnss_link: sysfs_remove_link(kernel_kobj, "cnss"); out: return ret; } static void cnss_remove_sysfs_link(struct cnss_plat_data *plat_priv) { sysfs_remove_link(kernel_kobj, "shutdown_wlan"); sysfs_remove_link(kernel_kobj, "cnss"); } static int cnss_create_sysfs(struct cnss_plat_data *plat_priv) { int ret = 0; ret = devm_device_add_group(&plat_priv->plat_dev->dev, &cnss_attr_group); if (ret) { cnss_pr_err("Failed to create cnss device group, err = %d\n", ret); goto out; } cnss_create_sysfs_link(plat_priv); return 0; out: return ret; } static void cnss_remove_sysfs(struct cnss_plat_data *plat_priv) { cnss_remove_sysfs_link(plat_priv); devm_device_remove_group(&plat_priv->plat_dev->dev, &cnss_attr_group); } static int cnss_event_work_init(struct cnss_plat_data *plat_priv) { spin_lock_init(&plat_priv->event_lock); plat_priv->event_wq = alloc_workqueue("cnss_driver_event", WQ_UNBOUND, 1); if (!plat_priv->event_wq) { cnss_pr_err("Failed to create event workqueue!\n"); return -EFAULT; } INIT_WORK(&plat_priv->event_work, cnss_driver_event_work); INIT_LIST_HEAD(&plat_priv->event_list); return 0; } 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); del_timer(&plat_priv->fw_boot_timer); complete_all(&plat_priv->power_up_complete); complete_all(&plat_priv->cal_complete); 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; timer_setup(&plat_priv->fw_boot_timer, cnss_bus_fw_boot_timeout_hdlr, 0); 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) cnss_pr_err("Failed to init platform device wakeup source, err = %d\n", ret); INIT_WORK(&plat_priv->recovery_work, cnss_recovery_work_handler); init_completion(&plat_priv->power_up_complete); init_completion(&plat_priv->cal_complete); init_completion(&plat_priv->rddm_complete); init_completion(&plat_priv->recovery_complete); mutex_init(&plat_priv->dev_lock); mutex_init(&plat_priv->driver_ops_lock); return 0; } static void cnss_misc_deinit(struct cnss_plat_data *plat_priv) { complete_all(&plat_priv->recovery_complete); complete_all(&plat_priv->rddm_complete); 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); } static void cnss_init_control_params(struct cnss_plat_data *plat_priv) { plat_priv->ctrl_params.quirks = CNSS_QUIRKS_DEFAULT; if (of_property_read_bool(plat_priv->plat_dev->dev.of_node, "cnss-daemon-support")) plat_priv->ctrl_params.quirks |= BIT(ENABLE_DAEMON_SUPPORT); if (of_property_read_bool(plat_priv->plat_dev->dev.of_node, "cnss-enable-self-recovery")) plat_priv->ctrl_params.quirks |= BIT(LINK_DOWN_SELF_RECOVERY); 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; } static void cnss_get_wlaon_pwr_ctrl_info(struct cnss_plat_data *plat_priv) { struct device *dev = &plat_priv->plat_dev->dev; plat_priv->set_wlaon_pwr_ctrl = of_property_read_bool(dev->of_node, "qcom,set-wlaon-pwr-ctrl"); cnss_pr_dbg("set_wlaon_pwr_ctrl is %d\n", plat_priv->set_wlaon_pwr_ctrl); } static bool cnss_use_fw_path_with_prefix(struct cnss_plat_data *plat_priv) { return of_property_read_bool(plat_priv->plat_dev->dev.of_node, "qcom,converged-dt"); } static const struct platform_device_id cnss_platform_id_table[] = { { .name = "qca6174", .driver_data = QCA6174_DEVICE_ID, }, { .name = "qca6290", .driver_data = QCA6290_DEVICE_ID, }, { .name = "qca6390", .driver_data = QCA6390_DEVICE_ID, }, { .name = "qca6490", .driver_data = QCA6490_DEVICE_ID, }, { }, }; static const struct of_device_id cnss_of_match_table[] = { { .compatible = "qcom,cnss", .data = (void *)&cnss_platform_id_table[0]}, { .compatible = "qcom,cnss-qca6290", .data = (void *)&cnss_platform_id_table[1]}, { .compatible = "qcom,cnss-qca6390", .data = (void *)&cnss_platform_id_table[2]}, { .compatible = "qcom,cnss-qca6490", .data = (void *)&cnss_platform_id_table[3]}, { }, }; MODULE_DEVICE_TABLE(of, cnss_of_match_table); #ifdef OPLUS_FEATURE_WIFI_DCS_SWITCH //Add for wifi switch monitor static void icnss_create_fw_state_kobj(void); static void icnss_remove_fw_state_kobj(void); static ssize_t icnss_show_fw_ready(struct device_driver *driver, char *buf) { bool firmware_ready = false; bool bdfloadsuccess = false; bool regdbloadsuccess = false; bool cnssprobesuccess = false; if (!plat_env) { cnss_pr_err("icnss_show_fw_ready plat_env is NULL!\n"); } else { firmware_ready = test_bit(CNSS_FW_READY, &plat_env->driver_state); regdbloadsuccess = test_bit(CNSS_LOAD_REGDB_SUCCESS, &plat_env->loadRegdbState); bdfloadsuccess = test_bit(CNSS_LOAD_BDF_SUCCESS, &plat_env->loadBdfState); #ifdef OPLUS_FEATURE_WIFI_DCS_SWITCH //avoid wifi firmware ready check fail when idle shutdown cnss_pr_info("firmware_ready: %d; power_on: %d", firmware_ready, plat_env->powered_on); if (!firmware_ready && !plat_env->powered_on && regdbloadsuccess && bdfloadsuccess) { firmware_ready = true; } #endif /* OPLUS_FEATURE_WIFI_DCS_SWITCH */ } cnssprobesuccess = (cnssprobestate == CNSS_PROBE_SUCCESS); return sprintf(buf, "%s:%s:%s:%s", (firmware_ready ? "fwstatus_ready" : "fwstatus_not_ready"), (regdbloadsuccess ? "regdb_loadsuccess" : "regdb_loadfail"), (bdfloadsuccess ? "bdf_loadsuccess" : "bdf_loadfail"), (cnssprobesuccess ? "cnssprobe_success" : "cnssprobe_fail") ); } struct driver_attribute fw_ready_attr = { .attr = { .name = "firmware_ready", .mode = S_IRUGO, }, .show = icnss_show_fw_ready, //read only so we don't need to impl store func }; #endif /* VENDOR_EDIT */ static inline bool cnss_use_nv_mac(struct cnss_plat_data *plat_priv) { return of_property_read_bool(plat_priv->plat_dev->dev.of_node, "use-nv-mac"); } static inline int cnss_get_cal_duration(struct cnss_plat_data *plat_priv) { return of_property_read_u32(plat_priv->plat_dev->dev.of_node, "qcom,cnss-cal-duration", &plat_priv->cal_duration); } static int cnss_probe(struct platform_device *plat_dev) { int ret = 0; struct cnss_plat_data *plat_priv; const struct of_device_id *of_id; const struct platform_device_id *device_id; #ifdef OPLUS_BUG_STABILITY //Add for: disable wifi while power off charging because modem img will not mount if (qpnp_is_power_off_charging() && (get_boot_mode() != MSM_BOOT_MODE__WLAN) && (get_boot_mode() != MSM_BOOT_MODE__RF)) { cnss_pr_err("charge mode do not load wifi!\n"); goto out; } #endif /* OPLUS_BUG_STABILITY */ if (cnss_get_plat_priv(plat_dev)) { cnss_pr_err("Driver is already initialized!\n"); ret = -EEXIST; goto out; } of_id = of_match_device(cnss_of_match_table, &plat_dev->dev); if (!of_id || !of_id->data) { cnss_pr_err("Failed to find of match device!\n"); ret = -ENODEV; goto out; } device_id = of_id->data; plat_priv = devm_kzalloc(&plat_dev->dev, sizeof(*plat_priv), GFP_KERNEL); if (!plat_priv) { ret = -ENOMEM; goto out; } plat_priv->plat_dev = plat_dev; plat_priv->device_id = device_id->driver_data; plat_priv->bus_type = cnss_get_bus_type(plat_priv->device_id); plat_priv->use_nv_mac = cnss_use_nv_mac(plat_priv); if (cnss_get_cal_duration(plat_priv) != 0) plat_priv->cal_duration = CNSS_INVALID_CAL_DURATION; plat_priv->use_fw_path_with_prefix = cnss_use_fw_path_with_prefix(plat_priv); cnss_set_plat_priv(plat_dev, plat_priv); platform_set_drvdata(plat_dev, plat_priv); INIT_LIST_HEAD(&plat_priv->vreg_list); INIT_LIST_HEAD(&plat_priv->clk_list); cnss_get_wlaon_pwr_ctrl_info(plat_priv); cnss_get_cpr_info(plat_priv); cnss_init_control_params(plat_priv); #ifdef OPLUS_FEATURE_WIFI_DCS_SWITCH //Add for wifi switch monitor icnss_create_fw_state_kobj(); #endif /* OPLUS_FEATURE_WIFI_DCS_SWITCH */ ret = cnss_get_resources(plat_priv); if (ret) goto reset_ctx; if (!test_bit(SKIP_DEVICE_BOOT, &plat_priv->ctrl_params.quirks)) { ret = cnss_power_on_device(plat_priv); if (ret) goto free_res; ret = cnss_bus_init(plat_priv); if (ret) goto power_off; } ret = cnss_register_esoc(plat_priv); if (ret) goto deinit_bus; ret = cnss_register_bus_scale(plat_priv); if (ret) goto unreg_esoc; ret = cnss_create_sysfs(plat_priv); if (ret) goto unreg_bus_scale; ret = cnss_event_work_init(plat_priv); if (ret) goto remove_sysfs; ret = cnss_qmi_init(plat_priv); if (ret) goto deinit_event_work; cnss_debugfs_create(plat_priv); ret = cnss_misc_init(plat_priv); if (ret) goto destroy_debugfs; cnss_register_coex_service(plat_priv); cnss_register_ims_service(plat_priv); ret = cnss_genl_init(); if (ret < 0) cnss_pr_err("CNSS genl init failed %d\n", ret); #ifdef OPLUS_FEATURE_WIFI_DCS_SWITCH //Add for wifi switch monitor cnssprobestate = CNSS_PROBE_SUCCESS; #endif /* OPLUS_FEATURE_WIFI_DCS_SWITCH */ cnss_pr_info("Platform driver probed successfully.\n"); return 0; destroy_debugfs: cnss_debugfs_destroy(plat_priv); cnss_qmi_deinit(plat_priv); deinit_event_work: cnss_event_work_deinit(plat_priv); remove_sysfs: cnss_remove_sysfs(plat_priv); unreg_bus_scale: cnss_unregister_bus_scale(plat_priv); unreg_esoc: cnss_unregister_esoc(plat_priv); deinit_bus: if (!test_bit(SKIP_DEVICE_BOOT, &plat_priv->ctrl_params.quirks)) cnss_bus_deinit(plat_priv); power_off: if (!test_bit(SKIP_DEVICE_BOOT, &plat_priv->ctrl_params.quirks)) cnss_power_off_device(plat_priv); free_res: cnss_put_resources(plat_priv); reset_ctx: #ifdef OPLUS_FEATURE_WIFI_DCS_SWITCH //Add for wifi switch monitor icnss_remove_fw_state_kobj(); #endif /* OPLUS_FEATURE_WIFI_DCS_SWITCH */ platform_set_drvdata(plat_dev, NULL); cnss_set_plat_priv(plat_dev, NULL); out: #ifdef OPLUS_FEATURE_WIFI_DCS_SWITCH //Add for wifi switch monitor cnssprobestate = CNSS_PROBE_FAIL; #endif /* OPLUS_FEATURE_WIFI_DCS_SWITCH */ return ret; } static int cnss_remove(struct platform_device *plat_dev) { struct cnss_plat_data *plat_priv = platform_get_drvdata(plat_dev); cnss_genl_exit(); cnss_unregister_ims_service(plat_priv); cnss_unregister_coex_service(plat_priv); cnss_misc_deinit(plat_priv); cnss_debugfs_destroy(plat_priv); cnss_qmi_deinit(plat_priv); cnss_event_work_deinit(plat_priv); cnss_remove_sysfs(plat_priv); cnss_unregister_bus_scale(plat_priv); cnss_unregister_esoc(plat_priv); cnss_bus_deinit(plat_priv); cnss_put_resources(plat_priv); platform_set_drvdata(plat_dev, NULL); plat_env = NULL; return 0; } static struct platform_driver cnss_platform_driver = { .probe = cnss_probe, .remove = cnss_remove, .driver = { .name = "cnss2", .of_match_table = cnss_of_match_table, #ifdef CONFIG_CNSS_ASYNC .probe_type = PROBE_PREFER_ASYNCHRONOUS, #endif }, }; #ifdef OPLUS_FEATURE_WIFI_DCS_SWITCH //Add for wifi switch monitor static void icnss_create_fw_state_kobj(void) { if (driver_create_file(&(cnss_platform_driver.driver), &fw_ready_attr)) { cnss_pr_info("failed to create %s", fw_ready_attr.attr.name); } } static void icnss_remove_fw_state_kobj(void) { driver_remove_file(&(cnss_platform_driver.driver), &fw_ready_attr); } #endif /* OPLUS_FEATURE_WIFI_DCS_SWITCH */ static int __init cnss_initialize(void) { int ret = 0; cnss_debug_init(); ret = platform_driver_register(&cnss_platform_driver); if (ret) cnss_debug_deinit(); return ret; } static void __exit cnss_exit(void) { platform_driver_unregister(&cnss_platform_driver); cnss_debug_deinit(); } module_init(cnss_initialize); module_exit(cnss_exit); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("CNSS2 Platform Driver");