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

Commit e9872a7e authored by Yue Ma's avatar Yue Ma Committed by Gerrit - the friendly Code Review server
Browse files

cnss2: Add idle shutdown and restart support 



If WLAN interface is not brought up for certain amount of time
after it is created, idle shutdown will happen to power off WLAN
device. Idle restart will happen to power up WLAN device if WLAN
is needed by user again. Add the support in platform driver.

Change-Id: Ie9486bbfda38fe22180f53875689a215d9882e67
Signed-off-by: default avatarYue Ma <yuem@codeaurora.org>
parent c15a0078

drivers/net/wireless/cnss2/debug.c

+6 −0
Original line number Diff line number Diff line
@@ -85,6 +85,12 @@ static int cnss_stats_show_state(struct seq_file *s, 
		case CNSS_DRIVER_UNLOADING:

			seq_puts(s, "DRIVER_UNLOADING");

			continue;

		case CNSS_DRIVER_IDLE_RESTART:

			seq_puts(s, "IDLE_RESTART");

			continue;

		case CNSS_DRIVER_IDLE_SHUTDOWN:

			seq_puts(s, "IDLE_SHUTDOWN");

			continue;

		case CNSS_DRIVER_PROBED:

			seq_puts(s, "DRIVER_PROBED");

			continue;

drivers/net/wireless/cnss2/main.c

+95 −10
Original line number Diff line number Diff line
@@ -479,6 +479,10 @@ static char *cnss_driver_event_to_str(enum cnss_driver_event_type type) 
		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:
@@ -634,13 +638,74 @@ 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;

	}



	cnss_pr_dbg("Doing idle restart\n");



	ret = cnss_driver_event_post(plat_priv,

				     CNSS_DRIVER_EVENT_IDLE_RESTART,

				     CNSS_EVENT_SYNC, 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_boot_timeout(dev);



	reinit_completion(&plat_priv->power_up_complete);

	ret = wait_for_completion_timeout(&plat_priv->power_up_complete,

					  msecs_to_jiffies(timeout) << 2);

	if (!ret) {

		cnss_pr_err("Timeout waiting for idle restart to complete\n");

		ret = -EAGAIN;

		goto out;

	}



	return 0;



out:

	return ret;

}

EXPORT_SYMBOL(cnss_idle_restart);



int cnss_idle_shutdown(struct device *dev)

{

	return 0;

	struct cnss_plat_data *plat_priv = cnss_bus_dev_to_plat_priv(dev);

	int ret;



	if (!plat_priv) {

		cnss_pr_err("plat_priv is NULL\n");

		return -ENODEV;

	}



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

	ret = wait_for_completion_timeout(&plat_priv->recovery_complete,

					  RECOVERY_TIMEOUT);

	if (!ret) {

		cnss_pr_err("Timeout waiting for recovery to complete\n");

		CNSS_ASSERT(0);

	}



skip_wait:

	return cnss_driver_event_post(plat_priv,

				      CNSS_DRIVER_EVENT_IDLE_SHUTDOWN,

				      CNSS_EVENT_SYNC, NULL);

}

EXPORT_SYMBOL(cnss_idle_shutdown);
@@ -964,16 +1029,19 @@ static int cnss_driver_recovery_hdlr(struct cnss_plat_data *plat_priv, 
		goto out;

	}



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

		cnss_pr_err("Driver unload is in progress, ignore recovery\n");

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

			cnss_pr_err("Driver load is in progress, ignore recovery\n");

		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;

		}
@@ -1011,8 +1079,9 @@ void cnss_schedule_recovery(struct device *dev, 


	cnss_bus_update_status(plat_priv, CNSS_FW_DOWN);



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

		cnss_pr_dbg("Driver unload is in progress, ignore schedule recovery\n");

	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;

	}
@@ -1112,8 +1181,10 @@ int cnss_force_collect_rddm(struct device *dev) 
	}



	if (test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state) ||

	    test_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state)) {

		cnss_pr_info("Loading/Unloading is in progress, ignore forced collect rddm\n");

	    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;

	}
@@ -1177,7 +1248,13 @@ static int cnss_cold_boot_cal_done_hdlr(struct cnss_plat_data *plat_priv) 


static int cnss_power_up_hdlr(struct cnss_plat_data *plat_priv)

