Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4be30a3e authored by Yue Ma's avatar Yue Ma Committed by Yuanyuan Liu
Browse files

cnss2: Serialize wlan driver register/unregister in workqueue 



Serialize wlan driver register/unregister in workqueue context to
make sure everything is handled in sequence.

CRs-Fixed: 2012394
Change-Id: Ia1c6a547ce138d0099b9931ce6b87442b7bfbf7a
Signed-off-by: default avatarYuanyuan Liu <yuanliu@codeaurora.org>
Signed-off-by: default avatarYue Ma <yuem@codeaurora.org>
parent 8d0bafc0

drivers/net/wireless/cnss2/main.c

+213 −167
Original line number Diff line number Diff line
@@ -11,12 +11,14 @@ 
 */



#include <linux/delay.h>

#include <linux/jiffies.h>

#include <linux/module.h>

#include <linux/of.h>

#include <linux/of_device.h>

#include <linux/pm_wakeup.h>

#include <linux/rwsem.h>

#include <linux/suspend.h>

#include <linux/timer.h>

#include <soc/qcom/ramdump.h>

#include <soc/qcom/subsystem_notif.h>
@@ -452,6 +454,38 @@ out: 
	return ret;

}



static int cnss_driver_call_probe(struct cnss_plat_data *plat_priv)

{

	int ret;

	struct cnss_pci_data *pci_priv = plat_priv->bus_priv;



	if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {

		ret = plat_priv->driver_ops->reinit(pci_priv->pci_dev,

						    pci_priv->pci_device_id);

		if (ret) {

			cnss_pr_err("Failed to reinit host driver, err = %d\n",

				    ret);

			goto out;

		}

		clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);

	} else {

		ret = plat_priv->driver_ops->probe(pci_priv->pci_dev,

						   pci_priv->pci_device_id);

		if (ret) {

			cnss_pr_err("Failed to probe host driver, err = %d\n",

				    ret);

			goto out;

		}

		clear_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state);

		set_bit(CNSS_DRIVER_PROBED, &plat_priv->driver_state);

	}



	return 0;



out:

	return ret;

}



static int cnss_fw_ready_hdlr(struct cnss_plat_data *plat_priv)

{

	struct cnss_pci_data *pci_priv;
@@ -460,6 +494,8 @@ static int cnss_fw_ready_hdlr(struct cnss_plat_data *plat_priv) 
	if (!plat_priv)

		return -ENODEV;



	del_timer(&plat_priv->fw_ready_timer);



	set_bit(CNSS_FW_READY, &plat_priv->driver_state);



	pci_priv = plat_priv->bus_priv;
@@ -467,7 +503,7 @@ static int cnss_fw_ready_hdlr(struct cnss_plat_data *plat_priv) 
		return -ENODEV;



	if (test_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state))

		complete(&plat_priv->fw_ready_event);

		ret = cnss_driver_call_probe(plat_priv);

	else if (enable_waltest)

		ret = cnss_wlfw_wlan_mode_send_sync(plat_priv,

						    QMI_WLFW_WALTEST_V01);
@@ -475,6 +511,16 @@ static int cnss_fw_ready_hdlr(struct cnss_plat_data *plat_priv) 
		ret = cnss_wlfw_wlan_mode_send_sync(plat_priv,

						    QMI_WLFW_CALIBRATION_V01);



	if (ret)

		goto shutdown;



	return 0;



shutdown:

	cnss_pci_stop_mhi(pci_priv);

	cnss_suspend_pci_link(pci_priv);

	cnss_power_off_device(plat_priv);



	return ret;

}
@@ -514,6 +560,10 @@ static char *cnss_driver_event_to_str(enum cnss_driver_event_type type) 
		return "FW_READY";

	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_MAX:

		return "EVENT_MAX";

	}
