[linux.git] / drivers / slimbus / sched.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2011-2017, The Linux Foundation
 */

#include <linux/errno.h>
#include "slimbus.h"

/**
 * slim_ctrl_clk_pause() - Called by slimbus controller to enter/exit
 *			   'clock pause'
 * @ctrl: controller requesting bus to be paused or woken up
 * @wakeup: Wakeup this controller from clock pause.
 * @restart: Restart time value per spec used for clock pause. This value
 *	isn't used when controller is to be woken up.
 *
 * Slimbus specification needs this sequence to turn-off clocks for the bus.
 * The sequence involves sending 3 broadcast messages (reconfiguration
 * sequence) to inform all devices on the bus.
 * To exit clock-pause, controller typically wakes up active framer device.
 * This API executes clock pause reconfiguration sequence if wakeup is false.
 * If wakeup is true, controller's wakeup is called.
 * For entering clock-pause, -EBUSY is returned if a message txn in pending.
 */
int slim_ctrl_clk_pause(struct slim_controller *ctrl, bool wakeup, u8 restart)
{
	int i, ret = 0;
	unsigned long flags;
	struct slim_sched *sched = &ctrl->sched;
	struct slim_val_inf msg = {0, 0, NULL, NULL};

	DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
				3, SLIM_LA_MANAGER, &msg);

	if (wakeup == false && restart > SLIM_CLK_UNSPECIFIED)
		return -EINVAL;

	mutex_lock(&sched->m_reconf);
	if (wakeup) {
		if (sched->clk_state == SLIM_CLK_ACTIVE) {
			mutex_unlock(&sched->m_reconf);
			return 0;
		}

		/*
		 * Fine-tune calculation based on clock gear,
		 * message-bandwidth after bandwidth management
		 */
		ret = wait_for_completion_timeout(&sched->pause_comp,
				msecs_to_jiffies(100));
		if (!ret) {
			mutex_unlock(&sched->m_reconf);
			pr_err("Previous clock pause did not finish");
			return -ETIMEDOUT;
		}
		ret = 0;

		/*
		 * Slimbus framework will call controller wakeup
		 * Controller should make sure that it sets active framer
		 * out of clock pause
		 */
		if (sched->clk_state == SLIM_CLK_PAUSED && ctrl->wakeup)
			ret = ctrl->wakeup(ctrl);
		if (!ret)
			sched->clk_state = SLIM_CLK_ACTIVE;
		mutex_unlock(&sched->m_reconf);

		return ret;
	}

	/* already paused */
	if (ctrl->sched.clk_state == SLIM_CLK_PAUSED) {
		mutex_unlock(&sched->m_reconf);
		return 0;
	}

	spin_lock_irqsave(&ctrl->txn_lock, flags);
	for (i = 0; i < SLIM_MAX_TIDS; i++) {
		/* Pending response for a message */
		if (idr_find(&ctrl->tid_idr, i)) {
			spin_unlock_irqrestore(&ctrl->txn_lock, flags);
			mutex_unlock(&sched->m_reconf);
			return -EBUSY;
		}
	}
	spin_unlock_irqrestore(&ctrl->txn_lock, flags);

	sched->clk_state = SLIM_CLK_ENTERING_PAUSE;

	/* clock pause sequence */
	ret = slim_do_transfer(ctrl, &txn);
	if (ret)
		goto clk_pause_ret;

	txn.mc = SLIM_MSG_MC_NEXT_PAUSE_CLOCK;
	txn.rl = 4;
	msg.num_bytes = 1;
	msg.wbuf = &restart;
	ret = slim_do_transfer(ctrl, &txn);
	if (ret)
		goto clk_pause_ret;

	txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;
	txn.rl = 3;
	msg.num_bytes = 1;
	msg.wbuf = NULL;
	ret = slim_do_transfer(ctrl, &txn);

