Merge "icnss: Synchronize idle shutdown and restart" (3518238d) · Commits · e / devices / android_kernel_sony_msm8998

drivers/soc/qcom/icnss.c

+109 −0

Original line number	Diff line number	Diff line
		@@ -196,6 +196,8 @@ enum icnss_driver_event_type {
		ICNSS_DRIVER_EVENT_REGISTER_DRIVER,
		ICNSS_DRIVER_EVENT_UNREGISTER_DRIVER,
		ICNSS_DRIVER_EVENT_PD_SERVICE_DOWN,
		ICNSS_DRIVER_EVENT_IDLE_SHUTDOWN,
		ICNSS_DRIVER_EVENT_IDLE_RESTART,
		ICNSS_DRIVER_EVENT_MAX,
		};

		@@ -303,6 +305,7 @@ enum icnss_driver_state {
		ICNSS_REJUVENATE,
		ICNSS_BLOCK_SHUTDOWN,
		ICNSS_PDR,
		ICNSS_MODEM_CRASHED,
		};

		struct ce_irq_list {
		@@ -636,6 +639,10 @@ static char *icnss_driver_event_to_str(enum icnss_driver_event_type type)
		return "UNREGISTER_DRIVER";
		case ICNSS_DRIVER_EVENT_PD_SERVICE_DOWN:
		return "PD_SERVICE_DOWN";
		case ICNSS_DRIVER_EVENT_IDLE_SHUTDOWN:
		return "IDLE_SHUTDOWN";
		case ICNSS_DRIVER_EVENT_IDLE_RESTART:
		return "IDLE_RESTART";
		case ICNSS_DRIVER_EVENT_MAX:
		return "EVENT_MAX";
		}
		@@ -2303,6 +2310,7 @@ static int icnss_pd_restart_complete(struct icnss_priv *priv)
		icnss_call_driver_shutdown(priv);

		clear_bit(ICNSS_PDR, &priv->state);
		clear_bit(ICNSS_MODEM_CRASHED, &priv->state);
		clear_bit(ICNSS_REJUVENATE, &priv->state);
		clear_bit(ICNSS_PD_RESTART, &priv->state);
		priv->is_ssr = false;
		@@ -2494,6 +2502,52 @@ out:
		return ret;
		}

		static int icnss_driver_event_idle_shutdown(void *data)
		{
		int ret = 0;

		if (!penv->ops \|\| !penv->ops->idle_shutdown)
		return 0;

		if (test_bit(ICNSS_MODEM_CRASHED, &penv->state) \|\|
		test_bit(ICNSS_PDR, &penv->state) \|\|
		test_bit(ICNSS_REJUVENATE, &penv->state)) {
		icnss_pr_err("SSR/PDR is already in-progress during idle shutdown callback\n");
		ret = -EBUSY;
		} else {
		icnss_pr_dbg("Calling driver idle shutdown, state: 0x%lx\n",
		penv->state);
		icnss_block_shutdown(true);
		ret = penv->ops->idle_shutdown(&penv->pdev->dev);
		icnss_block_shutdown(false);
		}

		return ret;
		}

		static int icnss_driver_event_idle_restart(void *data)
		{
		int ret = 0;

		if (!penv->ops \|\| !penv->ops->idle_restart)
		return 0;

		if (test_bit(ICNSS_MODEM_CRASHED, &penv->state) \|\|
		test_bit(ICNSS_PDR, &penv->state) \|\|
		test_bit(ICNSS_REJUVENATE, &penv->state)) {
		icnss_pr_err("SSR/PDR is already in-progress during idle restart callback\n");
		ret = -EBUSY;
		} else {
		icnss_pr_dbg("Calling driver idle restart, state: 0x%lx\n",
		penv->state);
		icnss_block_shutdown(true);
		ret = penv->ops->idle_restart(&penv->pdev->dev);
		icnss_block_shutdown(false);
		}

		return ret;
		}

		static void icnss_driver_event_work(struct work_struct *work)
		{
		struct icnss_driver_event *event;
		@@ -2535,6 +2589,12 @@ static void icnss_driver_event_work(struct work_struct *work)
		ret = icnss_driver_event_pd_service_down(penv,
		event->data);
		break;
		case ICNSS_DRIVER_EVENT_IDLE_SHUTDOWN:
		ret = icnss_driver_event_idle_shutdown(event->data);
		break;
		case ICNSS_DRIVER_EVENT_IDLE_RESTART:
		ret = icnss_driver_event_idle_restart(event->data);
		break;
		default:
		icnss_pr_err("Invalid Event type: %d", event->type);
		kfree(event);
		@@ -2641,6 +2701,9 @@ static int icnss_modem_notifier_nb(struct notifier_block *nb,

		priv->is_ssr = true;

		if (notif->crashed)
		set_bit(ICNSS_MODEM_CRASHED, &priv->state);

		if (code == SUBSYS_BEFORE_SHUTDOWN && !notif->crashed &&
		test_bit(ICNSS_BLOCK_SHUTDOWN, &priv->state)) {
		if (!wait_for_completion_timeout(&priv->unblock_shutdown,
		@@ -3597,6 +3660,48 @@ out:
		}
		EXPORT_SYMBOL(icnss_trigger_recovery);

		int icnss_idle_shutdown(struct device *dev)
		{
		struct icnss_priv *priv = dev_get_drvdata(dev);

		if (!priv) {
		icnss_pr_err("Invalid drvdata: dev %pK", dev);
		return -EINVAL;
		}

		if (test_bit(ICNSS_MODEM_CRASHED, &priv->state) \|\|
		test_bit(ICNSS_PDR, &priv->state) \|\|
		test_bit(ICNSS_REJUVENATE, &penv->state)) {
		icnss_pr_err("SSR/PDR is already in-progress during idle shutdown\n");
		return -EBUSY;
		}

		return icnss_driver_event_post(ICNSS_DRIVER_EVENT_IDLE_SHUTDOWN,
		ICNSS_EVENT_SYNC_UNINTERRUPTIBLE, NULL);
		}
		EXPORT_SYMBOL(icnss_idle_shutdown);

		int icnss_idle_restart(struct device *dev)
		{
		struct icnss_priv *priv = dev_get_drvdata(dev);

		if (!priv) {
		icnss_pr_err("Invalid drvdata: dev %pK", dev);
		return -EINVAL;
		}

		if (test_bit(ICNSS_MODEM_CRASHED, &priv->state) \|\|
		test_bit(ICNSS_PDR, &priv->state) \|\|
		test_bit(ICNSS_REJUVENATE, &penv->state)) {
		icnss_pr_err("SSR/PDR is already in-progress during idle restart\n");
		return -EBUSY;
		}

		return icnss_driver_event_post(ICNSS_DRIVER_EVENT_IDLE_RESTART,
		ICNSS_EVENT_SYNC_UNINTERRUPTIBLE, NULL);
		}
		EXPORT_SYMBOL(icnss_idle_restart);


		static int icnss_smmu_init(struct icnss_priv *priv)
		{
		@@ -4053,6 +4158,10 @@ static int icnss_stats_show_state(struct seq_file s, struct icnss_priv priv)
		continue;
		case ICNSS_PDR:
		seq_puts(s, "PDR TRIGGERED");
		continue;
		case ICNSS_MODEM_CRASHED:
		seq_puts(s, "MODEM CRASHED");
		continue;
		}

		seq_printf(s, "UNKNOWN-%d", i);

include/soc/qcom/icnss.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -56,6 +56,8 @@ struct icnss_driver_ops {
		int (suspend_noirq)(struct device dev);
		int (resume_noirq)(struct device dev);
		int (uevent)(struct device dev, struct icnss_uevent_data *uevent);
		int (idle_shutdown)(struct device dev);
		int (idle_restart)(struct device dev);
		};


		@@ -159,4 +161,6 @@ extern u8 icnss_get_wlan_mac_address(struct device dev, uint32_t *num);
		extern int icnss_trigger_recovery(struct device *dev);
		extern void icnss_block_shutdown(bool status);
		extern bool icnss_is_pdr(void);
		extern int icnss_idle_restart(struct device *dev);
		extern int icnss_idle_shutdown(struct device *dev);
		#endif /* _ICNSS_WLAN_H_ */