@@ -521,78 +571,6 @@ static char *cnss_driver_event_to_str(enum cnss_driver_event_type type) 
	return "UNKNOWN";

};



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)

		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);

			break;

		case CNSS_DRIVER_EVENT_SERVER_EXIT:

			ret = cnss_wlfw_server_exit(plat_priv);

			break;

		case CNSS_DRIVER_EVENT_REQUEST_MEM:

			ret = cnss_pci_alloc_fw_mem(plat_priv->bus_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_DONE:

			ret = cnss_cold_boot_cal_done_hdlr(plat_priv);

			break;

		default:

			cnss_pr_err("Invalid driver event type: %d",

				    event->type);

			kfree(event);

			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);

}



static void cnss_recovery_work_func(struct work_struct *work)

{

	struct cnss_recovery_work_t *ctx =
@@ -722,40 +700,20 @@ int cnss_wlan_register_driver(struct cnss_wlan_driver *driver_ops) 
{

	int ret = 0;

	struct cnss_plat_data *plat_priv = cnss_get_plat_priv(NULL);

	struct cnss_subsys_info *subsys_info;



	if (!plat_priv) {

		cnss_pr_err("plat_priv is NULL!\n");

		ret = -ENODEV;

		goto out;

		return -ENODEV;

	}



	if (plat_priv->driver_ops) {

		cnss_pr_err("Driver has already registered!\n");

		ret = -EEXIST;

		goto out;

	}



	set_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state);

	plat_priv->driver_ops = driver_ops;

	subsys_info = &plat_priv->subsys_info;



	subsys_info->subsys_handle =

		subsystem_get(subsys_info->subsys_desc.name);

	if (!subsys_info->subsys_handle) {

		ret = -EINVAL;

		goto reset_ctx;

	} else if (IS_ERR(subsys_info->subsys_handle)) {

		ret = PTR_ERR(subsys_info->subsys_handle);

		goto reset_ctx;

		return -EEXIST;

	}



	return 0;

reset_ctx:

	cnss_pr_err("Failed to get subsystem, err = %d\n", ret);

	clear_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state);

	plat_priv->driver_ops = NULL;

out:

	ret = cnss_driver_event_post(plat_priv,

				     CNSS_DRIVER_EVENT_REGISTER_DRIVER,

				     true, driver_ops);

	return ret;

}

EXPORT_SYMBOL(cnss_wlan_register_driver);
@@ -763,18 +721,15 @@ EXPORT_SYMBOL(cnss_wlan_register_driver); 
void cnss_wlan_unregister_driver(struct cnss_wlan_driver *driver_ops)

{

	struct cnss_plat_data *plat_priv = cnss_get_plat_priv(NULL);

	struct cnss_subsys_info *subsys_info;



	if (!plat_priv) {

		cnss_pr_err("plat_priv is NULL!\n");

		return;

	}



	set_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state);

	subsys_info = &plat_priv->subsys_info;

	subsystem_put(subsys_info->subsys_handle);

	subsys_info->subsys_handle = NULL;

	plat_priv->driver_ops = NULL;

	cnss_driver_event_post(plat_priv,

			       CNSS_DRIVER_EVENT_UNREGISTER_DRIVER,

			       true, NULL);

}

EXPORT_SYMBOL(cnss_wlan_unregister_driver);
@@ -934,30 +889,9 @@ static int cnss_qca6174_powerup(struct cnss_plat_data *plat_priv) 
		goto power_off;

	}



	if (test_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state)) {

		ret = plat_priv->driver_ops->probe(pci_priv->pci_dev,

						   pci_priv->pci_device_id);

		if (ret) {

			cnss_pr_err("Failed to probe host driver, err = %d\n",

				    ret);

			goto suspend_link;

		}

		clear_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state);

		set_bit(CNSS_DRIVER_PROBED, &plat_priv->driver_state);

	} else if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {

		ret = plat_priv->driver_ops->reinit(pci_priv->pci_dev,

						    pci_priv->pci_device_id);

		if (ret) {

			cnss_pr_err("Failed to reinit host driver, err = %d\n",

				    ret);

			goto suspend_link;

		}

		clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);

	} else {

		cnss_pr_err("Driver state is not correct to power up!\n");

		ret = -EINVAL;

	ret = cnss_driver_call_probe(plat_priv);

	if (ret)

		goto suspend_link;

	}



	return 0;

