1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) STMicroelectronics 2018 - All Rights Reserved
4  * Authors: Ludovic Barre <ludovic.barre@st.com> for STMicroelectronics.
5  *          Fabien Dessenne <fabien.dessenne@st.com> for STMicroelectronics.
6  */
7 
8 #include <linux/arm-smccc.h>
9 #include <linux/dma-mapping.h>
10 #include <linux/interrupt.h>
11 #include <linux/io.h>
12 #include <linux/mailbox_client.h>
13 #include <linux/mfd/syscon.h>
14 #include <linux/module.h>
15 #include <linux/of.h>
16 #include <linux/of_reserved_mem.h>
17 #include <linux/platform_device.h>
18 #include <linux/pm_wakeirq.h>
19 #include <linux/regmap.h>
20 #include <linux/remoteproc.h>
21 #include <linux/reset.h>
22 #include <linux/slab.h>
23 #include <linux/workqueue.h>
24 
25 #include "remoteproc_internal.h"
26 
27 #define HOLD_BOOT		0
28 #define RELEASE_BOOT		1
29 
30 #define MBOX_NB_VQ		2
31 #define MBOX_NB_MBX		4
32 
33 #define STM32_SMC_RCC		0x82001000
34 #define STM32_SMC_REG_WRITE	0x1
35 
36 #define STM32_MBX_VQ0		"vq0"
37 #define STM32_MBX_VQ0_ID	0
38 #define STM32_MBX_VQ1		"vq1"
39 #define STM32_MBX_VQ1_ID	1
40 #define STM32_MBX_SHUTDOWN	"shutdown"
41 #define STM32_MBX_DETACH	"detach"
42 
43 #define RSC_TBL_SIZE		1024
44 
45 #define M4_STATE_OFF		0
46 #define M4_STATE_INI		1
47 #define M4_STATE_CRUN		2
48 #define M4_STATE_CSTOP		3
49 #define M4_STATE_STANDBY	4
50 #define M4_STATE_CRASH		5
51 
52 struct stm32_syscon {
53 	struct regmap *map;
54 	u32 reg;
55 	u32 mask;
56 };
57 
58 struct stm32_rproc_mem {
59 	char name[20];
60 	void __iomem *cpu_addr;
61 	phys_addr_t bus_addr;
62 	u32 dev_addr;
63 	size_t size;
64 };
65 
66 struct stm32_rproc_mem_ranges {
67 	u32 dev_addr;
68 	u32 bus_addr;
69 	u32 size;
70 };
71 
72 struct stm32_mbox {
73 	const unsigned char name[10];
74 	struct mbox_chan *chan;
75 	struct mbox_client client;
76 	struct work_struct vq_work;
77 	int vq_id;
78 };
79 
80 struct stm32_rproc {
81 	struct reset_control *rst;
82 	struct reset_control *hold_boot_rst;
83 	struct stm32_syscon hold_boot;
84 	struct stm32_syscon pdds;
85 	struct stm32_syscon m4_state;
86 	struct stm32_syscon rsctbl;
87 	int wdg_irq;
88 	u32 nb_rmems;
89 	struct stm32_rproc_mem *rmems;
90 	struct stm32_mbox mb[MBOX_NB_MBX];
91 	struct workqueue_struct *workqueue;
92 	bool hold_boot_smc;
93 	void __iomem *rsc_va;
94 };
95 
96 static int stm32_rproc_pa_to_da(struct rproc *rproc, phys_addr_t pa, u64 *da)
97 {
98 	unsigned int i;
99 	struct stm32_rproc *ddata = rproc->priv;
100 	struct stm32_rproc_mem *p_mem;
101 
102 	for (i = 0; i < ddata->nb_rmems; i++) {
103 		p_mem = &ddata->rmems[i];
104 
105 		if (pa < p_mem->bus_addr ||
106 		    pa >= p_mem->bus_addr + p_mem->size)
107 			continue;
108 		*da = pa - p_mem->bus_addr + p_mem->dev_addr;
109 		dev_dbg(rproc->dev.parent, "pa %pa to da %llx\n", &pa, *da);
110 		return 0;
111 	}
112 
113 	return -EINVAL;
114 }
115 
116 static int stm32_rproc_mem_alloc(struct rproc *rproc,
117 				 struct rproc_mem_entry *mem)
118 {
119 	struct device *dev = rproc->dev.parent;
120 	void *va;
121 
122 	dev_dbg(dev, "map memory: %pad+%zx\n", &mem->dma, mem->len);
123 	va = (__force void *)ioremap_wc(mem->dma, mem->len);
124 	if (IS_ERR_OR_NULL(va)) {
125 		dev_err(dev, "Unable to map memory region: %pad+0x%zx\n",
126 			&mem->dma, mem->len);
127 		return -ENOMEM;
128 	}
129 
130 	/* Update memory entry va */
131 	mem->va = va;
132 
133 	return 0;
134 }
135 
136 static int stm32_rproc_mem_release(struct rproc *rproc,
137 				   struct rproc_mem_entry *mem)
138 {
139 	dev_dbg(rproc->dev.parent, "unmap memory: %pa\n", &mem->dma);
140 	iounmap((__force __iomem void *)mem->va);
141 
142 	return 0;
143 }
144 
145 static int stm32_rproc_of_memory_translations(struct platform_device *pdev,
146 					      struct stm32_rproc *ddata)
147 {
148 	struct device *parent, *dev = &pdev->dev;
149 	struct device_node *np;
150 	struct stm32_rproc_mem *p_mems;
151 	struct stm32_rproc_mem_ranges *mem_range;
152 	int cnt, array_size, i, ret = 0;
153 
154 	parent = dev->parent;
155 	np = parent->of_node;
156 
157 	cnt = of_property_count_elems_of_size(np, "dma-ranges",
158 					      sizeof(*mem_range));
159 	if (cnt <= 0) {
160 		dev_err(dev, "%s: dma-ranges property not defined\n", __func__);
161 		return -EINVAL;
162 	}
163 
164 	p_mems = devm_kcalloc(dev, cnt, sizeof(*p_mems), GFP_KERNEL);
165 	if (!p_mems)
166 		return -ENOMEM;
167 	mem_range = kcalloc(cnt, sizeof(*mem_range), GFP_KERNEL);
168 	if (!mem_range)
169 		return -ENOMEM;
170 
171 	array_size = cnt * sizeof(struct stm32_rproc_mem_ranges) / sizeof(u32);
172 
173 	ret = of_property_read_u32_array(np, "dma-ranges",
174 					 (u32 *)mem_range, array_size);
175 	if (ret) {
176 		dev_err(dev, "error while get dma-ranges property: %x\n", ret);
177 		goto free_mem;
178 	}
179 
180 	for (i = 0; i < cnt; i++) {
181 		p_mems[i].bus_addr = mem_range[i].bus_addr;
182 		p_mems[i].dev_addr = mem_range[i].dev_addr;
183 		p_mems[i].size     = mem_range[i].size;
184 
185 		dev_dbg(dev, "memory range[%i]: da %#x, pa %pa, size %#zx:\n",
186 			i, p_mems[i].dev_addr, &p_mems[i].bus_addr,
187 			p_mems[i].size);
188 	}
189 
190 	ddata->rmems = p_mems;
191 	ddata->nb_rmems = cnt;
192 
193 free_mem:
194 	kfree(mem_range);
195 	return ret;
196 }
197 
198 static int stm32_rproc_mbox_idx(struct rproc *rproc, const unsigned char *name)
199 {
200 	struct stm32_rproc *ddata = rproc->priv;
201 	int i;
202 
203 	for (i = 0; i < ARRAY_SIZE(ddata->mb); i++) {
204 		if (!strncmp(ddata->mb[i].name, name, strlen(name)))
205 			return i;
206 	}
207 	dev_err(&rproc->dev, "mailbox %s not found\n", name);
208 
209 	return -EINVAL;
210 }
211 
212 static int stm32_rproc_prepare(struct rproc *rproc)
213 {
214 	struct device *dev = rproc->dev.parent;
215 	struct device_node *np = dev->of_node;
216 	struct of_phandle_iterator it;
217 	struct rproc_mem_entry *mem;
218 	struct reserved_mem *rmem;
219 	u64 da;
220 	int index = 0;
221 
222 	/* Register associated reserved memory regions */
223 	of_phandle_iterator_init(&it, np, "memory-region", NULL, 0);
224 	while (of_phandle_iterator_next(&it) == 0) {
225 		rmem = of_reserved_mem_lookup(it.node);
226 		if (!rmem) {
227 			of_node_put(it.node);
228 			dev_err(dev, "unable to acquire memory-region\n");
229 			return -EINVAL;
230 		}
231 
232 		if (stm32_rproc_pa_to_da(rproc, rmem->base, &da) < 0) {
233 			of_node_put(it.node);
234 			dev_err(dev, "memory region not valid %pa\n",
235 				&rmem->base);
236 			return -EINVAL;
237 		}
238 
239 		/*  No need to map vdev buffer */
240 		if (strcmp(it.node->name, "vdev0buffer")) {
241 			/* Register memory region */
242 			mem = rproc_mem_entry_init(dev, NULL,
243 						   (dma_addr_t)rmem->base,
244 						   rmem->size, da,
245 						   stm32_rproc_mem_alloc,
246 						   stm32_rproc_mem_release,
247 						   it.node->name);
248 
249 			if (mem)
250 				rproc_coredump_add_segment(rproc, da,
251 							   rmem->size);
252 		} else {
253 			/* Register reserved memory for vdev buffer alloc */
254 			mem = rproc_of_resm_mem_entry_init(dev, index,
255 							   rmem->size,
256 							   rmem->base,
257 							   it.node->name);
258 		}
259 
260 		if (!mem) {
261 			of_node_put(it.node);
262 			return -ENOMEM;
263 		}
264 
265 		rproc_add_carveout(rproc, mem);
266 		index++;
267 	}
268 
269 	return 0;
270 }
271 
272 static int stm32_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
273 {
274 	if (rproc_elf_load_rsc_table(rproc, fw))
275 		dev_warn(&rproc->dev, "no resource table found for this firmware\n");
276 
277 	return 0;
278 }
279 
280 static irqreturn_t stm32_rproc_wdg(int irq, void *data)
281 {
282 	struct platform_device *pdev = data;
283 	struct rproc *rproc = platform_get_drvdata(pdev);
284 
285 	rproc_report_crash(rproc, RPROC_WATCHDOG);
286 
287 	return IRQ_HANDLED;
288 }
289 
290 static void stm32_rproc_mb_vq_work(struct work_struct *work)
291 {
292 	struct stm32_mbox *mb = container_of(work, struct stm32_mbox, vq_work);
293 	struct rproc *rproc = dev_get_drvdata(mb->client.dev);
294 
295 	mutex_lock(&rproc->lock);
296 
297 	if (rproc->state != RPROC_RUNNING)
298 		goto unlock_mutex;
299 
300 	if (rproc_vq_interrupt(rproc, mb->vq_id) == IRQ_NONE)
301 		dev_dbg(&rproc->dev, "no message found in vq%d\n", mb->vq_id);
302 
303 unlock_mutex:
304 	mutex_unlock(&rproc->lock);
305 }
306 
307 static void stm32_rproc_mb_callback(struct mbox_client *cl, void *data)
308 {
309 	struct rproc *rproc = dev_get_drvdata(cl->dev);
310 	struct stm32_mbox *mb = container_of(cl, struct stm32_mbox, client);
311 	struct stm32_rproc *ddata = rproc->priv;
312 
313 	queue_work(ddata->workqueue, &mb->vq_work);
314 }
315 
316 static void stm32_rproc_free_mbox(struct rproc *rproc)
317 {
318 	struct stm32_rproc *ddata = rproc->priv;
319 	unsigned int i;
320 
321 	for (i = 0; i < ARRAY_SIZE(ddata->mb); i++) {
322 		if (ddata->mb[i].chan)
323 			mbox_free_channel(ddata->mb[i].chan);
324 		ddata->mb[i].chan = NULL;
325 	}
326 }
327 
328 static const struct stm32_mbox stm32_rproc_mbox[MBOX_NB_MBX] = {
329 	{
330 		.name = STM32_MBX_VQ0,
331 		.vq_id = STM32_MBX_VQ0_ID,
332 		.client = {
333 			.rx_callback = stm32_rproc_mb_callback,
334 			.tx_block = false,
335 		},
336 	},
337 	{
338 		.name = STM32_MBX_VQ1,
339 		.vq_id = STM32_MBX_VQ1_ID,
340 		.client = {
341 			.rx_callback = stm32_rproc_mb_callback,
342 			.tx_block = false,
343 		},
344 	},
345 	{
346 		.name = STM32_MBX_SHUTDOWN,
347 		.vq_id = -1,
348 		.client = {
349 			.tx_block = true,
350 			.tx_done = NULL,
351 			.tx_tout = 500, /* 500 ms time out */
352 		},
353 	},
354 	{
355 		.name = STM32_MBX_DETACH,
356 		.vq_id = -1,
357 		.client = {
358 			.tx_block = true,
359 			.tx_done = NULL,
360 			.tx_tout = 200, /* 200 ms time out to detach should be fair enough */
361 		},
362 	}
363 };
364 
365 static int stm32_rproc_request_mbox(struct rproc *rproc)
366 {
367 	struct stm32_rproc *ddata = rproc->priv;
368 	struct device *dev = &rproc->dev;
369 	unsigned int i;
370 	int j;
371 	const unsigned char *name;
372 	struct mbox_client *cl;
373 
374 	/* Initialise mailbox structure table */
375 	memcpy(ddata->mb, stm32_rproc_mbox, sizeof(stm32_rproc_mbox));
376 
377 	for (i = 0; i < MBOX_NB_MBX; i++) {
378 		name = ddata->mb[i].name;
379 
380 		cl = &ddata->mb[i].client;
381 		cl->dev = dev->parent;
382 
383 		ddata->mb[i].chan = mbox_request_channel_byname(cl, name);
384 		if (IS_ERR(ddata->mb[i].chan)) {
385 			if (PTR_ERR(ddata->mb[i].chan) == -EPROBE_DEFER) {
386 				dev_err_probe(dev->parent,
387 					      PTR_ERR(ddata->mb[i].chan),
388 					      "failed to request mailbox %s\n",
389 					      name);
390 				goto err_probe;
391 			}
392 			dev_warn(dev, "cannot get %s mbox\n", name);
393 			ddata->mb[i].chan = NULL;
394 		}
395 		if (ddata->mb[i].vq_id >= 0) {
396 			INIT_WORK(&ddata->mb[i].vq_work,
397 				  stm32_rproc_mb_vq_work);
398 		}
399 	}
400 
401 	return 0;
402 
403 err_probe:
404 	for (j = i - 1; j >= 0; j--)
405 		if (ddata->mb[j].chan)
406 			mbox_free_channel(ddata->mb[j].chan);
407 	return -EPROBE_DEFER;
408 }
409 
410 static int stm32_rproc_set_hold_boot(struct rproc *rproc, bool hold)
411 {
412 	struct stm32_rproc *ddata = rproc->priv;
413 	struct stm32_syscon hold_boot = ddata->hold_boot;
414 	struct arm_smccc_res smc_res;
415 	int val, err;
416 
417 	/*
418 	 * Three ways to manage the hold boot
419 	 * - using SCMI: the hold boot is managed as a reset,
420 	 * - using Linux(no SCMI): the hold boot is managed as a syscon register
421 	 * - using SMC call (deprecated): use SMC reset interface
422 	 */
423 
424 	val = hold ? HOLD_BOOT : RELEASE_BOOT;
425 
426 	if (ddata->hold_boot_rst) {
427 		/* Use the SCMI reset controller */
428 		if (!hold)
429 			err = reset_control_deassert(ddata->hold_boot_rst);
430 		else
431 			err =  reset_control_assert(ddata->hold_boot_rst);
432 	} else if (IS_ENABLED(CONFIG_HAVE_ARM_SMCCC) && ddata->hold_boot_smc) {
433 		/* Use the SMC call */
434 		arm_smccc_smc(STM32_SMC_RCC, STM32_SMC_REG_WRITE,
435 			      hold_boot.reg, val, 0, 0, 0, 0, &smc_res);
436 		err = smc_res.a0;
437 	} else {
438 		/* Use syscon */
439 		err = regmap_update_bits(hold_boot.map, hold_boot.reg,
440 					 hold_boot.mask, val);
441 	}
442 
443 	if (err)
444 		dev_err(&rproc->dev, "failed to set hold boot\n");
445 
446 	return err;
447 }
448 
449 static void stm32_rproc_add_coredump_trace(struct rproc *rproc)
450 {
451 	struct rproc_debug_trace *trace;
452 	struct rproc_dump_segment *segment;
453 	bool already_added;
454 
455 	list_for_each_entry(trace, &rproc->traces, node) {
456 		already_added = false;
457 
458 		list_for_each_entry(segment, &rproc->dump_segments, node) {
459 			if (segment->da == trace->trace_mem.da) {
460 				already_added = true;
461 				break;
462 			}
463 		}
464 
465 		if (!already_added)
466 			rproc_coredump_add_segment(rproc, trace->trace_mem.da,
467 						   trace->trace_mem.len);
468 	}
469 }
470 
471 static int stm32_rproc_start(struct rproc *rproc)
472 {
473 	struct stm32_rproc *ddata = rproc->priv;
474 	int err;
475 
476 	stm32_rproc_add_coredump_trace(rproc);
477 
478 	/* clear remote proc Deep Sleep */
479 	if (ddata->pdds.map) {
480 		err = regmap_update_bits(ddata->pdds.map, ddata->pdds.reg,
481 					 ddata->pdds.mask, 0);
482 		if (err) {
483 			dev_err(&rproc->dev, "failed to clear pdds\n");
484 			return err;
485 		}
486 	}
487 
488 	err = stm32_rproc_set_hold_boot(rproc, false);
489 	if (err)
490 		return err;
491 
492 	return stm32_rproc_set_hold_boot(rproc, true);
493 }
494 
495 static int stm32_rproc_attach(struct rproc *rproc)
496 {
497 	stm32_rproc_add_coredump_trace(rproc);
498 
499 	return stm32_rproc_set_hold_boot(rproc, true);
500 }
501 
502 static int stm32_rproc_detach(struct rproc *rproc)
503 {
504 	struct stm32_rproc *ddata = rproc->priv;
505 	int err, idx;
506 
507 	/* Inform the remote processor of the detach */
508 	idx = stm32_rproc_mbox_idx(rproc, STM32_MBX_DETACH);
509 	if (idx >= 0 && ddata->mb[idx].chan) {
510 		err = mbox_send_message(ddata->mb[idx].chan, "stop");
511 		if (err < 0)
512 			dev_warn(&rproc->dev, "warning: remote FW detach without ack\n");
513 	}
514 
515 	/* Allow remote processor to auto-reboot */
516 	return stm32_rproc_set_hold_boot(rproc, false);
517 }
518 
519 static int stm32_rproc_stop(struct rproc *rproc)
520 {
521 	struct stm32_rproc *ddata = rproc->priv;
522 	int err, idx;
523 
524 	/* request shutdown of the remote processor */
525 	if (rproc->state != RPROC_OFFLINE && rproc->state != RPROC_CRASHED) {
526 		idx = stm32_rproc_mbox_idx(rproc, STM32_MBX_SHUTDOWN);
527 		if (idx >= 0 && ddata->mb[idx].chan) {
528 			err = mbox_send_message(ddata->mb[idx].chan, "detach");
529 			if (err < 0)
530 				dev_warn(&rproc->dev, "warning: remote FW shutdown without ack\n");
531 		}
532 	}
533 
534 	err = stm32_rproc_set_hold_boot(rproc, true);
535 	if (err)
536 		return err;
537 
538 	err = reset_control_assert(ddata->rst);
539 	if (err) {
540 		dev_err(&rproc->dev, "failed to assert the reset\n");
541 		return err;
542 	}
543 
544 	/* to allow platform Standby power mode, set remote proc Deep Sleep */
545 	if (ddata->pdds.map) {
546 		err = regmap_update_bits(ddata->pdds.map, ddata->pdds.reg,
547 					 ddata->pdds.mask, 1);
548 		if (err) {
549 			dev_err(&rproc->dev, "failed to set pdds\n");
550 			return err;
551 		}
552 	}
553 
554 	/* update coprocessor state to OFF if available */
555 	if (ddata->m4_state.map) {
556 		err = regmap_update_bits(ddata->m4_state.map,
557 					 ddata->m4_state.reg,
558 					 ddata->m4_state.mask,
559 					 M4_STATE_OFF);
560 		if (err) {
561 			dev_err(&rproc->dev, "failed to set copro state\n");
562 			return err;
563 		}
564 	}
565 
566 	return 0;
567 }
568 
569 static void stm32_rproc_kick(struct rproc *rproc, int vqid)
570 {
571 	struct stm32_rproc *ddata = rproc->priv;
572 	unsigned int i;
573 	int err;
574 
575 	if (WARN_ON(vqid >= MBOX_NB_VQ))
576 		return;
577 
578 	for (i = 0; i < MBOX_NB_MBX; i++) {
579 		if (vqid != ddata->mb[i].vq_id)
580 			continue;
581 		if (!ddata->mb[i].chan)
582 			return;
583 		err = mbox_send_message(ddata->mb[i].chan, "kick");
584 		if (err < 0)
585 			dev_err(&rproc->dev, "%s: failed (%s, err:%d)\n",
586 				__func__, ddata->mb[i].name, err);
587 		return;
588 	}
589 }
590 
591 static int stm32_rproc_da_to_pa(struct rproc *rproc,
592 				u64 da, phys_addr_t *pa)
593 {
594 	struct stm32_rproc *ddata = rproc->priv;
595 	struct device *dev = rproc->dev.parent;
596 	struct stm32_rproc_mem *p_mem;
597 	unsigned int i;
598 
599 	for (i = 0; i < ddata->nb_rmems; i++) {
600 		p_mem = &ddata->rmems[i];
601 
602 		if (da < p_mem->dev_addr ||
603 		    da >= p_mem->dev_addr + p_mem->size)
604 			continue;
605 
606 		*pa = da - p_mem->dev_addr + p_mem->bus_addr;
607 		dev_dbg(dev, "da %llx to pa %pap\n", da, pa);
608 
609 		return 0;
610 	}
611 
612 	dev_err(dev, "can't translate da %llx\n", da);
613 
614 	return -EINVAL;
615 }
616 
617 static struct resource_table *
618 stm32_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
619 {
620 	struct stm32_rproc *ddata = rproc->priv;
621 	struct device *dev = rproc->dev.parent;
622 	phys_addr_t rsc_pa;
623 	u32 rsc_da;
624 	int err;
625 
626 	/* The resource table has already been mapped, nothing to do */
627 	if (ddata->rsc_va)
628 		goto done;
629 
630 	err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
631 	if (err) {
632 		dev_err(dev, "failed to read rsc tbl addr\n");
633 		return ERR_PTR(-EINVAL);
634 	}
635 
636 	if (!rsc_da)
637 		/* no rsc table */
638 		return ERR_PTR(-ENOENT);
639 
640 	err = stm32_rproc_da_to_pa(rproc, rsc_da, &rsc_pa);
641 	if (err)
642 		return ERR_PTR(err);
643 
644 	ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
645 	if (IS_ERR_OR_NULL(ddata->rsc_va)) {
646 		dev_err(dev, "Unable to map memory region: %pa+%x\n",
647 			&rsc_pa, RSC_TBL_SIZE);
648 		ddata->rsc_va = NULL;
649 		return ERR_PTR(-ENOMEM);
650 	}
651 
652 done:
653 	/*
654 	 * Assuming the resource table fits in 1kB is fair.
655 	 * Notice for the detach, that this 1 kB memory area has to be reserved in the coprocessor
656 	 * firmware for the resource table. On detach, the remoteproc core re-initializes this
657 	 * entire area by overwriting it with the initial values stored in rproc->clean_table.
658 	 */
659 	*table_sz = RSC_TBL_SIZE;
660 	return (__force struct resource_table *)ddata->rsc_va;
661 }
662 
663 static const struct rproc_ops st_rproc_ops = {
664 	.prepare	= stm32_rproc_prepare,
665 	.start		= stm32_rproc_start,
666 	.stop		= stm32_rproc_stop,
667 	.attach		= stm32_rproc_attach,
668 	.detach		= stm32_rproc_detach,
669 	.kick		= stm32_rproc_kick,
670 	.load		= rproc_elf_load_segments,
671 	.parse_fw	= stm32_rproc_parse_fw,
672 	.find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
673 	.get_loaded_rsc_table = stm32_rproc_get_loaded_rsc_table,
674 	.sanity_check	= rproc_elf_sanity_check,
675 	.get_boot_addr	= rproc_elf_get_boot_addr,
676 };
677 
678 static const struct of_device_id stm32_rproc_match[] = {
679 	{ .compatible = "st,stm32mp1-m4" },
680 	{},
681 };
682 MODULE_DEVICE_TABLE(of, stm32_rproc_match);
683 
684 static int stm32_rproc_get_syscon(struct device_node *np, const char *prop,
685 				  struct stm32_syscon *syscon)
686 {
687 	int err = 0;
688 
689 	syscon->map = syscon_regmap_lookup_by_phandle(np, prop);
690 	if (IS_ERR(syscon->map)) {
691 		err = PTR_ERR(syscon->map);
692 		syscon->map = NULL;
693 		goto out;
694 	}
695 
696 	err = of_property_read_u32_index(np, prop, 1, &syscon->reg);
697 	if (err)
698 		goto out;
699 
700 	err = of_property_read_u32_index(np, prop, 2, &syscon->mask);
701 
702 out:
703 	return err;
704 }
705 
706 static int stm32_rproc_parse_dt(struct platform_device *pdev,
707 				struct stm32_rproc *ddata, bool *auto_boot)
708 {
709 	struct device *dev = &pdev->dev;
710 	struct device_node *np = dev->of_node;
711 	struct stm32_syscon tz;
712 	unsigned int tzen;
713 	int err, irq;
714 
715 	irq = platform_get_irq(pdev, 0);
716 	if (irq == -EPROBE_DEFER)
717 		return dev_err_probe(dev, irq, "failed to get interrupt\n");
718 
719 	if (irq > 0) {
720 		err = devm_request_irq(dev, irq, stm32_rproc_wdg, 0,
721 				       dev_name(dev), pdev);
722 		if (err)
723 			return dev_err_probe(dev, err,
724 					     "failed to request wdg irq\n");
725 
726 		ddata->wdg_irq = irq;
727 
728 		if (of_property_read_bool(np, "wakeup-source")) {
729 			device_init_wakeup(dev, true);
730 			dev_pm_set_wake_irq(dev, irq);
731 		}
732 
733 		dev_info(dev, "wdg irq registered\n");
734 	}
735 
736 	ddata->rst = devm_reset_control_get_optional(dev, "mcu_rst");
737 	if (!ddata->rst) {
738 		/* Try legacy fallback method: get it by index */
739 		ddata->rst = devm_reset_control_get_by_index(dev, 0);
740 	}
741 	if (IS_ERR(ddata->rst))
742 		return dev_err_probe(dev, PTR_ERR(ddata->rst),
743 				     "failed to get mcu_reset\n");
744 
745 	/*
746 	 * Three ways to manage the hold boot
747 	 * - using SCMI: the hold boot is managed as a reset
748 	 *    The DT "reset-mames" property should be defined with 2 items:
749 	 *        reset-names = "mcu_rst", "hold_boot";
750 	 * - using SMC call (deprecated): use SMC reset interface
751 	 *    The DT "reset-mames" property is optional, "st,syscfg-tz" is required
752 	 * - default(no SCMI, no SMC): the hold boot is managed as a syscon register
753 	 *    The DT "reset-mames" property is optional, "st,syscfg-holdboot" is required
754 	 */
755 
756 	ddata->hold_boot_rst = devm_reset_control_get_optional(dev, "hold_boot");
757 	if (IS_ERR(ddata->hold_boot_rst))
758 		return dev_err_probe(dev, PTR_ERR(ddata->hold_boot_rst),
759 				     "failed to get hold_boot reset\n");
760 
761 	if (!ddata->hold_boot_rst && IS_ENABLED(CONFIG_HAVE_ARM_SMCCC)) {
762 		/* Manage the MCU_BOOT using SMC call */
763 		err = stm32_rproc_get_syscon(np, "st,syscfg-tz", &tz);
764 		if (!err) {
765 			err = regmap_read(tz.map, tz.reg, &tzen);
766 			if (err) {
767 				dev_err(dev, "failed to read tzen\n");
768 				return err;
769 			}
770 			ddata->hold_boot_smc = tzen & tz.mask;
771 		}
772 	}
773 
774 	if (!ddata->hold_boot_rst && !ddata->hold_boot_smc) {
775 		/* Default: hold boot manage it through the syscon controller */
776 		err = stm32_rproc_get_syscon(np, "st,syscfg-holdboot",
777 					     &ddata->hold_boot);
778 		if (err) {
779 			dev_err(dev, "failed to get hold boot\n");
780 			return err;
781 		}
782 	}
783 
784 	err = stm32_rproc_get_syscon(np, "st,syscfg-pdds", &ddata->pdds);
785 	if (err)
786 		dev_info(dev, "failed to get pdds\n");
787 
788 	*auto_boot = of_property_read_bool(np, "st,auto-boot");
789 
790 	/*
791 	 * See if we can check the M4 status, i.e if it was started
792 	 * from the boot loader or not.
793 	 */
794 	err = stm32_rproc_get_syscon(np, "st,syscfg-m4-state",
795 				     &ddata->m4_state);
796 	if (err) {
797 		/* remember this */
798 		ddata->m4_state.map = NULL;
799 		/* no coprocessor state syscon (optional) */
800 		dev_warn(dev, "m4 state not supported\n");
801 
802 		/* no need to go further */
803 		return 0;
804 	}
805 
806 	/* See if we can get the resource table */
807 	err = stm32_rproc_get_syscon(np, "st,syscfg-rsc-tbl",
808 				     &ddata->rsctbl);
809 	if (err) {
810 		/* no rsc table syscon (optional) */
811 		dev_warn(dev, "rsc tbl syscon not supported\n");
812 	}
813 
814 	return 0;
815 }
816 
817 static int stm32_rproc_get_m4_status(struct stm32_rproc *ddata,
818 				     unsigned int *state)
819 {
820 	/* See stm32_rproc_parse_dt() */
821 	if (!ddata->m4_state.map) {
822 		/*
823 		 * We couldn't get the coprocessor's state, assume
824 		 * it is not running.
825 		 */
826 		*state = M4_STATE_OFF;
827 		return 0;
828 	}
829 
830 	return regmap_read(ddata->m4_state.map, ddata->m4_state.reg, state);
831 }
832 
833 static int stm32_rproc_probe(struct platform_device *pdev)
834 {
835 	struct device *dev = &pdev->dev;
836 	struct stm32_rproc *ddata;
837 	struct device_node *np = dev->of_node;
838 	struct rproc *rproc;
839 	unsigned int state;
840 	int ret;
841 
842 	ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
843 	if (ret)
844 		return ret;
845 
846 	rproc = rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata));
847 	if (!rproc)
848 		return -ENOMEM;
849 
850 	ddata = rproc->priv;
851 
852 	rproc_coredump_set_elf_info(rproc, ELFCLASS32, EM_NONE);
853 
854 	ret = stm32_rproc_parse_dt(pdev, ddata, &rproc->auto_boot);
855 	if (ret)
856 		goto free_rproc;
857 
858 	ret = stm32_rproc_of_memory_translations(pdev, ddata);
859 	if (ret)
860 		goto free_rproc;
861 
862 	ret = stm32_rproc_get_m4_status(ddata, &state);
863 	if (ret)
864 		goto free_rproc;
865 
866 	if (state == M4_STATE_CRUN)
867 		rproc->state = RPROC_DETACHED;
868 
869 	rproc->has_iommu = false;
870 	ddata->workqueue = create_workqueue(dev_name(dev));
871 	if (!ddata->workqueue) {
872 		dev_err(dev, "cannot create workqueue\n");
873 		ret = -ENOMEM;
874 		goto free_resources;
875 	}
876 
877 	platform_set_drvdata(pdev, rproc);
878 
879 	ret = stm32_rproc_request_mbox(rproc);
880 	if (ret)
881 		goto free_wkq;
882 
883 	ret = rproc_add(rproc);
884 	if (ret)
885 		goto free_mb;
886 
887 	return 0;
888 
889 free_mb:
890 	stm32_rproc_free_mbox(rproc);
891 free_wkq:
892 	destroy_workqueue(ddata->workqueue);
893 free_resources:
894 	rproc_resource_cleanup(rproc);
895 free_rproc:
896 	if (device_may_wakeup(dev)) {
897 		dev_pm_clear_wake_irq(dev);
898 		device_init_wakeup(dev, false);
899 	}
900 	rproc_free(rproc);
901 	return ret;
902 }
903 
904 static void stm32_rproc_remove(struct platform_device *pdev)
905 {
906 	struct rproc *rproc = platform_get_drvdata(pdev);
907 	struct stm32_rproc *ddata = rproc->priv;
908 	struct device *dev = &pdev->dev;
909 
910 	if (atomic_read(&rproc->power) > 0)
911 		rproc_shutdown(rproc);
912 
913 	rproc_del(rproc);
914 	stm32_rproc_free_mbox(rproc);
915 	destroy_workqueue(ddata->workqueue);
916 
917 	if (device_may_wakeup(dev)) {
918 		dev_pm_clear_wake_irq(dev);
919 		device_init_wakeup(dev, false);
920 	}
921 	rproc_free(rproc);
922 }
923 
924 static int stm32_rproc_suspend(struct device *dev)
925 {
926 	struct rproc *rproc = dev_get_drvdata(dev);
927 	struct stm32_rproc *ddata = rproc->priv;
928 
929 	if (device_may_wakeup(dev))
930 		return enable_irq_wake(ddata->wdg_irq);
931 
932 	return 0;
933 }
934 
935 static int stm32_rproc_resume(struct device *dev)
936 {
937 	struct rproc *rproc = dev_get_drvdata(dev);
938 	struct stm32_rproc *ddata = rproc->priv;
939 
940 	if (device_may_wakeup(dev))
941 		return disable_irq_wake(ddata->wdg_irq);
942 
943 	return 0;
944 }
945 
946 static DEFINE_SIMPLE_DEV_PM_OPS(stm32_rproc_pm_ops,
947 				stm32_rproc_suspend, stm32_rproc_resume);
948 
949 static struct platform_driver stm32_rproc_driver = {
950 	.probe = stm32_rproc_probe,
951 	.remove_new = stm32_rproc_remove,
952 	.driver = {
953 		.name = "stm32-rproc",
954 		.pm = pm_ptr(&stm32_rproc_pm_ops),
955 		.of_match_table = stm32_rproc_match,
956 	},
957 };
958 module_platform_driver(stm32_rproc_driver);
959 
960 MODULE_DESCRIPTION("STM32 Remote Processor Control Driver");
961 MODULE_AUTHOR("Ludovic Barre <ludovic.barre@st.com>");
962 MODULE_AUTHOR("Fabien Dessenne <fabien.dessenne@st.com>");
963 MODULE_LICENSE("GPL v2");
964 
965