[mirror_ubuntu-jammy-kernel.git] / drivers / remoteproc / qcom_q6v5.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Qualcomm Peripheral Image Loader for Q6V5
 *
 * Copyright (C) 2016-2018 Linaro Ltd.
 * Copyright (C) 2014 Sony Mobile Communications AB
 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
 */
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/soc/qcom/smem.h>
#include <linux/soc/qcom/smem_state.h>
#include <linux/remoteproc.h>
#include "qcom_common.h"
#include "qcom_q6v5.h"

#define Q6V5_PANIC_DELAY_MS	200

/**
 * qcom_q6v5_prepare() - reinitialize the qcom_q6v5 context before start
 * @q6v5:	reference to qcom_q6v5 context to be reinitialized
 *
 * Return: 0 on success, negative errno on failure
 */
int qcom_q6v5_prepare(struct qcom_q6v5 *q6v5)
{
	reinit_completion(&q6v5->start_done);
	reinit_completion(&q6v5->stop_done);

	q6v5->running = true;
	q6v5->handover_issued = false;

	enable_irq(q6v5->handover_irq);

	return 0;
}
EXPORT_SYMBOL_GPL(qcom_q6v5_prepare);

/**
 * qcom_q6v5_unprepare() - unprepare the qcom_q6v5 context after stop
 * @q6v5:	reference to qcom_q6v5 context to be unprepared
 *
 * Return: 0 on success, 1 if handover hasn't yet been called
 */
int qcom_q6v5_unprepare(struct qcom_q6v5 *q6v5)
{
	disable_irq(q6v5->handover_irq);

	return !q6v5->handover_issued;
}
EXPORT_SYMBOL_GPL(qcom_q6v5_unprepare);

static irqreturn_t q6v5_wdog_interrupt(int irq, void *data)
{
	struct qcom_q6v5 *q6v5 = data;
	size_t len;
	char *msg;

	/* Sometimes the stop triggers a watchdog rather than a stop-ack */
	if (!q6v5->running) {
		complete(&q6v5->stop_done);
		return IRQ_HANDLED;
	}

	msg = qcom_smem_get(QCOM_SMEM_HOST_ANY, q6v5->crash_reason, &len);
	if (!IS_ERR(msg) && len > 0 && msg[0])
		dev_err(q6v5->dev, "watchdog received: %s\n", msg);
	else
		dev_err(q6v5->dev, "watchdog without message\n");

	rproc_report_crash(q6v5->rproc, RPROC_WATCHDOG);

	return IRQ_HANDLED;
}

static irqreturn_t q6v5_fatal_interrupt(int irq, void *data)
{
	struct qcom_q6v5 *q6v5 = data;
	size_t len;
	char *msg;

	msg = qcom_smem_get(QCOM_SMEM_HOST_ANY, q6v5->crash_reason, &len);
	if (!IS_ERR(msg) && len > 0 && msg[0])
		dev_err(q6v5->dev, "fatal error received: %s\n", msg);
	else
		dev_err(q6v5->dev, "fatal error without message\n");

	q6v5->running = false;
	rproc_report_crash(q6v5->rproc, RPROC_FATAL_ERROR);

	return IRQ_HANDLED;
}

static irqreturn_t q6v5_ready_interrupt(int irq, void *data)
{
	struct qcom_q6v5 *q6v5 = data;

	complete(&q6v5->start_done);

	return IRQ_HANDLED;
}

/**
 * qcom_q6v5_wait_for_start() - wait for remote processor start signal
 * @q6v5:	reference to qcom_q6v5 context
 * @timeout:	timeout to wait for the event, in jiffies
 *
 * qcom_q6v5_unprepare() should not be called when this function fails.
 *
 * Return: 0 on success, -ETIMEDOUT on timeout
 */
int qcom_q6v5_wait_for_start(struct qcom_q6v5 *q6v5, int timeout)
{
	int ret;

	ret = wait_for_completion_timeout(&q6v5->start_done, timeout);
	if (!ret)
		disable_irq(q6v5->handover_irq);

	return !ret ? -ETIMEDOUT : 0;
}
EXPORT_SYMBOL_GPL(qcom_q6v5_wait_for_start);

static irqreturn_t q6v5_handover_interrupt(int irq, void *data)
{
	struct qcom_q6v5 *q6v5 = data;

	if (q6v5->handover)
		q6v5->handover(q6v5);

	q6v5->handover_issued = true;

	return IRQ_HANDLED;
}

static irqreturn_t q6v5_stop_interrupt(int irq, void *data)
{
	struct qcom_q6v5 *q6v5 = data;

	complete(&q6v5->stop_done);

	return IRQ_HANDLED;
}