suspend_link:
@@ -985,7 +919,6 @@ static int cnss_qca6174_shutdown(struct cnss_plat_data *plat_priv) 
		cnss_pci_set_monitor_wake_intr(pci_priv, false);

		cnss_pci_set_auto_suspended(pci_priv, 0);

	} else {

		set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);

		plat_priv->driver_ops->shutdown(pci_priv->pci_dev);

	}
@@ -1048,43 +981,13 @@ static int cnss_qca6290_powerup(struct cnss_plat_data *plat_priv) 


	cnss_set_pin_connect_status(plat_priv);



	if (qmi_bypass)

		goto skip_fw_ready;



	reinit_completion(&plat_priv->fw_ready_event);

	ret = wait_for_completion_timeout(&plat_priv->fw_ready_event,

					  msecs_to_jiffies(FW_READY_TIMEOUT));



	if (ret == 0) {

		cnss_pr_err("Timeout for FW ready event!\n");

		ret = -EBUSY;

		goto stop_mhi;

	}



skip_fw_ready:

	if (test_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state)) {

		ret = plat_priv->driver_ops->probe(pci_priv->pci_dev,

						   pci_priv->pci_device_id);

		if (ret) {

			cnss_pr_err("Failed to probe host driver, err = %d\n",

				    ret);

			goto stop_mhi;

		}

		clear_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state);

		set_bit(CNSS_DRIVER_PROBED, &plat_priv->driver_state);

	} else if (test_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state)) {

		ret = plat_priv->driver_ops->reinit(pci_priv->pci_dev,

						    pci_priv->pci_device_id);

		if (ret) {

			cnss_pr_err("Failed to reinit host driver, err = %d\n",

				    ret);

	if (qmi_bypass) {

		ret = cnss_driver_call_probe(plat_priv);

		if (ret)

			goto stop_mhi;

		}

		clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);

	} else {

		cnss_pr_err("Driver state is not correct to power up!\n");

		ret = -EINVAL;

		goto stop_mhi;

		mod_timer(&plat_priv->fw_ready_timer,

			  jiffies + msecs_to_jiffies(FW_READY_TIMEOUT));

	}



	return 0;
@@ -1116,7 +1019,6 @@ static int cnss_qca6290_shutdown(struct cnss_plat_data *plat_priv) 
		cnss_pci_set_monitor_wake_intr(pci_priv, false);

		cnss_pci_set_auto_suspended(pci_priv, 0);

	} else {

		set_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);

		plat_priv->driver_ops->shutdown(pci_priv->pci_dev);

	}
@@ -1146,6 +1048,9 @@ static int cnss_powerup(const struct subsys_desc *subsys_desc) 
		return -ENODEV;

	}



	if (!plat_priv->driver_ops)

		return 0;



	switch (plat_priv->device_id) {

	case QCA6174_DEVICE_ID:

		ret = cnss_qca6174_powerup(plat_priv);
@@ -1343,6 +1248,131 @@ void cnss_schedule_recovery(struct device *dev, 
}

EXPORT_SYMBOL(cnss_schedule_recovery);



void fw_ready_timeout(unsigned long data)

{

	struct cnss_plat_data *plat_priv = (struct cnss_plat_data *)data;

	struct cnss_pci_data *pci_priv = plat_priv->bus_priv;



	cnss_pr_err("Timeout waiting for FW ready indication!\n");



	cnss_pci_stop_mhi(pci_priv);

	cnss_suspend_pci_link(pci_priv);

	cnss_power_off_device(plat_priv);

}



static int cnss_register_driver_hdlr(struct cnss_plat_data *plat_priv,

				     void *data)

{

	int ret = 0;

	struct cnss_subsys_info *subsys_info;



	set_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state);

	plat_priv->driver_ops = data;

	subsys_info = &plat_priv->subsys_info;



	ret = cnss_powerup(&subsys_info->subsys_desc);

	if (ret) {

		clear_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state);

		plat_priv->driver_ops = NULL;

	}



	return ret;

}



