[linux-2.6-block.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/interconnect.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/soc/qcom/qcom_aoss.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_LOAD_STATE_MSG_LEN	64
#define Q6V5_PANIC_DELAY_MS	200

static int q6v5_load_state_toggle(struct qcom_q6v5 *q6v5, bool enable)
{
	int ret;

	if (!q6v5->qmp)
		return 0;

	ret = qmp_send(q6v5->qmp, "{class: image, res: load_state, name: %s, val: %s}",
		       q6v5->load_state, enable ? "on" : "off");
	if (ret)
		dev_err(q6v5->dev, "failed to toggle load state\n");

	return ret;
}

/**
 * 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)
{
	int ret;

	ret = icc_set_bw(q6v5->path, 0, UINT_MAX);
	if (ret < 0) {
		dev_err(q6v5->dev, "failed to set bandwidth request\n");
		return ret;
	}

	ret = q6v5_load_state_toggle(q6v5, true);
	if (ret) {
		icc_set_bw(q6v5->path, 0, 0);
		return ret;
	}

	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);
	q6v5_load_state_toggle(q6v5, false);

	/* Disable interconnect vote, in case handover never happened */
	icc_set_bw(q6v5->path, 0, 0);

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

	q6v5->running = false;
	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;

	if (!q6v5->running)
		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, "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);

	icc_set_bw(q6v5->path, 0, 0);

	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 remote isn't running */
	if (q6v5->rproc->state != RPROC_RUNNING || 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
 * @load_state: load state resource string
 * @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, const char *load_state,
		   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);
	}

	q6v5->load_state = devm_kstrdup_const(&pdev->dev, load_state, GFP_KERNEL);
	q6v5->qmp = qmp_get(&pdev->dev);
	if (IS_ERR(q6v5->qmp)) {
		if (PTR_ERR(q6v5->qmp) != -ENODEV)
			return dev_err_probe(&pdev->dev, PTR_ERR(q6v5->qmp),
					     "failed to acquire load state\n");
		q6v5->qmp = NULL;
	} else if (!q6v5->load_state) {
		if (!load_state)
			dev_err(&pdev->dev, "load state resource string empty\n");

		qmp_put(q6v5->qmp);
		return load_state ? -ENOMEM : -EINVAL;
	}

	q6v5->path = devm_of_icc_get(&pdev->dev, NULL);
	if (IS_ERR(q6v5->path))
		return dev_err_probe(&pdev->dev, PTR_ERR(q6v5->path),
				     "failed to acquire interconnect path\n");

	return 0;
}
EXPORT_SYMBOL_GPL(qcom_q6v5_init);

/**
 * qcom_q6v5_deinit() - deinitialize the q6v5 common struct
 * @q6v5:	reference to qcom_q6v5 context to be deinitialized
 */
void qcom_q6v5_deinit(struct qcom_q6v5 *q6v5)
{
	qmp_put(q6v5->qmp);
}
EXPORT_SYMBOL_GPL(qcom_q6v5_deinit);

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>
8d9be5c6	11	#include <linux/interconnect.h>
3b415c8f	12	#include <linux/interrupt.h>
ded79d06	13	#include <linux/module.h>
eee412e9	14	#include <linux/soc/qcom/qcom_aoss.h>
3b415c8f BA	15	#include <linux/soc/qcom/smem.h>
	16	#include <linux/soc/qcom/smem_state.h>
	17	#include <linux/remoteproc.h>
ed5da808	18	#include "qcom_common.h"
3b415c8f BA	19	#include "qcom_q6v5.h"
3b415c8f BA	20
c1fe10d2	21	#define Q6V5_LOAD_STATE_MSG_LEN 64
e9142f5c BA	22	#define Q6V5_PANIC_DELAY_MS 200
e9142f5c BA	23
c1fe10d2 SS	24	static int q6v5_load_state_toggle(struct qcom_q6v5 *q6v5, bool enable)
c1fe10d2 SS	25	{
c1fe10d2 SS	26	int ret;
	27
	28	if (!q6v5->qmp)
	29	return 0;
	30
b4f63bbf	31	ret = qmp_send(q6v5->qmp, "{class: image, res: load_state, name: %s, val: %s}",
c1fe10d2	32	q6v5->load_state, enable ? "on" : "off");
c1fe10d2 SS	33	if (ret)
	34	dev_err(q6v5->dev, "failed to toggle load state\n");
	35
	36	return ret;
	37	}
	38