/**
 * qcom_q6v5_request_stop() - request the remote processor to stop
 * @q6v5:	reference to qcom_q6v5 context
 * @sysmon:	reference to the remote's sysmon instance, or NULL
 *
 * Return: 0 on success, negative errno on failure
 */
int qcom_q6v5_request_stop(struct qcom_q6v5 *q6v5, struct qcom_sysmon *sysmon)
{
	int ret;

	q6v5->running = false;

	/* Don't perform SMP2P dance if sysmon already shut down the remote */
	if (qcom_sysmon_shutdown_acked(sysmon))
		return 0;

	qcom_smem_state_update_bits(q6v5->state,
				    BIT(q6v5->stop_bit), BIT(q6v5->stop_bit));

	ret = wait_for_completion_timeout(&q6v5->stop_done, 5 * HZ);

	qcom_smem_state_update_bits(q6v5->state, BIT(q6v5->stop_bit), 0);

	return ret == 0 ? -ETIMEDOUT : 0;
}
EXPORT_SYMBOL_GPL(qcom_q6v5_request_stop);

/**
 * qcom_q6v5_panic() - panic handler to invoke a stop on the remote
 * @q6v5:	reference to qcom_q6v5 context
 *
 * Set the stop bit and sleep in order to allow the remote processor to flush
 * its caches etc for post mortem debugging.
 *
 * Return: 200ms
 */
unsigned long qcom_q6v5_panic(struct qcom_q6v5 *q6v5)
{
	qcom_smem_state_update_bits(q6v5->state,
				    BIT(q6v5->stop_bit), BIT(q6v5->stop_bit));

	return Q6V5_PANIC_DELAY_MS;
}
EXPORT_SYMBOL_GPL(qcom_q6v5_panic);

/**
 * qcom_q6v5_init() - initializer of the q6v5 common struct
 * @q6v5:	handle to be initialized
 * @pdev:	platform_device reference for acquiring resources
 * @rproc:	associated remoteproc instance
 * @crash_reason: SMEM id for crash reason string, or 0 if none
 * @handover:	function to be called when proxy resources should be released
 *
 * Return: 0 on success, negative errno on failure
 */
int qcom_q6v5_init(struct qcom_q6v5 *q6v5, struct platform_device *pdev,
		   struct rproc *rproc, int crash_reason,
		   void (*handover)(struct qcom_q6v5 *q6v5))
{
	int ret;

	q6v5->rproc = rproc;
	q6v5->dev = &pdev->dev;
	q6v5->crash_reason = crash_reason;
	q6v5->handover = handover;

	init_completion(&q6v5->start_done);
	init_completion(&q6v5->stop_done);

	q6v5->wdog_irq = platform_get_irq_byname(pdev, "wdog");
	if (q6v5->wdog_irq < 0)
		return q6v5->wdog_irq;

	ret = devm_request_threaded_irq(&pdev->dev, q6v5->wdog_irq,
					NULL, q6v5_wdog_interrupt,
					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
					"q6v5 wdog", q6v5);
	if (ret) {
		dev_err(&pdev->dev, "failed to acquire wdog IRQ\n");
		return ret;
	}

	q6v5->fatal_irq = platform_get_irq_byname(pdev, "fatal");
	if (q6v5->fatal_irq < 0)
		return q6v5->fatal_irq;

	ret = devm_request_threaded_irq(&pdev->dev, q6v5->fatal_irq,
					NULL, q6v5_fatal_interrupt,
					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
					"q6v5 fatal", q6v5);
	if (ret) {
		dev_err(&pdev->dev, "failed to acquire fatal IRQ\n");
		return ret;
	}

	q6v5->ready_irq = platform_get_irq_byname(pdev, "ready");
	if (q6v5->ready_irq < 0)
		return q6v5->ready_irq;

	ret = devm_request_threaded_irq(&pdev->dev, q6v5->ready_irq,
					NULL, q6v5_ready_interrupt,
					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
					"q6v5 ready", q6v5);
	if (ret) {
		dev_err(&pdev->dev, "failed to acquire ready IRQ\n");
		return ret;
	}

	q6v5->handover_irq = platform_get_irq_byname(pdev, "handover");
	if (q6v5->handover_irq < 0)
		return q6v5->handover_irq;

	ret = devm_request_threaded_irq(&pdev->dev, q6v5->handover_irq,
					NULL, q6v5_handover_interrupt,
					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
					"q6v5 handover", q6v5);
	if (ret) {
		dev_err(&pdev->dev, "failed to acquire handover IRQ\n");
		return ret;
	}
	disable_irq(q6v5->handover_irq);

	q6v5->stop_irq = platform_get_irq_byname(pdev, "stop-ack");
	if (q6v5->stop_irq < 0)
		return q6v5->stop_irq;

	ret = devm_request_threaded_irq(&pdev->dev, q6v5->stop_irq,
					NULL, q6v5_stop_interrupt,
					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
					"q6v5 stop", q6v5);
	if (ret) {
		dev_err(&pdev->dev, "failed to acquire stop-ack IRQ\n");
		return ret;
	}

	q6v5->state = devm_qcom_smem_state_get(&pdev->dev, "stop", &q6v5->stop_bit);
	if (IS_ERR(q6v5->state)) {
		dev_err(&pdev->dev, "failed to acquire stop state\n");
		return PTR_ERR(q6v5->state);
	}

	return 0;
}
EXPORT_SYMBOL_GPL(qcom_q6v5_init);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Qualcomm Peripheral Image Loader for Q6V5");
Commit	Line	Data
3b415c8f BA	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Qualcomm Peripheral Image Loader for Q6V5
	4	*
	5	* Copyright (C) 2016-2018 Linaro Ltd.
	6	* Copyright (C) 2014 Sony Mobile Communications AB
	7	* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
	8	*/
	9	#include <linux/kernel.h>
	10	#include <linux/platform_device.h>
	11	#include <linux/interrupt.h>