static int cnss_unregister_driver_hdlr(struct cnss_plat_data *plat_priv)

{

	struct cnss_subsys_info *subsys_info;



	set_bit(CNSS_DRIVER_LOAD_UNLOAD, &plat_priv->driver_state);

	subsys_info = &plat_priv->subsys_info;

	cnss_shutdown(&subsys_info->subsys_desc, false);

	subsys_info->subsys_handle = NULL;

	plat_priv->driver_ops = NULL;



	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);

			break;

		case CNSS_DRIVER_EVENT_SERVER_EXIT:

			ret = cnss_wlfw_server_exit(plat_priv);

			break;

		case CNSS_DRIVER_EVENT_REQUEST_MEM:

			ret = cnss_pci_alloc_fw_mem(plat_priv->bus_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_DONE:

			ret = cnss_cold_boot_cal_done_hdlr(plat_priv);

			break;

		case CNSS_DRIVER_EVENT_REGISTER_DRIVER:

			ret = cnss_register_driver_hdlr(plat_priv,

							event->data);

			break;

		case CNSS_DRIVER_EVENT_UNREGISTER_DRIVER:

			ret = cnss_unregister_driver_hdlr(plat_priv);

			break;

		default:

			cnss_pr_err("Invalid driver event type: %d",

				    event->type);

			kfree(event);

			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_register_subsys(struct cnss_plat_data *plat_priv)

{

	int ret = 0;
@@ -1377,7 +1407,22 @@ int cnss_register_subsys(struct cnss_plat_data *plat_priv) 
		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;

}
@@ -1387,6 +1432,7 @@ 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);

}
@@ -1618,14 +1664,11 @@ static int cnss_event_work_init(struct cnss_plat_data *plat_priv) 
	INIT_LIST_HEAD(&plat_priv->event_list);

	INIT_WORK(&plat_priv->cnss_recovery_work.work,

		  cnss_recovery_work_func);

	init_completion(&plat_priv->fw_ready_event);



	return 0;

}



static void cnss_event_work_deinit(struct cnss_plat_data *plat_priv)

{

	complete_all(&plat_priv->fw_ready_event);

	destroy_workqueue(plat_priv->event_wq);

}
@@ -1715,6 +1758,9 @@ static int cnss_probe(struct platform_device *plat_dev) 
	if (ret)

		goto deinit_qmi;



	setup_timer(&plat_priv->fw_ready_timer,

		    fw_ready_timeout, (unsigned long)plat_priv);



	register_pm_notifier(&cnss_pm_notifier);



	cnss_pr_info("Platform driver probed successfully.\n");

drivers/net/wireless/cnss2/main.h

+3 −1
Original line number Diff line number Diff line
@@ -97,6 +97,8 @@ enum cnss_driver_event_type { 
	CNSS_DRIVER_EVENT_FW_MEM_READY,

	CNSS_DRIVER_EVENT_FW_READY,

	CNSS_DRIVER_EVENT_COLD_BOOT_CAL_DONE,

	CNSS_DRIVER_EVENT_REGISTER_DRIVER,

	CNSS_DRIVER_EVENT_UNREGISTER_DRIVER,

	CNSS_DRIVER_EVENT_MAX,

};
@@ -153,7 +155,6 @@ struct cnss_plat_data { 
	uint32_t recovery_count;

	struct cnss_wlan_mac_info wlan_mac_info;

	unsigned long driver_state;

	struct completion fw_ready_event;

	struct list_head event_list;

	spinlock_t event_lock; /* spinlock for driver work event handling */

	struct work_struct event_work;
@@ -171,6 +172,7 @@ struct cnss_plat_data { 
	struct cnss_pin_connect_result pin_result;

	struct dentry *root_dentry;

	atomic_t pm_count;

	struct timer_list fw_ready_timer;

};



void *cnss_bus_dev_to_bus_priv(struct device *dev);