3b415c8f BA	39	/**
	40	* qcom_q6v5_prepare() - reinitialize the qcom_q6v5 context before start
	41	* @q6v5: reference to qcom_q6v5 context to be reinitialized
	42	*
	43	* Return: 0 on success, negative errno on failure
	44	*/
	45	int qcom_q6v5_prepare(struct qcom_q6v5 *q6v5)
	46	{
c1fe10d2 SS	47	int ret;
c1fe10d2 SS	48
8d9be5c6 BA	49	ret = icc_set_bw(q6v5->path, 0, UINT_MAX);
	50	if (ret < 0) {
	51	dev_err(q6v5->dev, "failed to set bandwidth request\n");
	52	return ret;
	53	}
	54
c1fe10d2	55	ret = q6v5_load_state_toggle(q6v5, true);
8d9be5c6 BA	56	if (ret) {
8d9be5c6 BA	57	icc_set_bw(q6v5->path, 0, 0);
c1fe10d2	58	return ret;
8d9be5c6	59	}
c1fe10d2	60
3b415c8f BA	61	reinit_completion(&q6v5->start_done);
	62	reinit_completion(&q6v5->stop_done);
	63
	64	q6v5->running = true;
	65	q6v5->handover_issued = false;
	66
	67	enable_irq(q6v5->handover_irq);
	68
	69	return 0;
	70	}
ded79d06	71	EXPORT_SYMBOL_GPL(qcom_q6v5_prepare);
3b415c8f BA	72
	73	/**
	74	* qcom_q6v5_unprepare() - unprepare the qcom_q6v5 context after stop
	75	* @q6v5: reference to qcom_q6v5 context to be unprepared
	76	*
	77	* Return: 0 on success, 1 if handover hasn't yet been called
	78	*/
	79	int qcom_q6v5_unprepare(struct qcom_q6v5 *q6v5)
	80	{
	81	disable_irq(q6v5->handover_irq);
c1fe10d2	82	q6v5_load_state_toggle(q6v5, false);
3b415c8f	83
8d9be5c6 BA	84	/* Disable interconnect vote, in case handover never happened */
	85	icc_set_bw(q6v5->path, 0, 0);
	86
3b415c8f BA	87	return !q6v5->handover_issued;
3b415c8f BA	88	}
ded79d06	89	EXPORT_SYMBOL_GPL(qcom_q6v5_unprepare);
3b415c8f BA	90
	91	static irqreturn_t q6v5_wdog_interrupt(int irq, void *data)
	92	{
	93	struct qcom_q6v5 *q6v5 = data;
	94	size_t len;
	95	char *msg;
	96
	97	/* Sometimes the stop triggers a watchdog rather than a stop-ack */
	98	if (!q6v5->running) {
	99	complete(&q6v5->stop_done);
	100	return IRQ_HANDLED;
	101	}
	102
	103	msg = qcom_smem_get(QCOM_SMEM_HOST_ANY, q6v5->crash_reason, &len);
	104	if (!IS_ERR(msg) && len > 0 && msg[0])
	105	dev_err(q6v5->dev, "watchdog received: %s\n", msg);
	106	else
	107	dev_err(q6v5->dev, "watchdog without message\n");
	108
0ad7e3ed	109	q6v5->running = false;
3b415c8f BA	110	rproc_report_crash(q6v5->rproc, RPROC_WATCHDOG);
	111
	112	return IRQ_HANDLED;
	113	}
	114
	115	static irqreturn_t q6v5_fatal_interrupt(int irq, void *data)
	116	{
	117	struct qcom_q6v5 *q6v5 = data;
	118	size_t len;
	119	char *msg;
	120
0ad7e3ed SG	121	if (!q6v5->running)
	122	return IRQ_HANDLED;
	123
3b415c8f BA	124	msg = qcom_smem_get(QCOM_SMEM_HOST_ANY, q6v5->crash_reason, &len);
	125	if (!IS_ERR(msg) && len > 0 && msg[0])
	126	dev_err(q6v5->dev, "fatal error received: %s\n", msg);
	127	else
	128	dev_err(q6v5->dev, "fatal error without message\n");
	129
d3ae96c0	130	q6v5->running = false;
3b415c8f BA	131	rproc_report_crash(q6v5->rproc, RPROC_FATAL_ERROR);
	132
	133	return IRQ_HANDLED;
	134	}
	135
	136	static irqreturn_t q6v5_ready_interrupt(int irq, void *data)
	137	{
	138	struct qcom_q6v5 *q6v5 = data;
	139
	140	complete(&q6v5->start_done);
	141
	142	return IRQ_HANDLED;
	143	}
	144
	145	/**
	146	* qcom_q6v5_wait_for_start() - wait for remote processor start signal
	147	* @q6v5: reference to qcom_q6v5 context
	148	* @timeout: timeout to wait for the event, in jiffies
	149	*
	150	* qcom_q6v5_unprepare() should not be called when this function fails.
	151	*
	152	* Return: 0 on success, -ETIMEDOUT on timeout
	153	*/
	154	int qcom_q6v5_wait_for_start(struct qcom_q6v5 *q6v5, int timeout)
	155	{
	156	int ret;
	157
	158	ret = wait_for_completion_timeout(&q6v5->start_done, timeout);
	159	if (!ret)
	160	disable_irq(q6v5->handover_irq);
	161
	162	return !ret ? -ETIMEDOUT : 0;
	163	}
