static int wkup_m3_rproc_remove(struct platform_device *pdev) { struct rproc *rproc = platform_get_drvdata(pdev); rproc_del(rproc); rproc_free(rproc); pm_runtime_put_sync(&pdev->dev); pm_runtime_disable(&pdev->dev); return 0; }
static int st_rproc_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; const struct of_device_id *match; struct st_rproc *ddata; struct device_node *np = dev->of_node; struct rproc *rproc; int enabled; int ret; match = of_match_device(st_rproc_match, dev); if (!match || !match->data) { dev_err(dev, "No device match found\n"); return -ENODEV; } rproc = rproc_alloc(dev, np->name, &st_rproc_ops, NULL, sizeof(*ddata)); if (!rproc) return -ENOMEM; rproc->has_iommu = false; ddata = rproc->priv; ddata->config = (struct st_rproc_config *)match->data; platform_set_drvdata(pdev, rproc); ret = st_rproc_parse_dt(pdev); if (ret) goto free_rproc; enabled = st_rproc_state(pdev); if (enabled < 0) { ret = enabled; goto free_rproc; } if (enabled) { atomic_inc(&rproc->power); rproc->state = RPROC_RUNNING; } else { clk_set_rate(ddata->clk, ddata->clk_rate); } ret = rproc_add(rproc); if (ret) goto free_rproc; return 0; free_rproc: rproc_free(rproc); return ret; }
static int adsp_remove(struct platform_device *pdev) { struct qcom_adsp *adsp = platform_get_drvdata(pdev); rproc_del(adsp->rproc); qcom_remove_glink_subdev(adsp->rproc, &adsp->glink_subdev); qcom_remove_sysmon_subdev(adsp->sysmon); qcom_remove_ssr_subdev(adsp->rproc, &adsp->ssr_subdev); pm_runtime_disable(adsp->dev); rproc_free(adsp->rproc); return 0; }
static int st_rproc_remove(struct platform_device *pdev) { struct rproc *rproc = platform_get_drvdata(pdev); struct st_rproc *ddata = rproc->priv; rproc_del(rproc); clk_disable_unprepare(ddata->clk); of_reserved_mem_device_release(&pdev->dev); rproc_free(rproc); return 0; }
/** * st_slim_rproc_put() - put slim rproc resources * @slim_rproc: Pointer to the st_slim_rproc struct * * Function for calling respective _put() functions on slim_rproc resources. * */ void st_slim_rproc_put(struct st_slim_rproc *slim_rproc) { int clk; if (!slim_rproc) return; slim_clk_disable(slim_rproc); for (clk = 0; clk < ST_SLIM_MAX_CLK && slim_rproc->clks[clk]; clk++) clk_put(slim_rproc->clks[clk]); rproc_del(slim_rproc->rproc); rproc_free(slim_rproc->rproc); }
static int da8xx_rproc_remove(struct platform_device *pdev) { struct rproc *rproc = platform_get_drvdata(pdev); struct da8xx_rproc *drproc = (struct da8xx_rproc *)rproc->priv; struct device *dev = &pdev->dev; /* * The devm subsystem might end up releasing things before * freeing the irq, thus allowing an interrupt to sneak in while * the device is being removed. This should prevent that. */ disable_irq(drproc->irq); rproc_del(rproc); rproc_free(rproc); if (dev->of_node) of_reserved_mem_device_release(dev); return 0; }
static int wkup_m3_rproc_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct wkup_m3_platform_data *pdata = dev->platform_data; /* umem always needs to be processed first */ const char *mem_names[WKUPM3_MEM_MAX] = { "umem", "dmem" }; struct wkup_m3_rproc *wkupm3; const char *fw_name; struct rproc *rproc; struct resource *res; const __be32 *addrp; u32 l4_offset = 0; u64 size; int ret; int i; if (!(pdata && pdata->deassert_reset && pdata->assert_reset && pdata->reset_name)) { dev_err(dev, "Platform data missing!\n"); return -ENODEV; } ret = of_property_read_string(dev->of_node, "ti,pm-firmware", &fw_name); if (ret) { dev_err(dev, "No firmware filename given\n"); return -ENODEV; } pm_runtime_enable(&pdev->dev); ret = pm_runtime_get_sync(&pdev->dev); if (ret < 0) { dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n"); goto err; } rproc = rproc_alloc(dev, "wkup_m3", &wkup_m3_rproc_ops, fw_name, sizeof(*wkupm3)); if (!rproc) { ret = -ENOMEM; goto err; } rproc->auto_boot = false; wkupm3 = rproc->priv; wkupm3->rproc = rproc; wkupm3->pdev = pdev; for (i = 0; i < ARRAY_SIZE(mem_names); i++) { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, mem_names[i]); wkupm3->mem[i].cpu_addr = devm_ioremap_resource(dev, res); if (IS_ERR(wkupm3->mem[i].cpu_addr)) { dev_err(&pdev->dev, "devm_ioremap_resource failed for resource %d\n", i); ret = PTR_ERR(wkupm3->mem[i].cpu_addr); goto err; } wkupm3->mem[i].bus_addr = res->start; wkupm3->mem[i].size = resource_size(res); addrp = of_get_address(dev->of_node, i, &size, NULL); /* * The wkupm3 has umem at address 0 in its view, so the device * addresses for each memory region is computed as a relative * offset of the bus address for umem, and therefore needs to be * processed first. */ if (!strcmp(mem_names[i], "umem")) l4_offset = be32_to_cpu(*addrp); wkupm3->mem[i].dev_addr = be32_to_cpu(*addrp) - l4_offset; } dev_set_drvdata(dev, rproc); ret = rproc_add(rproc); if (ret) { dev_err(dev, "rproc_add failed\n"); goto err_put_rproc; } return 0; err_put_rproc: rproc_free(rproc); err: pm_runtime_put_noidle(dev); pm_runtime_disable(dev); return ret; }
static int adsp_probe(struct platform_device *pdev) { const struct adsp_pil_data *desc; struct qcom_adsp *adsp; struct rproc *rproc; int ret; desc = of_device_get_match_data(&pdev->dev); if (!desc) return -EINVAL; rproc = rproc_alloc(&pdev->dev, pdev->name, &adsp_ops, desc->firmware_name, sizeof(*adsp)); if (!rproc) { dev_err(&pdev->dev, "unable to allocate remoteproc\n"); return -ENOMEM; } adsp = (struct qcom_adsp *)rproc->priv; adsp->dev = &pdev->dev; adsp->rproc = rproc; platform_set_drvdata(pdev, adsp); ret = adsp_alloc_memory_region(adsp); if (ret) goto free_rproc; ret = adsp_init_clock(adsp); if (ret) goto free_rproc; pm_runtime_enable(adsp->dev); ret = adsp_init_reset(adsp); if (ret) goto disable_pm; ret = adsp_init_mmio(adsp, pdev); if (ret) goto disable_pm; ret = qcom_q6v5_init(&adsp->q6v5, pdev, rproc, desc->crash_reason_smem, qcom_adsp_pil_handover); if (ret) goto disable_pm; qcom_add_glink_subdev(rproc, &adsp->glink_subdev); qcom_add_ssr_subdev(rproc, &adsp->ssr_subdev, desc->ssr_name); adsp->sysmon = qcom_add_sysmon_subdev(rproc, desc->sysmon_name, desc->ssctl_id); ret = rproc_add(rproc); if (ret) goto disable_pm; return 0; disable_pm: pm_runtime_disable(adsp->dev); free_rproc: rproc_free(rproc); return ret; }
struct st_slim_rproc *st_slim_rproc_alloc(struct platform_device *pdev, char *fw_name) { struct device *dev = &pdev->dev; struct st_slim_rproc *slim_rproc; struct device_node *np = dev->of_node; struct rproc *rproc; struct resource *res; int err, i; const struct rproc_fw_ops *elf_ops; if (!fw_name) return ERR_PTR(-EINVAL); if (!of_device_is_compatible(np, "st,slim-rproc")) return ERR_PTR(-EINVAL); rproc = rproc_alloc(dev, np->name, &slim_rproc_ops, fw_name, sizeof(*slim_rproc)); if (!rproc) return ERR_PTR(-ENOMEM); rproc->has_iommu = false; slim_rproc = rproc->priv; slim_rproc->rproc = rproc; elf_ops = rproc->fw_ops; /* Use some generic elf ops */ slim_rproc_fw_ops.load = elf_ops->load; slim_rproc_fw_ops.sanity_check = elf_ops->sanity_check; rproc->fw_ops = &slim_rproc_fw_ops; /* get imem and dmem */ for (i = 0; i < ARRAY_SIZE(mem_names); i++) { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, mem_names[i]); slim_rproc->mem[i].cpu_addr = devm_ioremap_resource(dev, res); if (IS_ERR(slim_rproc->mem[i].cpu_addr)) { dev_err(&pdev->dev, "devm_ioremap_resource failed\n"); err = PTR_ERR(slim_rproc->mem[i].cpu_addr); goto err; } slim_rproc->mem[i].bus_addr = res->start; slim_rproc->mem[i].size = resource_size(res); } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "slimcore"); slim_rproc->slimcore = devm_ioremap_resource(dev, res); if (IS_ERR(slim_rproc->slimcore)) { dev_err(&pdev->dev, "failed to ioremap slimcore IO\n"); err = PTR_ERR(slim_rproc->slimcore); goto err; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "peripherals"); slim_rproc->peri = devm_ioremap_resource(dev, res); if (IS_ERR(slim_rproc->peri)) { dev_err(&pdev->dev, "failed to ioremap peripherals IO\n"); err = PTR_ERR(slim_rproc->peri); goto err; } err = slim_clk_get(slim_rproc, dev); if (err) goto err; err = slim_clk_enable(slim_rproc); if (err) { dev_err(dev, "Failed to enable clocks\n"); goto err_clk_put; } /* Register as a remoteproc device */ err = rproc_add(rproc); if (err) { dev_err(dev, "registration of slim remoteproc failed\n"); goto err_clk_dis; } return slim_rproc; err_clk_dis: slim_clk_disable(slim_rproc); err_clk_put: for (i = 0; i < ST_SLIM_MAX_CLK && slim_rproc->clks[i]; i++) clk_put(slim_rproc->clks[i]); err: rproc_free(rproc); return ERR_PTR(err); }
static int da8xx_rproc_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct da8xx_rproc *drproc; struct rproc *rproc; struct irq_data *irq_data; struct resource *bootreg_res; struct resource *chipsig_res; struct clk *dsp_clk; void __iomem *chipsig; void __iomem *bootreg; int irq; int ret; irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(dev, "platform_get_irq(pdev, 0) error: %d\n", irq); return irq; } irq_data = irq_get_irq_data(irq); if (!irq_data) { dev_err(dev, "irq_get_irq_data(%d): NULL\n", irq); return -EINVAL; } bootreg_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "host1cfg"); bootreg = devm_ioremap_resource(dev, bootreg_res); if (IS_ERR(bootreg)) return PTR_ERR(bootreg); chipsig_res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "chipsig"); chipsig = devm_ioremap_resource(dev, chipsig_res); if (IS_ERR(chipsig)) return PTR_ERR(chipsig); dsp_clk = devm_clk_get(dev, NULL); if (IS_ERR(dsp_clk)) { dev_err(dev, "clk_get error: %ld\n", PTR_ERR(dsp_clk)); return PTR_ERR(dsp_clk); } if (dev->of_node) { ret = of_reserved_mem_device_init(dev); if (ret) { dev_err(dev, "device does not have specific CMA pool: %d\n", ret); return ret; } } rproc = rproc_alloc(dev, "dsp", &da8xx_rproc_ops, da8xx_fw_name, sizeof(*drproc)); if (!rproc) { ret = -ENOMEM; goto free_mem; } drproc = rproc->priv; drproc->rproc = rproc; drproc->dsp_clk = dsp_clk; rproc->has_iommu = false; ret = da8xx_rproc_get_internal_memories(pdev, drproc); if (ret) goto free_rproc; platform_set_drvdata(pdev, rproc); /* everything the ISR needs is now setup, so hook it up */ ret = devm_request_threaded_irq(dev, irq, da8xx_rproc_callback, handle_event, 0, "da8xx-remoteproc", rproc); if (ret) { dev_err(dev, "devm_request_threaded_irq error: %d\n", ret); goto free_rproc; } /* * rproc_add() can end up enabling the DSP's clk with the DSP * *not* in reset, but da8xx_rproc_start() needs the DSP to be * held in reset at the time it is called. */ ret = davinci_clk_reset_assert(drproc->dsp_clk); if (ret) goto free_rproc; drproc->chipsig = chipsig; drproc->bootreg = bootreg; drproc->ack_fxn = irq_data->chip->irq_ack; drproc->irq_data = irq_data; drproc->irq = irq; ret = rproc_add(rproc); if (ret) { dev_err(dev, "rproc_add failed: %d\n", ret); goto free_rproc; } return 0; free_rproc: rproc_free(rproc); free_mem: if (dev->of_node) of_reserved_mem_device_release(dev); return ret; }