{

	return cnss_bus_dev_powerup(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)
@@ -1361,9 +1438,17 @@ static void cnss_driver_event_work(struct work_struct *work) 
		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;

drivers/net/wireless/cnss2/main.h

+5 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
#define QMI_WLFW_MAX_TIMESTAMP_LEN	32

#define QMI_WLFW_MAX_NUM_MEM_SEG	32

#define CNSS_RDDM_TIMEOUT_MS		20000

#define RECOVERY_TIMEOUT		60000



#define CNSS_EVENT_SYNC   BIT(0)

#define CNSS_EVENT_UNINTERRUPTIBLE BIT(1)
@@ -171,6 +172,8 @@ enum cnss_driver_event_type { 
	CNSS_DRIVER_EVENT_FORCE_FW_ASSERT,

	CNSS_DRIVER_EVENT_POWER_UP,

	CNSS_DRIVER_EVENT_POWER_DOWN,

	CNSS_DRIVER_EVENT_IDLE_RESTART,

	CNSS_DRIVER_EVENT_IDLE_SHUTDOWN,

	CNSS_DRIVER_EVENT_QDSS_TRACE_REQ_MEM,

	CNSS_DRIVER_EVENT_QDSS_TRACE_SAVE,

	CNSS_DRIVER_EVENT_QDSS_TRACE_FREE,
@@ -186,6 +189,8 @@ enum cnss_driver_state { 
	CNSS_COLD_BOOT_CAL,

	CNSS_DRIVER_LOADING,

	CNSS_DRIVER_UNLOADING,

	CNSS_DRIVER_IDLE_RESTART,

	CNSS_DRIVER_IDLE_SHUTDOWN,

	CNSS_DRIVER_PROBED,

	CNSS_DRIVER_RECOVERY,

	CNSS_FW_BOOT_RECOVERY,

drivers/net/wireless/cnss2/pci.c

+21 −2
Original line number Diff line number Diff line
@@ -51,7 +51,6 @@ 


#define FW_ASSERT_TIMEOUT		5000

#define DEV_RDDM_TIMEOUT		5000

#define RECOVERY_TIMEOUT		60000



#ifdef CONFIG_CNSS_EMULATION

#define EMULATION_HW			1
@@ -525,6 +524,18 @@ int cnss_pci_call_driver_probe(struct cnss_pci_data *pci_priv) 
		clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);

		clear_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state);

		set_bit(CNSS_DRIVER_PROBED, &plat_priv->driver_state);

	} else if (test_bit(CNSS_DRIVER_IDLE_RESTART,

			    &plat_priv->driver_state)) {

		ret = pci_priv->driver_ops->idle_restart(pci_priv->pci_dev,

			pci_priv->pci_device_id);

		if (ret) {

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

				    ret);

			goto out;

		}

		clear_bit(CNSS_DRIVER_RECOVERY, &plat_priv->driver_state);

		clear_bit(CNSS_DRIVER_IDLE_RESTART, &plat_priv->driver_state);

		complete(&plat_priv->power_up_complete);

	} else {

		complete(&plat_priv->power_up_complete);

	}
@@ -564,6 +575,10 @@ int cnss_pci_call_driver_remove(struct cnss_pci_data *pci_priv) 
		pci_priv->driver_ops->remove(pci_priv->pci_dev);

		clear_bit(CNSS_DRIVER_PROBED, &plat_priv->driver_state);

		clear_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state);

	} else if (test_bit(CNSS_DRIVER_IDLE_SHUTDOWN,

			    &plat_priv->driver_state)) {

		pci_priv->driver_ops->idle_shutdown(pci_priv->pci_dev);

		clear_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state);

	}



	return 0;
@@ -707,6 +722,7 @@ static int cnss_qca6174_shutdown(struct cnss_pci_data *pci_priv) 
	cnss_power_off_device(plat_priv);



	clear_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state);

	clear_bit(CNSS_DRIVER_IDLE_SHUTDOWN, &plat_priv->driver_state);



	return ret;

}
@@ -816,7 +832,9 @@ static int cnss_qca6290_shutdown(struct cnss_pci_data *pci_priv) 
	cnss_pci_set_auto_suspended(pci_priv, 0);



	if ((test_bit(CNSS_DRIVER_LOADING, &plat_priv->driver_state) ||

	     test_bit(CNSS_DRIVER_UNLOADING, &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)) &&

	    test_bit(CNSS_DEV_ERR_NOTIFY, &plat_priv->driver_state)) {

		del_timer(&pci_priv->dev_rddm_timer);

		cnss_pci_collect_dump(pci_priv);
@@ -835,6 +853,7 @@ static int cnss_qca6290_shutdown(struct cnss_pci_data *pci_priv) 
	clear_bit(CNSS_FW_READY, &plat_priv->driver_state);

	clear_bit(CNSS_FW_MEM_READY, &plat_priv->driver_state);

	clear_bit(CNSS_DRIVER_UNLOADING, &plat_priv->driver_state);

	clear_bit(CNSS_DRIVER_IDLE_SHUTDOWN, &plat_priv->driver_state);



	return ret;

}