1 // SPDX-License-Identifier: GPL-2.0
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.
8 #include <linux/arm-smccc.h>
9 #include <linux/dma-mapping.h>
10 #include <linux/interrupt.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>
25 #include "remoteproc_internal.h"
28 #define RELEASE_BOOT 1
33 #define STM32_SMC_RCC 0x82001000
34 #define STM32_SMC_REG_WRITE 0x1
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"
43 #define RSC_TBL_SIZE 1024
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
58 struct stm32_rproc_mem
{
60 void __iomem
*cpu_addr
;
66 struct stm32_rproc_mem_ranges
{
73 const unsigned char name
[10];
74 struct mbox_chan
*chan
;
75 struct mbox_client client
;
76 struct work_struct vq_work
;
81 struct reset_control
*rst
;
82 struct stm32_syscon hold_boot
;
83 struct stm32_syscon pdds
;
84 struct stm32_syscon m4_state
;
85 struct stm32_syscon rsctbl
;
88 struct stm32_rproc_mem
*rmems
;
89 struct stm32_mbox mb
[MBOX_NB_MBX
];
90 struct workqueue_struct
*workqueue
;
95 static int stm32_rproc_pa_to_da(struct rproc
*rproc
, phys_addr_t pa
, u64
*da
)
98 struct stm32_rproc
*ddata
= rproc
->priv
;
99 struct stm32_rproc_mem
*p_mem
;
101 for (i
= 0; i
< ddata
->nb_rmems
; i
++) {
102 p_mem
= &ddata
->rmems
[i
];
104 if (pa
< p_mem
->bus_addr
||
105 pa
>= p_mem
->bus_addr
+ p_mem
->size
)
107 *da
= pa
- p_mem
->bus_addr
+ p_mem
->dev_addr
;
108 dev_dbg(rproc
->dev
.parent
, "pa %pa to da %llx\n", &pa
, *da
);
115 static int stm32_rproc_mem_alloc(struct rproc
*rproc
,
116 struct rproc_mem_entry
*mem
)
118 struct device
*dev
= rproc
->dev
.parent
;
121 dev_dbg(dev
, "map memory: %pa+%x\n", &mem
->dma
, mem
->len
);
122 va
= ioremap_wc(mem
->dma
, mem
->len
);
123 if (IS_ERR_OR_NULL(va
)) {
124 dev_err(dev
, "Unable to map memory region: %pa+%x\n",
125 &mem
->dma
, mem
->len
);
129 /* Update memory entry va */
135 static int stm32_rproc_mem_release(struct rproc
*rproc
,
136 struct rproc_mem_entry
*mem
)
138 dev_dbg(rproc
->dev
.parent
, "unmap memory: %pa\n", &mem
->dma
);
144 static int stm32_rproc_of_memory_translations(struct platform_device
*pdev
,
145 struct stm32_rproc
*ddata
)
147 struct device
*parent
, *dev
= &pdev
->dev
;
148 struct device_node
*np
;
149 struct stm32_rproc_mem
*p_mems
;
150 struct stm32_rproc_mem_ranges
*mem_range
;
151 int cnt
, array_size
, i
, ret
= 0;
153 parent
= dev
->parent
;
154 np
= parent
->of_node
;
156 cnt
= of_property_count_elems_of_size(np
, "dma-ranges",
159 dev_err(dev
, "%s: dma-ranges property not defined\n", __func__
);
163 p_mems
= devm_kcalloc(dev
, cnt
, sizeof(*p_mems
), GFP_KERNEL
);
166 mem_range
= kcalloc(cnt
, sizeof(*mem_range
), GFP_KERNEL
);
170 array_size
= cnt
* sizeof(struct stm32_rproc_mem_ranges
) / sizeof(u32
);
172 ret
= of_property_read_u32_array(np
, "dma-ranges",
173 (u32
*)mem_range
, array_size
);
175 dev_err(dev
, "error while get dma-ranges property: %x\n", ret
);
179 for (i
= 0; i
< cnt
; i
++) {
180 p_mems
[i
].bus_addr
= mem_range
[i
].bus_addr
;
181 p_mems
[i
].dev_addr
= mem_range
[i
].dev_addr
;
182 p_mems
[i
].size
= mem_range
[i
].size
;
184 dev_dbg(dev
, "memory range[%i]: da %#x, pa %pa, size %#zx:\n",
185 i
, p_mems
[i
].dev_addr
, &p_mems
[i
].bus_addr
,
189 ddata
->rmems
= p_mems
;
190 ddata
->nb_rmems
= cnt
;
197 static int stm32_rproc_mbox_idx(struct rproc
*rproc
, const unsigned char *name
)
199 struct stm32_rproc
*ddata
= rproc
->priv
;
202 for (i
= 0; i
< ARRAY_SIZE(ddata
->mb
); i
++) {
203 if (!strncmp(ddata
->mb
[i
].name
, name
, strlen(name
)))
206 dev_err(&rproc
->dev
, "mailbox %s not found\n", name
);
211 static int stm32_rproc_prepare(struct rproc
*rproc
)
213 struct device
*dev
= rproc
->dev
.parent
;
214 struct device_node
*np
= dev
->of_node
;
215 struct of_phandle_iterator it
;
216 struct rproc_mem_entry
*mem
;
217 struct reserved_mem
*rmem
;
221 /* Register associated reserved memory regions */
222 of_phandle_iterator_init(&it
, np
, "memory-region", NULL
, 0);
223 while (of_phandle_iterator_next(&it
) == 0) {
224 rmem
= of_reserved_mem_lookup(it
.node
);
226 dev_err(dev
, "unable to acquire memory-region\n");
230 if (stm32_rproc_pa_to_da(rproc
, rmem
->base
, &da
) < 0) {
231 dev_err(dev
, "memory region not valid %pa\n",
236 /* No need to map vdev buffer */
237 if (strcmp(it
.node
->name
, "vdev0buffer")) {
238 /* Register memory region */
239 mem
= rproc_mem_entry_init(dev
, NULL
,
240 (dma_addr_t
)rmem
->base
,
242 stm32_rproc_mem_alloc
,
243 stm32_rproc_mem_release
,
247 rproc_coredump_add_segment(rproc
, da
,
250 /* Register reserved memory for vdev buffer alloc */
251 mem
= rproc_of_resm_mem_entry_init(dev
, index
,
260 rproc_add_carveout(rproc
, mem
);
267 static int stm32_rproc_parse_fw(struct rproc
*rproc
, const struct firmware
*fw
)
269 if (rproc_elf_load_rsc_table(rproc
, fw
))
270 dev_warn(&rproc
->dev
, "no resource table found for this firmware\n");
275 static irqreturn_t
stm32_rproc_wdg(int irq
, void *data
)
277 struct platform_device
*pdev
= data
;
278 struct rproc
*rproc
= platform_get_drvdata(pdev
);
280 rproc_report_crash(rproc
, RPROC_WATCHDOG
);
285 static void stm32_rproc_mb_vq_work(struct work_struct
*work
)
287 struct stm32_mbox
*mb
= container_of(work
, struct stm32_mbox
, vq_work
);
288 struct rproc
*rproc
= dev_get_drvdata(mb
->client
.dev
);
290 if (rproc_vq_interrupt(rproc
, mb
->vq_id
) == IRQ_NONE
)
291 dev_dbg(&rproc
->dev
, "no message found in vq%d\n", mb
->vq_id
);
294 static void stm32_rproc_mb_callback(struct mbox_client
*cl
, void *data
)
296 struct rproc
*rproc
= dev_get_drvdata(cl
->dev
);
297 struct stm32_mbox
*mb
= container_of(cl
, struct stm32_mbox
, client
);
298 struct stm32_rproc
*ddata
= rproc
->priv
;
300 queue_work(ddata
->workqueue
, &mb
->vq_work
);
303 static void stm32_rproc_free_mbox(struct rproc
*rproc
)
305 struct stm32_rproc
*ddata
= rproc
->priv
;
308 for (i
= 0; i
< ARRAY_SIZE(ddata
->mb
); i
++) {
309 if (ddata
->mb
[i
].chan
)
310 mbox_free_channel(ddata
->mb
[i
].chan
);
311 ddata
->mb
[i
].chan
= NULL
;
315 static const struct stm32_mbox stm32_rproc_mbox
[MBOX_NB_MBX
] = {
317 .name
= STM32_MBX_VQ0
,
318 .vq_id
= STM32_MBX_VQ0_ID
,
320 .rx_callback
= stm32_rproc_mb_callback
,
325 .name
= STM32_MBX_VQ1
,
326 .vq_id
= STM32_MBX_VQ1_ID
,
328 .rx_callback
= stm32_rproc_mb_callback
,
333 .name
= STM32_MBX_SHUTDOWN
,
338 .tx_tout
= 500, /* 500 ms time out */
342 .name
= STM32_MBX_DETACH
,
347 .tx_tout
= 200, /* 200 ms time out to detach should be fair enough */
352 static int stm32_rproc_request_mbox(struct rproc
*rproc
)
354 struct stm32_rproc
*ddata
= rproc
->priv
;
355 struct device
*dev
= &rproc
->dev
;
358 const unsigned char *name
;
359 struct mbox_client
*cl
;
361 /* Initialise mailbox structure table */
362 memcpy(ddata
->mb
, stm32_rproc_mbox
, sizeof(stm32_rproc_mbox
));
364 for (i
= 0; i
< MBOX_NB_MBX
; i
++) {
365 name
= ddata
->mb
[i
].name
;
367 cl
= &ddata
->mb
[i
].client
;
368 cl
->dev
= dev
->parent
;
370 ddata
->mb
[i
].chan
= mbox_request_channel_byname(cl
, name
);
371 if (IS_ERR(ddata
->mb
[i
].chan
)) {
372 if (PTR_ERR(ddata
->mb
[i
].chan
) == -EPROBE_DEFER
) {
373 dev_err_probe(dev
->parent
,
374 PTR_ERR(ddata
->mb
[i
].chan
),
375 "failed to request mailbox %s\n",
379 dev_warn(dev
, "cannot get %s mbox\n", name
);
380 ddata
->mb
[i
].chan
= NULL
;
382 if (ddata
->mb
[i
].vq_id
>= 0) {
383 INIT_WORK(&ddata
->mb
[i
].vq_work
,
384 stm32_rproc_mb_vq_work
);
391 for (j
= i
- 1; j
>= 0; j
--)
392 if (ddata
->mb
[j
].chan
)
393 mbox_free_channel(ddata
->mb
[j
].chan
);
394 return -EPROBE_DEFER
;
397 static int stm32_rproc_set_hold_boot(struct rproc
*rproc
, bool hold
)
399 struct stm32_rproc
*ddata
= rproc
->priv
;
400 struct stm32_syscon hold_boot
= ddata
->hold_boot
;
401 struct arm_smccc_res smc_res
;
404 val
= hold
? HOLD_BOOT
: RELEASE_BOOT
;
406 if (IS_ENABLED(CONFIG_HAVE_ARM_SMCCC
) && ddata
->secured_soc
) {
407 arm_smccc_smc(STM32_SMC_RCC
, STM32_SMC_REG_WRITE
,
408 hold_boot
.reg
, val
, 0, 0, 0, 0, &smc_res
);
411 err
= regmap_update_bits(hold_boot
.map
, hold_boot
.reg
,
412 hold_boot
.mask
, val
);
416 dev_err(&rproc
->dev
, "failed to set hold boot\n");
421 static void stm32_rproc_add_coredump_trace(struct rproc
*rproc
)
423 struct rproc_debug_trace
*trace
;
424 struct rproc_dump_segment
*segment
;
427 list_for_each_entry(trace
, &rproc
->traces
, node
) {
428 already_added
= false;
430 list_for_each_entry(segment
, &rproc
->dump_segments
, node
) {
431 if (segment
->da
== trace
->trace_mem
.da
) {
432 already_added
= true;
438 rproc_coredump_add_segment(rproc
, trace
->trace_mem
.da
,
439 trace
->trace_mem
.len
);
443 static int stm32_rproc_start(struct rproc
*rproc
)
445 struct stm32_rproc
*ddata
= rproc
->priv
;
448 stm32_rproc_add_coredump_trace(rproc
);
450 /* clear remote proc Deep Sleep */
451 if (ddata
->pdds
.map
) {
452 err
= regmap_update_bits(ddata
->pdds
.map
, ddata
->pdds
.reg
,
453 ddata
->pdds
.mask
, 0);
455 dev_err(&rproc
->dev
, "failed to clear pdds\n");
460 err
= stm32_rproc_set_hold_boot(rproc
, false);
464 return stm32_rproc_set_hold_boot(rproc
, true);
467 static int stm32_rproc_attach(struct rproc
*rproc
)
469 stm32_rproc_add_coredump_trace(rproc
);
471 return stm32_rproc_set_hold_boot(rproc
, true);
474 static int stm32_rproc_detach(struct rproc
*rproc
)
476 struct stm32_rproc
*ddata
= rproc
->priv
;
477 int err
, dummy_data
, idx
;
479 /* Inform the remote processor of the detach */
480 idx
= stm32_rproc_mbox_idx(rproc
, STM32_MBX_DETACH
);
481 if (idx
>= 0 && ddata
->mb
[idx
].chan
) {
482 /* A dummy data is sent to allow to block on transmit */
483 err
= mbox_send_message(ddata
->mb
[idx
].chan
,
486 dev_warn(&rproc
->dev
, "warning: remote FW detach without ack\n");
489 /* Allow remote processor to auto-reboot */
490 return stm32_rproc_set_hold_boot(rproc
, false);
493 static int stm32_rproc_stop(struct rproc
*rproc
)
495 struct stm32_rproc
*ddata
= rproc
->priv
;
496 int err
, dummy_data
, idx
;
498 /* request shutdown of the remote processor */
499 if (rproc
->state
!= RPROC_OFFLINE
) {
500 idx
= stm32_rproc_mbox_idx(rproc
, STM32_MBX_SHUTDOWN
);
501 if (idx
>= 0 && ddata
->mb
[idx
].chan
) {
502 /* a dummy data is sent to allow to block on transmit */
503 err
= mbox_send_message(ddata
->mb
[idx
].chan
,
506 dev_warn(&rproc
->dev
, "warning: remote FW shutdown without ack\n");
510 err
= stm32_rproc_set_hold_boot(rproc
, true);
514 err
= reset_control_assert(ddata
->rst
);
516 dev_err(&rproc
->dev
, "failed to assert the reset\n");
520 /* to allow platform Standby power mode, set remote proc Deep Sleep */
521 if (ddata
->pdds
.map
) {
522 err
= regmap_update_bits(ddata
->pdds
.map
, ddata
->pdds
.reg
,
523 ddata
->pdds
.mask
, 1);
525 dev_err(&rproc
->dev
, "failed to set pdds\n");
530 /* update coprocessor state to OFF if available */
531 if (ddata
->m4_state
.map
) {
532 err
= regmap_update_bits(ddata
->m4_state
.map
,
534 ddata
->m4_state
.mask
,
537 dev_err(&rproc
->dev
, "failed to set copro state\n");
545 static void stm32_rproc_kick(struct rproc
*rproc
, int vqid
)
547 struct stm32_rproc
*ddata
= rproc
->priv
;
551 if (WARN_ON(vqid
>= MBOX_NB_VQ
))
554 for (i
= 0; i
< MBOX_NB_MBX
; i
++) {
555 if (vqid
!= ddata
->mb
[i
].vq_id
)
557 if (!ddata
->mb
[i
].chan
)
559 err
= mbox_send_message(ddata
->mb
[i
].chan
, (void *)(long)vqid
);
561 dev_err(&rproc
->dev
, "%s: failed (%s, err:%d)\n",
562 __func__
, ddata
->mb
[i
].name
, err
);
567 static int stm32_rproc_da_to_pa(struct rproc
*rproc
,
568 u64 da
, phys_addr_t
*pa
)
570 struct stm32_rproc
*ddata
= rproc
->priv
;
571 struct device
*dev
= rproc
->dev
.parent
;
572 struct stm32_rproc_mem
*p_mem
;
575 for (i
= 0; i
< ddata
->nb_rmems
; i
++) {
576 p_mem
= &ddata
->rmems
[i
];
578 if (da
< p_mem
->dev_addr
||
579 da
>= p_mem
->dev_addr
+ p_mem
->size
)
582 *pa
= da
- p_mem
->dev_addr
+ p_mem
->bus_addr
;
583 dev_dbg(dev
, "da %llx to pa %#x\n", da
, *pa
);
588 dev_err(dev
, "can't translate da %llx\n", da
);
593 static struct resource_table
*
594 stm32_rproc_get_loaded_rsc_table(struct rproc
*rproc
, size_t *table_sz
)
596 struct stm32_rproc
*ddata
= rproc
->priv
;
597 struct device
*dev
= rproc
->dev
.parent
;
602 /* The resource table has already been mapped, nothing to do */
606 err
= regmap_read(ddata
->rsctbl
.map
, ddata
->rsctbl
.reg
, &rsc_da
);
608 dev_err(dev
, "failed to read rsc tbl addr\n");
609 return ERR_PTR(-EINVAL
);
614 return ERR_PTR(-ENOENT
);
616 err
= stm32_rproc_da_to_pa(rproc
, rsc_da
, &rsc_pa
);
620 ddata
->rsc_va
= devm_ioremap_wc(dev
, rsc_pa
, RSC_TBL_SIZE
);
621 if (IS_ERR_OR_NULL(ddata
->rsc_va
)) {
622 dev_err(dev
, "Unable to map memory region: %pa+%zx\n",
623 &rsc_pa
, RSC_TBL_SIZE
);
624 ddata
->rsc_va
= NULL
;
625 return ERR_PTR(-ENOMEM
);
630 * Assuming the resource table fits in 1kB is fair.
631 * Notice for the detach, that this 1 kB memory area has to be reserved in the coprocessor
632 * firmware for the resource table. On detach, the remoteproc core re-initializes this
633 * entire area by overwriting it with the initial values stored in rproc->clean_table.
635 *table_sz
= RSC_TBL_SIZE
;
636 return (struct resource_table
*)ddata
->rsc_va
;
639 static const struct rproc_ops st_rproc_ops
= {
640 .prepare
= stm32_rproc_prepare
,
641 .start
= stm32_rproc_start
,
642 .stop
= stm32_rproc_stop
,
643 .attach
= stm32_rproc_attach
,
644 .detach
= stm32_rproc_detach
,
645 .kick
= stm32_rproc_kick
,
646 .load
= rproc_elf_load_segments
,
647 .parse_fw
= stm32_rproc_parse_fw
,
648 .find_loaded_rsc_table
= rproc_elf_find_loaded_rsc_table
,
649 .get_loaded_rsc_table
= stm32_rproc_get_loaded_rsc_table
,
650 .sanity_check
= rproc_elf_sanity_check
,
651 .get_boot_addr
= rproc_elf_get_boot_addr
,
654 static const struct of_device_id stm32_rproc_match
[] = {
655 { .compatible
= "st,stm32mp1-m4" },
658 MODULE_DEVICE_TABLE(of
, stm32_rproc_match
);
660 static int stm32_rproc_get_syscon(struct device_node
*np
, const char *prop
,
661 struct stm32_syscon
*syscon
)
665 syscon
->map
= syscon_regmap_lookup_by_phandle(np
, prop
);
666 if (IS_ERR(syscon
->map
)) {
667 err
= PTR_ERR(syscon
->map
);
672 err
= of_property_read_u32_index(np
, prop
, 1, &syscon
->reg
);
676 err
= of_property_read_u32_index(np
, prop
, 2, &syscon
->mask
);
682 static int stm32_rproc_parse_dt(struct platform_device
*pdev
,
683 struct stm32_rproc
*ddata
, bool *auto_boot
)
685 struct device
*dev
= &pdev
->dev
;
686 struct device_node
*np
= dev
->of_node
;
687 struct stm32_syscon tz
;
691 irq
= platform_get_irq(pdev
, 0);
692 if (irq
== -EPROBE_DEFER
)
693 return dev_err_probe(dev
, irq
, "failed to get interrupt\n");
696 err
= devm_request_irq(dev
, irq
, stm32_rproc_wdg
, 0,
697 dev_name(dev
), pdev
);
699 return dev_err_probe(dev
, err
,
700 "failed to request wdg irq\n");
702 ddata
->wdg_irq
= irq
;
704 if (of_property_read_bool(np
, "wakeup-source")) {
705 device_init_wakeup(dev
, true);
706 dev_pm_set_wake_irq(dev
, irq
);
709 dev_info(dev
, "wdg irq registered\n");
712 ddata
->rst
= devm_reset_control_get_by_index(dev
, 0);
713 if (IS_ERR(ddata
->rst
))
714 return dev_err_probe(dev
, PTR_ERR(ddata
->rst
),
715 "failed to get mcu_reset\n");
718 * if platform is secured the hold boot bit must be written by
719 * smc call and read normally.
720 * if not secure the hold boot bit could be read/write normally
722 err
= stm32_rproc_get_syscon(np
, "st,syscfg-tz", &tz
);
724 dev_err(dev
, "failed to get tz syscfg\n");
728 err
= regmap_read(tz
.map
, tz
.reg
, &tzen
);
730 dev_err(dev
, "failed to read tzen\n");
733 ddata
->secured_soc
= tzen
& tz
.mask
;
735 err
= stm32_rproc_get_syscon(np
, "st,syscfg-holdboot",
738 dev_err(dev
, "failed to get hold boot\n");
742 err
= stm32_rproc_get_syscon(np
, "st,syscfg-pdds", &ddata
->pdds
);
744 dev_info(dev
, "failed to get pdds\n");
746 *auto_boot
= of_property_read_bool(np
, "st,auto-boot");
749 * See if we can check the M4 status, i.e if it was started
750 * from the boot loader or not.
752 err
= stm32_rproc_get_syscon(np
, "st,syscfg-m4-state",
756 ddata
->m4_state
.map
= NULL
;
757 /* no coprocessor state syscon (optional) */
758 dev_warn(dev
, "m4 state not supported\n");
760 /* no need to go further */
764 /* See if we can get the resource table */
765 err
= stm32_rproc_get_syscon(np
, "st,syscfg-rsc-tbl",
768 /* no rsc table syscon (optional) */
769 dev_warn(dev
, "rsc tbl syscon not supported\n");
775 static int stm32_rproc_get_m4_status(struct stm32_rproc
*ddata
,
778 /* See stm32_rproc_parse_dt() */
779 if (!ddata
->m4_state
.map
) {
781 * We couldn't get the coprocessor's state, assume
784 *state
= M4_STATE_OFF
;
788 return regmap_read(ddata
->m4_state
.map
, ddata
->m4_state
.reg
, state
);
791 static int stm32_rproc_probe(struct platform_device
*pdev
)
793 struct device
*dev
= &pdev
->dev
;
794 struct stm32_rproc
*ddata
;
795 struct device_node
*np
= dev
->of_node
;
800 ret
= dma_coerce_mask_and_coherent(dev
, DMA_BIT_MASK(32));
804 rproc
= rproc_alloc(dev
, np
->name
, &st_rproc_ops
, NULL
, sizeof(*ddata
));
810 rproc_coredump_set_elf_info(rproc
, ELFCLASS32
, EM_NONE
);
812 ret
= stm32_rproc_parse_dt(pdev
, ddata
, &rproc
->auto_boot
);
816 ret
= stm32_rproc_of_memory_translations(pdev
, ddata
);
820 ret
= stm32_rproc_get_m4_status(ddata
, &state
);
824 if (state
== M4_STATE_CRUN
)
825 rproc
->state
= RPROC_DETACHED
;
827 rproc
->has_iommu
= false;
828 ddata
->workqueue
= create_workqueue(dev_name(dev
));
829 if (!ddata
->workqueue
) {
830 dev_err(dev
, "cannot create workqueue\n");
835 platform_set_drvdata(pdev
, rproc
);
837 ret
= stm32_rproc_request_mbox(rproc
);
841 ret
= rproc_add(rproc
);
848 stm32_rproc_free_mbox(rproc
);
850 destroy_workqueue(ddata
->workqueue
);
852 rproc_resource_cleanup(rproc
);
854 if (device_may_wakeup(dev
)) {
855 dev_pm_clear_wake_irq(dev
);
856 device_init_wakeup(dev
, false);
862 static int stm32_rproc_remove(struct platform_device
*pdev
)
864 struct rproc
*rproc
= platform_get_drvdata(pdev
);
865 struct stm32_rproc
*ddata
= rproc
->priv
;
866 struct device
*dev
= &pdev
->dev
;
868 if (atomic_read(&rproc
->power
) > 0)
869 rproc_shutdown(rproc
);
872 stm32_rproc_free_mbox(rproc
);
873 destroy_workqueue(ddata
->workqueue
);
875 if (device_may_wakeup(dev
)) {
876 dev_pm_clear_wake_irq(dev
);
877 device_init_wakeup(dev
, false);
884 static int __maybe_unused
stm32_rproc_suspend(struct device
*dev
)
886 struct rproc
*rproc
= dev_get_drvdata(dev
);
887 struct stm32_rproc
*ddata
= rproc
->priv
;
889 if (device_may_wakeup(dev
))
890 return enable_irq_wake(ddata
->wdg_irq
);
895 static int __maybe_unused
stm32_rproc_resume(struct device
*dev
)
897 struct rproc
*rproc
= dev_get_drvdata(dev
);
898 struct stm32_rproc
*ddata
= rproc
->priv
;
900 if (device_may_wakeup(dev
))
901 return disable_irq_wake(ddata
->wdg_irq
);
906 static SIMPLE_DEV_PM_OPS(stm32_rproc_pm_ops
,
907 stm32_rproc_suspend
, stm32_rproc_resume
);
909 static struct platform_driver stm32_rproc_driver
= {
910 .probe
= stm32_rproc_probe
,
911 .remove
= stm32_rproc_remove
,
913 .name
= "stm32-rproc",
914 .pm
= &stm32_rproc_pm_ops
,
915 .of_match_table
= of_match_ptr(stm32_rproc_match
),
918 module_platform_driver(stm32_rproc_driver
);
920 MODULE_DESCRIPTION("STM32 Remote Processor Control Driver");
921 MODULE_AUTHOR("Ludovic Barre <ludovic.barre@st.com>");
922 MODULE_AUTHOR("Fabien Dessenne <fabien.dessenne@st.com>");
923 MODULE_LICENSE("GPL v2");