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; }
/* Handle probe of a modem device */ static int sproc_probe(struct platform_device *pdev) { struct ste_modem_device *mdev = container_of(pdev, struct ste_modem_device, pdev); struct sproc *sproc; struct rproc *rproc; int err; dev_dbg(&mdev->pdev.dev, "probe ste-modem\n"); if (!mdev->ops.setup || !mdev->ops.kick || !mdev->ops.kick_subscribe || !mdev->ops.power) { dev_err(&mdev->pdev.dev, "invalid mdev ops\n"); return -EINVAL; } rproc = rproc_alloc(&mdev->pdev.dev, mdev->pdev.name, &sproc_ops, SPROC_MODEM_FIRMWARE, sizeof(*sproc)); if (!rproc) return -ENOMEM; sproc = rproc->priv; sproc->mdev = mdev; sproc->rproc = rproc; mdev->drv_data = sproc; /* Provide callback functions to modem device */ sproc->mdev->ops.setup(sproc->mdev, &sproc_dev_cb); /* Set the STE-modem specific firmware handler */ rproc->fw_ops = &sproc_fw_ops; /* * STE-modem requires the firmware to be located * at the start of the shared memory region. So we need to * reserve space for firmware at the start. */ sproc->fw_addr = dma_alloc_coherent(rproc->dev.parent, SPROC_FW_SIZE, &sproc->fw_dma_addr, GFP_KERNEL); if (!sproc->fw_addr) { sproc_err(sproc, "Cannot allocate memory for fw\n"); err = -ENOMEM; goto free_rproc; } /* Register as a remoteproc device */ err = rproc_add(rproc); if (err) goto free_mem; return 0; free_mem: dma_free_coherent(rproc->dev.parent, SPROC_FW_SIZE, sproc->fw_addr, sproc->fw_dma_addr); free_rproc: /* Reset device data upon error */ mdev->drv_data = NULL; rproc_put(rproc); return err; }
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; }
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 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; }
static int zynqmp_r5_remoteproc_probe(struct platform_device *pdev) { const unsigned char *prop; struct resource *res; int ret = 0; int method = 0; struct zynqmp_r5_rproc_pdata *local; local = devm_kzalloc(&pdev->dev, sizeof(struct zynqmp_r5_rproc_pdata), GFP_KERNEL); if (!local) return -ENOMEM; platform_set_drvdata(pdev, local); /* Declare vring for firmware */ res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vring0"); if (!res) { dev_err(&pdev->dev, "invalid address for vring0\n"); return -ENXIO; } /* FIXME: it may need to extend to 64/48 bit */ ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); if (ret) { dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret); goto dma_mask_fault; } prop = of_get_property(pdev->dev.of_node, "core_conf", NULL); if (!prop) { dev_warn(&pdev->dev, "default core_conf used: lock-step\n"); prop = "lock-step"; } dev_info(&pdev->dev, "RPU core_conf: %s\n", prop); if (!strcmp(prop, "split0")) { local->rpu_mode = SPLIT; local->rpu_id = 0; } else if (!strcmp(prop, "split1")) { local->rpu_mode = SPLIT; local->rpu_id = 1; } else if (!strcmp(prop, "lock-step")) { local->rpu_mode = LOCK_STEP; local->rpu_id = 0; } else { dev_err(&pdev->dev, "Invalid core_conf mode provided - %s , %d\n", prop, local->rpu_mode); goto dma_mask_fault; } prop = of_get_property(pdev->dev.of_node, "method", NULL); if (!prop) { dev_warn(&pdev->dev, "default method used: smc\n"); prop = "smc"; } dev_info(&pdev->dev, "IPI/RPU control method: %s\n", prop); if (!strcmp(prop, "direct")) { method = HW; local->ipi_ops = &ipi_hw_ops; local->rpu_ops = &rpu_hw_ops; } else if (!strcmp(prop, "hvc")) { method = HVC; local->ipi_ops = &ipi_hvc_ops; local->rpu_ops = &rpu_hvc_ops; } else if (!strcmp(prop, "smc")) { method = SMC; local->ipi_ops = &ipi_smc_ops; local->rpu_ops = &rpu_smc_ops; } else { dev_err(&pdev->dev, "Invalid method provided - %s\n", prop); goto dma_mask_fault; } /* Handle direct hardware access */ /* (TODO: remove once RPU and IPI drivers are ready ) */ if (method == HW) { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rpu_base"); local->rpu_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(local->rpu_base)) { dev_err(&pdev->dev, "Unable to map RPU I/O memory\n"); ret = PTR_ERR(local->rpu_base); goto dma_mask_fault; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "apb_base"); local->crl_apb_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(local->crl_apb_base)) { dev_err(&pdev->dev, "Unable to map CRL_APB I/O memory\n"); ret = PTR_ERR(local->crl_apb_base); goto dma_mask_fault; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ipi"); local->ipi_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(local->ipi_base)) { pr_err("%s: Unable to map IPI\n", __func__); ret = PTR_ERR(local->ipi_base); goto dma_mask_fault; } } prop = of_get_property(pdev->dev.of_node, "bootmem", NULL); if (!prop) { dev_warn(&pdev->dev, "default bootmem property used: tcm\n"); prop = "tcm"; } dev_info(&pdev->dev, "RPU bootmem: %s\n", prop); if (!strcmp(prop, "tcm")) { local->bootmem = TCM; } else if (!strcmp(prop, "ocm")) { local->bootmem = OCM; } else { dev_err(&pdev->dev, "Invalid R5 bootmem property - %s\n", prop); goto dma_mask_fault; } /* IPI IRQ */ local->vring0 = platform_get_irq(pdev, 0); if (local->vring0 < 0) { ret = local->vring0; dev_err(&pdev->dev, "unable to find IPI IRQ\n"); goto dma_mask_fault; } ret = devm_request_irq(&pdev->dev, local->vring0, r5_remoteproc_interrupt, 0, dev_name(&pdev->dev), &pdev->dev); if (ret) { dev_err(&pdev->dev, "IRQ %d already allocated\n", local->vring0); goto dma_mask_fault; } dev_dbg(&pdev->dev, "vring0 irq: %d\n", local->vring0); ret = of_property_read_u32(pdev->dev.of_node, "ipi_dest_mask", &local->ipi_dest_mask); if (ret < 0) { dev_warn(&pdev->dev, "default ipi_dest_mask used: 0x100\n"); local->ipi_dest_mask = 0x100; } dev_info(&pdev->dev, "ipi_dest_mask: 0x%x\n", local->ipi_dest_mask); /* Module param firmware first */ prop = of_get_property(pdev->dev.of_node, "firmware", NULL); if (firmware) prop = firmware; else if (!prop) prop = DEFAULT_FIRMWARE_NAME; if (prop) { dev_dbg(&pdev->dev, "Using firmware: %s\n", prop); local->rproc = rproc_alloc(&pdev->dev, dev_name(&pdev->dev), &zynqmp_r5_rproc_ops, prop, sizeof(struct rproc)); if (!local->rproc) { dev_err(&pdev->dev, "rproc allocation failed\n"); goto rproc_fault; } ret = rproc_add(local->rproc); if (ret) { dev_err(&pdev->dev, "rproc registration failed\n"); goto rproc_fault; } } else { ret = -ENODEV; } return ret; rproc_fault: rproc_put(local->rproc); dma_mask_fault: dma_release_declared_memory(&pdev->dev); err_exit: return 0; }
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(pdev, IORESOURCE_MEM, 0); bootreg = devm_ioremap_resource(dev, bootreg_res); if (IS_ERR(bootreg)) return PTR_ERR(bootreg); chipsig_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 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); } rproc = rproc_alloc(dev, "dsp", &da8xx_rproc_ops, da8xx_fw_name, sizeof(*drproc)); if (!rproc) return -ENOMEM; drproc = rproc->priv; drproc->rproc = rproc; rproc->has_iommu = false; 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 = reset_assert(dev); 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; drproc->dsp_clk = dsp_clk; ret = rproc_add(rproc); if (ret) { dev_err(dev, "rproc_add failed: %d\n", ret); goto free_rproc; } return 0; free_rproc: rproc_put(rproc); return ret; }
static int zynqmp_r5_remoteproc_probe(struct platform_device *pdev) { const unsigned char *prop; struct resource *res; int ret = 0; int method = 0; char *rproc_firmware = 0; struct zynqmp_r5_rproc_pdata *local; local = devm_kzalloc(&pdev->dev, sizeof(struct zynqmp_r5_rproc_pdata), GFP_KERNEL); if (!local) return -ENOMEM; platform_set_drvdata(pdev, local); /* FIXME: it may need to extend to 64/48 bit */ ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); if (ret) { dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret); goto dma_mask_fault; } prop = of_get_property(pdev->dev.of_node, "core_conf", NULL); if (!prop) { dev_warn(&pdev->dev, "default core_conf used: lock-step\n"); prop = "lock-step"; } dev_info(&pdev->dev, "RPU core_conf: %s\n", prop); if (!strcmp(prop, "split0")) { local->rpu_mode = SPLIT; local->rpu_id = 0; } else if (!strcmp(prop, "split1")) { local->rpu_mode = SPLIT; local->rpu_id = 1; } else if (!strcmp(prop, "lock-step")) { local->rpu_mode = LOCK_STEP; local->rpu_id = 0; } else { dev_err(&pdev->dev, "Invalid core_conf mode provided - %s , %d\n", prop, local->rpu_mode); ret = -EINVAL; goto dma_mask_fault; } prop = of_get_property(pdev->dev.of_node, "method", NULL); if (!prop) { dev_warn(&pdev->dev, "default method used: smc\n"); prop = "direct"; } dev_info(&pdev->dev, "IPI/RPU control method: %s\n", prop); if (!strcmp(prop, "direct")) { method = HW; local->ipi_ops = &ipi_hw_ops; local->rpu_ops = &rpu_hw_ops; } else if (!strcmp(prop, "hvc")) { method = HVC; local->ipi_ops = &ipi_hvc_ops; local->rpu_ops = &rpu_hvc_ops; } else if (!strcmp(prop, "smc")) { method = SMC; local->ipi_ops = &ipi_smc_ops; local->rpu_ops = &rpu_smc_ops; } else { dev_err(&pdev->dev, "Invalid method provided - %s\n", prop); ret = -EINVAL; goto dma_mask_fault; } /* Handle direct hardware access */ /* (TODO: remove once RPU and IPI drivers are ready ) */ if (method == HW) { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rpu_base"); local->rpu_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (IS_ERR(local->rpu_base)) { dev_err(&pdev->dev, "Unable to map RPU I/O memory\n"); ret = PTR_ERR(local->rpu_base); goto dma_mask_fault; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "apb_base"); local->crl_apb_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (IS_ERR(local->crl_apb_base)) { dev_err(&pdev->dev, "Unable to map CRL_APB I/O memory\n"); ret = PTR_ERR(local->crl_apb_base); goto dma_mask_fault; } res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ipi"); local->ipi_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (IS_ERR(local->ipi_base)) { pr_err("%s: Unable to map IPI\n", __func__); ret = PTR_ERR(local->ipi_base); goto dma_mask_fault; } } /* IPI IRQ */ local->vring0 = platform_get_irq(pdev, 0); if (local->vring0 < 0) { ret = local->vring0; dev_err(&pdev->dev, "unable to find IPI IRQ\n"); goto dma_mask_fault; } ret = devm_request_irq(&pdev->dev, local->vring0, r5_remoteproc_interrupt, IRQF_SHARED, dev_name(&pdev->dev), &pdev->dev); if (ret) { dev_err(&pdev->dev, "IRQ %d already allocated\n", local->vring0); goto dma_mask_fault; } dev_dbg(&pdev->dev, "vring0 irq: %d\n", local->vring0); if (local->rpu_id == 0) { local->ipi_dest_mask = RPU_0_IPI_MASK; rproc_firmware = firmware; } else { local->ipi_dest_mask = RPU_1_IPI_MASK; rproc_firmware = firmware1; } dev_dbg(&pdev->dev, "Using firmware: %s\n", rproc_firmware); local->rproc = rproc_alloc(&pdev->dev, dev_name(&pdev->dev), &zynqmp_r5_rproc_ops, rproc_firmware, sizeof(struct rproc)); if (!local->rproc) { dev_err(&pdev->dev, "rproc allocation failed\n"); goto rproc_fault; } zynqmp_r5_rproc_init(local->rproc); ret = rproc_add(local->rproc); if (ret) { dev_err(&pdev->dev, "rproc registration failed\n"); goto rproc_fault; } return ret; rproc_fault: rproc_put(local->rproc); dma_mask_fault: dma_release_declared_memory(&pdev->dev); return ret; }
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; struct reset_control *dsp_reset; 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); } dsp_reset = devm_reset_control_get_exclusive(dev, NULL); if (IS_ERR(dsp_reset)) { if (PTR_ERR(dsp_reset) != -EPROBE_DEFER) dev_err(dev, "unable to get reset control: %ld\n", PTR_ERR(dsp_reset)); return PTR_ERR(dsp_reset); } 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; } /* error recovery is not supported at present */ rproc->recovery_disabled = true; drproc = rproc->priv; drproc->rproc = rproc; drproc->dsp_clk = dsp_clk; drproc->dsp_reset = dsp_reset; 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 = reset_control_assert(dsp_reset); 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; }
static int wkup_m3_rproc_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct wkup_m3_platform_data *pdata = dev->platform_data; struct wkup_m3_rproc *m3_rproc; struct rproc *rproc; int irq, ret; struct resource *res; struct task_struct *task; if (!wkup_m3_pm_ops) return -EPROBE_DEFER; pm_runtime_enable(&pdev->dev); ret = pm_runtime_get_sync(&pdev->dev); if (IS_ERR_VALUE(ret)) { dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n"); return ret; } rproc = rproc_alloc(dev, "wkup_m3", &wkup_m3_rproc_ops, "am335x-pm-firmware.elf", sizeof(*m3_rproc)); if (!rproc) return -ENOMEM; m3_rproc = rproc->priv; m3_rproc->rproc = rproc; m3_rproc->pdev = pdev; m3_rproc_static = m3_rproc; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ipc_regs"); m3_rproc->ipc_mem_base = devm_ioremap_resource(dev, res); if (!m3_rproc->ipc_mem_base) { dev_err(dev, "could not ioremap ipc_mem\n"); ret = -EADDRNOTAVAIL; goto err; } irq = platform_get_irq(pdev, 0); if (!irq) { dev_err(&pdev->dev, "no irq resource\n"); ret = -ENXIO; goto err; } ret = devm_request_irq(dev, irq, wkup_m3_txev_handler, IRQF_DISABLED, "wkup_m3_txev", m3_rproc); if (ret) { dev_err(dev, "request_irq failed\n"); goto err; } if (!(pdata && pdata->deassert_reset)) { dev_err(dev, "Platform data missing deassert_reset!\n"); ret = -ENODEV; } /* Register as a remoteproc device */ ret = rproc_add(rproc); if (ret) { dev_err(dev, "rproc_add failed\n"); goto err; } /* * Wait for firmware loading completion in a thread so we * can boot the wkup_m3 as soon as it's ready without holding * up kernel boot */ task = kthread_run((void *)wkup_m3_rproc_loader_thread, rproc, "wkup_m3_rproc_loader"); if (IS_ERR(task)) { dev_err(dev, "can't create rproc_loader thread\n"); goto err; } return 0; err: rproc_put(rproc); pm_runtime_put_sync(&pdev->dev); return ret; }
static int mb_remoteproc_probe(struct platform_device *pdev) { const unsigned char *prop; struct platform_device *bram_pdev; struct device_node *bram_dev; struct resource *res; /* IO mem resources */ int ret = 0; int count = 0; struct mb_rproc_pdata *local; local = devm_kzalloc(&pdev->dev, sizeof(*local), GFP_KERNEL); if (!local) return -ENOMEM; platform_set_drvdata(pdev, local); /* Declare memory for firmware */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&pdev->dev, "invalid address\n"); return -ENODEV; } local->mem_start = res->start; local->mem_end = res->end; /* Alloc phys addr from 0 to max_addr for firmware */ ret = dma_declare_coherent_memory(&pdev->dev, local->mem_start, local->mem_start, local->mem_end - local->mem_start + 1, DMA_MEMORY_IO); if (!ret) { dev_err(&pdev->dev, "dma_declare_coherent_memory failed\n"); return -ENOMEM; } ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)); if (ret) { dev_err(&pdev->dev, "dma_set_coherent_mask: %d\n", ret); goto dma_mask_fault; } /* Alloc IRQ based on DTS to be sure that no other driver will use it */ while (1) { int irq; /* Allocating shared IRQs will ensure that any module will * use these IRQs */ irq = platform_get_irq(pdev, count++); if (irq == -ENXIO || irq == -EINVAL) break; ret = devm_request_irq(&pdev->dev, irq, mb_remoteproc_interrupt, 0, dev_name(&pdev->dev), &pdev->dev); if (ret) { dev_err(&pdev->dev, "IRQ %d already allocated\n", irq); goto dma_mask_fault; } dev_info(&pdev->dev, "%d: Alloc irq: %d\n", count, irq); } /* Find out reset gpio and keep microblaze in reset */ local->reset_gpio = of_get_named_gpio(pdev->dev.of_node, "reset", 0); if (local->reset_gpio < 0) { dev_err(&pdev->dev, "reset-gpio property not found\n"); ret = local->reset_gpio; goto dma_mask_fault; } ret = devm_gpio_request_one(&pdev->dev, local->reset_gpio, GPIOF_OUT_INIT_HIGH, "mb_reset"); if (ret) { dev_err(&pdev->dev, "Please specify gpio reset addr\n"); goto dma_mask_fault; } /* Find out reset gpio and keep microblaze in reset */ local->mb_debug_gpio = of_get_named_gpio(pdev->dev.of_node, "debug", 0); if (local->mb_debug_gpio < 0) { dev_err(&pdev->dev, "mb-debug-gpio property not found\n"); ret = local->mb_debug_gpio; goto dma_mask_fault; } ret = devm_gpio_request_one(&pdev->dev, local->mb_debug_gpio, GPIOF_OUT_INIT_LOW, "mb_debug"); if (ret) { dev_err(&pdev->dev, "Please specify gpio debug pin\n"); goto dma_mask_fault; } /* IPI number for getting irq from firmware */ local->ipi = of_get_named_gpio(pdev->dev.of_node, "ipino", 0); if (local->ipi < 0) { dev_err(&pdev->dev, "ipi-gpio property not found\n"); ret = local->ipi; goto dma_mask_fault; } ret = devm_gpio_request_one(&pdev->dev, local->ipi, GPIOF_IN, "mb_ipi"); if (ret) { dev_err(&pdev->dev, "Please specify gpio reset addr\n"); goto dma_mask_fault; } ret = devm_request_irq(&pdev->dev, gpio_to_irq(local->ipi), ipi_kick, IRQF_SHARED|IRQF_TRIGGER_RISING, dev_name(&pdev->dev), local); if (ret) { dev_err(&pdev->dev, "IRQ %d already allocated\n", local->ipi); goto dma_mask_fault; } /* Find out vring0 pin */ local->vring0 = of_get_named_gpio(pdev->dev.of_node, "vring0", 0); if (local->vring0 < 0) { dev_err(&pdev->dev, "reset-gpio property not found\n"); ret = local->vring0; goto dma_mask_fault; } ret = devm_gpio_request_one(&pdev->dev, local->vring0, GPIOF_DIR_OUT, "mb_vring0"); if (ret) { dev_err(&pdev->dev, "Please specify gpio reset addr\n"); goto dma_mask_fault; } /* Find out vring1 pin */ local->vring1 = of_get_named_gpio(pdev->dev.of_node, "vring1", 0); if (local->vring1 < 0) { dev_err(&pdev->dev, "reset-gpio property not found\n"); ret = local->vring1; goto dma_mask_fault; } ret = devm_gpio_request_one(&pdev->dev, local->vring1, GPIOF_DIR_OUT, "mb_vring1"); if (ret) { dev_err(&pdev->dev, "Please specify gpio reset addr\n"); goto dma_mask_fault; } /* Allocate bram device */ bram_dev = of_parse_phandle(pdev->dev.of_node, "bram", 0); if (!bram_dev) { dev_err(&pdev->dev, "Please specify bram connection\n"); ret = -ENODEV; goto dma_mask_fault; } bram_pdev = of_find_device_by_node(bram_dev); if (!bram_pdev) { dev_err(&pdev->dev, "BRAM device hasn't found\n"); ret = -ENODEV; goto dma_mask_fault; } res = platform_get_resource(bram_pdev, IORESOURCE_MEM, 0); local->vbase = devm_ioremap_resource(&pdev->dev, res); if (!local->vbase) { ret = -ENODEV; goto dma_mask_fault; } /* Load simple bootloader to bram */ local->bootloader = of_get_property(pdev->dev.of_node, "bram-firmware", NULL); if (!local->bootloader) { dev_err(&pdev->dev, "Please specify BRAM firmware\n"); ret = -ENODEV; goto dma_mask_fault; } dev_info(&pdev->dev, "Using microblaze BRAM bootloader: %s\n", local->bootloader); /* Module param firmware first */ if (firmware) prop = firmware; else prop = of_get_property(pdev->dev.of_node, "firmware", NULL); if (prop) { dev_info(&pdev->dev, "Using firmware: %s\n", prop); local->rproc = rproc_alloc(&pdev->dev, dev_name(&pdev->dev), &mb_rproc_ops, prop, sizeof(struct rproc)); if (!local->rproc) { dev_err(&pdev->dev, "rproc allocation failed\n"); ret = -ENODEV; goto dma_mask_fault; } ret = rproc_add(local->rproc); if (ret) { dev_err(&pdev->dev, "rproc registration failed\n"); rproc_put(local->rproc); goto dma_mask_fault; } return 0; } else { ret = -ENODEV; } dma_mask_fault: dma_release_declared_memory(&pdev->dev); return ret; }
static int qproc_probe(struct platform_device *pdev) { struct qproc *qproc; struct rproc *rproc; int ret; int i; struct device_node *np; struct resource r; rproc = rproc_alloc(&pdev->dev, pdev->name, &qproc_ops, "mba.mbn", sizeof(*qproc)); if (!rproc) return -ENOMEM; rproc->fw_ops = &qproc_fw_ops; qproc = (struct qproc *)rproc->priv; qproc->dev = &pdev->dev; qproc->rproc = rproc; platform_set_drvdata(pdev, qproc); init_completion(&qproc->start_done); ret = qproc_init_mem(qproc, pdev); if (ret) goto free_rproc; ret = qproc_init_clocks(qproc); if (ret) goto free_rproc; ret = qproc_init_regulators(qproc); if (ret) goto free_rproc; //FIXME need to convert this to a proper reset... // ret = qproc_init_reset(qproc); // if (ret) // goto free_rproc; ret = qproc_request_irq(qproc, pdev, "wdog", qproc_wdog_interrupt); if (ret < 0) goto free_rproc; qproc->wdog_irq = ret; ret = qproc_request_irq(qproc, pdev, "fatal", qproc_fatal_interrupt); if (ret < 0) goto free_rproc; qproc->fatal_irq = ret; ret = qproc_request_irq(qproc, pdev, "ready", qproc_ready_interrupt); if (ret < 0) goto free_rproc; qproc->ready_irq = ret; ret = qproc_request_irq(qproc, pdev, "handover", qproc_handover_interrupt); if (ret < 0) goto free_rproc; qproc->handover_irq = ret; ret = qproc_request_irq(qproc, pdev, "stop-ack", qproc_stop_ack_interrupt); if (ret < 0) goto free_rproc; qproc->stop_ack_irq = ret; qproc->stop_gpio = devm_gpiod_get(&pdev->dev, "qcom,stop", GPIOD_OUT_LOW); if (IS_ERR(qproc->stop_gpio)) { dev_err(&pdev->dev, "failed to acquire stop gpio\n"); return PTR_ERR(qproc->stop_gpio); } for (i = 0; i < ARRAY_SIZE(qproc_attrs); i++) { ret = device_create_file(&pdev->dev, &qproc_attrs[i]); if (ret) { dev_err(&pdev->dev, "unable to create sysfs file\n"); goto remove_device_files; } } np = of_parse_phandle(pdev->dev.of_node, "memory-region", 0); if (!np) { dev_err(&pdev->dev, "No memory region specified\n"); } else { ret = of_address_to_resource(np, 0, &r); of_node_put(np); if (ret) return ret; qproc->reloc_phys = r.start; qproc->reloc_size = resource_size(&r); dev_info(&pdev->dev, "Found relocation area %lu@%pad\n", qproc->reloc_size, &qproc->reloc_phys); } ret = rproc_add(rproc); if (ret) goto remove_device_files; return 0; remove_device_files: for (i--; i >= 0; i--) device_remove_file(&pdev->dev, &qproc_attrs[i]); free_rproc: rproc_put(rproc); return ret; }