static int __init pl111_platform_drm_init(void) { int ret; pr_info("DRM %s\n", __func__); pl111_drm_device = platform_device_register_full(&pl111_drm_pdevinfo); if (pl111_drm_device == NULL) { pr_err("DRM platform_device_register_full() failed\n"); return -ENOMEM; } ret = amba_driver_register(&pl111_amba_driver); if (ret != 0) { pr_err("DRM amba_driver_register() failed %d\n", ret); goto err_amba_reg; } ret = platform_driver_register(&platform_drm_driver); if (ret != 0) { pr_err("DRM platform_driver_register() failed %d\n", ret); goto err_pdrv_reg; } return 0; err_pdrv_reg: amba_driver_unregister(&pl111_amba_driver); err_amba_reg: platform_device_unregister(pl111_drm_device); return ret; }
static void __init imx51_dt_init(void) { struct platform_device_info devinfo = { .name = "cpufreq-cpu0", }; of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); platform_device_register_full(&devinfo); } static const char *imx51_dt_board_compat[] __initdata = { "fsl,imx51", NULL }; static void __init imx51_timer_init(void) { mx51_clocks_init_dt(); } DT_MACHINE_START(IMX51_DT, "Freescale i.MX51 (Device Tree Support)") .map_io = mx51_map_io, .init_early = imx51_init_early, .init_irq = mx51_init_irq, .handle_irq = imx51_handle_irq, .init_time = imx51_timer_init, .init_machine = imx51_dt_init, .init_late = imx51_init_late, .dt_compat = imx51_dt_board_compat, .restart = mxc_restart, MACHINE_END
void __init sh73a0_add_standard_devices_dt(void) { struct platform_device_info devinfo = { .name = "cpufreq-cpu0", .id = -1, }; /* clocks are setup late during boot in the case of DT */ sh73a0_clock_init(); platform_add_devices(sh73a0_devices_dt, ARRAY_SIZE(sh73a0_devices_dt)); of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); /* Instantiate cpufreq-cpu0 */ platform_device_register_full(&devinfo); } static const char *sh73a0_boards_compat_dt[] __initdata = { "renesas,sh73a0", NULL, }; DT_MACHINE_START(SH73A0_DT, "Generic SH73A0 (Flattened Device Tree)") .smp = smp_ops(sh73a0_smp_ops), .map_io = sh73a0_map_io, .init_early = sh73a0_init_delay, .nr_irqs = NR_IRQS_LEGACY, .init_machine = sh73a0_add_standard_devices_dt, .dt_compat = sh73a0_boards_compat_dt, MACHINE_END
static void __init koelsch_add_du_device(void) { struct platform_device_info info = { .name = "rcar-du-r8a7791", .id = -1, .res = du_resources, .num_res = ARRAY_SIZE(du_resources), .data = &koelsch_du_pdata, .size_data = sizeof(koelsch_du_pdata), .dma_mask = DMA_BIT_MASK(32), }; platform_device_register_full(&info); } /* * This is a really crude hack to provide clkdev support to platform * devices until they get moved to DT. */ static const struct clk_name clk_names[] __initconst = { { "du0", "du.0", "rcar-du-r8a7791" }, { "du1", "du.1", "rcar-du-r8a7791" }, { "lvds0", "lvds.0", "rcar-du-r8a7791" }, }; static void __init koelsch_add_standard_devices(void) { shmobile_clk_workaround(clk_names, ARRAY_SIZE(clk_names), false); of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); koelsch_add_du_device(); }
static void __init koelsch_add_du_device(void) { struct platform_device_info info = { .name = "rcar-du-r8a7791", .id = -1, .res = du_resources, .num_res = ARRAY_SIZE(du_resources), .data = &koelsch_du_pdata, .size_data = sizeof(koelsch_du_pdata), .dma_mask = DMA_BIT_MASK(32), }; platform_device_register_full(&info); } /* Sound */ static struct rsnd_ssi_platform_info rsnd_ssi[] = { RSND_SSI(AUDIOPP_DMAC_SLAVE_CMD0_TO_SSI0, gic_spi(370), 0), RSND_SSI(AUDIOPP_DMAC_SLAVE_SSI1_TO_SCU1, gic_spi(371), RSND_SSI_CLK_PIN_SHARE), }; static struct rsnd_src_platform_info rsnd_src[2] = { RSND_SRC(0, AUDIO_DMAC_SLAVE_SCU0_TX), RSND_SRC(0, AUDIO_DMAC_SLAVE_SCU1_RX), }; static struct rsnd_dvc_platform_info rsnd_dvc = { }; static struct rsnd_dai_platform_info rsnd_dai = { .playback = { .ssi = &rsnd_ssi[0], .src = &rsnd_src[0], .dvc = &rsnd_dvc, }, .capture = { .ssi = &rsnd_ssi[1], .src = &rsnd_src[1], }, };
static struct platform_device * lpe_audio_platdev_create(struct drm_i915_private *dev_priv) { struct drm_device *dev = &dev_priv->drm; struct platform_device_info pinfo = {}; struct resource *rsc; struct platform_device *platdev; struct intel_hdmi_lpe_audio_pdata *pdata; pdata = kzalloc(sizeof(*pdata), GFP_KERNEL); if (!pdata) return ERR_PTR(-ENOMEM); rsc = kcalloc(2, sizeof(*rsc), GFP_KERNEL); if (!rsc) { kfree(pdata); return ERR_PTR(-ENOMEM); } rsc[0].start = rsc[0].end = dev_priv->lpe_audio.irq; rsc[0].flags = IORESOURCE_IRQ; rsc[0].name = "hdmi-lpe-audio-irq"; rsc[1].start = pci_resource_start(dev->pdev, 0) + I915_HDMI_LPE_AUDIO_BASE; rsc[1].end = pci_resource_start(dev->pdev, 0) + I915_HDMI_LPE_AUDIO_BASE + I915_HDMI_LPE_AUDIO_SIZE - 1; rsc[1].flags = IORESOURCE_MEM; rsc[1].name = "hdmi-lpe-audio-mmio"; pinfo.parent = dev->dev; pinfo.name = "hdmi-lpe-audio"; pinfo.id = -1; pinfo.res = rsc; pinfo.num_res = 2; pinfo.data = pdata; pinfo.size_data = sizeof(*pdata); pinfo.dma_mask = DMA_BIT_MASK(32); pdata->num_pipes = INTEL_INFO(dev_priv)->num_pipes; pdata->num_ports = IS_CHERRYVIEW(dev_priv) ? 3 : 2; /* B,C,D or B,C */ pdata->port[0].pipe = -1; pdata->port[1].pipe = -1; pdata->port[2].pipe = -1; spin_lock_init(&pdata->lpe_audio_slock); platdev = platform_device_register_full(&pinfo); kfree(rsc); kfree(pdata); if (IS_ERR(platdev)) { DRM_ERROR("Failed to allocate LPE audio platform device\n"); return platdev; } pm_runtime_no_callbacks(&platdev->dev); return platdev; }
void __init r8a7779_add_vin_device(int id, struct rcar_vin_platform_data *pdata) { BUG_ON(id < 0 || id > 3); vin_info_table[id]->data = pdata; vin_info_table[id]->size_data = sizeof(*pdata); platform_device_register_full(vin_info_table[id]); }
int __init dm646x_init_edma(struct edma_rsv_info *rsv) { struct platform_device *edma_pdev; dm646x_edma_pdata.rsv = rsv; edma_pdev = platform_device_register_full(&dm646x_edma_device); return IS_ERR(edma_pdev) ? PTR_ERR(edma_pdev) : 0; }
static void __init mxc_init_ext_ethernet(void) { mx31ads_cs8900_resources[1].start = irq_find_mapping(domain, EXPIO_INT_ENET_INT); mx31ads_cs8900_resources[1].end = irq_find_mapping(domain, EXPIO_INT_ENET_INT); platform_device_register_full( (struct platform_device_info *)&mx31ads_cs8900_devinfo); }
static void __init marzen_init(void) { regulator_register_always_on(0, "fixed-3.3V", fixed3v3_power_consumers, ARRAY_SIZE(fixed3v3_power_consumers), 3300000); regulator_register_fixed(1, dummy_supplies, ARRAY_SIZE(dummy_supplies)); pinctrl_register_mappings(marzen_pinctrl_map, ARRAY_SIZE(marzen_pinctrl_map)); r8a7779_pinmux_init(); r8a7779_init_irq_extpin(1); /* IRQ1 as individual interrupt */ r8a7779_add_standard_devices(); platform_device_register_full(&vin1_info); platform_device_register_full(&vin3_info); platform_add_devices(marzen_devices, ARRAY_SIZE(marzen_devices)); marzen_add_du_device(); }
static int hb_cpufreq_driver_init(void) { struct platform_device_info devinfo = { .name = "cpufreq-cpu0", }; struct device *cpu_dev; struct clk *cpu_clk; struct device_node *np; int ret; if ((!of_machine_is_compatible("calxeda,highbank")) && (!of_machine_is_compatible("calxeda,ecx-2000"))) return -ENODEV; for_each_child_of_node(of_find_node_by_path("/cpus"), np) if (of_get_property(np, "operating-points", NULL)) break; if (!np) { pr_err("failed to find highbank cpufreq node\n"); return -ENOENT; } cpu_dev = get_cpu_device(0); if (!cpu_dev) { pr_err("failed to get highbank cpufreq device\n"); ret = -ENODEV; goto out_put_node; } cpu_dev->of_node = np; cpu_clk = clk_get(cpu_dev, NULL); if (IS_ERR(cpu_clk)) { ret = PTR_ERR(cpu_clk); pr_err("failed to get cpu0 clock: %d\n", ret); goto out_put_node; } ret = clk_notifier_register(cpu_clk, &hb_cpufreq_clk_nb); if (ret) { pr_err("failed to register clk notifier: %d\n", ret); goto out_put_node; } /* Instantiate cpufreq-cpu0 */ platform_device_register_full(&devinfo); out_put_node: of_node_put(np); return ret; } module_init(hb_cpufreq_driver_init); MODULE_AUTHOR("Mark Langsdorf <*****@*****.**>"); MODULE_DESCRIPTION("Calxeda Highbank cpufreq driver"); MODULE_LICENSE("GPL");
int __init da830_register_edma(struct edma_rsv_info *rsv) { struct platform_device *edma_pdev; da8xx_edma0_pdata.rsv = rsv; da8xx_edma0_pdata.slave_map = da830_edma_map; da8xx_edma0_pdata.slavecnt = ARRAY_SIZE(da830_edma_map); edma_pdev = platform_device_register_full(&da8xx_edma0_device); return IS_ERR(edma_pdev) ? PTR_ERR(edma_pdev) : 0; }
static void __init genmai_add_standard_devices(void) { r7s72100_clock_init(); r7s72100_add_dt_devices(); platform_device_register_full(ðer_info); r7s72100_register_rspi(0); r7s72100_register_rspi(1); r7s72100_register_rspi(2); r7s72100_register_rspi(3); r7s72100_register_rspi(4); spi_register_board_info(spi_info, ARRAY_SIZE(spi_info)); }
static void __init koelsch_add_du_device(void) { struct platform_device_info info = { .name = "rcar-du-r8a7791", .id = -1, .res = du_resources, .num_res = ARRAY_SIZE(du_resources), .data = &koelsch_du_pdata, .size_data = sizeof(koelsch_du_pdata), .dma_mask = DMA_BIT_MASK(32), }; platform_device_register_full(&info); } /* * This is a really crude hack to provide clkdev support to platform * devices until they get moved to DT. */ static const struct clk_name clk_names[] __initconst = { { "cmt0", "fck", "sh-cmt-48-gen2.0" }, { "du0", "du.0", "rcar-du-r8a7791" }, { "du1", "du.1", "rcar-du-r8a7791" }, { "lvds0", "lvds.0", "rcar-du-r8a7791" }, }; /* * This is a really crude hack to work around core platform clock issues */ static const struct clk_name clk_enables[] __initconst = { { "ether", NULL, "ee700000.ethernet" }, { "i2c2", NULL, "e6530000.i2c" }, { "msiof0", NULL, "e6e20000.spi" }, { "qspi_mod", NULL, "e6b10000.spi" }, { "sdhi0", NULL, "ee100000.sd" }, { "sdhi1", NULL, "ee140000.sd" }, { "sdhi2", NULL, "ee160000.sd" }, { "thermal", NULL, "e61f0000.thermal" }, }; static void __init koelsch_add_standard_devices(void) { shmobile_clk_workaround(clk_names, ARRAY_SIZE(clk_names), false); shmobile_clk_workaround(clk_enables, ARRAY_SIZE(clk_enables), true); r8a7791_add_dt_devices(); of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); koelsch_add_du_device(); }
int __init da850_register_edma(struct edma_rsv_info *rsv[2]) { struct platform_device *edma_pdev; if (rsv) { da8xx_edma0_pdata.rsv = rsv[0]; da850_edma1_pdata.rsv = rsv[1]; } da8xx_edma0_pdata.slave_map = da850_edma0_map; da8xx_edma0_pdata.slavecnt = ARRAY_SIZE(da850_edma0_map); edma_pdev = platform_device_register_full(&da8xx_edma0_device); if (IS_ERR(edma_pdev)) { pr_warn("%s: Failed to register eDMA0\n", __func__); return PTR_ERR(edma_pdev); } da850_edma1_pdata.slave_map = da850_edma1_map; da850_edma1_pdata.slavecnt = ARRAY_SIZE(da850_edma1_map); edma_pdev = platform_device_register_full(&da850_edma1_device); return IS_ERR(edma_pdev) ? PTR_ERR(edma_pdev) : 0; }
static void __init imx51_dt_init(void) { struct platform_device_info devinfo = { .name = "cpufreq-dt", }; imx51_ipu_mipi_setup(); imx_src_init(); of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); platform_device_register_full(&devinfo); } static void __init imx51_init_late(void) { mx51_neon_fixup(); imx51_pm_init(); }
static void __init mx21ads_board_init(void) { imx21_soc_init(); mxc_gpio_setup_multiple_pins(mx21ads_pins, ARRAY_SIZE(mx21ads_pins), "mx21ads"); imx21_add_imx_uart0(&uart_pdata_rts); imx21_add_imx_uart2(&uart_pdata_norts); imx21_add_imx_uart3(&uart_pdata_rts); imx21_add_imx_fb(&mx21ads_fb_data); imx21_add_mxc_mmc(0, &mx21ads_sdhc_pdata); imx21_add_mxc_nand(&mx21ads_nand_board_info); platform_add_devices(platform_devices, ARRAY_SIZE(platform_devices)); platform_device_register_full(&mx21ads_cs8900_devinfo); }
static int ce4100_spi_probe(struct pci_dev *dev, const struct pci_device_id *ent) { struct platform_device_info pi; int ret; struct platform_device *pdev; struct pxa2xx_spi_master spi_pdata; struct ssp_device *ssp; ret = pcim_enable_device(dev); if (ret) return ret; ret = pcim_iomap_regions(dev, 1 << 0, "PXA2xx SPI"); if (ret) return ret; memset(&spi_pdata, 0, sizeof(spi_pdata)); spi_pdata.num_chipselect = dev->devfn; ssp = &spi_pdata.ssp; ssp->phys_base = pci_resource_start(dev, 0); ssp->mmio_base = pcim_iomap_table(dev)[0]; if (!ssp->mmio_base) { dev_err(&dev->dev, "failed to ioremap() registers\n"); return -EIO; } ssp->irq = dev->irq; ssp->port_id = dev->devfn; ssp->type = PXA25x_SSP; memset(&pi, 0, sizeof(pi)); pi.parent = &dev->dev; pi.name = "pxa2xx-spi"; pi.id = ssp->port_id; pi.data = &spi_pdata; pi.size_data = sizeof(spi_pdata); pdev = platform_device_register_full(&pi); if (IS_ERR(pdev)) return PTR_ERR(pdev); pci_set_drvdata(dev, pdev); return 0; }
static void __init lager_add_vin_device(unsigned idx, struct rcar_vin_platform_data *pdata) { struct platform_device_info vin_info = { .parent = &platform_bus, .name = "r8a7790-vin", .id = idx, .res = &vin_resources[idx * 2], .num_res = 2, .dma_mask = DMA_BIT_MASK(32), .data = pdata, .size_data = sizeof(*pdata), }; BUG_ON(idx > 1); platform_device_register_full(&vin_info); } #define LAGER_CAMERA(idx, name, addr, pdata, flag) \ static struct i2c_board_info i2c_cam##idx##_device = { \ I2C_BOARD_INFO(name, addr), \ }; \ \ static struct rcar_vin_platform_data vin##idx##_pdata = { \ .flags = flag, \ }; \ \ static struct soc_camera_link cam##idx##_link = { \ .bus_id = idx, \ .board_info = &i2c_cam##idx##_device, \ .i2c_adapter_id = 2, \ .module_name = name, \ .priv = pdata, \ } /* Camera 0 is not currently supported due to adv7612 support missing */ LAGER_CAMERA(1, "adv7180", 0x20, NULL, RCAR_VIN_BT656); static void __init lager_add_camera1_device(void) { platform_device_register_data(&platform_bus, "soc-camera-pdrv", 1, &cam1_link, sizeof(cam1_link)); lager_add_vin_device(1, &vin1_pdata); }
static int __init omap2_system_dma_init(void) { struct platform_device *pdev; int res; res = omap_hwmod_for_each_by_class("dma", omap2_system_dma_init_dev, NULL); if (res) return res; if (of_have_populated_dt()) return res; pdev = platform_device_register_full(&omap_dma_dev_info); if (IS_ERR(pdev)) return PTR_ERR(pdev); return res; }
/** * dcdbas_init: initialize driver */ static int __init dcdbas_init(void) { int error; error = platform_driver_register(&dcdbas_driver); if (error) return error; dcdbas_pdev_reg = platform_device_register_full(&dcdbas_dev_info); if (IS_ERR(dcdbas_pdev_reg)) { error = PTR_ERR(dcdbas_pdev_reg); goto err_unregister_driver; } return 0; err_unregister_driver: platform_driver_unregister(&dcdbas_driver); return error; }
static void __init imx27_dt_init(void) { struct platform_device_info devinfo = { .name = "cpufreq-dt", }; of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); platform_device_register_full(&devinfo); } static const char * const imx27_dt_board_compat[] __initconst = { "fsl,imx27", NULL }; DT_MACHINE_START(IMX27_DT, "Freescale i.MX27 (Device Tree Support)") .map_io = mx27_map_io, .init_early = imx27_init_early, .init_irq = mx27_init_irq, .init_machine = imx27_dt_init, .dt_compat = imx27_dt_board_compat, MACHINE_END
static void __init lager_add_du_device(void) { struct platform_device_info info = { .name = "rcar-du-r8a7790", .id = -1, .res = du_resources, .num_res = ARRAY_SIZE(du_resources), .data = &lager_du_pdata, .size_data = sizeof(lager_du_pdata), .dma_mask = DMA_BIT_MASK(32), }; platform_device_register_full(&info); } /* LEDS */ static struct gpio_led lager_leds[] = { { .name = "led8", .gpio = RCAR_GP_PIN(5, 17), .default_state = LEDS_GPIO_DEFSTATE_ON, }, { .name = "led7",
static int __init dm644x_init_devices(void) { struct platform_device *edma_pdev; int ret = 0; if (!cpu_is_davinci_dm644x()) return 0; edma_pdev = platform_device_register_full(&dm644x_edma_device); if (IS_ERR(edma_pdev)) { pr_warn("%s: Failed to register eDMA\n", __func__); return PTR_ERR(edma_pdev); } platform_device_register(&dm644x_mdio_device); platform_device_register(&dm644x_emac_device); ret = davinci_init_wdt(); if (ret) pr_warn("%s: watchdog init failed: %d\n", __func__, ret); return ret; }
static int tegra124_cpufreq_probe(struct platform_device *pdev) { struct tegra124_cpufreq_priv *priv; struct device_node *np; struct device *cpu_dev; struct platform_device_info cpufreq_dt_devinfo = {}; int ret; priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; cpu_dev = get_cpu_device(0); if (!cpu_dev) return -ENODEV; np = of_cpu_device_node_get(0); if (!np) return -ENODEV; priv->vdd_cpu_reg = regulator_get(cpu_dev, "vdd-cpu"); if (IS_ERR(priv->vdd_cpu_reg)) { ret = PTR_ERR(priv->vdd_cpu_reg); goto out_put_np; } priv->cpu_clk = of_clk_get_by_name(np, "cpu_g"); if (IS_ERR(priv->cpu_clk)) { ret = PTR_ERR(priv->cpu_clk); goto out_put_vdd_cpu_reg; } priv->dfll_clk = of_clk_get_by_name(np, "dfll"); if (IS_ERR(priv->dfll_clk)) { ret = PTR_ERR(priv->dfll_clk); goto out_put_cpu_clk; } priv->pllx_clk = of_clk_get_by_name(np, "pll_x"); if (IS_ERR(priv->pllx_clk)) { ret = PTR_ERR(priv->pllx_clk); goto out_put_dfll_clk; } priv->pllp_clk = of_clk_get_by_name(np, "pll_p"); if (IS_ERR(priv->pllp_clk)) { ret = PTR_ERR(priv->pllp_clk); goto out_put_pllx_clk; } ret = tegra124_cpu_switch_to_dfll(priv); if (ret) goto out_put_pllp_clk; cpufreq_dt_devinfo.name = "cpufreq-dt"; cpufreq_dt_devinfo.parent = &pdev->dev; cpufreq_dt_devinfo.data = &cpufreq_dt_pd; cpufreq_dt_devinfo.size_data = sizeof(cpufreq_dt_pd); priv->cpufreq_dt_pdev = platform_device_register_full(&cpufreq_dt_devinfo); if (IS_ERR(priv->cpufreq_dt_pdev)) { ret = PTR_ERR(priv->cpufreq_dt_pdev); goto out_switch_to_pllx; } platform_set_drvdata(pdev, priv); return 0; out_switch_to_pllx: tegra124_cpu_switch_to_pllx(priv); out_put_pllp_clk: clk_put(priv->pllp_clk); out_put_pllx_clk: clk_put(priv->pllx_clk); out_put_dfll_clk: clk_put(priv->dfll_clk); out_put_cpu_clk: clk_put(priv->cpu_clk); out_put_vdd_cpu_reg: regulator_put(priv->vdd_cpu_reg); out_put_np: of_node_put(np); return ret; }
static int da8xx_probe(struct platform_device *pdev) { struct resource musb_resources[2]; struct musb_hdrc_platform_data *pdata = dev_get_platdata(&pdev->dev); struct da8xx_glue *glue; struct platform_device_info pinfo; struct clk *clk; struct device_node *np = pdev->dev.of_node; int ret; glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL); if (!glue) return -ENOMEM; clk = devm_clk_get(&pdev->dev, "usb20"); if (IS_ERR(clk)) { dev_err(&pdev->dev, "failed to get clock\n"); return PTR_ERR(clk); } glue->phy = devm_phy_get(&pdev->dev, "usb-phy"); if (IS_ERR(glue->phy)) { if (PTR_ERR(glue->phy) != -EPROBE_DEFER) dev_err(&pdev->dev, "failed to get phy\n"); return PTR_ERR(glue->phy); } glue->dev = &pdev->dev; glue->clk = clk; if (IS_ENABLED(CONFIG_OF) && np) { pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); if (!pdata) return -ENOMEM; pdata->config = &da8xx_config; pdata->mode = musb_get_mode(&pdev->dev); pdata->power = get_vbus_power(&pdev->dev); } pdata->platform_ops = &da8xx_ops; glue->usb_phy = usb_phy_generic_register(); ret = PTR_ERR_OR_ZERO(glue->usb_phy); if (ret) { dev_err(&pdev->dev, "failed to register usb_phy\n"); return ret; } platform_set_drvdata(pdev, glue); memset(musb_resources, 0x00, sizeof(*musb_resources) * ARRAY_SIZE(musb_resources)); musb_resources[0].name = pdev->resource[0].name; musb_resources[0].start = pdev->resource[0].start; musb_resources[0].end = pdev->resource[0].end; musb_resources[0].flags = pdev->resource[0].flags; musb_resources[1].name = pdev->resource[1].name; musb_resources[1].start = pdev->resource[1].start; musb_resources[1].end = pdev->resource[1].end; musb_resources[1].flags = pdev->resource[1].flags; pinfo = da8xx_dev_info; pinfo.parent = &pdev->dev; pinfo.res = musb_resources; pinfo.num_res = ARRAY_SIZE(musb_resources); pinfo.data = pdata; pinfo.size_data = sizeof(*pdata); glue->musb = platform_device_register_full(&pinfo); ret = PTR_ERR_OR_ZERO(glue->musb); if (ret) { dev_err(&pdev->dev, "failed to register musb device: %d\n", ret); usb_phy_generic_unregister(glue->usb_phy); } return ret; }
static void __init bockw_init(void) { void __iomem *base; struct clk *clk; int i; r8a7778_clock_init(); r8a7778_init_irq_extpin(1); r8a7778_add_standard_devices(); platform_device_register_resndata(&platform_bus, "r8a777x-ether", -1, ether_resources, ARRAY_SIZE(ether_resources), ðer_platform_data, sizeof(ether_platform_data)); platform_device_register_full(&vin0_info); /* VIN1 has a pin conflict with Ether */ if (!IS_ENABLED(CONFIG_SH_ETH)) platform_device_register_full(&vin1_info); platform_device_register_data(&platform_bus, "soc-camera-pdrv", 0, &iclink0_ml86v7667, sizeof(iclink0_ml86v7667)); platform_device_register_data(&platform_bus, "soc-camera-pdrv", 1, &iclink1_ml86v7667, sizeof(iclink1_ml86v7667)); i2c_register_board_info(0, i2c0_devices, ARRAY_SIZE(i2c0_devices)); spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info)); pinctrl_register_mappings(bockw_pinctrl_map, ARRAY_SIZE(bockw_pinctrl_map)); r8a7778_pinmux_init(); platform_device_register_resndata( &platform_bus, "sh_mmcif", -1, mmc_resources, ARRAY_SIZE(mmc_resources), &sh_mmcif_plat, sizeof(struct sh_mmcif_plat_data)); platform_device_register_resndata( &platform_bus, "rcar_usb_phy", -1, usb_phy_resources, ARRAY_SIZE(usb_phy_resources), &usb_phy_platform_data, sizeof(struct rcar_phy_platform_data)); /* for SMSC */ fpga = ioremap_nocache(FPGA, SZ_1M); if (fpga) { /* * CAUTION * * IRQ0/1 is cascaded interrupt from FPGA. * it should be cared in the future * Now, it is assuming IRQ0 was used only from SMSC. */ u16 val = ioread16(fpga + IRQ0MR); val &= ~(1 << 4); /* enable SMSC911x */ iowrite16(val, fpga + IRQ0MR); regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies)); platform_device_register_resndata( &platform_bus, "smsc911x", -1, smsc911x_resources, ARRAY_SIZE(smsc911x_resources), &smsc911x_data, sizeof(smsc911x_data)); } /* for SDHI */ base = ioremap_nocache(PFC, 0x200); if (base) { /* * FIXME * * SDHI CD/WP pin needs pull-up */ iowrite32(ioread32(base + PUPR4) | (3 << 26), base + PUPR4); iounmap(base); platform_device_register_resndata( &platform_bus, "sh_mobile_sdhi", 0, sdhi0_resources, ARRAY_SIZE(sdhi0_resources), &sdhi0_info, sizeof(struct sh_mobile_sdhi_info)); } /* for Audio */ clk = clk_get(NULL, "audio_clk_b"); clk_set_rate(clk, 24576000); clk_put(clk); rsnd_codec_power(5, 1); /* enable ak4642 */ platform_device_register_simple( "ak4554-adc-dac", 0, NULL, 0); platform_device_register_simple( "ak4554-adc-dac", 1, NULL, 0); platform_device_register_resndata( &platform_bus, "rcar_sound", -1, rsnd_resources, ARRAY_SIZE(rsnd_resources), &rsnd_info, sizeof(rsnd_info)); for (i = 0; i < ARRAY_SIZE(rsnd_card_info); i++) { struct platform_device_info cardinfo = { .parent = &platform_bus, .name = "asoc-simple-card", .id = i, .data = &rsnd_card_info[i], .size_data = sizeof(struct asoc_simple_card_info), .dma_mask = ~0, }; platform_device_register_full(&cardinfo); } } static void __init bockw_init_late(void) { r8a7778_init_late(); ADD_USB_FUNC_DEVICE_IF_POSSIBLE(); }
void __init r8a7778_init_late(void) { platform_device_register_full(&ehci_info); platform_device_register_full(&ohci_info); }
static int da8xx_probe(struct platform_device *pdev) { struct resource musb_resources[2]; struct musb_hdrc_platform_data *pdata = dev_get_platdata(&pdev->dev); struct platform_device *musb; struct da8xx_glue *glue; struct platform_device_info pinfo; struct clk *clk; int ret = -ENOMEM; glue = kzalloc(sizeof(*glue), GFP_KERNEL); if (!glue) { dev_err(&pdev->dev, "failed to allocate glue context\n"); goto err0; } clk = clk_get(&pdev->dev, "usb20"); if (IS_ERR(clk)) { dev_err(&pdev->dev, "failed to get clock\n"); ret = PTR_ERR(clk); goto err3; } ret = clk_enable(clk); if (ret) { dev_err(&pdev->dev, "failed to enable clock\n"); goto err4; } glue->dev = &pdev->dev; glue->clk = clk; pdata->platform_ops = &da8xx_ops; platform_set_drvdata(pdev, glue); memset(musb_resources, 0x00, sizeof(*musb_resources) * ARRAY_SIZE(musb_resources)); musb_resources[0].name = pdev->resource[0].name; musb_resources[0].start = pdev->resource[0].start; musb_resources[0].end = pdev->resource[0].end; musb_resources[0].flags = pdev->resource[0].flags; musb_resources[1].name = pdev->resource[1].name; musb_resources[1].start = pdev->resource[1].start; musb_resources[1].end = pdev->resource[1].end; musb_resources[1].flags = pdev->resource[1].flags; pinfo = da8xx_dev_info; pinfo.parent = &pdev->dev; pinfo.res = musb_resources; pinfo.num_res = ARRAY_SIZE(musb_resources); pinfo.data = pdata; pinfo.size_data = sizeof(*pdata); glue->musb = musb = platform_device_register_full(&pinfo); if (IS_ERR(musb)) { ret = PTR_ERR(musb); dev_err(&pdev->dev, "failed to register musb device: %d\n", ret); goto err5; } return 0; err5: clk_disable(clk); err4: clk_put(clk); err3: kfree(glue); err0: return ret; }
mutex_lock(&acpi_parent->physical_node_lock); list = &acpi_parent->physical_node_list; if (!list_empty(list)) { entry = list_first_entry(list, struct acpi_device_physical_node, node); pdevinfo.parent = entry->dev; } mutex_unlock(&acpi_parent->physical_node_lock); } pdevinfo.name = dev_name(&adev->dev); pdevinfo.id = -1; pdevinfo.res = resources; pdevinfo.num_res = count; pdevinfo.acpi_node.companion = adev; pdev = platform_device_register_full(&pdevinfo); if (IS_ERR(pdev)) { dev_err(&adev->dev, "platform device creation failed: %ld\n", PTR_ERR(pdev)); pdev = NULL; } else { dev_dbg(&adev->dev, "created platform device %s\n", dev_name(&pdev->dev)); } kfree(resources); return 1; } static struct acpi_scan_handler platform_handler = { .ids = acpi_platform_device_ids,