ded79d06	164	EXPORT_SYMBOL_GPL(qcom_q6v5_wait_for_start);
3b415c8f BA	165
	166	static irqreturn_t q6v5_handover_interrupt(int irq, void *data)
	167	{
	168	struct qcom_q6v5 *q6v5 = data;
	169
	170	if (q6v5->handover)
	171	q6v5->handover(q6v5);
	172
8d9be5c6 BA	173	icc_set_bw(q6v5->path, 0, 0);
8d9be5c6 BA	174
3b415c8f BA	175	q6v5->handover_issued = true;
	176
	177	return IRQ_HANDLED;
	178	}
	179
	180	static irqreturn_t q6v5_stop_interrupt(int irq, void *data)
	181	{
	182	struct qcom_q6v5 *q6v5 = data;
	183
	184	complete(&q6v5->stop_done);
	185
	186	return IRQ_HANDLED;
	187	}
	188
	189	/**
	190	* qcom_q6v5_request_stop() - request the remote processor to stop
	191	* @q6v5: reference to qcom_q6v5 context
ed5da808	192	* @sysmon: reference to the remote's sysmon instance, or NULL
3b415c8f BA	193	*
	194	* Return: 0 on success, negative errno on failure
	195	*/
ed5da808	196	int qcom_q6v5_request_stop(struct qcom_q6v5 q6v5, struct qcom_sysmon sysmon)
3b415c8f BA	197	{
	198	int ret;
	199
5b7be880 SS	200	q6v5->running = false;
5b7be880 SS	201
3cc889eb GK	202	/* Don't perform SMP2P dance if remote isn't running */
3cc889eb GK	203	if (q6v5->rproc->state != RPROC_RUNNING \|\| qcom_sysmon_shutdown_acked(sysmon))
ed5da808 BA	204	return 0;
ed5da808 BA	205
3b415c8f BA	206	qcom_smem_state_update_bits(q6v5->state,
	207	BIT(q6v5->stop_bit), BIT(q6v5->stop_bit));
	208
	209	ret = wait_for_completion_timeout(&q6v5->stop_done, 5 * HZ);
	210
	211	qcom_smem_state_update_bits(q6v5->state, BIT(q6v5->stop_bit), 0);
	212
	213	return ret == 0 ? -ETIMEDOUT : 0;
	214	}