ded79d06	12	#include <linux/module.h>
3b415c8f BA	13	#include <linux/soc/qcom/smem.h>
	14	#include <linux/soc/qcom/smem_state.h>
	15	#include <linux/remoteproc.h>
ed5da808	16	#include "qcom_common.h"
3b415c8f BA	17	#include "qcom_q6v5.h"
3b415c8f BA	18
e9142f5c BA	19	#define Q6V5_PANIC_DELAY_MS 200
e9142f5c BA	20
3b415c8f BA	21	/**
	22	* qcom_q6v5_prepare() - reinitialize the qcom_q6v5 context before start
	23	* @q6v5: reference to qcom_q6v5 context to be reinitialized
	24	*
	25	* Return: 0 on success, negative errno on failure
	26	*/
	27	int qcom_q6v5_prepare(struct qcom_q6v5 *q6v5)
	28	{
	29	reinit_completion(&q6v5->start_done);
	30	reinit_completion(&q6v5->stop_done);
	31
	32	q6v5->running = true;
	33	q6v5->handover_issued = false;
	34
	35	enable_irq(q6v5->handover_irq);
	36
	37	return 0;
	38	}
ded79d06	39	EXPORT_SYMBOL_GPL(qcom_q6v5_prepare);
3b415c8f BA	40
	41	/**
	42	* qcom_q6v5_unprepare() - unprepare the qcom_q6v5 context after stop
	43	* @q6v5: reference to qcom_q6v5 context to be unprepared
	44	*
	45	* Return: 0 on success, 1 if handover hasn't yet been called
	46	*/
	47	int qcom_q6v5_unprepare(struct qcom_q6v5 *q6v5)
	48	{
	49	disable_irq(q6v5->handover_irq);
	50
	51	return !q6v5->handover_issued;
	52	}
