static void __init at91_dt_device_init(void) { of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); }
static int bbif_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct resource *mem_res; int ret; int i; void __iomem *bbif_misc_base; pr_debug("%s: Entry\n", __func__); bbif_regulator_init(pdev); mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); bbif_base = devm_ioremap_resource(&pdev->dev, mem_res); if (IS_ERR(bbif_base)) return PTR_ERR(bbif_base); ret = misc_register(bbif_misc_dev); if (ret < 0) { misc_deregister(bbif_misc_dev); return ret; } /*ADC config */ bbif_misc_base = bbif_base + BBIF_MISC; __raw_writel(SIGMA_DELTA_VAL_0, bbif_misc_base + BBIF_MAP_SIGMA_DELTA_0); __raw_writel(SIGMA_DELTA_VAL_1, bbif_misc_base + BBIF_MAP_SIGMA_DELTA_1); __raw_writel(SIGMA_DELTA_VAL_2, bbif_misc_base + BBIF_MAP_SIGMA_DELTA_2); __raw_writel(SIGMA_DELTA_VAL_3, bbif_misc_base + BBIF_MAP_SIGMA_DELTA_3); __raw_writel(0, bbif_misc_base + BBIF_PRI_MODE); /* If the values are different make sure i=1 & i=2 are reversed */ for (i = 0; i < 6; i++) { __raw_writel(0, bbif_misc_base + BBIF_ADC_CFG + i*4); __raw_writel(BBIF_BBRX_TEST1, bbif_misc_base + BBIF_BBRX_TEST1_BASE + i*4); __raw_writel(BBIF_BBRX_TEST2, bbif_misc_base + BBIF_BBRX_TEST2_BASE + i*4); __raw_writel(BBIF_BBRX_TEST3, bbif_misc_base + BBIF_BBRX_TEST3_BASE + i*4); __raw_writel(BBIF_CONFIG_LTE_20_DPD, bbif_misc_base + BBIF_BBRX_CONFIG_BASE + i*4); __raw_writel(0, bbif_misc_base + BBIF_BBRX_CONTROL_BASE + i*4); usleep(100000); __raw_writel(7, bbif_misc_base + BBIF_BBRX_CONTROL_BASE + i*4); } /* DAC config */ set_combodac_cfg(0); reset_msbcal(); reset_dccal(); set_combodac_cfg(2); return of_platform_populate(np, NULL, NULL, &pdev->dev); }
static int pl353_smc_probe(struct platform_device *pdev) { struct pl353_smc_data *pl353_smc; struct device_node *child; struct resource *res; int err; struct device_node *of_node = pdev->dev.of_node; const struct of_device_id *matches = NULL; pl353_smc = devm_kzalloc(&pdev->dev, sizeof(*pl353_smc), GFP_KERNEL); if (!pl353_smc) return -ENOMEM; /* Get the NAND controller virtual address */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); pl353_smc_base = devm_ioremap_resource(&pdev->dev, res); if (IS_ERR(pl353_smc_base)) return PTR_ERR(pl353_smc_base); pl353_smc->aclk = devm_clk_get(&pdev->dev, "aclk"); if (IS_ERR(pl353_smc->aclk)) { dev_err(&pdev->dev, "aclk clock not found.\n"); return PTR_ERR(pl353_smc->aclk); } pl353_smc->memclk = devm_clk_get(&pdev->dev, "memclk"); if (IS_ERR(pl353_smc->memclk)) { dev_err(&pdev->dev, "memclk clock not found.\n"); return PTR_ERR(pl353_smc->memclk); } err = clk_prepare_enable(pl353_smc->aclk); if (err) { dev_err(&pdev->dev, "Unable to enable AXI clock.\n"); return err; } err = clk_prepare_enable(pl353_smc->memclk); if (err) { dev_err(&pdev->dev, "Unable to enable memory clock.\n"); goto out_clk_dis_aper; } platform_set_drvdata(pdev, pl353_smc); /* clear interrupts */ writel(PL353_SMC_CFG_CLR_DEFAULT_MASK, pl353_smc_base + PL353_SMC_CFG_CLR_OFFS); /* Find compatible children. Only a single child is supported */ for_each_available_child_of_node(of_node, child) { if (of_match_node(matches_nand, child)) { pl353_smc_init_nand_interface(pdev, child); if (!matches) { matches = matches_nand; } else { dev_err(&pdev->dev, "incompatible configuration\n"); goto out_clk_disable; } } if (of_match_node(matches_nor, child)) { static int counts; if (!matches) { matches = matches_nor; } else { if (matches != matches_nor || counts > 1) { dev_err(&pdev->dev, "incompatible configuration\n"); goto out_clk_disable; } } counts++; } } if (matches) of_platform_populate(of_node, matches, NULL, &pdev->dev); return 0; out_clk_disable: clk_disable_unprepare(pl353_smc->memclk); out_clk_dis_aper: clk_disable_unprepare(pl353_smc->aclk); return err; }
static int __devinit tegra30_ahub_probe(struct platform_device *pdev) { struct clk *clk; int i; struct resource *res0, *res1, *region; u32 of_dma[2]; void __iomem *regs_apbif, *regs_ahub; int ret = 0; if (ahub) return -ENODEV; /* * The AHUB hosts a register bus: the "configlink". For this to * operate correctly, all devices on this bus must be out of reset. * Ensure that here. */ for (i = 0; i < ARRAY_SIZE(configlink_clocks); i++) { clk = clk_get_sys(NULL, configlink_clocks[i]); if (IS_ERR(clk)) { dev_err(&pdev->dev, "Can't get clock %s\n", configlink_clocks[i]); ret = PTR_ERR(clk); goto err; } tegra_periph_reset_deassert(clk); clk_put(clk); } ahub = devm_kzalloc(&pdev->dev, sizeof(struct tegra30_ahub), GFP_KERNEL); if (!ahub) { dev_err(&pdev->dev, "Can't allocate tegra30_ahub\n"); ret = -ENOMEM; goto err; } dev_set_drvdata(&pdev->dev, ahub); ahub->dev = &pdev->dev; ahub->clk_d_audio = clk_get(&pdev->dev, "d_audio"); if (IS_ERR(ahub->clk_d_audio)) { dev_err(&pdev->dev, "Can't retrieve ahub d_audio clock\n"); ret = PTR_ERR(ahub->clk_d_audio); goto err; } ahub->clk_apbif = clk_get(&pdev->dev, "apbif"); if (IS_ERR(ahub->clk_apbif)) { dev_err(&pdev->dev, "Can't retrieve ahub apbif clock\n"); ret = PTR_ERR(ahub->clk_apbif); goto err_clk_put_d_audio; } if (of_property_read_u32_array(pdev->dev.of_node, "nvidia,dma-request-selector", of_dma, 2) < 0) { dev_err(&pdev->dev, "Missing property nvidia,dma-request-selector\n"); ret = -ENODEV; goto err_clk_put_d_audio; } ahub->dma_sel = of_dma[1]; res0 = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res0) { dev_err(&pdev->dev, "No apbif memory resource\n"); ret = -ENODEV; goto err_clk_put_apbif; } region = devm_request_mem_region(&pdev->dev, res0->start, resource_size(res0), DRV_NAME); if (!region) { dev_err(&pdev->dev, "request region apbif failed\n"); ret = -EBUSY; goto err_clk_put_apbif; } ahub->apbif_addr = res0->start; regs_apbif = devm_ioremap(&pdev->dev, res0->start, resource_size(res0)); if (!regs_apbif) { dev_err(&pdev->dev, "ioremap apbif failed\n"); ret = -ENOMEM; goto err_clk_put_apbif; } ahub->regmap_apbif = devm_regmap_init_mmio(&pdev->dev, regs_apbif, &tegra30_ahub_apbif_regmap_config); if (IS_ERR(ahub->regmap_apbif)) { dev_err(&pdev->dev, "apbif regmap init failed\n"); ret = PTR_ERR(ahub->regmap_apbif); goto err_clk_put_apbif; } regcache_cache_only(ahub->regmap_apbif, true); res1 = platform_get_resource(pdev, IORESOURCE_MEM, 1); if (!res1) { dev_err(&pdev->dev, "No ahub memory resource\n"); ret = -ENODEV; goto err_clk_put_apbif; } region = devm_request_mem_region(&pdev->dev, res1->start, resource_size(res1), DRV_NAME); if (!region) { dev_err(&pdev->dev, "request region ahub failed\n"); ret = -EBUSY; goto err_clk_put_apbif; } regs_ahub = devm_ioremap(&pdev->dev, res1->start, resource_size(res1)); if (!regs_ahub) { dev_err(&pdev->dev, "ioremap ahub failed\n"); ret = -ENOMEM; goto err_clk_put_apbif; } ahub->regmap_ahub = devm_regmap_init_mmio(&pdev->dev, regs_ahub, &tegra30_ahub_ahub_regmap_config); if (IS_ERR(ahub->regmap_ahub)) { dev_err(&pdev->dev, "ahub regmap init failed\n"); ret = PTR_ERR(ahub->regmap_ahub); goto err_clk_put_apbif; } regcache_cache_only(ahub->regmap_ahub, true); pm_runtime_enable(&pdev->dev); if (!pm_runtime_enabled(&pdev->dev)) { ret = tegra30_ahub_runtime_resume(&pdev->dev); if (ret) goto err_pm_disable; } of_platform_populate(pdev->dev.of_node, NULL, ahub_auxdata, &pdev->dev); return 0; err_pm_disable: pm_runtime_disable(&pdev->dev); err_clk_put_apbif: clk_put(ahub->clk_apbif); err_clk_put_d_audio: clk_put(ahub->clk_d_audio); ahub = 0; err: return ret; }
static int msm_iommu_probe(struct platform_device *pdev) { struct iommu_pmon *pmon_info; struct msm_iommu_drvdata *drvdata; struct resource *r; int ret, needs_alt_core_clk, needs_alt_iface_clk; int global_cfg_irq, global_client_irq; u32 temp; drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL); if (!drvdata) return -ENOMEM; r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "iommu_base"); if (!r) return -EINVAL; drvdata->base = devm_ioremap(&pdev->dev, r->start, resource_size(r)); if (!drvdata->base) return -ENOMEM; drvdata->phys_base = r->start; r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "smmu_local_base"); if (r) { drvdata->smmu_local_base = devm_ioremap(&pdev->dev, r->start, resource_size(r)); if (!drvdata->smmu_local_base) return -ENOMEM; } drvdata->glb_base = drvdata->base; if (of_device_is_compatible(pdev->dev.of_node, "qcom,msm-mmu-500")) drvdata->model = MMU_500; if (of_get_property(pdev->dev.of_node, "vdd-supply", NULL)) { drvdata->gdsc = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(drvdata->gdsc)) return PTR_ERR(drvdata->gdsc); drvdata->alt_gdsc = devm_regulator_get(&pdev->dev, "qcom,alt-vdd"); if (IS_ERR(drvdata->alt_gdsc)) drvdata->alt_gdsc = NULL; } else { pr_debug("Warning: No regulator specified for IOMMU\n"); } drvdata->pclk = devm_clk_get(&pdev->dev, "iface_clk"); if (IS_ERR(drvdata->pclk)) return PTR_ERR(drvdata->pclk); drvdata->clk = devm_clk_get(&pdev->dev, "core_clk"); if (IS_ERR(drvdata->clk)) return PTR_ERR(drvdata->clk); needs_alt_core_clk = of_property_read_bool(pdev->dev.of_node, "qcom,needs-alt-core-clk"); if (needs_alt_core_clk) { drvdata->aclk = devm_clk_get(&pdev->dev, "alt_core_clk"); if (IS_ERR(drvdata->aclk)) return PTR_ERR(drvdata->aclk); } needs_alt_iface_clk = of_property_read_bool(pdev->dev.of_node, "qcom,needs-alt-iface-clk"); if (needs_alt_iface_clk) { drvdata->aiclk = devm_clk_get(&pdev->dev, "alt_iface_clk"); if (IS_ERR(drvdata->aiclk)) return PTR_ERR(drvdata->aiclk); } if (!of_property_read_u32(pdev->dev.of_node, "qcom,cb-base-offset", &temp)) drvdata->cb_base = drvdata->base + temp; else drvdata->cb_base = drvdata->base + 0x8000; if (clk_get_rate(drvdata->clk) == 0) { ret = clk_round_rate(drvdata->clk, 1000); clk_set_rate(drvdata->clk, ret); } if (drvdata->aclk && clk_get_rate(drvdata->aclk) == 0) { ret = clk_round_rate(drvdata->aclk, 1000); clk_set_rate(drvdata->aclk, ret); } if (drvdata->aiclk && clk_get_rate(drvdata->aiclk) == 0) { ret = clk_round_rate(drvdata->aiclk, 1000); clk_set_rate(drvdata->aiclk, ret); } ret = msm_iommu_parse_dt(pdev, drvdata); if (ret) return ret; dev_info(&pdev->dev, "device %s (model: %d) mapped at %p, with %d ctx banks\n", drvdata->name, drvdata->model, drvdata->base, drvdata->ncb); platform_set_drvdata(pdev, drvdata); pmon_info = msm_iommu_pm_alloc(&pdev->dev); if (pmon_info != NULL) { ret = msm_iommu_pmon_parse_dt(pdev, pmon_info); if (ret) { msm_iommu_pm_free(&pdev->dev); pr_info("%s: pmon not available.\n", drvdata->name); } else { pmon_info->iommu.base = drvdata->base; pmon_info->iommu.ops = msm_get_iommu_access_ops(); pmon_info->iommu.hw_ops = iommu_pm_get_hw_ops_v1(); pmon_info->iommu.iommu_name = drvdata->name; ret = msm_iommu_pm_iommu_register(pmon_info); if (ret) { pr_err("%s iommu register fail\n", drvdata->name); msm_iommu_pm_free(&pdev->dev); } else { pr_debug("%s iommu registered for pmon\n", pmon_info->iommu.iommu_name); } } } global_cfg_irq = platform_get_irq_byname(pdev, "global_cfg_NS_irq"); if (global_cfg_irq > 0) { ret = devm_request_threaded_irq(&pdev->dev, global_cfg_irq, NULL, msm_iommu_global_fault_handler, IRQF_ONESHOT | IRQF_SHARED | IRQF_TRIGGER_RISING, "msm_iommu_global_cfg_irq", pdev); if (ret < 0) pr_err("Request Global CFG IRQ %d failed with ret=%d\n", global_cfg_irq, ret); } global_client_irq = platform_get_irq_byname(pdev, "global_client_NS_irq"); if (global_client_irq > 0) { ret = devm_request_threaded_irq(&pdev->dev, global_client_irq, NULL, msm_iommu_global_fault_handler, IRQF_ONESHOT | IRQF_SHARED | IRQF_TRIGGER_RISING, "msm_iommu_global_client_irq", pdev); if (ret < 0) pr_err("Request Global Client IRQ %d failed with ret=%d\n", global_client_irq, ret); } ret = of_platform_populate(pdev->dev.of_node, msm_iommu_ctx_match_table, NULL, &pdev->dev); if (ret) pr_err("Failed to create iommu context device\n"); return ret; }
static int __devinit mdss_dsi_ctrl_probe(struct platform_device *pdev) { int rc = 0; u32 index; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; if (pdev->dev.of_node) { struct resource *mdss_dsi_mres; const char *ctrl_name; ctrl_pdata = platform_get_drvdata(pdev); if (!ctrl_pdata) { ctrl_pdata = devm_kzalloc(&pdev->dev, sizeof(struct mdss_dsi_ctrl_pdata), GFP_KERNEL); if (!ctrl_pdata) { pr_err("%s: FAILED: cannot alloc dsi ctrl\n", __func__); rc = -ENOMEM; goto error_no_mem; } platform_set_drvdata(pdev, ctrl_pdata); } ctrl_name = of_get_property(pdev->dev.of_node, "label", NULL); if (!ctrl_name) pr_info("%s:%d, DSI Ctrl name not specified\n", __func__, __LINE__); else pr_info("%s: DSI Ctrl name = %s\n", __func__, ctrl_name); rc = of_property_read_u32(pdev->dev.of_node, "cell-index", &index); if (rc) { dev_err(&pdev->dev, "%s: Cell-index not specified, rc=%d\n", __func__, rc); goto error_no_mem; } if (index == 0) pdev->id = 1; else pdev->id = 2; mdss_dsi_mres = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mdss_dsi_mres) { pr_err("%s:%d unable to get the MDSS resources", __func__, __LINE__); rc = -ENOMEM; goto error_no_mem; } if (mdss_dsi_mres) { mdss_dsi_base = ioremap(mdss_dsi_mres->start, resource_size(mdss_dsi_mres)); if (!mdss_dsi_base) { pr_err("%s:%d unable to remap dsi resources", __func__, __LINE__); rc = -ENOMEM; goto error_no_mem; } } rc = of_platform_populate(pdev->dev.of_node, NULL, NULL, &pdev->dev); if (rc) { dev_err(&pdev->dev, "%s: failed to add child nodes, rc=%d\n", __func__, rc); goto error_ioremap; } /* Parse the regulator information */ rc = mdss_dsi_get_dt_vreg_data(&pdev->dev, &ctrl_pdata->power_data); if (rc) { pr_err("%s: failed to get vreg data from dt. rc=%d\n", __func__, rc); goto error_vreg; } pr_debug("%s: Dsi Ctrl->%d initialized\n", __func__, index); } return 0; error_ioremap: iounmap(mdss_dsi_base); error_no_mem: devm_kfree(&pdev->dev, ctrl_pdata); error_vreg: mdss_dsi_put_dt_vreg_data(&pdev->dev, &ctrl_pdata->power_data); return rc; }
static int dwc3_omap_probe(struct platform_device *pdev) { struct device_node *node = pdev->dev.of_node; struct dwc3_omap *omap; struct resource *res; struct device *dev = &pdev->dev; struct regulator *vbus_reg = NULL; int ret; int irq; u32 reg; void __iomem *base; if (!node) { dev_err(dev, "device node not found\n"); return -EINVAL; } omap = devm_kzalloc(dev, sizeof(*omap), GFP_KERNEL); if (!omap) return -ENOMEM; platform_set_drvdata(pdev, omap); irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(dev, "missing IRQ resource\n"); return -EINVAL; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); base = devm_ioremap_resource(dev, res); if (IS_ERR(base)) return PTR_ERR(base); if (of_property_read_bool(node, "vbus-supply")) { vbus_reg = devm_regulator_get(dev, "vbus"); if (IS_ERR(vbus_reg)) { dev_err(dev, "vbus init failed\n"); return PTR_ERR(vbus_reg); } } omap->dev = dev; omap->irq = irq; omap->base = base; omap->vbus_reg = vbus_reg; pm_runtime_enable(dev); ret = pm_runtime_get_sync(dev); if (ret < 0) { dev_err(dev, "get_sync failed with err %d\n", ret); goto err1; } dwc3_omap_map_offset(omap); dwc3_omap_set_utmi_mode(omap); /* check the DMA Status */ reg = dwc3_omap_readl(omap->base, USBOTGSS_SYSCONFIG); irq_set_status_flags(omap->irq, IRQ_NOAUTOEN); ret = devm_request_threaded_irq(dev, omap->irq, dwc3_omap_interrupt, dwc3_omap_interrupt_thread, IRQF_SHARED, "dwc3-omap", omap); if (ret) { dev_err(dev, "failed to request IRQ #%d --> %d\n", omap->irq, ret); goto err1; } ret = dwc3_omap_extcon_register(omap); if (ret < 0) goto err1; ret = of_platform_populate(node, NULL, NULL, dev); if (ret) { dev_err(&pdev->dev, "failed to create dwc3 core\n"); goto err1; } dwc3_omap_enable_irqs(omap); enable_irq(omap->irq); return 0; err1: pm_runtime_put_sync(dev); pm_runtime_disable(dev); return ret; }
static int msm_iommu_parse_dt(struct platform_device *pdev, struct msm_iommu_drvdata *drvdata) { struct device_node *child; int ret = 0; struct resource *r; drvdata->dev = &pdev->dev; ret = __get_bus_vote_client(pdev, drvdata); if (ret) goto fail; ret = msm_iommu_parse_bfb_settings(pdev, drvdata); if (ret) goto fail; for_each_child_of_node(pdev->dev.of_node, child) drvdata->ncb++; drvdata->asid = devm_kzalloc(&pdev->dev, drvdata->ncb * sizeof(int), GFP_KERNEL); if (!drvdata->asid) { pr_err("Unable to get memory for asid array\n"); ret = -ENOMEM; goto fail; } ret = of_property_read_string(pdev->dev.of_node, "label", &drvdata->name); if (ret) goto fail; drvdata->sec_id = -1; of_property_read_u32(pdev->dev.of_node, "qcom,iommu-secure-id", &drvdata->sec_id); r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "clk_base"); if (r) { drvdata->clk_reg_virt = devm_ioremap(&pdev->dev, r->start, resource_size(r)); if (!drvdata->clk_reg_virt) { pr_err("Failed to map resource for iommu clk: %pr\n", r); ret = -ENOMEM; goto fail; } } drvdata->halt_enabled = of_property_read_bool(pdev->dev.of_node, "qcom,iommu-enable-halt"); ret = of_platform_populate(pdev->dev.of_node, msm_iommu_v1_ctx_match_table, NULL, &pdev->dev); if (ret) pr_err("Failed to create iommu context device\n"); msm_iommu_add_drv(drvdata); fail: __put_bus_vote_client(drvdata); return ret; }
static int st_dwc3_probe(struct platform_device *pdev) { struct st_dwc3 *dwc3_data; struct resource *res; struct device *dev = &pdev->dev; struct device_node *node = dev->of_node, *child; struct regmap *regmap; int ret; dwc3_data = devm_kzalloc(dev, sizeof(*dwc3_data), GFP_KERNEL); if (!dwc3_data) return -ENOMEM; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "reg-glue"); dwc3_data->glue_base = devm_ioremap_resource(dev, res); if (IS_ERR(dwc3_data->glue_base)) return PTR_ERR(dwc3_data->glue_base); regmap = syscon_regmap_lookup_by_phandle(node, "st,syscfg"); if (IS_ERR(regmap)) return PTR_ERR(regmap); dma_set_coherent_mask(dev, dev->coherent_dma_mask); dwc3_data->dev = dev; dwc3_data->regmap = regmap; res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "syscfg-reg"); if (!res) { ret = -ENXIO; goto undo_platform_dev_alloc; } dwc3_data->syscfg_reg_off = res->start; dev_vdbg(&pdev->dev, "glue-logic addr 0x%p, syscfg-reg offset 0x%x\n", dwc3_data->glue_base, dwc3_data->syscfg_reg_off); dwc3_data->rstc_pwrdn = devm_reset_control_get(dev, "powerdown"); if (IS_ERR(dwc3_data->rstc_pwrdn)) { dev_err(&pdev->dev, "could not get power controller\n"); ret = PTR_ERR(dwc3_data->rstc_pwrdn); goto undo_platform_dev_alloc; } /* Manage PowerDown */ reset_control_deassert(dwc3_data->rstc_pwrdn); dwc3_data->rstc_rst = devm_reset_control_get(dev, "softreset"); if (IS_ERR(dwc3_data->rstc_rst)) { dev_err(&pdev->dev, "could not get reset controller\n"); ret = PTR_ERR(dwc3_data->rstc_pwrdn); goto undo_powerdown; } /* Manage SoftReset */ reset_control_deassert(dwc3_data->rstc_rst); child = of_get_child_by_name(node, "dwc3"); if (!child) { dev_err(&pdev->dev, "failed to find dwc3 core node\n"); ret = -ENODEV; goto undo_softreset; } dwc3_data->dr_mode = of_usb_get_dr_mode(child); /* Allocate and initialize the core */ ret = of_platform_populate(node, NULL, NULL, dev); if (ret) { dev_err(dev, "failed to add dwc3 core\n"); goto undo_softreset; } /* * Configure the USB port as device or host according to the static * configuration passed from DT. * DRD is the only mode currently supported so this will be enhanced * as soon as OTG is available. */ ret = st_dwc3_drd_init(dwc3_data); if (ret) { dev_err(dev, "drd initialisation failed\n"); goto undo_softreset; } /* ST glue logic init */ st_dwc3_init(dwc3_data); platform_set_drvdata(pdev, dwc3_data); return 0; undo_softreset: reset_control_assert(dwc3_data->rstc_rst); undo_powerdown: reset_control_assert(dwc3_data->rstc_pwrdn); undo_platform_dev_alloc: platform_device_put(pdev); return ret; }
static int __init c6x_device_probe(void) { of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); return 0; }
static void __init u8500_init_machine(void) { struct device *parent = NULL; int i2c0_devs; int i; /* Pinmaps must be in place before devices register */ if (of_machine_is_compatible("st-ericsson,mop500")) mop500_pinmaps_init(); else if (of_machine_is_compatible("calaosystems,snowball-a9500")) snowball_pinmaps_init(); else if (of_machine_is_compatible("st-ericsson,hrefv60+")) hrefv60_pinmaps_init(); parent = u8500_of_init_devices(); for (i = 0; i < ARRAY_SIZE(mop500_platform_devs); i++) mop500_platform_devs[i]->dev.parent = parent; /* automatically probe child nodes of db8500 device */ of_platform_populate(NULL, u8500_local_bus_nodes, u8500_auxdata_lookup, parent); if (of_machine_is_compatible("st-ericsson,mop500")) { mop500_gpio_keys[0].gpio = GPIO_PROX_SENSOR; platform_add_devices(mop500_platform_devs, ARRAY_SIZE(mop500_platform_devs)); mop500_sdi_init(parent); i2c0_devs = ARRAY_SIZE(mop500_i2c0_devices); i2c_register_board_info(0, mop500_i2c0_devices, i2c0_devs); i2c_register_board_info(2, mop500_i2c2_devices, ARRAY_SIZE(mop500_i2c2_devices)); mop500_uib_init(); } else if (of_machine_is_compatible("st-ericsson,hrefv60+")) { /* * The HREFv60 board removed a GPIO expander and routed * all these GPIO pins to the internal GPIO controller * instead. */ mop500_gpio_keys[0].gpio = HREFV60_PROX_SENSE_GPIO; platform_add_devices(mop500_platform_devs, ARRAY_SIZE(mop500_platform_devs)); hrefv60_sdi_init(parent); i2c0_devs = ARRAY_SIZE(mop500_i2c0_devices); i2c0_devs -= NUM_PRE_V60_I2C0_DEVICES; i2c_register_board_info(0, mop500_i2c0_devices, i2c0_devs); i2c_register_board_info(2, mop500_i2c2_devices, ARRAY_SIZE(mop500_i2c2_devices)); mop500_uib_init(); } /* This board has full regulator constraints */ regulator_has_full_constraints(); }
static void __init spear600_dt_init(void) { of_platform_populate(NULL, of_default_bus_match_table, spear6xx_auxdata_lookup, NULL); }
static void __init ap_init_of(void) { unsigned long sc_dec; struct device_node *root; struct device_node *syscon; struct device *parent; struct soc_device *soc_dev; struct soc_device_attribute *soc_dev_attr; u32 ap_sc_id; int err; int i; /* Here we create an SoC device for the root node */ root = of_find_node_by_path("/"); if (!root) return; syscon = of_find_node_by_path("/syscon"); if (!syscon) return; ap_syscon_base = of_iomap(syscon, 0); if (!ap_syscon_base) return; ap_sc_id = readl(ap_syscon_base); soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL); if (!soc_dev_attr) return; err = of_property_read_string(root, "compatible", &soc_dev_attr->soc_id); if (err) return; err = of_property_read_string(root, "model", &soc_dev_attr->machine); if (err) return; soc_dev_attr->family = "Integrator"; soc_dev_attr->revision = kasprintf(GFP_KERNEL, "%c", 'A' + (ap_sc_id & 0x0f)); soc_dev = soc_device_register(soc_dev_attr); if (IS_ERR(soc_dev)) { kfree(soc_dev_attr->revision); kfree(soc_dev_attr); return; } parent = soc_device_to_device(soc_dev); integrator_init_sysfs(parent, ap_sc_id); of_platform_populate(root, of_default_bus_match_table, ap_auxdata_lookup, parent); sc_dec = readl(ap_syscon_base + INTEGRATOR_SC_DEC_OFFSET); for (i = 0; i < 4; i++) { struct lm_device *lmdev; if ((sc_dec & (16 << i)) == 0) continue; lmdev = kzalloc(sizeof(struct lm_device), GFP_KERNEL); if (!lmdev) continue; lmdev->resource.start = 0xc0000000 + 0x10000000 * i; lmdev->resource.end = lmdev->resource.start + 0x0fffffff; lmdev->resource.flags = IORESOURCE_MEM; lmdev->irq = IRQ_AP_EXPINT0 + i; lmdev->id = i; lm_device_register(lmdev); } }
static void __init picoxcell_init_machine(void) { of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); picoxcell_setup_restart(); }
static int dwc3_exynos_probe(struct platform_device *pdev) { struct dwc3_exynos *exynos; struct clk *clk; struct device *dev = &pdev->dev; struct device_node *node = dev->of_node; int ret = -ENOMEM; exynos = devm_kzalloc(dev, sizeof(*exynos), GFP_KERNEL); if (!exynos) { dev_err(dev, "not enough memory\n"); goto err1; } /* * Right now device-tree probed devices don't get dma_mask set. * Since shared usb code relies on it, set it here for now. * Once we move to full device tree support this will vanish off. */ ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32)); if (ret) goto err1; platform_set_drvdata(pdev, exynos); ret = dwc3_exynos_register_phys(exynos); if (ret) { dev_err(dev, "couldn't register PHYs\n"); goto err1; } clk = devm_clk_get(dev, "usbdrd30"); if (IS_ERR(clk)) { dev_err(dev, "couldn't get clock\n"); ret = -EINVAL; goto err1; } exynos->dev = dev; exynos->clk = clk; clk_prepare_enable(exynos->clk); if (node) { ret = of_platform_populate(node, NULL, NULL, dev); if (ret) { dev_err(dev, "failed to add dwc3 core\n"); goto err2; } } else { dev_err(dev, "no device node, failed to add dwc3 core\n"); ret = -ENODEV; goto err2; } return 0; err2: clk_disable_unprepare(clk); err1: return ret; }
static int exynos_adc_probe(struct platform_device *pdev) { struct exynos_adc *info = NULL; struct device_node *np = pdev->dev.of_node; struct s3c2410_ts_mach_info *pdata = dev_get_platdata(&pdev->dev); struct iio_dev *indio_dev = NULL; struct resource *mem; bool has_ts = false; int ret = -ENODEV; int irq; indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(struct exynos_adc)); if (!indio_dev) { dev_err(&pdev->dev, "failed allocating iio device\n"); return -ENOMEM; } info = iio_priv(indio_dev); info->data = exynos_adc_get_data(pdev); if (!info->data) { dev_err(&pdev->dev, "failed getting exynos_adc_data\n"); return -EINVAL; } mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); info->regs = devm_ioremap_resource(&pdev->dev, mem); if (IS_ERR(info->regs)) return PTR_ERR(info->regs); if (info->data->needs_adc_phy) { info->pmu_map = syscon_regmap_lookup_by_phandle( pdev->dev.of_node, "samsung,syscon-phandle"); if (IS_ERR(info->pmu_map)) { dev_err(&pdev->dev, "syscon regmap lookup failed.\n"); return PTR_ERR(info->pmu_map); } } irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(&pdev->dev, "no irq resource?\n"); return irq; } info->irq = irq; irq = platform_get_irq(pdev, 1); if (irq == -EPROBE_DEFER) return irq; info->tsirq = irq; info->dev = &pdev->dev; init_completion(&info->completion); info->clk = devm_clk_get(&pdev->dev, "adc"); if (IS_ERR(info->clk)) { dev_err(&pdev->dev, "failed getting clock, err = %ld\n", PTR_ERR(info->clk)); return PTR_ERR(info->clk); } if (info->data->needs_sclk) { info->sclk = devm_clk_get(&pdev->dev, "sclk"); if (IS_ERR(info->sclk)) { dev_err(&pdev->dev, "failed getting sclk clock, err = %ld\n", PTR_ERR(info->sclk)); return PTR_ERR(info->sclk); } } info->vdd = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(info->vdd)) { dev_err(&pdev->dev, "failed getting regulator, err = %ld\n", PTR_ERR(info->vdd)); return PTR_ERR(info->vdd); } ret = regulator_enable(info->vdd); if (ret) return ret; ret = exynos_adc_prepare_clk(info); if (ret) goto err_disable_reg; ret = exynos_adc_enable_clk(info); if (ret) goto err_unprepare_clk; platform_set_drvdata(pdev, indio_dev); indio_dev->name = dev_name(&pdev->dev); indio_dev->dev.parent = &pdev->dev; indio_dev->dev.of_node = pdev->dev.of_node; indio_dev->info = &exynos_adc_iio_info; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = exynos_adc_iio_channels; indio_dev->num_channels = info->data->num_channels; ret = request_irq(info->irq, exynos_adc_isr, 0, dev_name(&pdev->dev), info); if (ret < 0) { dev_err(&pdev->dev, "failed requesting irq, irq = %d\n", info->irq); goto err_disable_clk; } ret = iio_device_register(indio_dev); if (ret) goto err_irq; if (info->data->init_hw) info->data->init_hw(info); /* leave out any TS related code if unreachable */ if (IS_REACHABLE(CONFIG_INPUT)) { has_ts = of_property_read_bool(pdev->dev.of_node, "has-touchscreen") || pdata; } if (pdata) info->delay = pdata->delay; else info->delay = 10000; if (has_ts) ret = exynos_adc_ts_init(info); if (ret) goto err_iio; ret = of_platform_populate(np, exynos_adc_match, NULL, &indio_dev->dev); if (ret < 0) { dev_err(&pdev->dev, "failed adding child nodes\n"); goto err_of_populate; } return 0; err_of_populate: device_for_each_child(&indio_dev->dev, NULL, exynos_adc_remove_devices); if (has_ts) { input_unregister_device(info->input); free_irq(info->tsirq, info); } err_iio: iio_device_unregister(indio_dev); err_irq: free_irq(info->irq, info); err_disable_clk: if (info->data->exit_hw) info->data->exit_hw(info); exynos_adc_disable_clk(info); err_unprepare_clk: exynos_adc_unprepare_clk(info); err_disable_reg: regulator_disable(info->vdd); return ret; }
static int kdwc3_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *node = pdev->dev.of_node; struct dwc3_keystone *kdwc; struct resource *res; int error, irq; kdwc = devm_kzalloc(dev, sizeof(*kdwc), GFP_KERNEL); if (!kdwc) return -ENOMEM; platform_set_drvdata(pdev, kdwc); kdwc->dev = dev; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); kdwc->usbss = devm_ioremap_resource(dev, res); if (IS_ERR(kdwc->usbss)) return PTR_ERR(kdwc->usbss); kdwc3_dma_mask = dma_get_mask(dev); dev->dma_mask = &kdwc3_dma_mask; kdwc->clk = devm_clk_get(kdwc->dev, "usb"); error = clk_prepare_enable(kdwc->clk); if (error < 0) { dev_err(kdwc->dev, "unable to enable usb clock, error %d\n", error); return error; } irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(&pdev->dev, "missing irq\n"); error = irq; goto err_irq; } error = devm_request_irq(dev, irq, dwc3_keystone_interrupt, IRQF_SHARED, dev_name(dev), kdwc); if (error) { dev_err(dev, "failed to request IRQ #%d --> %d\n", irq, error); goto err_irq; } kdwc3_enable_irqs(kdwc); error = of_platform_populate(node, NULL, NULL, dev); if (error) { dev_err(&pdev->dev, "failed to create dwc3 core\n"); goto err_core; } return 0; err_core: kdwc3_disable_irqs(kdwc); err_irq: clk_disable_unprepare(kdwc->clk); return error; }
static int ssbi_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct resource *mem_res; struct ssbi *ssbi; int ret = 0; const char *type; ssbi = kzalloc(sizeof(struct ssbi), GFP_KERNEL); if (!ssbi) { pr_err("can not allocate ssbi_data\n"); return -ENOMEM; } mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem_res) { pr_err("missing mem resource\n"); ret = -EINVAL; goto err_get_mem_res; } ssbi->base = ioremap(mem_res->start, resource_size(mem_res)); if (!ssbi->base) { pr_err("ioremap of 0x%p failed\n", (void *)mem_res->start); ret = -EINVAL; goto err_ioremap; } platform_set_drvdata(pdev, ssbi); type = of_get_property(np, "qcom,controller-type", NULL); if (type == NULL) { pr_err("Missing qcom,controller-type property\n"); ret = -EINVAL; goto err_ssbi_controller; } dev_info(&pdev->dev, "SSBI controller type: '%s'\n", type); if (strcmp(type, "ssbi") == 0) ssbi->controller_type = MSM_SBI_CTRL_SSBI; else if (strcmp(type, "ssbi2") == 0) ssbi->controller_type = MSM_SBI_CTRL_SSBI2; else if (strcmp(type, "pmic-arbiter") == 0) ssbi->controller_type = MSM_SBI_CTRL_PMIC_ARBITER; else { pr_err("Unknown qcom,controller-type\n"); ret = -EINVAL; goto err_ssbi_controller; } if (ssbi->controller_type == MSM_SBI_CTRL_PMIC_ARBITER) { ssbi->read = ssbi_pa_read_bytes; ssbi->write = ssbi_pa_write_bytes; } else { ssbi->read = ssbi_read_bytes; ssbi->write = ssbi_write_bytes; } spin_lock_init(&ssbi->lock); ret = of_platform_populate(np, NULL, NULL, &pdev->dev); if (ret) goto err_ssbi_controller; return 0; err_ssbi_controller: platform_set_drvdata(pdev, NULL); iounmap(ssbi->base); err_ioremap: err_get_mem_res: kfree(ssbi); return ret; }
static int mdss_dsi_ctrl_probe(struct platform_device *pdev) { int rc = 0, i = 0; u32 index; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; struct device_node *dsi_pan_node = NULL; char panel_cfg[MDSS_MAX_PANEL_LEN]; const char *ctrl_name; bool cmd_cfg_cont_splash = true; struct mdss_panel_cfg *pan_cfg = NULL; if (!mdss_is_ready()) { pr_err("%s: MDP not probed yet!\n", __func__); return -EPROBE_DEFER; } if (!pdev->dev.of_node) { pr_err("DSI driver only supports device tree probe\n"); return -ENOTSUPP; } pr_info("%s ++ \n", __func__); pan_cfg = mdss_panel_intf_type(MDSS_PANEL_INTF_HDMI); if (IS_ERR(pan_cfg)) { return PTR_ERR(pan_cfg); } else if (pan_cfg) { pr_debug("%s: HDMI is primary\n", __func__); return -ENODEV; } ctrl_pdata = platform_get_drvdata(pdev); if (!ctrl_pdata) { ctrl_pdata = devm_kzalloc(&pdev->dev, sizeof(struct mdss_dsi_ctrl_pdata), GFP_KERNEL); if (!ctrl_pdata) { pr_err("%s: FAILED: cannot alloc dsi ctrl\n", __func__); rc = -ENOMEM; goto error_no_mem; } platform_set_drvdata(pdev, ctrl_pdata); } ctrl_name = of_get_property(pdev->dev.of_node, "label", NULL); if (!ctrl_name) pr_err("%s:%d, DSI Ctrl name not specified\n", __func__, __LINE__); else pr_err("%s: DSI Ctrl name = %s\n", __func__, ctrl_name); rc = of_property_read_u32(pdev->dev.of_node, "cell-index", &index); if (rc) { dev_err(&pdev->dev, "%s: Cell-index not specified, rc=%d\n", __func__, rc); goto error_no_mem; } if (index == 0) pdev->id = 1; else pdev->id = 2; rc = of_platform_populate(pdev->dev.of_node, NULL, NULL, &pdev->dev); if (rc) { dev_err(&pdev->dev, "%s: failed to add child nodes, rc=%d\n", __func__, rc); goto error_no_mem; } /* Parse the regulator information */ for (i = 0; i < DSI_MAX_PM; i++) { rc = mdss_dsi_get_dt_vreg_data(&pdev->dev, &ctrl_pdata->power_data[i], i); if (rc) { DEV_ERR("%s: '%s' get_dt_vreg_data failed.rc=%d\n", __func__, __mdss_dsi_pm_name(i), rc); goto error_vreg; } } /* DSI panels can be different between controllers */ rc = mdss_dsi_get_panel_cfg(panel_cfg); if (!rc) /* dsi panel cfg not present */ pr_warn("%s:%d:dsi specific cfg not present\n", __func__, __LINE__); /* find panel device node */ dsi_pan_node = mdss_dsi_find_panel_of_node(pdev, panel_cfg); if (!dsi_pan_node) { pr_err("%s: can't find panel node %s\n", __func__, panel_cfg); goto error_pan_node; } cmd_cfg_cont_splash = mdss_panel_get_boot_cfg() ? true : false; rc = mdss_dsi_panel_init(dsi_pan_node, ctrl_pdata, cmd_cfg_cont_splash); if (rc) { pr_err("%s: dsi panel init failed\n", __func__); goto error_pan_node; } rc = dsi_panel_device_register(dsi_pan_node, ctrl_pdata); if (rc) { pr_err("%s: dsi panel dev reg failed\n", __func__); goto error_pan_node; } pr_info("%s: Dsi Ctrl->%d initialized\n", __func__, index); return 0; error_pan_node: of_node_put(dsi_pan_node); error_vreg: for (; i >= 0; i--) mdss_dsi_put_dt_vreg_data(&pdev->dev, &ctrl_pdata->power_data[i]); error_no_mem: devm_kfree(&pdev->dev, ctrl_pdata); return rc; }
static int __devinit smsc_hub_probe(struct platform_device *pdev) { int ret = 0; struct smsc_hub_platform_data *pdata; struct device_node *node = pdev->dev.of_node; struct i2c_adapter *i2c_adap; struct i2c_board_info i2c_info; struct of_dev_auxdata *hsic_host_auxdata = NULL; if (pdev->dev.of_node) { dev_dbg(&pdev->dev, "device tree enabled\n"); pdata = msm_hub_dt_to_pdata(pdev); if (IS_ERR(pdata)) return PTR_ERR(pdata); } else { pdata = pdev->dev.platform_data; } hsic_host_auxdata = dev_get_platdata(&pdev->dev); if (!pdata) { dev_err(&pdev->dev, "No platform data\n"); return -ENODEV; } if (pdata->model_id == 0) { dev_dbg(&pdev->dev, "standalone HSIC config enabled\n"); return of_platform_populate(node, NULL, hsic_host_auxdata, &pdev->dev); } if (!pdata->hub_reset) return -EINVAL; smsc_hub = devm_kzalloc(&pdev->dev, sizeof(*smsc_hub), GFP_KERNEL); if (!smsc_hub) return -ENOMEM; smsc_hub->dev = &pdev->dev; smsc_hub->pdata = pdata; if (of_get_property(pdev->dev.of_node, "hub-vbus-supply", NULL)) { smsc_hub->hub_vbus_reg = devm_regulator_get(&pdev->dev, "hub-vbus"); ret = PTR_ERR(smsc_hub->hub_vbus_reg); if (ret == -EPROBE_DEFER) { dev_dbg(&pdev->dev, "failed to get hub_vbus\n"); return ret; } } ret = msm_hsic_hub_init_vdd(smsc_hub, 1); if (ret) { dev_err(&pdev->dev, "failed to init hub VDD\n"); return ret; } ret = msm_hsic_hub_init_clock(smsc_hub, 1); if (ret) { dev_err(&pdev->dev, "failed to init hub clock\n"); goto uninit_vdd; } ret = msm_hsic_hub_init_gpio(smsc_hub, 1); if (ret) { dev_err(&pdev->dev, "failed to init hub gpios\n"); goto uninit_clock; } if (pdata->model_id == SMSC3502_ID) { ret = device_create_file(&pdev->dev, &dev_attr_enable); if (ret < 0) { dev_err(&pdev->dev, "fail to create sysfs file\n"); goto uninit_gpio; } pm_runtime_forbid(&pdev->dev); goto done; } gpio_direction_output(pdata->hub_reset, 0); udelay(5); gpio_direction_output(pdata->hub_reset, 1); if (!IS_ERR_OR_NULL(smsc_hub->hub_vbus_reg)) { ret = regulator_enable(smsc_hub->hub_vbus_reg); if (ret) { dev_err(&pdev->dev, "unable to enable hub_vbus\n"); goto uninit_gpio; } } ret = i2c_add_driver(&hsic_hub_driver); if (ret < 0) { dev_err(&pdev->dev, "failed to add I2C hsic_hub_driver\n"); goto i2c_add_fail; } usleep_range(10000, 12000); i2c_adap = i2c_get_adapter(SMSC_GSBI_I2C_BUS_ID); if (!i2c_adap) { dev_err(&pdev->dev, "failed to get i2c adapter\n"); i2c_del_driver(&hsic_hub_driver); goto i2c_add_fail; } memset(&i2c_info, 0, sizeof(struct i2c_board_info)); strlcpy(i2c_info.type, "i2c_hsic_hub", I2C_NAME_SIZE); msleep(250); switch (pdata->model_id) { case SMSC3503_ID: normal_i2c[0] = SMSC3503_I2C_ADDR; break; case SMSC4604_ID: normal_i2c[0] = SMSC4604_I2C_ADDR; break; default: dev_err(&pdev->dev, "unsupported SMSC model-id\n"); i2c_put_adapter(i2c_adap); i2c_del_driver(&hsic_hub_driver); goto uninit_gpio; } smsc_hub->client = i2c_new_probed_device(i2c_adap, &i2c_info, normal_i2c, NULL); i2c_put_adapter(i2c_adap); i2c_add_fail: ret = of_platform_populate(node, NULL, hsic_host_auxdata, &pdev->dev); if (ret) { dev_err(&pdev->dev, "failed to add child node, ret=%d\n", ret); goto uninit_gpio; } smsc_hub->enabled = true; if (!smsc_hub->client) dev_err(&pdev->dev, "failed to connect to smsc_hub through I2C\n"); done: pm_runtime_set_active(&pdev->dev); pm_runtime_enable(&pdev->dev); return 0; uninit_gpio: msm_hsic_hub_init_gpio(smsc_hub, 0); uninit_clock: msm_hsic_hub_init_clock(smsc_hub, 0); uninit_vdd: msm_hsic_hub_init_vdd(smsc_hub, 0); return ret; }
static void __init rockchip_dt_init(void) { rockchip_suspend_init(); of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); }
int cros_ec_register(struct cros_ec_device *ec_dev) { struct device *dev = ec_dev->dev; int err = 0; ec_dev->max_request = sizeof(struct ec_params_hello); ec_dev->max_response = sizeof(struct ec_response_get_protocol_info); ec_dev->max_passthru = 0; ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL); if (!ec_dev->din) return -ENOMEM; ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL); if (!ec_dev->dout) return -ENOMEM; mutex_init(&ec_dev->lock); cros_ec_query_all(ec_dev); err = mfd_add_devices(ec_dev->dev, PLATFORM_DEVID_AUTO, &ec_cell, 1, NULL, ec_dev->irq, NULL); if (err) { dev_err(dev, "Failed to register Embedded Controller subdevice %d\n", err); return err; } if (ec_dev->max_passthru) { /* * Register a PD device as well on top of this device. * We make the following assumptions: * - behind an EC, we have a pd * - only one device added. * - the EC is responsive at init time (it is not true for a * sensor hub. */ err = mfd_add_devices(ec_dev->dev, PLATFORM_DEVID_AUTO, &ec_pd_cell, 1, NULL, ec_dev->irq, NULL); if (err) { dev_err(dev, "Failed to register Power Delivery subdevice %d\n", err); return err; } } if (IS_ENABLED(CONFIG_OF) && dev->of_node) { err = of_platform_populate(dev->of_node, NULL, NULL, dev); if (err) { mfd_remove_devices(dev); dev_err(dev, "Failed to register sub-devices\n"); return err; } } dev_info(dev, "Chrome EC device registered\n"); return 0; }
static int __devinit mdss_dsi_ctrl_probe(struct platform_device *pdev) { int rc = 0; u32 index; struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL; struct device_node *dsi_pan_node = NULL; char panel_cfg[MDSS_MAX_PANEL_LEN]; struct resource *mdss_dsi_mres; const char *ctrl_name; bool cmd_cfg_cont_splash = true; if (!mdss_is_ready()) { pr_err("%s: MDP not probed yet!\n", __func__); return -EPROBE_DEFER; } if (!pdev->dev.of_node) { pr_err("DSI driver only supports device tree probe\n"); return -ENOTSUPP; } ctrl_pdata = platform_get_drvdata(pdev); if (!ctrl_pdata) { ctrl_pdata = devm_kzalloc(&pdev->dev, sizeof(struct mdss_dsi_ctrl_pdata), GFP_KERNEL); if (!ctrl_pdata) { pr_err("%s: FAILED: cannot alloc dsi ctrl\n", __func__); rc = -ENOMEM; goto error_no_mem; } platform_set_drvdata(pdev, ctrl_pdata); } ctrl_name = of_get_property(pdev->dev.of_node, "label", NULL); if (!ctrl_name) pr_info("%s:%d, DSI Ctrl name not specified\n", __func__, __LINE__); else pr_info("%s: DSI Ctrl name = %s\n", __func__, ctrl_name); rc = of_property_read_u32(pdev->dev.of_node, "cell-index", &index); if (rc) { dev_err(&pdev->dev, "%s: Cell-index not specified, rc=%d\n", __func__, rc); goto error_no_mem; } if (index == 0) pdev->id = 1; else pdev->id = 2; mdss_dsi_mres = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mdss_dsi_mres) { pr_err("%s:%d unable to get the MDSS resources", __func__, __LINE__); rc = -ENOMEM; goto error_no_mem; } mdss_dsi_base = ioremap(mdss_dsi_mres->start, resource_size(mdss_dsi_mres)); if (!mdss_dsi_base) { pr_err("%s:%d unable to remap dsi resources", __func__, __LINE__); rc = -ENOMEM; goto error_no_mem; } rc = of_platform_populate(pdev->dev.of_node, NULL, NULL, &pdev->dev); if (rc) { dev_err(&pdev->dev, "%s: failed to add child nodes, rc=%d\n", __func__, rc); goto error_ioremap; } /* Parse the regulator information */ rc = mdss_dsi_get_dt_vreg_data(&pdev->dev, &ctrl_pdata->power_data); if (rc) { pr_err("%s: failed to get vreg data from dt. rc=%d\n", __func__, rc); goto error_vreg; } /* DSI panels can be different between controllers */ rc = mdss_dsi_get_panel_cfg(panel_cfg); if (!rc) /* dsi panel cfg not present */ pr_warn("%s:%d:dsi specific cfg not present\n", __func__, __LINE__); /* find panel device node */ dsi_pan_node = mdss_dsi_find_panel_of_node(pdev, panel_cfg); if (!dsi_pan_node) { pr_err("%s: can't find panel node %s\n", __func__, panel_cfg); goto error_pan_node; } cmd_cfg_cont_splash = mdss_panel_get_boot_cfg() ? true : false; rc = mdss_dsi_panel_init(dsi_pan_node, ctrl_pdata, cmd_cfg_cont_splash); if (rc) { pr_err("%s: dsi panel init failed\n", __func__); goto error_pan_node; } rc = dsi_panel_device_register(dsi_pan_node, ctrl_pdata); if (rc) { pr_err("%s: dsi panel dev reg failed\n", __func__); goto error_pan_node; } pr_debug("%s: Dsi Ctrl->%d initialized\n", __func__, index); return 0; error_pan_node: of_node_put(dsi_pan_node); error_vreg: mdss_dsi_put_dt_vreg_data(&pdev->dev, &ctrl_pdata->power_data); error_ioremap: iounmap(mdss_dsi_base); error_no_mem: devm_kfree(&pdev->dev, ctrl_pdata); return rc; }
static void __init v2m_dt_init(void) { l2x0_of_init(0x00400000, 0xfe0fffff); of_platform_populate(NULL, v2m_dt_bus_match, NULL, NULL); }
static int dwc3_of_simple_probe(struct platform_device *pdev) { struct dwc3_of_simple *simple; struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; int ret; int i; bool shared_resets = false; simple = devm_kzalloc(dev, sizeof(*simple), GFP_KERNEL); if (!simple) return -ENOMEM; platform_set_drvdata(pdev, simple); simple->dev = dev; /* * Some controllers need to toggle the usb3-otg reset before trying to * initialize the PHY, otherwise the PHY times out. */ if (of_device_is_compatible(np, "rockchip,rk3399-dwc3")) simple->need_reset = true; if (of_device_is_compatible(np, "amlogic,meson-axg-dwc3") || of_device_is_compatible(np, "amlogic,meson-gxl-dwc3")) { shared_resets = true; simple->pulse_resets = true; } simple->resets = of_reset_control_array_get(np, shared_resets, true); if (IS_ERR(simple->resets)) { ret = PTR_ERR(simple->resets); dev_err(dev, "failed to get device resets, err=%d\n", ret); return ret; } if (simple->pulse_resets) { ret = reset_control_reset(simple->resets); if (ret) goto err_resetc_put; } else { ret = reset_control_deassert(simple->resets); if (ret) goto err_resetc_put; } ret = dwc3_of_simple_clk_init(simple, of_count_phandle_with_args(np, "clocks", "#clock-cells")); if (ret) goto err_resetc_assert; ret = of_platform_populate(np, NULL, NULL, dev); if (ret) { for (i = 0; i < simple->num_clocks; i++) { clk_disable_unprepare(simple->clks[i]); clk_put(simple->clks[i]); } goto err_resetc_assert; } pm_runtime_set_active(dev); pm_runtime_enable(dev); pm_runtime_get_sync(dev); return 0; err_resetc_assert: if (!simple->pulse_resets) reset_control_assert(simple->resets); err_resetc_put: reset_control_put(simple->resets); return ret; }
static void __init kirkwood_dt_init(void) { pr_info("Kirkwood: %s, TCLK=%d.\n", kirkwood_id(), kirkwood_tclk); /* * Disable propagation of mbus errors to the CPU local bus, * as this causes mbus errors (which can occur for example * for PCI aborts) to throw CPU aborts, which we're not set * up to deal with. */ writel(readl(CPU_CONFIG) & ~CPU_CONFIG_ERROR_PROP, CPU_CONFIG); kirkwood_setup_cpu_mbus(); kirkwood_l2_init(); /* Setup root of clk tree */ kirkwood_of_clk_init(); kirkwood_cpuidle_init(); #ifdef CONFIG_KEXEC kexec_reinit = kirkwood_enable_pcie; #endif if (of_machine_is_compatible("globalscale,dreamplug")) dreamplug_init(); if (of_machine_is_compatible("globalscale,guruplug")) guruplug_dt_init(); if (of_machine_is_compatible("dlink,dns-kirkwood")) dnskw_init(); if (of_machine_is_compatible("iom,iconnect")) iconnect_init(); if (of_machine_is_compatible("raidsonic,ib-nas62x0")) ib62x0_init(); if (of_machine_is_compatible("qnap,ts219")) qnap_dt_ts219_init(); if (of_machine_is_compatible("seagate,dockstar")) dockstar_dt_init(); if (of_machine_is_compatible("seagate,goflexnet")) goflexnet_init(); if (of_machine_is_compatible("buffalo,lsxl")) lsxl_init(); if (of_machine_is_compatible("iom,ix2-200")) iomega_ix2_200_init(); if (of_machine_is_compatible("keymile,km_kirkwood")) km_kirkwood_init(); if (of_machine_is_compatible("lacie,cloudbox") || of_machine_is_compatible("lacie,inetspace_v2") || of_machine_is_compatible("lacie,netspace_lite_v2") || of_machine_is_compatible("lacie,netspace_max_v2") || of_machine_is_compatible("lacie,netspace_mini_v2") || of_machine_is_compatible("lacie,netspace_v2")) ns2_init(); if (of_machine_is_compatible("mpl,cec4")) mplcec4_init(); if (of_machine_is_compatible("netgear,readynas-duo-v2")) netgear_readynas_init(); if (of_machine_is_compatible("plathome,openblocks-a6")) openblocks_a6_init(); if (of_machine_is_compatible("usi,topkick")) usi_topkick_init(); of_platform_populate(NULL, kirkwood_dt_match_table, NULL, NULL); }
static void __init odroid_dt_machine_init(void) { of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); }
static void __init sunxi_dt_init(void) { sunxi_setup_restart(); of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); }
static void __init s3c2416_dt_machine_init(void) { of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); s3c_pm_init(); }
static int exynos_adc_probe(struct platform_device *pdev) { struct exynos_adc *info = NULL; struct device_node *np = pdev->dev.of_node; struct iio_dev *indio_dev = NULL; struct resource *mem; int ret = -ENODEV; int irq; if (!np) return ret; indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(struct exynos_adc)); if (!indio_dev) { dev_err(&pdev->dev, "failed allocating iio device\n"); return -ENOMEM; } info = iio_priv(indio_dev); info->data = exynos_adc_get_data(pdev); if (!info->data) { dev_err(&pdev->dev, "failed getting exynos_adc_data\n"); return -EINVAL; } mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); info->regs = devm_ioremap_resource(&pdev->dev, mem); if (IS_ERR(info->regs)) return PTR_ERR(info->regs); if (info->data->needs_adc_phy) { mem = platform_get_resource(pdev, IORESOURCE_MEM, 1); info->enable_reg = devm_ioremap_resource(&pdev->dev, mem); if (IS_ERR(info->enable_reg)) return PTR_ERR(info->enable_reg); } irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(&pdev->dev, "no irq resource?\n"); return irq; } info->irq = irq; info->dev = &pdev->dev; init_completion(&info->completion); info->clk = devm_clk_get(&pdev->dev, "adc"); if (IS_ERR(info->clk)) { dev_err(&pdev->dev, "failed getting clock, err = %ld\n", PTR_ERR(info->clk)); return PTR_ERR(info->clk); } if (info->data->needs_sclk) { info->sclk = devm_clk_get(&pdev->dev, "sclk"); if (IS_ERR(info->sclk)) { dev_err(&pdev->dev, "failed getting sclk clock, err = %ld\n", PTR_ERR(info->sclk)); return PTR_ERR(info->sclk); } } info->vdd = devm_regulator_get(&pdev->dev, "vdd"); if (IS_ERR(info->vdd)) { dev_err(&pdev->dev, "failed getting regulator, err = %ld\n", PTR_ERR(info->vdd)); return PTR_ERR(info->vdd); } ret = regulator_enable(info->vdd); if (ret) return ret; ret = exynos_adc_prepare_clk(info); if (ret) goto err_disable_reg; ret = exynos_adc_enable_clk(info); if (ret) goto err_unprepare_clk; platform_set_drvdata(pdev, indio_dev); indio_dev->name = dev_name(&pdev->dev); indio_dev->dev.parent = &pdev->dev; indio_dev->dev.of_node = pdev->dev.of_node; indio_dev->info = &exynos_adc_iio_info; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = exynos_adc_iio_channels; indio_dev->num_channels = info->data->num_channels; ret = request_irq(info->irq, exynos_adc_isr, 0, dev_name(&pdev->dev), info); if (ret < 0) { dev_err(&pdev->dev, "failed requesting irq, irq = %d\n", info->irq); goto err_disable_clk; } ret = iio_device_register(indio_dev); if (ret) goto err_irq; if (info->data->init_hw) info->data->init_hw(info); ret = of_platform_populate(np, exynos_adc_match, NULL, &indio_dev->dev); if (ret < 0) { dev_err(&pdev->dev, "failed adding child nodes\n"); goto err_of_populate; } return 0; err_of_populate: device_for_each_child(&indio_dev->dev, NULL, exynos_adc_remove_devices); iio_device_unregister(indio_dev); err_irq: free_irq(info->irq, info); err_disable_clk: if (info->data->exit_hw) info->data->exit_hw(info); exynos_adc_disable_clk(info); err_unprepare_clk: exynos_adc_unprepare_clk(info); err_disable_reg: regulator_disable(info->vdd); return ret; }