1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * ST's Remote Processor Control Driver
4 *
5 * Copyright (C) 2015 STMicroelectronics - All Rights Reserved
6 *
7 * Author: Ludovic Barre <ludovic.barre@st.com>
8 */
9
10#include <linux/clk.h>
11#include <linux/dma-mapping.h>
12#include <linux/err.h>
13#include <linux/interrupt.h>
14#include <linux/kernel.h>
15#include <linux/mailbox_client.h>
16#include <linux/mfd/syscon.h>
17#include <linux/module.h>
18#include <linux/of.h>
19#include <linux/of_address.h>
20#include <linux/of_device.h>
21#include <linux/of_reserved_mem.h>
22#include <linux/platform_device.h>
23#include <linux/regmap.h>
24#include <linux/remoteproc.h>
25#include <linux/reset.h>
26
27#include "remoteproc_internal.h"
28
29#define ST_RPROC_VQ0		0
30#define ST_RPROC_VQ1		1
31#define ST_RPROC_MAX_VRING	2
32
33#define MBOX_RX			0
34#define MBOX_TX			1
35#define MBOX_MAX		2
36
37struct st_rproc_config {
38	bool			sw_reset;
39	bool			pwr_reset;
40	unsigned long		bootaddr_mask;
41};
42
43struct st_rproc {
44	struct st_rproc_config	*config;
45	struct reset_control	*sw_reset;
46	struct reset_control	*pwr_reset;
47	struct clk		*clk;
48	u32			clk_rate;
49	struct regmap		*boot_base;
50	u32			boot_offset;
51	struct mbox_chan	*mbox_chan[ST_RPROC_MAX_VRING * MBOX_MAX];
52	struct mbox_client mbox_client_vq0;
53	struct mbox_client mbox_client_vq1;
54};
55
56static void st_rproc_mbox_callback(struct device *dev, u32 msg)
57{
58	struct rproc *rproc = dev_get_drvdata(dev);
59
60	if (rproc_vq_interrupt(rproc, msg) == IRQ_NONE)
61		dev_dbg(dev, "no message was found in vqid %d\n", msg);
62}
63
64static
65void st_rproc_mbox_callback_vq0(struct mbox_client *mbox_client, void *data)
66{
67	st_rproc_mbox_callback(mbox_client->dev, 0);
68}
69
70static
71void st_rproc_mbox_callback_vq1(struct mbox_client *mbox_client, void *data)
72{
73	st_rproc_mbox_callback(mbox_client->dev, 1);
74}
75
76static void st_rproc_kick(struct rproc *rproc, int vqid)
77{
78	struct st_rproc *ddata = rproc->priv;
79	struct device *dev = rproc->dev.parent;
80	int ret;
81
82	/* send the index of the triggered virtqueue in the mailbox payload */
83	if (WARN_ON(vqid >= ST_RPROC_MAX_VRING))
84		return;
85
86	ret = mbox_send_message(ddata->mbox_chan[vqid * MBOX_MAX + MBOX_TX],
87				(void *)&vqid);
88	if (ret < 0)
89		dev_err(dev, "failed to send message via mbox: %d\n", ret);
90}
91
92static int st_rproc_mem_alloc(struct rproc *rproc,
93			      struct rproc_mem_entry *mem)
94{
95	struct device *dev = rproc->dev.parent;
96	void *va;
97
98	va = ioremap_wc(mem->dma, mem->len);
99	if (!va) {
100		dev_err(dev, "Unable to map memory region: %pa+%zx\n",
101			&mem->dma, mem->len);
102		return -ENOMEM;
103	}
104
105	/* Update memory entry va */
106	mem->va = va;
107
108	return 0;
109}
110
111static int st_rproc_mem_release(struct rproc *rproc,
112				struct rproc_mem_entry *mem)
113{
114	iounmap(mem->va);
115
116	return 0;
117}
118
119static int st_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
120{
121	struct device *dev = rproc->dev.parent;
122	struct device_node *np = dev->of_node;
123	struct rproc_mem_entry *mem;
124	struct reserved_mem *rmem;
125	struct of_phandle_iterator it;
126	int index = 0;
127
128	of_phandle_iterator_init(&it, np, "memory-region", NULL, 0);
129	while (of_phandle_iterator_next(&it) == 0) {
130		rmem = of_reserved_mem_lookup(it.node);
131		if (!rmem) {
132			of_node_put(it.node);
133			dev_err(dev, "unable to acquire memory-region\n");
134			return -EINVAL;
135		}
136
137		/*  No need to map vdev buffer */
138		if (strcmp(it.node->name, "vdev0buffer")) {
139			/* Register memory region */
140			mem = rproc_mem_entry_init(dev, NULL,
141						   (dma_addr_t)rmem->base,
142						   rmem->size, rmem->base,
143						   st_rproc_mem_alloc,
144						   st_rproc_mem_release,
145						   it.node->name);
146		} else {
147			/* Register reserved memory for vdev buffer allocation */
148			mem = rproc_of_resm_mem_entry_init(dev, index,
149							   rmem->size,
150							   rmem->base,
151							   it.node->name);
152		}
153
154		if (!mem) {
155			of_node_put(it.node);
156			return -ENOMEM;
157		}
158
159		rproc_add_carveout(rproc, mem);
160		index++;
161	}
162
163	return rproc_elf_load_rsc_table(rproc, fw);
164}
165
166static int st_rproc_start(struct rproc *rproc)
167{
168	struct st_rproc *ddata = rproc->priv;
169	int err;
170
171	regmap_update_bits(ddata->boot_base, ddata->boot_offset,
172			   ddata->config->bootaddr_mask, rproc->bootaddr);
173
174	err = clk_enable(ddata->clk);
175	if (err) {
176		dev_err(&rproc->dev, "Failed to enable clock\n");
177		return err;
178	}
179
180	if (ddata->config->sw_reset) {
181		err = reset_control_deassert(ddata->sw_reset);
182		if (err) {
183			dev_err(&rproc->dev, "Failed to deassert S/W Reset\n");
184			goto sw_reset_fail;
185		}
186	}
187
188	if (ddata->config->pwr_reset) {
189		err = reset_control_deassert(ddata->pwr_reset);
190		if (err) {
191			dev_err(&rproc->dev, "Failed to deassert Power Reset\n");
192			goto pwr_reset_fail;
193		}
194	}
195
196	dev_info(&rproc->dev, "Started from 0x%llx\n", rproc->bootaddr);
197
198	return 0;
199
200
201pwr_reset_fail:
202	if (ddata->config->pwr_reset)
203		reset_control_assert(ddata->sw_reset);
204sw_reset_fail:
205	clk_disable(ddata->clk);
206
207	return err;
208}
209
210static int st_rproc_stop(struct rproc *rproc)
211{
212	struct st_rproc *ddata = rproc->priv;
213	int sw_err = 0, pwr_err = 0;
214
215	if (ddata->config->sw_reset) {
216		sw_err = reset_control_assert(ddata->sw_reset);
217		if (sw_err)
218			dev_err(&rproc->dev, "Failed to assert S/W Reset\n");
219	}
220
221	if (ddata->config->pwr_reset) {
222		pwr_err = reset_control_assert(ddata->pwr_reset);
223		if (pwr_err)
224			dev_err(&rproc->dev, "Failed to assert Power Reset\n");
225	}
226
227	clk_disable(ddata->clk);
228
229	return sw_err ?: pwr_err;
230}
231
232static const struct rproc_ops st_rproc_ops = {
233	.kick			= st_rproc_kick,
234	.start			= st_rproc_start,
235	.stop			= st_rproc_stop,
236	.parse_fw		= st_rproc_parse_fw,
237	.load			= rproc_elf_load_segments,
238	.find_loaded_rsc_table	= rproc_elf_find_loaded_rsc_table,
239	.sanity_check		= rproc_elf_sanity_check,
240	.get_boot_addr		= rproc_elf_get_boot_addr,
241};
242
243/*
244 * Fetch state of the processor: 0 is off, 1 is on.
245 */
246static int st_rproc_state(struct platform_device *pdev)
247{
248	struct rproc *rproc = platform_get_drvdata(pdev);
249	struct st_rproc *ddata = rproc->priv;
250	int reset_sw = 0, reset_pwr = 0;
251
252	if (ddata->config->sw_reset)
253		reset_sw = reset_control_status(ddata->sw_reset);
254
255	if (ddata->config->pwr_reset)
256		reset_pwr = reset_control_status(ddata->pwr_reset);
257
258	if (reset_sw < 0 || reset_pwr < 0)
259		return -EINVAL;
260
261	return !reset_sw && !reset_pwr;
262}
263
264static const struct st_rproc_config st40_rproc_cfg = {
265	.sw_reset = true,
266	.pwr_reset = true,
267	.bootaddr_mask = GENMASK(28, 1),
268};
269
270static const struct st_rproc_config st231_rproc_cfg = {
271	.sw_reset = true,
272	.pwr_reset = false,
273	.bootaddr_mask = GENMASK(31, 6),
274};
275
276static const struct of_device_id st_rproc_match[] = {
277	{ .compatible = "st,st40-rproc", .data = &st40_rproc_cfg },
278	{ .compatible = "st,st231-rproc", .data = &st231_rproc_cfg },
279	{},
280};
281MODULE_DEVICE_TABLE(of, st_rproc_match);
282
283static int st_rproc_parse_dt(struct platform_device *pdev)
284{
285	struct device *dev = &pdev->dev;
286	struct rproc *rproc = platform_get_drvdata(pdev);
287	struct st_rproc *ddata = rproc->priv;
288	struct device_node *np = dev->of_node;
289	int err;
290
291	if (ddata->config->sw_reset) {
292		ddata->sw_reset = devm_reset_control_get_exclusive(dev,
293								   "sw_reset");
294		if (IS_ERR(ddata->sw_reset)) {
295			dev_err(dev, "Failed to get S/W Reset\n");
296			return PTR_ERR(ddata->sw_reset);
297		}
298	}
299
300	if (ddata->config->pwr_reset) {
301		ddata->pwr_reset = devm_reset_control_get_exclusive(dev,
302								    "pwr_reset");
303		if (IS_ERR(ddata->pwr_reset)) {
304			dev_err(dev, "Failed to get Power Reset\n");
305			return PTR_ERR(ddata->pwr_reset);
306		}
307	}
308
309	ddata->clk = devm_clk_get(dev, NULL);
310	if (IS_ERR(ddata->clk)) {
311		dev_err(dev, "Failed to get clock\n");
312		return PTR_ERR(ddata->clk);
313	}
314
315	err = of_property_read_u32(np, "clock-frequency", &ddata->clk_rate);
316	if (err) {
317		dev_err(dev, "failed to get clock frequency\n");
318		return err;
319	}
320
321	ddata->boot_base = syscon_regmap_lookup_by_phandle(np, "st,syscfg");
322	if (IS_ERR(ddata->boot_base)) {
323		dev_err(dev, "Boot base not found\n");
324		return PTR_ERR(ddata->boot_base);
325	}
326
327	err = of_property_read_u32_index(np, "st,syscfg", 1,
328					 &ddata->boot_offset);
329	if (err) {
330		dev_err(dev, "Boot offset not found\n");
331		return -EINVAL;
332	}
333
334	err = clk_prepare(ddata->clk);
335	if (err)
336		dev_err(dev, "failed to get clock\n");
337
338	return err;
339}
340
341static int st_rproc_probe(struct platform_device *pdev)
342{
343	struct device *dev = &pdev->dev;
344	const struct of_device_id *match;
345	struct st_rproc *ddata;
346	struct device_node *np = dev->of_node;
347	struct rproc *rproc;
348	struct mbox_chan *chan;
349	int enabled;
350	int ret, i;
351
352	match = of_match_device(st_rproc_match, dev);
353	if (!match || !match->data) {
354		dev_err(dev, "No device match found\n");
355		return -ENODEV;
356	}
357
358	rproc = rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata));
359	if (!rproc)
360		return -ENOMEM;
361
362	rproc->has_iommu = false;
363	ddata = rproc->priv;
364	ddata->config = (struct st_rproc_config *)match->data;
365
366	platform_set_drvdata(pdev, rproc);
367
368	ret = st_rproc_parse_dt(pdev);
369	if (ret)
370		goto free_rproc;
371
372	enabled = st_rproc_state(pdev);
373	if (enabled < 0) {
374		ret = enabled;
375		goto free_clk;
376	}
377
378	if (enabled) {
379		atomic_inc(&rproc->power);
380		rproc->state = RPROC_RUNNING;
381	} else {
382		clk_set_rate(ddata->clk, ddata->clk_rate);
383	}
384
385	if (of_get_property(np, "mbox-names", NULL)) {
386		ddata->mbox_client_vq0.dev		= dev;
387		ddata->mbox_client_vq0.tx_done		= NULL;
388		ddata->mbox_client_vq0.tx_block	= false;
389		ddata->mbox_client_vq0.knows_txdone	= false;
390		ddata->mbox_client_vq0.rx_callback	= st_rproc_mbox_callback_vq0;
391
392		ddata->mbox_client_vq1.dev		= dev;
393		ddata->mbox_client_vq1.tx_done		= NULL;
394		ddata->mbox_client_vq1.tx_block	= false;
395		ddata->mbox_client_vq1.knows_txdone	= false;
396		ddata->mbox_client_vq1.rx_callback	= st_rproc_mbox_callback_vq1;
397
398		/*
399		 * To control a co-processor without IPC mechanism.
400		 * This driver can be used without mbox and rpmsg.
401		 */
402		chan = mbox_request_channel_byname(&ddata->mbox_client_vq0, "vq0_rx");
403		if (IS_ERR(chan)) {
404			dev_err(&rproc->dev, "failed to request mbox chan 0\n");
405			ret = PTR_ERR(chan);
406			goto free_clk;
407		}
408		ddata->mbox_chan[ST_RPROC_VQ0 * MBOX_MAX + MBOX_RX] = chan;
409
410		chan = mbox_request_channel_byname(&ddata->mbox_client_vq0, "vq0_tx");
411		if (IS_ERR(chan)) {
412			dev_err(&rproc->dev, "failed to request mbox chan 0\n");
413			ret = PTR_ERR(chan);
414			goto free_mbox;
415		}
416		ddata->mbox_chan[ST_RPROC_VQ0 * MBOX_MAX + MBOX_TX] = chan;
417
418		chan = mbox_request_channel_byname(&ddata->mbox_client_vq1, "vq1_rx");
419		if (IS_ERR(chan)) {
420			dev_err(&rproc->dev, "failed to request mbox chan 1\n");
421			ret = PTR_ERR(chan);
422			goto free_mbox;
423		}
424		ddata->mbox_chan[ST_RPROC_VQ1 * MBOX_MAX + MBOX_RX] = chan;
425
426		chan = mbox_request_channel_byname(&ddata->mbox_client_vq1, "vq1_tx");
427		if (IS_ERR(chan)) {
428			dev_err(&rproc->dev, "failed to request mbox chan 1\n");
429			ret = PTR_ERR(chan);
430			goto free_mbox;
431		}
432		ddata->mbox_chan[ST_RPROC_VQ1 * MBOX_MAX + MBOX_TX] = chan;
433	}
434
435	ret = rproc_add(rproc);
436	if (ret)
437		goto free_mbox;
438
439	return 0;
440
441free_mbox:
442	for (i = 0; i < ST_RPROC_MAX_VRING * MBOX_MAX; i++)
443		mbox_free_channel(ddata->mbox_chan[i]);
444free_clk:
445	clk_unprepare(ddata->clk);
446free_rproc:
447	rproc_free(rproc);
448	return ret;
449}
450
451static int st_rproc_remove(struct platform_device *pdev)
452{
453	struct rproc *rproc = platform_get_drvdata(pdev);
454	struct st_rproc *ddata = rproc->priv;
455	int i;
456
457	rproc_del(rproc);
458
459	clk_disable_unprepare(ddata->clk);
460
461	for (i = 0; i < ST_RPROC_MAX_VRING * MBOX_MAX; i++)
462		mbox_free_channel(ddata->mbox_chan[i]);
463
464	rproc_free(rproc);
465
466	return 0;
467}
468
469static struct platform_driver st_rproc_driver = {
470	.probe = st_rproc_probe,
471	.remove = st_rproc_remove,
472	.driver = {
473		.name = "st-rproc",
474		.of_match_table = of_match_ptr(st_rproc_match),
475	},
476};
477module_platform_driver(st_rproc_driver);
478
479MODULE_DESCRIPTION("ST Remote Processor Control Driver");
480MODULE_AUTHOR("Ludovic Barre <ludovic.barre@st.com>");
481MODULE_LICENSE("GPL v2");
482