Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Copyright (C) STMicroelectronics 2018 - All Rights Reserved
0004  * Authors: Ludovic Barre <ludovic.barre@st.com> for STMicroelectronics.
0005  *          Fabien Dessenne <fabien.dessenne@st.com> for STMicroelectronics.
0006  */
0007 
0008 #include <linux/arm-smccc.h>
0009 #include <linux/dma-mapping.h>
0010 #include <linux/interrupt.h>
0011 #include <linux/io.h>
0012 #include <linux/mailbox_client.h>
0013 #include <linux/mfd/syscon.h>
0014 #include <linux/module.h>
0015 #include <linux/of_address.h>
0016 #include <linux/of_device.h>
0017 #include <linux/of_reserved_mem.h>
0018 #include <linux/pm_wakeirq.h>
0019 #include <linux/regmap.h>
0020 #include <linux/remoteproc.h>
0021 #include <linux/reset.h>
0022 #include <linux/slab.h>
0023 #include <linux/workqueue.h>
0024 
0025 #include "remoteproc_internal.h"
0026 
0027 #define HOLD_BOOT       0
0028 #define RELEASE_BOOT        1
0029 
0030 #define MBOX_NB_VQ      2
0031 #define MBOX_NB_MBX     4
0032 
0033 #define STM32_SMC_RCC       0x82001000
0034 #define STM32_SMC_REG_WRITE 0x1
0035 
0036 #define STM32_MBX_VQ0       "vq0"
0037 #define STM32_MBX_VQ0_ID    0
0038 #define STM32_MBX_VQ1       "vq1"
0039 #define STM32_MBX_VQ1_ID    1
0040 #define STM32_MBX_SHUTDOWN  "shutdown"
0041 #define STM32_MBX_DETACH    "detach"
0042 
0043 #define RSC_TBL_SIZE        1024
0044 
0045 #define M4_STATE_OFF        0
0046 #define M4_STATE_INI        1
0047 #define M4_STATE_CRUN       2
0048 #define M4_STATE_CSTOP      3
0049 #define M4_STATE_STANDBY    4
0050 #define M4_STATE_CRASH      5
0051 
0052 struct stm32_syscon {
0053     struct regmap *map;
0054     u32 reg;
0055     u32 mask;
0056 };
0057 
0058 struct stm32_rproc_mem {
0059     char name[20];
0060     void __iomem *cpu_addr;
0061     phys_addr_t bus_addr;
0062     u32 dev_addr;
0063     size_t size;
0064 };
0065 
0066 struct stm32_rproc_mem_ranges {
0067     u32 dev_addr;
0068     u32 bus_addr;
0069     u32 size;
0070 };
0071 
0072 struct stm32_mbox {
0073     const unsigned char name[10];
0074     struct mbox_chan *chan;
0075     struct mbox_client client;
0076     struct work_struct vq_work;
0077     int vq_id;
0078 };
0079 
0080 struct stm32_rproc {
0081     struct reset_control *rst;
0082     struct stm32_syscon hold_boot;
0083     struct stm32_syscon pdds;
0084     struct stm32_syscon m4_state;
0085     struct stm32_syscon rsctbl;
0086     int wdg_irq;
0087     u32 nb_rmems;
0088     struct stm32_rproc_mem *rmems;
0089     struct stm32_mbox mb[MBOX_NB_MBX];
0090     struct workqueue_struct *workqueue;
0091     bool secured_soc;
0092     void __iomem *rsc_va;
0093 };
0094 
0095 static int stm32_rproc_pa_to_da(struct rproc *rproc, phys_addr_t pa, u64 *da)
0096 {
0097     unsigned int i;
0098     struct stm32_rproc *ddata = rproc->priv;
0099     struct stm32_rproc_mem *p_mem;
0100 
0101     for (i = 0; i < ddata->nb_rmems; i++) {
0102         p_mem = &ddata->rmems[i];
0103 
0104         if (pa < p_mem->bus_addr ||
0105             pa >= p_mem->bus_addr + p_mem->size)
0106             continue;
0107         *da = pa - p_mem->bus_addr + p_mem->dev_addr;
0108         dev_dbg(rproc->dev.parent, "pa %pa to da %llx\n", &pa, *da);
0109         return 0;
0110     }
0111 
0112     return -EINVAL;
0113 }
0114 
0115 static int stm32_rproc_mem_alloc(struct rproc *rproc,
0116                  struct rproc_mem_entry *mem)
0117 {
0118     struct device *dev = rproc->dev.parent;
0119     void *va;
0120 
0121     dev_dbg(dev, "map memory: %pa+%x\n", &mem->dma, mem->len);
0122     va = ioremap_wc(mem->dma, mem->len);
0123     if (IS_ERR_OR_NULL(va)) {
0124         dev_err(dev, "Unable to map memory region: %pa+%x\n",
0125             &mem->dma, mem->len);
0126         return -ENOMEM;
0127     }
0128 
0129     /* Update memory entry va */
0130     mem->va = va;
0131 
0132     return 0;
0133 }
0134 
0135 static int stm32_rproc_mem_release(struct rproc *rproc,
0136                    struct rproc_mem_entry *mem)
0137 {
0138     dev_dbg(rproc->dev.parent, "unmap memory: %pa\n", &mem->dma);
0139     iounmap(mem->va);
0140 
0141     return 0;
0142 }
0143 
0144 static int stm32_rproc_of_memory_translations(struct platform_device *pdev,
0145                           struct stm32_rproc *ddata)
0146 {
0147     struct device *parent, *dev = &pdev->dev;
0148     struct device_node *np;
0149     struct stm32_rproc_mem *p_mems;
0150     struct stm32_rproc_mem_ranges *mem_range;
0151     int cnt, array_size, i, ret = 0;
0152 
0153     parent = dev->parent;
0154     np = parent->of_node;
0155 
0156     cnt = of_property_count_elems_of_size(np, "dma-ranges",
0157                           sizeof(*mem_range));
0158     if (cnt <= 0) {
0159         dev_err(dev, "%s: dma-ranges property not defined\n", __func__);
0160         return -EINVAL;
0161     }
0162 
0163     p_mems = devm_kcalloc(dev, cnt, sizeof(*p_mems), GFP_KERNEL);
0164     if (!p_mems)
0165         return -ENOMEM;
0166     mem_range = kcalloc(cnt, sizeof(*mem_range), GFP_KERNEL);
0167     if (!mem_range)
0168         return -ENOMEM;
0169 
0170     array_size = cnt * sizeof(struct stm32_rproc_mem_ranges) / sizeof(u32);
0171 
0172     ret = of_property_read_u32_array(np, "dma-ranges",
0173                      (u32 *)mem_range, array_size);
0174     if (ret) {
0175         dev_err(dev, "error while get dma-ranges property: %x\n", ret);
0176         goto free_mem;
0177     }
0178 
0179     for (i = 0; i < cnt; i++) {
0180         p_mems[i].bus_addr = mem_range[i].bus_addr;
0181         p_mems[i].dev_addr = mem_range[i].dev_addr;
0182         p_mems[i].size     = mem_range[i].size;
0183 
0184         dev_dbg(dev, "memory range[%i]: da %#x, pa %pa, size %#zx:\n",
0185             i, p_mems[i].dev_addr, &p_mems[i].bus_addr,
0186             p_mems[i].size);
0187     }
0188 
0189     ddata->rmems = p_mems;
0190     ddata->nb_rmems = cnt;
0191 
0192 free_mem:
0193     kfree(mem_range);
0194     return ret;
0195 }
0196 
0197 static int stm32_rproc_mbox_idx(struct rproc *rproc, const unsigned char *name)
0198 {
0199     struct stm32_rproc *ddata = rproc->priv;
0200     int i;
0201 
0202     for (i = 0; i < ARRAY_SIZE(ddata->mb); i++) {
0203         if (!strncmp(ddata->mb[i].name, name, strlen(name)))
0204             return i;
0205     }
0206     dev_err(&rproc->dev, "mailbox %s not found\n", name);
0207 
0208     return -EINVAL;
0209 }
0210 
0211 static int stm32_rproc_prepare(struct rproc *rproc)
0212 {
0213     struct device *dev = rproc->dev.parent;
0214     struct device_node *np = dev->of_node;
0215     struct of_phandle_iterator it;
0216     struct rproc_mem_entry *mem;
0217     struct reserved_mem *rmem;
0218     u64 da;
0219     int index = 0;
0220 
0221     /* Register associated reserved memory regions */
0222     of_phandle_iterator_init(&it, np, "memory-region", NULL, 0);
0223     while (of_phandle_iterator_next(&it) == 0) {
0224         rmem = of_reserved_mem_lookup(it.node);
0225         if (!rmem) {
0226             dev_err(dev, "unable to acquire memory-region\n");
0227             return -EINVAL;
0228         }
0229 
0230         if (stm32_rproc_pa_to_da(rproc, rmem->base, &da) < 0) {
0231             dev_err(dev, "memory region not valid %pa\n",
0232                 &rmem->base);
0233             return -EINVAL;
0234         }
0235 
0236         /*  No need to map vdev buffer */
0237         if (strcmp(it.node->name, "vdev0buffer")) {
0238             /* Register memory region */
0239             mem = rproc_mem_entry_init(dev, NULL,
0240                            (dma_addr_t)rmem->base,
0241                            rmem->size, da,
0242                            stm32_rproc_mem_alloc,
0243                            stm32_rproc_mem_release,
0244                            it.node->name);
0245 
0246             if (mem)
0247                 rproc_coredump_add_segment(rproc, da,
0248                                rmem->size);
0249         } else {
0250             /* Register reserved memory for vdev buffer alloc */
0251             mem = rproc_of_resm_mem_entry_init(dev, index,
0252                                rmem->size,
0253                                rmem->base,
0254                                it.node->name);
0255         }
0256 
0257         if (!mem)
0258             return -ENOMEM;
0259 
0260         rproc_add_carveout(rproc, mem);
0261         index++;
0262     }
0263 
0264     return 0;
0265 }
0266 
0267 static int stm32_rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
0268 {
0269     if (rproc_elf_load_rsc_table(rproc, fw))
0270         dev_warn(&rproc->dev, "no resource table found for this firmware\n");
0271 
0272     return 0;
0273 }
0274 
0275 static irqreturn_t stm32_rproc_wdg(int irq, void *data)
0276 {
0277     struct platform_device *pdev = data;
0278     struct rproc *rproc = platform_get_drvdata(pdev);
0279 
0280     rproc_report_crash(rproc, RPROC_WATCHDOG);
0281 
0282     return IRQ_HANDLED;
0283 }
0284 
0285 static void stm32_rproc_mb_vq_work(struct work_struct *work)
0286 {
0287     struct stm32_mbox *mb = container_of(work, struct stm32_mbox, vq_work);
0288     struct rproc *rproc = dev_get_drvdata(mb->client.dev);
0289 
0290     if (rproc_vq_interrupt(rproc, mb->vq_id) == IRQ_NONE)
0291         dev_dbg(&rproc->dev, "no message found in vq%d\n", mb->vq_id);
0292 }
0293 
0294 static void stm32_rproc_mb_callback(struct mbox_client *cl, void *data)
0295 {
0296     struct rproc *rproc = dev_get_drvdata(cl->dev);
0297     struct stm32_mbox *mb = container_of(cl, struct stm32_mbox, client);
0298     struct stm32_rproc *ddata = rproc->priv;
0299 
0300     queue_work(ddata->workqueue, &mb->vq_work);
0301 }
0302 
0303 static void stm32_rproc_free_mbox(struct rproc *rproc)
0304 {
0305     struct stm32_rproc *ddata = rproc->priv;
0306     unsigned int i;
0307 
0308     for (i = 0; i < ARRAY_SIZE(ddata->mb); i++) {
0309         if (ddata->mb[i].chan)
0310             mbox_free_channel(ddata->mb[i].chan);
0311         ddata->mb[i].chan = NULL;
0312     }
0313 }
0314 
0315 static const struct stm32_mbox stm32_rproc_mbox[MBOX_NB_MBX] = {
0316     {
0317         .name = STM32_MBX_VQ0,
0318         .vq_id = STM32_MBX_VQ0_ID,
0319         .client = {
0320             .rx_callback = stm32_rproc_mb_callback,
0321             .tx_block = false,
0322         },
0323     },
0324     {
0325         .name = STM32_MBX_VQ1,
0326         .vq_id = STM32_MBX_VQ1_ID,
0327         .client = {
0328             .rx_callback = stm32_rproc_mb_callback,
0329             .tx_block = false,
0330         },
0331     },
0332     {
0333         .name = STM32_MBX_SHUTDOWN,
0334         .vq_id = -1,
0335         .client = {
0336             .tx_block = true,
0337             .tx_done = NULL,
0338             .tx_tout = 500, /* 500 ms time out */
0339         },
0340     },
0341     {
0342         .name = STM32_MBX_DETACH,
0343         .vq_id = -1,
0344         .client = {
0345             .tx_block = true,
0346             .tx_done = NULL,
0347             .tx_tout = 200, /* 200 ms time out to detach should be fair enough */
0348         },
0349     }
0350 };
0351 
0352 static int stm32_rproc_request_mbox(struct rproc *rproc)
0353 {
0354     struct stm32_rproc *ddata = rproc->priv;
0355     struct device *dev = &rproc->dev;
0356     unsigned int i;
0357     int j;
0358     const unsigned char *name;
0359     struct mbox_client *cl;
0360 
0361     /* Initialise mailbox structure table */
0362     memcpy(ddata->mb, stm32_rproc_mbox, sizeof(stm32_rproc_mbox));
0363 
0364     for (i = 0; i < MBOX_NB_MBX; i++) {
0365         name = ddata->mb[i].name;
0366 
0367         cl = &ddata->mb[i].client;
0368         cl->dev = dev->parent;
0369 
0370         ddata->mb[i].chan = mbox_request_channel_byname(cl, name);
0371         if (IS_ERR(ddata->mb[i].chan)) {
0372             if (PTR_ERR(ddata->mb[i].chan) == -EPROBE_DEFER) {
0373                 dev_err_probe(dev->parent,
0374                           PTR_ERR(ddata->mb[i].chan),
0375                           "failed to request mailbox %s\n",
0376                           name);
0377                 goto err_probe;
0378             }
0379             dev_warn(dev, "cannot get %s mbox\n", name);
0380             ddata->mb[i].chan = NULL;
0381         }
0382         if (ddata->mb[i].vq_id >= 0) {
0383             INIT_WORK(&ddata->mb[i].vq_work,
0384                   stm32_rproc_mb_vq_work);
0385         }
0386     }
0387 
0388     return 0;
0389 
0390 err_probe:
0391     for (j = i - 1; j >= 0; j--)
0392         if (ddata->mb[j].chan)
0393             mbox_free_channel(ddata->mb[j].chan);
0394     return -EPROBE_DEFER;
0395 }
0396 
0397 static int stm32_rproc_set_hold_boot(struct rproc *rproc, bool hold)
0398 {
0399     struct stm32_rproc *ddata = rproc->priv;
0400     struct stm32_syscon hold_boot = ddata->hold_boot;
0401     struct arm_smccc_res smc_res;
0402     int val, err;
0403 
0404     val = hold ? HOLD_BOOT : RELEASE_BOOT;
0405 
0406     if (IS_ENABLED(CONFIG_HAVE_ARM_SMCCC) && ddata->secured_soc) {
0407         arm_smccc_smc(STM32_SMC_RCC, STM32_SMC_REG_WRITE,
0408                   hold_boot.reg, val, 0, 0, 0, 0, &smc_res);
0409         err = smc_res.a0;
0410     } else {
0411         err = regmap_update_bits(hold_boot.map, hold_boot.reg,
0412                      hold_boot.mask, val);
0413     }
0414 
0415     if (err)
0416         dev_err(&rproc->dev, "failed to set hold boot\n");
0417 
0418     return err;
0419 }
0420 
0421 static void stm32_rproc_add_coredump_trace(struct rproc *rproc)
0422 {
0423     struct rproc_debug_trace *trace;
0424     struct rproc_dump_segment *segment;
0425     bool already_added;
0426 
0427     list_for_each_entry(trace, &rproc->traces, node) {
0428         already_added = false;
0429 
0430         list_for_each_entry(segment, &rproc->dump_segments, node) {
0431             if (segment->da == trace->trace_mem.da) {
0432                 already_added = true;
0433                 break;
0434             }
0435         }
0436 
0437         if (!already_added)
0438             rproc_coredump_add_segment(rproc, trace->trace_mem.da,
0439                            trace->trace_mem.len);
0440     }
0441 }
0442 
0443 static int stm32_rproc_start(struct rproc *rproc)
0444 {
0445     struct stm32_rproc *ddata = rproc->priv;
0446     int err;
0447 
0448     stm32_rproc_add_coredump_trace(rproc);
0449 
0450     /* clear remote proc Deep Sleep */
0451     if (ddata->pdds.map) {
0452         err = regmap_update_bits(ddata->pdds.map, ddata->pdds.reg,
0453                      ddata->pdds.mask, 0);
0454         if (err) {
0455             dev_err(&rproc->dev, "failed to clear pdds\n");
0456             return err;
0457         }
0458     }
0459 
0460     err = stm32_rproc_set_hold_boot(rproc, false);
0461     if (err)
0462         return err;
0463 
0464     return stm32_rproc_set_hold_boot(rproc, true);
0465 }
0466 
0467 static int stm32_rproc_attach(struct rproc *rproc)
0468 {
0469     stm32_rproc_add_coredump_trace(rproc);
0470 
0471     return stm32_rproc_set_hold_boot(rproc, true);
0472 }
0473 
0474 static int stm32_rproc_detach(struct rproc *rproc)
0475 {
0476     struct stm32_rproc *ddata = rproc->priv;
0477     int err, idx;
0478 
0479     /* Inform the remote processor of the detach */
0480     idx = stm32_rproc_mbox_idx(rproc, STM32_MBX_DETACH);
0481     if (idx >= 0 && ddata->mb[idx].chan) {
0482         err = mbox_send_message(ddata->mb[idx].chan, "stop");
0483         if (err < 0)
0484             dev_warn(&rproc->dev, "warning: remote FW detach without ack\n");
0485     }
0486 
0487     /* Allow remote processor to auto-reboot */
0488     return stm32_rproc_set_hold_boot(rproc, false);
0489 }
0490 
0491 static int stm32_rproc_stop(struct rproc *rproc)
0492 {
0493     struct stm32_rproc *ddata = rproc->priv;
0494     int err, idx;
0495 
0496     /* request shutdown of the remote processor */
0497     if (rproc->state != RPROC_OFFLINE && rproc->state != RPROC_CRASHED) {
0498         idx = stm32_rproc_mbox_idx(rproc, STM32_MBX_SHUTDOWN);
0499         if (idx >= 0 && ddata->mb[idx].chan) {
0500             err = mbox_send_message(ddata->mb[idx].chan, "detach");
0501             if (err < 0)
0502                 dev_warn(&rproc->dev, "warning: remote FW shutdown without ack\n");
0503         }
0504     }
0505 
0506     err = stm32_rproc_set_hold_boot(rproc, true);
0507     if (err)
0508         return err;
0509 
0510     err = reset_control_assert(ddata->rst);
0511     if (err) {
0512         dev_err(&rproc->dev, "failed to assert the reset\n");
0513         return err;
0514     }
0515 
0516     /* to allow platform Standby power mode, set remote proc Deep Sleep */
0517     if (ddata->pdds.map) {
0518         err = regmap_update_bits(ddata->pdds.map, ddata->pdds.reg,
0519                      ddata->pdds.mask, 1);
0520         if (err) {
0521             dev_err(&rproc->dev, "failed to set pdds\n");
0522             return err;
0523         }
0524     }
0525 
0526     /* update coprocessor state to OFF if available */
0527     if (ddata->m4_state.map) {
0528         err = regmap_update_bits(ddata->m4_state.map,
0529                      ddata->m4_state.reg,
0530                      ddata->m4_state.mask,
0531                      M4_STATE_OFF);
0532         if (err) {
0533             dev_err(&rproc->dev, "failed to set copro state\n");
0534             return err;
0535         }
0536     }
0537 
0538     return 0;
0539 }
0540 
0541 static void stm32_rproc_kick(struct rproc *rproc, int vqid)
0542 {
0543     struct stm32_rproc *ddata = rproc->priv;
0544     unsigned int i;
0545     int err;
0546 
0547     if (WARN_ON(vqid >= MBOX_NB_VQ))
0548         return;
0549 
0550     for (i = 0; i < MBOX_NB_MBX; i++) {
0551         if (vqid != ddata->mb[i].vq_id)
0552             continue;
0553         if (!ddata->mb[i].chan)
0554             return;
0555         err = mbox_send_message(ddata->mb[i].chan, "kick");
0556         if (err < 0)
0557             dev_err(&rproc->dev, "%s: failed (%s, err:%d)\n",
0558                 __func__, ddata->mb[i].name, err);
0559         return;
0560     }
0561 }
0562 
0563 static int stm32_rproc_da_to_pa(struct rproc *rproc,
0564                 u64 da, phys_addr_t *pa)
0565 {
0566     struct stm32_rproc *ddata = rproc->priv;
0567     struct device *dev = rproc->dev.parent;
0568     struct stm32_rproc_mem *p_mem;
0569     unsigned int i;
0570 
0571     for (i = 0; i < ddata->nb_rmems; i++) {
0572         p_mem = &ddata->rmems[i];
0573 
0574         if (da < p_mem->dev_addr ||
0575             da >= p_mem->dev_addr + p_mem->size)
0576             continue;
0577 
0578         *pa = da - p_mem->dev_addr + p_mem->bus_addr;
0579         dev_dbg(dev, "da %llx to pa %pap\n", da, pa);
0580 
0581         return 0;
0582     }
0583 
0584     dev_err(dev, "can't translate da %llx\n", da);
0585 
0586     return -EINVAL;
0587 }
0588 
0589 static struct resource_table *
0590 stm32_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz)
0591 {
0592     struct stm32_rproc *ddata = rproc->priv;
0593     struct device *dev = rproc->dev.parent;
0594     phys_addr_t rsc_pa;
0595     u32 rsc_da;
0596     int err;
0597 
0598     /* The resource table has already been mapped, nothing to do */
0599     if (ddata->rsc_va)
0600         goto done;
0601 
0602     err = regmap_read(ddata->rsctbl.map, ddata->rsctbl.reg, &rsc_da);
0603     if (err) {
0604         dev_err(dev, "failed to read rsc tbl addr\n");
0605         return ERR_PTR(-EINVAL);
0606     }
0607 
0608     if (!rsc_da)
0609         /* no rsc table */
0610         return ERR_PTR(-ENOENT);
0611 
0612     err = stm32_rproc_da_to_pa(rproc, rsc_da, &rsc_pa);
0613     if (err)
0614         return ERR_PTR(err);
0615 
0616     ddata->rsc_va = devm_ioremap_wc(dev, rsc_pa, RSC_TBL_SIZE);
0617     if (IS_ERR_OR_NULL(ddata->rsc_va)) {
0618         dev_err(dev, "Unable to map memory region: %pa+%zx\n",
0619             &rsc_pa, RSC_TBL_SIZE);
0620         ddata->rsc_va = NULL;
0621         return ERR_PTR(-ENOMEM);
0622     }
0623 
0624 done:
0625     /*
0626      * Assuming the resource table fits in 1kB is fair.
0627      * Notice for the detach, that this 1 kB memory area has to be reserved in the coprocessor
0628      * firmware for the resource table. On detach, the remoteproc core re-initializes this
0629      * entire area by overwriting it with the initial values stored in rproc->clean_table.
0630      */
0631     *table_sz = RSC_TBL_SIZE;
0632     return (struct resource_table *)ddata->rsc_va;
0633 }
0634 
0635 static const struct rproc_ops st_rproc_ops = {
0636     .prepare    = stm32_rproc_prepare,
0637     .start      = stm32_rproc_start,
0638     .stop       = stm32_rproc_stop,
0639     .attach     = stm32_rproc_attach,
0640     .detach     = stm32_rproc_detach,
0641     .kick       = stm32_rproc_kick,
0642     .load       = rproc_elf_load_segments,
0643     .parse_fw   = stm32_rproc_parse_fw,
0644     .find_loaded_rsc_table = rproc_elf_find_loaded_rsc_table,
0645     .get_loaded_rsc_table = stm32_rproc_get_loaded_rsc_table,
0646     .sanity_check   = rproc_elf_sanity_check,
0647     .get_boot_addr  = rproc_elf_get_boot_addr,
0648 };
0649 
0650 static const struct of_device_id stm32_rproc_match[] = {
0651     { .compatible = "st,stm32mp1-m4" },
0652     {},
0653 };
0654 MODULE_DEVICE_TABLE(of, stm32_rproc_match);
0655 
0656 static int stm32_rproc_get_syscon(struct device_node *np, const char *prop,
0657                   struct stm32_syscon *syscon)
0658 {
0659     int err = 0;
0660 
0661     syscon->map = syscon_regmap_lookup_by_phandle(np, prop);
0662     if (IS_ERR(syscon->map)) {
0663         err = PTR_ERR(syscon->map);
0664         syscon->map = NULL;
0665         goto out;
0666     }
0667 
0668     err = of_property_read_u32_index(np, prop, 1, &syscon->reg);
0669     if (err)
0670         goto out;
0671 
0672     err = of_property_read_u32_index(np, prop, 2, &syscon->mask);
0673 
0674 out:
0675     return err;
0676 }
0677 
0678 static int stm32_rproc_parse_dt(struct platform_device *pdev,
0679                 struct stm32_rproc *ddata, bool *auto_boot)
0680 {
0681     struct device *dev = &pdev->dev;
0682     struct device_node *np = dev->of_node;
0683     struct stm32_syscon tz;
0684     unsigned int tzen;
0685     int err, irq;
0686 
0687     irq = platform_get_irq(pdev, 0);
0688     if (irq == -EPROBE_DEFER)
0689         return dev_err_probe(dev, irq, "failed to get interrupt\n");
0690 
0691     if (irq > 0) {
0692         err = devm_request_irq(dev, irq, stm32_rproc_wdg, 0,
0693                        dev_name(dev), pdev);
0694         if (err)
0695             return dev_err_probe(dev, err,
0696                          "failed to request wdg irq\n");
0697 
0698         ddata->wdg_irq = irq;
0699 
0700         if (of_property_read_bool(np, "wakeup-source")) {
0701             device_init_wakeup(dev, true);
0702             dev_pm_set_wake_irq(dev, irq);
0703         }
0704 
0705         dev_info(dev, "wdg irq registered\n");
0706     }
0707 
0708     ddata->rst = devm_reset_control_get_by_index(dev, 0);
0709     if (IS_ERR(ddata->rst))
0710         return dev_err_probe(dev, PTR_ERR(ddata->rst),
0711                      "failed to get mcu_reset\n");
0712 
0713     /*
0714      * if platform is secured the hold boot bit must be written by
0715      * smc call and read normally.
0716      * if not secure the hold boot bit could be read/write normally
0717      */
0718     err = stm32_rproc_get_syscon(np, "st,syscfg-tz", &tz);
0719     if (err) {
0720         dev_err(dev, "failed to get tz syscfg\n");
0721         return err;
0722     }
0723 
0724     err = regmap_read(tz.map, tz.reg, &tzen);
0725     if (err) {
0726         dev_err(dev, "failed to read tzen\n");
0727         return err;
0728     }
0729     ddata->secured_soc = tzen & tz.mask;
0730 
0731     err = stm32_rproc_get_syscon(np, "st,syscfg-holdboot",
0732                      &ddata->hold_boot);
0733     if (err) {
0734         dev_err(dev, "failed to get hold boot\n");
0735         return err;
0736     }
0737 
0738     err = stm32_rproc_get_syscon(np, "st,syscfg-pdds", &ddata->pdds);
0739     if (err)
0740         dev_info(dev, "failed to get pdds\n");
0741 
0742     *auto_boot = of_property_read_bool(np, "st,auto-boot");
0743 
0744     /*
0745      * See if we can check the M4 status, i.e if it was started
0746      * from the boot loader or not.
0747      */
0748     err = stm32_rproc_get_syscon(np, "st,syscfg-m4-state",
0749                      &ddata->m4_state);
0750     if (err) {
0751         /* remember this */
0752         ddata->m4_state.map = NULL;
0753         /* no coprocessor state syscon (optional) */
0754         dev_warn(dev, "m4 state not supported\n");
0755 
0756         /* no need to go further */
0757         return 0;
0758     }
0759 
0760     /* See if we can get the resource table */
0761     err = stm32_rproc_get_syscon(np, "st,syscfg-rsc-tbl",
0762                      &ddata->rsctbl);
0763     if (err) {
0764         /* no rsc table syscon (optional) */
0765         dev_warn(dev, "rsc tbl syscon not supported\n");
0766     }
0767 
0768     return 0;
0769 }
0770 
0771 static int stm32_rproc_get_m4_status(struct stm32_rproc *ddata,
0772                      unsigned int *state)
0773 {
0774     /* See stm32_rproc_parse_dt() */
0775     if (!ddata->m4_state.map) {
0776         /*
0777          * We couldn't get the coprocessor's state, assume
0778          * it is not running.
0779          */
0780         *state = M4_STATE_OFF;
0781         return 0;
0782     }
0783 
0784     return regmap_read(ddata->m4_state.map, ddata->m4_state.reg, state);
0785 }
0786 
0787 static int stm32_rproc_probe(struct platform_device *pdev)
0788 {
0789     struct device *dev = &pdev->dev;
0790     struct stm32_rproc *ddata;
0791     struct device_node *np = dev->of_node;
0792     struct rproc *rproc;
0793     unsigned int state;
0794     int ret;
0795 
0796     ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
0797     if (ret)
0798         return ret;
0799 
0800     rproc = rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata));
0801     if (!rproc)
0802         return -ENOMEM;
0803 
0804     ddata = rproc->priv;
0805 
0806     rproc_coredump_set_elf_info(rproc, ELFCLASS32, EM_NONE);
0807 
0808     ret = stm32_rproc_parse_dt(pdev, ddata, &rproc->auto_boot);
0809     if (ret)
0810         goto free_rproc;
0811 
0812     ret = stm32_rproc_of_memory_translations(pdev, ddata);
0813     if (ret)
0814         goto free_rproc;
0815 
0816     ret = stm32_rproc_get_m4_status(ddata, &state);
0817     if (ret)
0818         goto free_rproc;
0819 
0820     if (state == M4_STATE_CRUN)
0821         rproc->state = RPROC_DETACHED;
0822 
0823     rproc->has_iommu = false;
0824     ddata->workqueue = create_workqueue(dev_name(dev));
0825     if (!ddata->workqueue) {
0826         dev_err(dev, "cannot create workqueue\n");
0827         ret = -ENOMEM;
0828         goto free_resources;
0829     }
0830 
0831     platform_set_drvdata(pdev, rproc);
0832 
0833     ret = stm32_rproc_request_mbox(rproc);
0834     if (ret)
0835         goto free_wkq;
0836 
0837     ret = rproc_add(rproc);
0838     if (ret)
0839         goto free_mb;
0840 
0841     return 0;
0842 
0843 free_mb:
0844     stm32_rproc_free_mbox(rproc);
0845 free_wkq:
0846     destroy_workqueue(ddata->workqueue);
0847 free_resources:
0848     rproc_resource_cleanup(rproc);
0849 free_rproc:
0850     if (device_may_wakeup(dev)) {
0851         dev_pm_clear_wake_irq(dev);
0852         device_init_wakeup(dev, false);
0853     }
0854     rproc_free(rproc);
0855     return ret;
0856 }
0857 
0858 static int stm32_rproc_remove(struct platform_device *pdev)
0859 {
0860     struct rproc *rproc = platform_get_drvdata(pdev);
0861     struct stm32_rproc *ddata = rproc->priv;
0862     struct device *dev = &pdev->dev;
0863 
0864     if (atomic_read(&rproc->power) > 0)
0865         rproc_shutdown(rproc);
0866 
0867     rproc_del(rproc);
0868     stm32_rproc_free_mbox(rproc);
0869     destroy_workqueue(ddata->workqueue);
0870 
0871     if (device_may_wakeup(dev)) {
0872         dev_pm_clear_wake_irq(dev);
0873         device_init_wakeup(dev, false);
0874     }
0875     rproc_free(rproc);
0876 
0877     return 0;
0878 }
0879 
0880 static int __maybe_unused stm32_rproc_suspend(struct device *dev)
0881 {
0882     struct rproc *rproc = dev_get_drvdata(dev);
0883     struct stm32_rproc *ddata = rproc->priv;
0884 
0885     if (device_may_wakeup(dev))
0886         return enable_irq_wake(ddata->wdg_irq);
0887 
0888     return 0;
0889 }
0890 
0891 static int __maybe_unused stm32_rproc_resume(struct device *dev)
0892 {
0893     struct rproc *rproc = dev_get_drvdata(dev);
0894     struct stm32_rproc *ddata = rproc->priv;
0895 
0896     if (device_may_wakeup(dev))
0897         return disable_irq_wake(ddata->wdg_irq);
0898 
0899     return 0;
0900 }
0901 
0902 static SIMPLE_DEV_PM_OPS(stm32_rproc_pm_ops,
0903              stm32_rproc_suspend, stm32_rproc_resume);
0904 
0905 static struct platform_driver stm32_rproc_driver = {
0906     .probe = stm32_rproc_probe,
0907     .remove = stm32_rproc_remove,
0908     .driver = {
0909         .name = "stm32-rproc",
0910         .pm = &stm32_rproc_pm_ops,
0911         .of_match_table = of_match_ptr(stm32_rproc_match),
0912     },
0913 };
0914 module_platform_driver(stm32_rproc_driver);
0915 
0916 MODULE_DESCRIPTION("STM32 Remote Processor Control Driver");
0917 MODULE_AUTHOR("Ludovic Barre <ludovic.barre@st.com>");
0918 MODULE_AUTHOR("Fabien Dessenne <fabien.dessenne@st.com>");
0919 MODULE_LICENSE("GPL v2");
0920
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!