clk_pause_ret:
	if (ret) {
		sched->clk_state = SLIM_CLK_ACTIVE;
	} else {
		sched->clk_state = SLIM_CLK_PAUSED;
		complete(&sched->pause_comp);
	}
	mutex_unlock(&sched->m_reconf);

	return ret;
}
EXPORT_SYMBOL_GPL(slim_ctrl_clk_pause);
Commit	Line	Data
4b14e62a SD	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (c) 2011-2017, The Linux Foundation
	4	*/
	5
	6	#include <linux/errno.h>
	7	#include "slimbus.h"
	8
	9	/**
	10	* slim_ctrl_clk_pause() - Called by slimbus controller to enter/exit
	11	* 'clock pause'
	12	* @ctrl: controller requesting bus to be paused or woken up
	13	* @wakeup: Wakeup this controller from clock pause.
	14	* @restart: Restart time value per spec used for clock pause. This value
	15	* isn't used when controller is to be woken up.
	16	*
	17	* Slimbus specification needs this sequence to turn-off clocks for the bus.
	18	* The sequence involves sending 3 broadcast messages (reconfiguration
	19	* sequence) to inform all devices on the bus.
	20	* To exit clock-pause, controller typically wakes up active framer device.
	21	* This API executes clock pause reconfiguration sequence if wakeup is false.
	22	* If wakeup is true, controller's wakeup is called.
	23	* For entering clock-pause, -EBUSY is returned if a message txn in pending.
	24	*/
	25	int slim_ctrl_clk_pause(struct slim_controller *ctrl, bool wakeup, u8 restart)
	26	{
	27	int i, ret = 0;
	28	unsigned long flags;
	29	struct slim_sched *sched = &ctrl->sched;
	30	struct slim_val_inf msg = {0, 0, NULL, NULL};
	31
	32	DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
	33	3, SLIM_LA_MANAGER, &msg);
	34
	35	if (wakeup == false && restart > SLIM_CLK_UNSPECIFIED)
	36	return -EINVAL;
	37
	38	mutex_lock(&sched->m_reconf);
	39	if (wakeup) {
	40	if (sched->clk_state == SLIM_CLK_ACTIVE) {
	41	mutex_unlock(&sched->m_reconf);
	42	return 0;
	43	}
	44
	45	/*
	46	* Fine-tune calculation based on clock gear,
	47	* message-bandwidth after bandwidth management
	48	*/
	49	ret = wait_for_completion_timeout(&sched->pause_comp,
	50	msecs_to_jiffies(100));
	51	if (!ret) {
	52	mutex_unlock(&sched->m_reconf);
	53	pr_err("Previous clock pause did not finish");
	54	return -ETIMEDOUT;
	55	}
	56	ret = 0;
	57
	58	/*
	59	* Slimbus framework will call controller wakeup
	60	* Controller should make sure that it sets active framer
	61	* out of clock pause
	62	*/
	63	if (sched->clk_state == SLIM_CLK_PAUSED && ctrl->wakeup)
	64	ret = ctrl->wakeup(ctrl);
65	if (!ret)
66	sched->clk_state = SLIM_CLK_ACTIVE;
67	mutex_unlock(&sched->m_reconf);
68
69	return ret;
70	}
71
72	/* already paused */
73	if (ctrl->sched.clk_state == SLIM_CLK_PAUSED) {
74	mutex_unlock(&sched->m_reconf);
75	return 0;
76	}
77
78	spin_lock_irqsave(&ctrl->txn_lock, flags);
79	for (i = 0; i < SLIM_MAX_TIDS; i++) {
80	/* Pending response for a message */
81	if (idr_find(&ctrl->tid_idr, i)) {
82	spin_unlock_irqrestore(&ctrl->txn_lock, flags);
83	mutex_unlock(&sched->m_reconf);
84	return -EBUSY;
85	}
86	}
87	spin_unlock_irqrestore(&ctrl->txn_lock, flags);
88
89	sched->clk_state = SLIM_CLK_ENTERING_PAUSE;
90
91	/* clock pause sequence */
92	ret = slim_do_transfer(ctrl, &txn);
93	if (ret)
94	goto clk_pause_ret;
95
96	txn.mc = SLIM_MSG_MC_NEXT_PAUSE_CLOCK;
97	txn.rl = 4;
98	msg.num_bytes = 1;
99	msg.wbuf = &restart;
100	ret = slim_do_transfer(ctrl, &txn);
101	if (ret)
102	goto clk_pause_ret;
103
104	txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;
105	txn.rl = 3;
106	msg.num_bytes = 1;
107	msg.wbuf = NULL;
108	ret = slim_do_transfer(ctrl, &txn);
109
110	clk_pause_ret:
111	if (ret) {
112	sched->clk_state = SLIM_CLK_ACTIVE;
113	} else {
114	sched->clk_state = SLIM_CLK_PAUSED;
115	complete(&sched->pause_comp);
116	}
117	mutex_unlock(&sched->m_reconf);
118
119	return ret;
120	}
121	EXPORT_SYMBOL_GPL(slim_ctrl_clk_pause);