ded79d06	215	EXPORT_SYMBOL_GPL(qcom_q6v5_request_stop);
3b415c8f	216
e9142f5c BA	217	/**
	218	* qcom_q6v5_panic() - panic handler to invoke a stop on the remote
	219	* @q6v5: reference to qcom_q6v5 context
	220	*
	221	* Set the stop bit and sleep in order to allow the remote processor to flush
	222	* its caches etc for post mortem debugging.
	223	*
	224	* Return: 200ms
	225	*/
	226	unsigned long qcom_q6v5_panic(struct qcom_q6v5 *q6v5)
	227	{
	228	qcom_smem_state_update_bits(q6v5->state,
	229	BIT(q6v5->stop_bit), BIT(q6v5->stop_bit));
	230
	231	return Q6V5_PANIC_DELAY_MS;
	232	}
	233	EXPORT_SYMBOL_GPL(qcom_q6v5_panic);
	234
3b415c8f BA	235	/**
	236	* qcom_q6v5_init() - initializer of the q6v5 common struct
	237	* @q6v5: handle to be initialized
	238	* @pdev: platform_device reference for acquiring resources
	239	* @rproc: associated remoteproc instance
	240	* @crash_reason: SMEM id for crash reason string, or 0 if none
c1fe10d2	241	* @load_state: load state resource string
3b415c8f BA	242	* @handover: function to be called when proxy resources should be released
	243	*
	244	* Return: 0 on success, negative errno on failure
	245	*/
	246	int qcom_q6v5_init(struct qcom_q6v5 q6v5, struct platform_device pdev,
c1fe10d2	247	struct rproc rproc, int crash_reason, const char load_state,
3b415c8f BA	248	void (handover)(struct qcom_q6v5 q6v5))
	249	{
	250	int ret;
	251
	252	q6v5->rproc = rproc;
	253	q6v5->dev = &pdev->dev;
	254	q6v5->crash_reason = crash_reason;
	255	q6v5->handover = handover;
	256
	257	init_completion(&q6v5->start_done);
	258	init_completion(&q6v5->stop_done);
	259
	260	q6v5->wdog_irq = platform_get_irq_byname(pdev, "wdog");
d446609d	261	if (q6v5->wdog_irq < 0)
1e2517d1	262	return q6v5->wdog_irq;
1e2517d1	263
3b415c8f BA	264	ret = devm_request_threaded_irq(&pdev->dev, q6v5->wdog_irq,
	265	NULL, q6v5_wdog_interrupt,
	266	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	267	"q6v5 wdog", q6v5);
	268	if (ret) {
	269	dev_err(&pdev->dev, "failed to acquire wdog IRQ\n");
	270	return ret;
	271	}
	272
	273	q6v5->fatal_irq = platform_get_irq_byname(pdev, "fatal");
d446609d	274	if (q6v5->fatal_irq < 0)
1e2517d1	275	return q6v5->fatal_irq;
d5269c45	276
3b415c8f BA	277	ret = devm_request_threaded_irq(&pdev->dev, q6v5->fatal_irq,
	278	NULL, q6v5_fatal_interrupt,
	279	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	280	"q6v5 fatal", q6v5);
	281	if (ret) {
	282	dev_err(&pdev->dev, "failed to acquire fatal IRQ\n");
	283	return ret;
	284	}
	285
	286	q6v5->ready_irq = platform_get_irq_byname(pdev, "ready");
d446609d	287	if (q6v5->ready_irq < 0)
1e2517d1	288	return q6v5->ready_irq;
d5269c45	289
3b415c8f BA	290	ret = devm_request_threaded_irq(&pdev->dev, q6v5->ready_irq,
	291	NULL, q6v5_ready_interrupt,
	292	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	293	"q6v5 ready", q6v5);
	294	if (ret) {
	295	dev_err(&pdev->dev, "failed to acquire ready IRQ\n");
	296	return ret;
	297	}
	298
	299	q6v5->handover_irq = platform_get_irq_byname(pdev, "handover");
d446609d	300	if (q6v5->handover_irq < 0)
1e2517d1	301	return q6v5->handover_irq;
d5269c45	302
3b415c8f BA	303	ret = devm_request_threaded_irq(&pdev->dev, q6v5->handover_irq,
	304	NULL, q6v5_handover_interrupt,
	305	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	306	"q6v5 handover", q6v5);
	307	if (ret) {
	308	dev_err(&pdev->dev, "failed to acquire handover IRQ\n");
	309	return ret;
	310	}
	311	disable_irq(q6v5->handover_irq);
	312
	313	q6v5->stop_irq = platform_get_irq_byname(pdev, "stop-ack");
d446609d	314	if (q6v5->stop_irq < 0)
1e2517d1	315	return q6v5->stop_irq;
d5269c45	316
3b415c8f BA	317	ret = devm_request_threaded_irq(&pdev->dev, q6v5->stop_irq,
	318	NULL, q6v5_stop_interrupt,
	319	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	320	"q6v5 stop", q6v5);
	321	if (ret) {
	322	dev_err(&pdev->dev, "failed to acquire stop-ack IRQ\n");
	323	return ret;
	324	}
	325
632f1ca3	326	q6v5->state = devm_qcom_smem_state_get(&pdev->dev, "stop", &q6v5->stop_bit);
3b415c8f BA	327	if (IS_ERR(q6v5->state)) {
	328	dev_err(&pdev->dev, "failed to acquire stop state\n");
	329	return PTR_ERR(q6v5->state);
	330	}
	331
c1fe10d2 SS	332	q6v5->load_state = devm_kstrdup_const(&pdev->dev, load_state, GFP_KERNEL);
	333	q6v5->qmp = qmp_get(&pdev->dev);
	334	if (IS_ERR(q6v5->qmp)) {
	335	if (PTR_ERR(q6v5->qmp) != -ENODEV)
	336	return dev_err_probe(&pdev->dev, PTR_ERR(q6v5->qmp),
	337	"failed to acquire load state\n");
	338	q6v5->qmp = NULL;
	339	} else if (!q6v5->load_state) {
	340	if (!load_state)
	341	dev_err(&pdev->dev, "load state resource string empty\n");
	342
	343	qmp_put(q6v5->qmp);
	344	return load_state ? -ENOMEM : -EINVAL;
	345	}
	346
8d9be5c6 BA	347	q6v5->path = devm_of_icc_get(&pdev->dev, NULL);
	348	if (IS_ERR(q6v5->path))
	349	return dev_err_probe(&pdev->dev, PTR_ERR(q6v5->path),
	350	"failed to acquire interconnect path\n");
	351
3b415c8f BA	352	return 0;
3b415c8f BA	353	}
ded79d06 AB	354	EXPORT_SYMBOL_GPL(qcom_q6v5_init);
ded79d06 AB	355
c1fe10d2 SS	356	/**
	357	* qcom_q6v5_deinit() - deinitialize the q6v5 common struct
	358	* @q6v5: reference to qcom_q6v5 context to be deinitialized
	359	*/
	360	void qcom_q6v5_deinit(struct qcom_q6v5 *q6v5)
	361	{
	362	qmp_put(q6v5->qmp);
	363	}
	364	EXPORT_SYMBOL_GPL(qcom_q6v5_deinit);
	365
ded79d06 AB	366	MODULE_LICENSE("GPL v2");
ded79d06 AB	367	MODULE_DESCRIPTION("Qualcomm Peripheral Image Loader for Q6V5");