ded79d06	53	EXPORT_SYMBOL_GPL(qcom_q6v5_unprepare);
3b415c8f BA	54
	55	static irqreturn_t q6v5_wdog_interrupt(int irq, void *data)
	56	{
	57	struct qcom_q6v5 *q6v5 = data;
	58	size_t len;
	59	char *msg;
	60
	61	/* Sometimes the stop triggers a watchdog rather than a stop-ack */
	62	if (!q6v5->running) {
	63	complete(&q6v5->stop_done);
	64	return IRQ_HANDLED;
	65	}
	66
	67	msg = qcom_smem_get(QCOM_SMEM_HOST_ANY, q6v5->crash_reason, &len);
	68	if (!IS_ERR(msg) && len > 0 && msg[0])
	69	dev_err(q6v5->dev, "watchdog received: %s\n", msg);
	70	else
	71	dev_err(q6v5->dev, "watchdog without message\n");
	72
	73	rproc_report_crash(q6v5->rproc, RPROC_WATCHDOG);
	74
	75	return IRQ_HANDLED;
	76	}
	77
	78	static irqreturn_t q6v5_fatal_interrupt(int irq, void *data)
	79	{
	80	struct qcom_q6v5 *q6v5 = data;
	81	size_t len;
	82	char *msg;
	83
	84	msg = qcom_smem_get(QCOM_SMEM_HOST_ANY, q6v5->crash_reason, &len);
	85	if (!IS_ERR(msg) && len > 0 && msg[0])
	86	dev_err(q6v5->dev, "fatal error received: %s\n", msg);
	87	else
	88	dev_err(q6v5->dev, "fatal error without message\n");
	89
d3ae96c0	90	q6v5->running = false;
3b415c8f BA	91	rproc_report_crash(q6v5->rproc, RPROC_FATAL_ERROR);
	92
	93	return IRQ_HANDLED;
	94	}
	95
	96	static irqreturn_t q6v5_ready_interrupt(int irq, void *data)
	97	{
	98	struct qcom_q6v5 *q6v5 = data;
	99
	100	complete(&q6v5->start_done);
	101
	102	return IRQ_HANDLED;
	103	}
	104
	105	/**
	106	* qcom_q6v5_wait_for_start() - wait for remote processor start signal
	107	* @q6v5: reference to qcom_q6v5 context
	108	* @timeout: timeout to wait for the event, in jiffies
	109	*
	110	* qcom_q6v5_unprepare() should not be called when this function fails.
	111	*
	112	* Return: 0 on success, -ETIMEDOUT on timeout
	113	*/
	114	int qcom_q6v5_wait_for_start(struct qcom_q6v5 *q6v5, int timeout)
	115	{
	116	int ret;
	117
	118	ret = wait_for_completion_timeout(&q6v5->start_done, timeout);
	119	if (!ret)
	120	disable_irq(q6v5->handover_irq);
	121
	122	return !ret ? -ETIMEDOUT : 0;
	123	}
ded79d06	124	EXPORT_SYMBOL_GPL(qcom_q6v5_wait_for_start);
3b415c8f BA	125
	126	static irqreturn_t q6v5_handover_interrupt(int irq, void *data)
	127	{
	128	struct qcom_q6v5 *q6v5 = data;
	129
	130	if (q6v5->handover)
	131	q6v5->handover(q6v5);
	132
	133	q6v5->handover_issued = true;
	134
	135	return IRQ_HANDLED;
	136	}
	137
	138	static irqreturn_t q6v5_stop_interrupt(int irq, void *data)
	139	{
	140	struct qcom_q6v5 *q6v5 = data;
	141
	142	complete(&q6v5->stop_done);
	143
	144	return IRQ_HANDLED;
	145	}
	146
	147	/**
	148	* qcom_q6v5_request_stop() - request the remote processor to stop
	149	* @q6v5: reference to qcom_q6v5 context
ed5da808	150	* @sysmon: reference to the remote's sysmon instance, or NULL
3b415c8f BA	151	*
	152	* Return: 0 on success, negative errno on failure
	153	*/
ed5da808	154	int qcom_q6v5_request_stop(struct qcom_q6v5 q6v5, struct qcom_sysmon sysmon)
3b415c8f BA	155	{
	156	int ret;
	157
5b7be880 SS	158	q6v5->running = false;
5b7be880 SS	159
ed5da808 BA	160	/* Don't perform SMP2P dance if sysmon already shut down the remote */
	161	if (qcom_sysmon_shutdown_acked(sysmon))
	162	return 0;
	163
3b415c8f BA	164	qcom_smem_state_update_bits(q6v5->state,
	165	BIT(q6v5->stop_bit), BIT(q6v5->stop_bit));
	166
	167	ret = wait_for_completion_timeout(&q6v5->stop_done, 5 * HZ);
	168
	169	qcom_smem_state_update_bits(q6v5->state, BIT(q6v5->stop_bit), 0);
	170
	171	return ret == 0 ? -ETIMEDOUT : 0;
	172	}
ded79d06	173	EXPORT_SYMBOL_GPL(qcom_q6v5_request_stop);
3b415c8f	174
e9142f5c BA	175	/**
	176	* qcom_q6v5_panic() - panic handler to invoke a stop on the remote
	177	* @q6v5: reference to qcom_q6v5 context
	178	*
	179	* Set the stop bit and sleep in order to allow the remote processor to flush
	180	* its caches etc for post mortem debugging.
	181	*
	182	* Return: 200ms
	183	*/
	184	unsigned long qcom_q6v5_panic(struct qcom_q6v5 *q6v5)
	185	{
	186	qcom_smem_state_update_bits(q6v5->state,
	187	BIT(q6v5->stop_bit), BIT(q6v5->stop_bit));
	188
	189	return Q6V5_PANIC_DELAY_MS;
	190	}
	191	EXPORT_SYMBOL_GPL(qcom_q6v5_panic);
	192
