1
2
3
4
5
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_address.h>
16#include <linux/of_device.h>
17#include <linux/of_reserved_mem.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 3
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
42struct stm32_syscon {
43 struct regmap *map;
44 u32 reg;
45 u32 mask;
46};
47
48struct stm32_rproc_mem {
49 char name[20];
50 void __iomem *cpu_addr;
51 phys_addr_t bus_addr;
52 u32 dev_addr;
53 size_t size;
54};
55
56struct stm32_rproc_mem_ranges {
57 u32 dev_addr;
58 u32 bus_addr;
59 u32 size;
60};
61
62struct stm32_mbox {
63 const unsigned char name[10];
64 struct mbox_chan *chan;
65 struct mbox_client client;
66 struct work_struct vq_work;
67 int vq_id;
68};
69
70struct stm32_rproc {
71 struct reset_control *rst;
72 struct stm32_syscon hold_boot;
73 struct stm32_syscon pdds;
74 int wdg_irq;
75 u32 nb_rmems;
76 struct stm32_rproc_mem *rmems;
77 struct stm32_mbox mb[MBOX_NB_MBX];
78 struct workqueue_struct *workqueue;
79 bool secured_soc;
80};
81
82static int stm32_rproc_pa_to_da(struct rproc *rproc, phys_addr_t pa, u64 *da)
83{
84 unsigned int i;
85 struct stm32_rproc *ddata = rproc->priv;
86 struct stm32_rproc_mem *p_mem;
87
88 for (i = 0; i < ddata->nb_rmems; i++) {
89 p_mem = &ddata->rmems[i];
90
91 if (pa < p_mem->bus_addr ||
92 pa >= p_mem->bus_addr + p_mem->size)
93 continue;
94 *da = pa - p_mem->bus_addr + p_mem->dev_addr;
95 dev_dbg(rproc->dev.parent, "pa %pa to da %llx\n", &pa, *da);
96 return 0;
97 }
98
99 return -EINVAL;
100}
101
102static int stm32_rproc_mem_alloc(struct rproc *rproc,
103 struct rproc_mem_entry *mem)
104{
105 struct device *dev = rproc->dev.parent;
106 void *va;
107
108 dev_dbg(dev, "map memory: %pa+%x\n", &mem->dma, mem->len);
109 va = ioremap_wc(mem->dma, mem->len);
110 if (IS_ERR_OR_NULL(va)) {
111 dev_err(dev, "Unable to map memory region: %pa+%x\n",
112 &mem->dma, mem->len);
113 return -ENOMEM;
114 }
115
116
117 mem->va = va;
118
119 return 0;
120}
121
122static int stm32_rproc_mem_release(struct rproc *rproc,
123 struct rproc_mem_entry *mem)
124{
125 dev_dbg(rproc->dev.parent, "unmap memory: %pa\n", &mem->dma);
126 iounmap(mem->va);
127
128 return 0;
129}
130
131static int stm32_rproc_of_memory_translations(struct rproc *rproc)
132{
133 struct device *parent, *dev = rproc->dev.parent;
134 struct stm32_rproc *ddata = rproc->priv;
135 struct device_node *np;
136 struct stm32_rproc_mem *p_mems;
137 struct stm32_rproc_mem_ranges *mem_range;
138 int cnt, array_size, i, ret = 0;
139
140 parent = dev->parent;
141 np = parent->of_node;
142
143 cnt = of_property_count_elems_of_size(np, "dma-ranges",
144 sizeof(*mem_range));
145 if (cnt <= 0) {
146 dev_err(dev, "%s: dma-ranges property not defined\n", __func__);
147 return -EINVAL;
148 }
149
150 p_mems = devm_kcalloc(dev, cnt, sizeof(*p_mems), GFP_KERNEL);
151 if (!p_mems)
152 return -ENOMEM;
153 mem_range = kcalloc(cnt, sizeof(*mem_range), GFP_KERNEL);
154 if (!mem_range)
155 return -ENOMEM;
156
157 array_size = cnt * sizeof(struct stm32_rproc_mem_ranges) / sizeof(u32);
158
159 ret = of_property_read_u32_array(np, "dma-ranges",
160 (u32 *)mem_range, array_size);
161 if (ret) {
162 dev_err(dev, "error while get dma-ranges property: %x\n", ret);
163 goto free_mem;
164 }
165
166 for (i = 0; i < cnt; i++) {
167 p_mems[i].bus_addr = mem_range[i].bus_addr;
168 p_mems[i].dev_addr = mem_range[i].dev_addr;
169 p_mems[i].size = mem_range[i].size;
170
171 dev_dbg(dev, "memory range[%i]: da %#x, pa %pa, size %#zx:\n",
172 i, p_mems[i].dev_addr, &p_mems[i].bus_addr,
173 p_mems[i].size);
174 }
175
176 ddata->rmems = p_mems;
177 ddata->nb_rmems = cnt;
178
179free_mem:
180 kfree(mem_range);
181 return ret;
182}
183
184static int stm32_rproc_mbox_idx(struct rproc *rproc, const unsigned char *name)
185{
186 struct stm32_rproc *ddata = rproc->priv;
187 int i;
188
189 for (i = 0; i < ARRAY_SIZE(ddata->mb); i++) {
190 if (!strncmp(ddata->mb[i].name, name, strlen(name)))
191 return i;
192 }
193 dev_err(&rproc->dev, "mailbox %s not found\n", name);
194
195 return -EINVAL;
196}
197
198static int stm32_rproc_elf_load_rsc_table(struct rproc *rproc,
199 const struct firmware *fw)
200{
201 if (rproc_elf_load_rsc_table(rproc, fw))
202 dev_warn(&rproc->dev, "no resource table found for this firmware\n");
203
204 return 0;
205}
206
207static int stm32_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
208{
209 struct device *dev = rproc->dev.parent;
210 struct device_node *np = dev->of_node;
211 struct of_phandle_iterator it;
212 struct rproc_mem_entry *mem;
213 struct reserved_mem *rmem;
214 u64 da;
215 int index = 0;
216
217
218 of_phandle_iterator_init(&it, np, "memory-region", NULL, 0);
219 while (of_phandle_iterator_next(&it) == 0) {
220 rmem = of_reserved_mem_lookup(it.node);
221 if (!rmem) {
222 dev_err(dev, "unable to acquire memory-region\n");
223 return -EINVAL;
224 }
225
226 if (stm32_rproc_pa_to_da(rproc, rmem->base, &da) < 0) {
227 dev_err(dev, "memory region not valid %pa\n",
228 &rmem->base);
229 return -EINVAL;
230 }
231
232
233 if (strcmp(it.node->name, "vdev0buffer")) {
234
235 mem = rproc_mem_entry_init(dev, NULL,
236 (dma_addr_t)rmem->base,
237 rmem->size, da,
238 stm32_rproc_mem_alloc,
239 stm32_rproc_mem_release,
240 it.node->name);
241
242 if (mem)
243 rproc_coredump_add_segment(rproc, da,
244 rmem->size);
245 } else {
246
247 mem = rproc_of_resm_mem_entry_init(dev, index,
248 rmem->size,
249 rmem->base,
250 it.node->name);
251 }
252
253 if (!mem)
254 return -ENOMEM;
255
256 rproc_add_carveout(rproc, mem);
257 index++;
258 }
259
260 return stm32_rproc_elf_load_rsc_table(rproc, fw);
261}
262
263static irqreturn_t stm32_rproc_wdg(int irq, void *data)
264{
265 struct rproc *rproc = data;
266
267 rproc_report_crash(rproc, RPROC_WATCHDOG);
268
269 return IRQ_HANDLED;
270}
271
272static void stm32_rproc_mb_vq_work(struct work_struct *work)
273{
274 struct stm32_mbox *mb = container_of(work, struct stm32_mbox, vq_work);
275 struct rproc *rproc = dev_get_drvdata(mb->client.dev);
276
277 if (rproc_vq_interrupt(rproc, mb->vq_id) == IRQ_NONE)
278 dev_dbg(&rproc->dev, "no message found in vq%d\n", mb->vq_id);
279}
280
281static void stm32_rproc_mb_callback(struct mbox_client *cl, void *data)
282{
283 struct rproc *rproc = dev_get_drvdata(cl->dev);
284 struct stm32_mbox *mb = container_of(cl, struct stm32_mbox, client);
285 struct stm32_rproc *ddata = rproc->priv;
286
287 queue_work(ddata->workqueue, &mb->vq_work);
288}
289
290static void stm32_rproc_free_mbox(struct rproc *rproc)
291{
292 struct stm32_rproc *ddata = rproc->priv;
293 unsigned int i;
294
295 for (i = 0; i < ARRAY_SIZE(ddata->mb); i++) {
296 if (ddata->mb[i].chan)
297 mbox_free_channel(ddata->mb[i].chan);
298 ddata->mb[i].chan = NULL;
299 }
300}
301
302static const struct stm32_mbox stm32_rproc_mbox[MBOX_NB_MBX] = {
303 {
304 .name = STM32_MBX_VQ0,
305 .vq_id = STM32_MBX_VQ0_ID,
306 .client = {
307 .rx_callback = stm32_rproc_mb_callback,
308 .tx_block = false,
309 },
310 },
311 {
312 .name = STM32_MBX_VQ1,
313 .vq_id = STM32_MBX_VQ1_ID,
314 .client = {
315 .rx_callback = stm32_rproc_mb_callback,
316 .tx_block = false,
317 },
318 },
319 {
320 .name = STM32_MBX_SHUTDOWN,
321 .vq_id = -1,
322 .client = {
323 .tx_block = true,
324 .tx_done = NULL,
325 .tx_tout = 500,
326 },
327 }
328};
329
330static int stm32_rproc_request_mbox(struct rproc *rproc)
331{
332 struct stm32_rproc *ddata = rproc->priv;
333 struct device *dev = &rproc->dev;
334 unsigned int i;
335 int j;
336 const unsigned char *name;
337 struct mbox_client *cl;
338
339
340 memcpy(ddata->mb, stm32_rproc_mbox, sizeof(stm32_rproc_mbox));
341
342 for (i = 0; i < MBOX_NB_MBX; i++) {
343 name = ddata->mb[i].name;
344
345 cl = &ddata->mb[i].client;
346 cl->dev = dev->parent;
347
348 ddata->mb[i].chan = mbox_request_channel_byname(cl, name);
349 if (IS_ERR(ddata->mb[i].chan)) {
350 if (PTR_ERR(ddata->mb[i].chan) == -EPROBE_DEFER)
351 goto err_probe;
352 dev_warn(dev, "cannot get %s mbox\n", name);
353 ddata->mb[i].chan = NULL;
354 }
355 if (ddata->mb[i].vq_id >= 0) {
356 INIT_WORK(&ddata->mb[i].vq_work,
357 stm32_rproc_mb_vq_work);
358 }
359 }
360
361 return 0;
362
363err_probe:
364 for (j = i - 1; j >= 0; j--)
365 if (ddata->mb[j].chan)
366 mbox_free_channel(ddata->mb[j].chan);
367 return -EPROBE_DEFER;
368}
369
370static int stm32_rproc_set_hold_boot(struct rproc *rproc, bool hold)
371{
372 struct stm32_rproc *ddata = rproc->priv;
373 struct stm32_syscon hold_boot = ddata->hold_boot;
374 struct arm_smccc_res smc_res;
375 int val, err;
376
377 val = hold ? HOLD_BOOT : RELEASE_BOOT;
378
379 if (IS_ENABLED(CONFIG_HAVE_ARM_SMCCC) && ddata->secured_soc) {
380 arm_smccc_smc(STM32_SMC_RCC, STM32_SMC_REG_WRITE,
381 hold_boot.reg, val, 0, 0, 0, 0, &smc_res);
382 err = smc_res.a0;
383 } else {
384 err = regmap_update_bits(hold_boot.map, hold_boot.reg,
385 hold_boot.mask, val);
386 }
387
388 if (err)
389 dev_err(&rproc->dev, "failed to set hold boot\n");
390
391 return err;
392}
393
394static void stm32_rproc_add_coredump_trace(struct rproc *rproc)
395{
396 struct rproc_debug_trace *trace;
397 struct rproc_dump_segment *segment;
398 bool already_added;
399
400 list_for_each_entry(trace, &rproc->traces, node) {
401 already_added = false;
402
403 list_for_each_entry(segment, &rproc->dump_segments, node) {
404 if (segment->da == trace->trace_mem.da) {
405 already_added = true;
406 break;
407 }
408 }
409
410 if (!already_added)
411 rproc_coredump_add_segment(rproc, trace->trace_mem.da,
412 trace->trace_mem.len);
413 }
414}
415
416static int stm32_rproc_start(struct rproc *rproc)
417{
418 struct stm32_rproc *ddata = rproc->priv;
419 int err;
420
421 stm32_rproc_add_coredump_trace(rproc);
422
423
424 if (ddata->pdds.map) {
425 err = regmap_update_bits(ddata->pdds.map, ddata->pdds.reg,
426 ddata->pdds.mask, 0);
427 if (err) {
428 dev_err(&rproc->dev, "failed to clear pdds\n");
429 return err;
430 }
431 }
432
433 err = stm32_rproc_set_hold_boot(rproc, false);
434 if (err)
435 return err;
436
437 return stm32_rproc_set_hold_boot(rproc, true);
438}
439
440static int stm32_rproc_stop(struct rproc *rproc)
441{
442 struct stm32_rproc *ddata = rproc->priv;
443 int err, dummy_data, idx;
444
445
446 if (rproc->state != RPROC_OFFLINE) {
447 idx = stm32_rproc_mbox_idx(rproc, STM32_MBX_SHUTDOWN);
448 if (idx >= 0 && ddata->mb[idx].chan) {
449
450 err = mbox_send_message(ddata->mb[idx].chan,
451 &dummy_data);
452 if (err < 0)
453 dev_warn(&rproc->dev, "warning: remote FW shutdown without ack\n");
454 }
455 }
456
457 err = stm32_rproc_set_hold_boot(rproc, true);
458 if (err)
459 return err;
460
461 err = reset_control_assert(ddata->rst);
462 if (err) {
463 dev_err(&rproc->dev, "failed to assert the reset\n");
464 return err;
465 }
466
467
468 if (ddata->pdds.map) {
469 err = regmap_update_bits(ddata->pdds.map, ddata->pdds.reg,
470 ddata->pdds.mask, 1);
471 if (err) {
472 dev_err(&rproc->dev, "failed to set pdds\n");
473 return err;
474 }
475 }
476
477 return 0;
478}
479
480static void stm32_rproc_kick(struct rproc *rproc, int vqid)
481{
482 struct stm32_rproc *ddata = rproc->priv;
483 unsigned int i;
484 int err;
485
486 if (WARN_ON(vqid >= MBOX_NB_VQ))
487 return;
488
489 for (i = 0; i < MBOX_NB_MBX; i++) {
490 if (vqid != ddata->mb[i].vq_id)
491 continue;
492 if (!ddata->mb[i].chan)
493 return;
494 err = mbox_send_message(ddata->mb[i].chan, (void *)(long)vqid);
495 if (err < 0)
496 dev_err(&rproc->dev, "%s: failed (%s, err:%d)\n",
497 __func__, ddata->mb[i].name, err);
498 return;
499 }
500}
501
502static struct rproc_ops st_rproc_ops = {
503 .start = stm32_rproc_start,
504 .stop = stm32_rproc_stop,
505 .kick = stm32_rproc_kick,
506 .load = rproc_elf_load_segments,
507 .parse_fw = stm32_rproc_parse_fw,
508 .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
509 .sanity_check = rproc_elf_sanity_check,
510 .get_boot_addr = rproc_elf_get_boot_addr,
511};
512
513static const struct of_device_id stm32_rproc_match[] = {
514 { .compatible = "st,stm32mp1-m4" },
515 {},
516};
517MODULE_DEVICE_TABLE(of, stm32_rproc_match);
518
519static int stm32_rproc_get_syscon(struct device_node *np, const char *prop,
520 struct stm32_syscon *syscon)
521{
522 int err = 0;
523
524 syscon->map = syscon_regmap_lookup_by_phandle(np, prop);
525 if (IS_ERR(syscon->map)) {
526 err = PTR_ERR(syscon->map);
527 syscon->map = NULL;
528 goto out;
529 }
530
531 err = of_property_read_u32_index(np, prop, 1, &syscon->reg);
532 if (err)
533 goto out;
534
535 err = of_property_read_u32_index(np, prop, 2, &syscon->mask);
536
537out:
538 return err;
539}
540
541static int stm32_rproc_parse_dt(struct platform_device *pdev)
542{
543 struct device *dev = &pdev->dev;
544 struct device_node *np = dev->of_node;
545 struct rproc *rproc = platform_get_drvdata(pdev);
546 struct stm32_rproc *ddata = rproc->priv;
547 struct stm32_syscon tz;
548 unsigned int tzen;
549 int err, irq;
550
551 irq = platform_get_irq(pdev, 0);
552 if (irq == -EPROBE_DEFER)
553 return -EPROBE_DEFER;
554
555 if (irq > 0) {
556 err = devm_request_irq(dev, irq, stm32_rproc_wdg, 0,
557 dev_name(dev), rproc);
558 if (err) {
559 dev_err(dev, "failed to request wdg irq\n");
560 return err;
561 }
562
563 ddata->wdg_irq = irq;
564
565 if (of_property_read_bool(np, "wakeup-source")) {
566 device_init_wakeup(dev, true);
567 dev_pm_set_wake_irq(dev, irq);
568 }
569
570 dev_info(dev, "wdg irq registered\n");
571 }
572
573 ddata->rst = devm_reset_control_get_by_index(dev, 0);
574 if (IS_ERR(ddata->rst)) {
575 dev_err(dev, "failed to get mcu reset\n");
576 return PTR_ERR(ddata->rst);
577 }
578
579
580
581
582
583
584 err = stm32_rproc_get_syscon(np, "st,syscfg-tz", &tz);
585 if (err) {
586 dev_err(dev, "failed to get tz syscfg\n");
587 return err;
588 }
589
590 err = regmap_read(tz.map, tz.reg, &tzen);
591 if (err) {
592 dev_err(&rproc->dev, "failed to read tzen\n");
593 return err;
594 }
595 ddata->secured_soc = tzen & tz.mask;
596
597 err = stm32_rproc_get_syscon(np, "st,syscfg-holdboot",
598 &ddata->hold_boot);
599 if (err) {
600 dev_err(dev, "failed to get hold boot\n");
601 return err;
602 }
603
604 err = stm32_rproc_get_syscon(np, "st,syscfg-pdds", &ddata->pdds);
605 if (err)
606 dev_info(dev, "failed to get pdds\n");
607
608 rproc->auto_boot = of_property_read_bool(np, "st,auto-boot");
609
610 return stm32_rproc_of_memory_translations(rproc);
611}
612
613static int stm32_rproc_probe(struct platform_device *pdev)
614{
615 struct device *dev = &pdev->dev;
616 struct stm32_rproc *ddata;
617 struct device_node *np = dev->of_node;
618 struct rproc *rproc;
619 int ret;
620
621 ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
622 if (ret)
623 return ret;
624
625 rproc = rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata));
626 if (!rproc)
627 return -ENOMEM;
628
629 rproc_coredump_set_elf_info(rproc, ELFCLASS32, EM_NONE);
630 rproc->has_iommu = false;
631 ddata = rproc->priv;
632 ddata->workqueue = create_workqueue(dev_name(dev));
633 if (!ddata->workqueue) {
634 dev_err(dev, "cannot create workqueue\n");
635 ret = -ENOMEM;
636 goto free_rproc;
637 }
638
639 platform_set_drvdata(pdev, rproc);
640
641 ret = stm32_rproc_parse_dt(pdev);
642 if (ret)
643 goto free_wkq;
644
645 ret = stm32_rproc_request_mbox(rproc);
646 if (ret)
647 goto free_rproc;
648
649 ret = rproc_add(rproc);
650 if (ret)
651 goto free_mb;
652
653 return 0;
654
655free_mb:
656 stm32_rproc_free_mbox(rproc);
657free_wkq:
658 destroy_workqueue(ddata->workqueue);
659free_rproc:
660 if (device_may_wakeup(dev)) {
661 dev_pm_clear_wake_irq(dev);
662 device_init_wakeup(dev, false);
663 }
664 rproc_free(rproc);
665 return ret;
666}
667
668static int stm32_rproc_remove(struct platform_device *pdev)
669{
670 struct rproc *rproc = platform_get_drvdata(pdev);
671 struct stm32_rproc *ddata = rproc->priv;
672 struct device *dev = &pdev->dev;
673
674 if (atomic_read(&rproc->power) > 0)
675 rproc_shutdown(rproc);
676
677 rproc_del(rproc);
678 stm32_rproc_free_mbox(rproc);
679 destroy_workqueue(ddata->workqueue);
680
681 if (device_may_wakeup(dev)) {
682 dev_pm_clear_wake_irq(dev);
683 device_init_wakeup(dev, false);
684 }
685 rproc_free(rproc);
686
687 return 0;
688}
689
690static int __maybe_unused stm32_rproc_suspend(struct device *dev)
691{
692 struct rproc *rproc = dev_get_drvdata(dev);
693 struct stm32_rproc *ddata = rproc->priv;
694
695 if (device_may_wakeup(dev))
696 return enable_irq_wake(ddata->wdg_irq);
697
698 return 0;
699}
700
701static int __maybe_unused stm32_rproc_resume(struct device *dev)
702{
703 struct rproc *rproc = dev_get_drvdata(dev);
704 struct stm32_rproc *ddata = rproc->priv;
705
706 if (device_may_wakeup(dev))
707 return disable_irq_wake(ddata->wdg_irq);
708
709 return 0;
710}
711
712static SIMPLE_DEV_PM_OPS(stm32_rproc_pm_ops,
713 stm32_rproc_suspend, stm32_rproc_resume);
714
715static struct platform_driver stm32_rproc_driver = {
716 .probe = stm32_rproc_probe,
717 .remove = stm32_rproc_remove,
718 .driver = {
719 .name = "stm32-rproc",
720 .pm = &stm32_rproc_pm_ops,
721 .of_match_table = of_match_ptr(stm32_rproc_match),
722 },
723};
724module_platform_driver(stm32_rproc_driver);
725
726MODULE_DESCRIPTION("STM32 Remote Processor Control Driver");
727MODULE_AUTHOR("Ludovic Barre <ludovic.barre@st.com>");
728MODULE_AUTHOR("Fabien Dessenne <fabien.dessenne@st.com>");
729MODULE_LICENSE("GPL v2");
730
731