3b415c8f BA	193	/**
	194	* qcom_q6v5_init() - initializer of the q6v5 common struct
	195	* @q6v5: handle to be initialized
	196	* @pdev: platform_device reference for acquiring resources
	197	* @rproc: associated remoteproc instance
	198	* @crash_reason: SMEM id for crash reason string, or 0 if none
	199	* @handover: function to be called when proxy resources should be released
	200	*
	201	* Return: 0 on success, negative errno on failure
	202	*/
	203	int qcom_q6v5_init(struct qcom_q6v5 q6v5, struct platform_device pdev,
	204	struct rproc *rproc, int crash_reason,
	205	void (handover)(struct qcom_q6v5 q6v5))
	206	{
	207	int ret;
	208
	209	q6v5->rproc = rproc;
	210	q6v5->dev = &pdev->dev;
	211	q6v5->crash_reason = crash_reason;
	212	q6v5->handover = handover;
	213
	214	init_completion(&q6v5->start_done);
	215	init_completion(&q6v5->stop_done);
	216
	217	q6v5->wdog_irq = platform_get_irq_byname(pdev, "wdog");
d446609d	218	if (q6v5->wdog_irq < 0)
1e2517d1	219	return q6v5->wdog_irq;
1e2517d1	220
3b415c8f BA	221	ret = devm_request_threaded_irq(&pdev->dev, q6v5->wdog_irq,
	222	NULL, q6v5_wdog_interrupt,
	223	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	224	"q6v5 wdog", q6v5);
	225	if (ret) {
	226	dev_err(&pdev->dev, "failed to acquire wdog IRQ\n");
	227	return ret;
	228	}
	229
	230	q6v5->fatal_irq = platform_get_irq_byname(pdev, "fatal");
d446609d	231	if (q6v5->fatal_irq < 0)
1e2517d1	232	return q6v5->fatal_irq;
d5269c45	233
3b415c8f BA	234	ret = devm_request_threaded_irq(&pdev->dev, q6v5->fatal_irq,
	235	NULL, q6v5_fatal_interrupt,
	236	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	237	"q6v5 fatal", q6v5);
	238	if (ret) {
	239	dev_err(&pdev->dev, "failed to acquire fatal IRQ\n");
	240	return ret;
	241	}
	242
	243	q6v5->ready_irq = platform_get_irq_byname(pdev, "ready");
d446609d	244	if (q6v5->ready_irq < 0)
1e2517d1	245	return q6v5->ready_irq;
d5269c45	246
3b415c8f BA	247	ret = devm_request_threaded_irq(&pdev->dev, q6v5->ready_irq,
	248	NULL, q6v5_ready_interrupt,
	249	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	250	"q6v5 ready", q6v5);
	251	if (ret) {
	252	dev_err(&pdev->dev, "failed to acquire ready IRQ\n");
	253	return ret;
	254	}
	255
	256	q6v5->handover_irq = platform_get_irq_byname(pdev, "handover");
d446609d	257	if (q6v5->handover_irq < 0)
1e2517d1	258	return q6v5->handover_irq;
d5269c45	259
3b415c8f BA	260	ret = devm_request_threaded_irq(&pdev->dev, q6v5->handover_irq,
	261	NULL, q6v5_handover_interrupt,
	262	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	263	"q6v5 handover", q6v5);
	264	if (ret) {
	265	dev_err(&pdev->dev, "failed to acquire handover IRQ\n");
	266	return ret;
	267	}
	268	disable_irq(q6v5->handover_irq);
	269
	270	q6v5->stop_irq = platform_get_irq_byname(pdev, "stop-ack");
d446609d	271	if (q6v5->stop_irq < 0)
1e2517d1	272	return q6v5->stop_irq;
d5269c45	273
3b415c8f BA	274	ret = devm_request_threaded_irq(&pdev->dev, q6v5->stop_irq,
	275	NULL, q6v5_stop_interrupt,
	276	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	277	"q6v5 stop", q6v5);
	278	if (ret) {
	279	dev_err(&pdev->dev, "failed to acquire stop-ack IRQ\n");
	280	return ret;
	281	}
	282
632f1ca3	283	q6v5->state = devm_qcom_smem_state_get(&pdev->dev, "stop", &q6v5->stop_bit);
3b415c8f BA	284	if (IS_ERR(q6v5->state)) {
	285	dev_err(&pdev->dev, "failed to acquire stop state\n");
	286	return PTR_ERR(q6v5->state);
	287	}
	288
	289	return 0;
	290	}
ded79d06 AB	291	EXPORT_SYMBOL_GPL(qcom_q6v5_init);
	292
	293	MODULE_LICENSE("GPL v2");
	294	MODULE_DESCRIPTION("Qualcomm Peripheral Image Loader for Q6V5");