C++ s3c_set_platdata函数代码示例

void __init exynos4_dwmci_set_platdata(struct dw_mci_board *pd)
{
	struct dw_mci_board *npd;

	npd = s3c_set_platdata(pd, sizeof(struct dw_mci_board),
			&exynos4_device_dwmci);

	if (!npd->init)
		npd->init = exynos4_dwmci_init;
	if (!npd->get_bus_wd)
		npd->get_bus_wd = exynos4_dwmci_get_bus_wd;
}

void __init s5p_otg_set_platdata(struct s5p_otg_platdata *pd)
{
	struct s5p_otg_platdata *npd;

	npd = s3c_set_platdata(pd, sizeof(struct s5p_otg_platdata),
		&s3c_device_usbgadget);

	if (!npd->phy_init)
		npd->phy_init = s5p_usb_phy_init;
	if (!npd->phy_exit)
		npd->phy_exit = s5p_usb_phy_exit;
}

void __init s3c_hsotg_set_platdata(struct s3c_hsotg_plat *pd)
{
    struct s3c_hsotg_plat *npd;

    npd = s3c_set_platdata(pd, sizeof(struct s3c_hsotg_plat),
                           &s3c_device_usb_hsotg);

    if (!npd->phy_init)
        npd->phy_init = s5p_usb_phy_init;
    if (!npd->phy_exit)
        npd->phy_exit = s5p_usb_phy_exit;
}

void __init s5p_ohci_set_platdata(struct s5p_ohci_platdata *pd)
{
	struct s5p_ohci_platdata *npd;

	npd = s3c_set_platdata(pd, sizeof(struct s5p_ohci_platdata),
			&s5p_device_ohci);

	if (!npd->phy_init)
		npd->phy_init = s5p_usb_phy_init;
	if (!npd->phy_exit)
		npd->phy_exit = s5p_usb_phy_exit;
}

void __init s5p_usbswitch_set_platdata(struct s5p_usbswitch_platdata *pd)
{
	struct s5p_usbswitch_platdata *npd;

	npd = s3c_set_platdata(pd, sizeof(struct s5p_usbswitch_platdata),
			&s5p_device_usbswitch);

	s5p_usbswitch_resource[0].start = gpio_to_irq(npd->gpio_host_detect);
	s5p_usbswitch_resource[0].end = gpio_to_irq(npd->gpio_host_detect);

	s5p_usbswitch_resource[1].start = gpio_to_irq(npd->gpio_device_detect);
	s5p_usbswitch_resource[1].end = gpio_to_irq(npd->gpio_device_detect);
}

void __init s3c_i2c0_set_platdata(struct s3c2410_platform_i2c *pd)
{
	struct s3c2410_platform_i2c *npd;

	if (!pd)
		pd = &default_i2c_data;

	npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c),
			       &s3c_device_i2c0);

	if (!npd->cfg_gpio)
		npd->cfg_gpio = s3c_i2c0_cfg_gpio;
}

static void __init goni_machine_init(void)
{
	/* Radio: call before I2C 1 registeration */
	goni_radio_init();

	/* I2C0 */
	s3c_i2c0_set_platdata(NULL);

	/* I2C1 */
	s3c_i2c1_set_platdata(NULL);
	i2c_register_board_info(1, i2c1_devs, ARRAY_SIZE(i2c1_devs));

	/* TSP: call before I2C 2 registeration */
	goni_tsp_init();

	/* I2C2 */
	s3c_i2c2_set_platdata(&i2c2_data);
	i2c_register_board_info(2, i2c2_devs, ARRAY_SIZE(i2c2_devs));

	/* PMIC */
	goni_pmic_init();
	i2c_register_board_info(AP_I2C_GPIO_PMIC_BUS_4, i2c_gpio_pmic_devs,
			ARRAY_SIZE(i2c_gpio_pmic_devs));
	/* SDHCI */
	goni_setup_sdhci();

	/* SOUND */
	goni_sound_init();
	i2c_register_board_info(AP_I2C_GPIO_BUS_5, i2c_gpio5_devs,
			ARRAY_SIZE(i2c_gpio5_devs));

	/* FB */
	s3c_fb_set_platdata(&goni_lcd_pdata);

	/* FIMC */
	s3c_set_platdata(&goni_fimc_md_platdata, sizeof(goni_fimc_md_platdata),
			 &s5p_device_fimc_md);

	goni_camera_init();

	/* SPI */
	spi_register_board_info(spi_board_info, ARRAY_SIZE(spi_board_info));

	/* KEYPAD */
	samsung_keypad_set_platdata(&keypad_data);

	clk_xusbxti.rate = 24000000;

	platform_add_devices(goni_devices, ARRAY_SIZE(goni_devices));
}

void __init samsung_pwm_set_platdata(struct samsung_pwm_platdata *pd)
{
	int i;

	BUG_ON(!pd);

	/*
	 * Each 5 PWM Timers have own platform_device, but
	 * only one platform_data is valid for all of PWMs
	 */
	for (i = 0 ; i < 5; i++)
		s3c_set_platdata(pd, sizeof(struct samsung_pwm_platdata),
				&s3c_device_timer[i]);
}

void __init exynos_dwmci_set_platdata(struct dw_mci_board *pd)
{
	struct dw_mci_board *npd = NULL;

	if ((soc_is_exynos4210()) ||
		soc_is_exynos4212() || soc_is_exynos4412()) {
		npd = s3c_set_platdata(pd, sizeof(struct dw_mci_board), &exynos_device_dwmci);
	} else {
		printk("dwmci platform data support only exynos4/5!\n");
#ifdef CONFIG_SLP
	npd = s3c_set_platdata(pd, sizeof(struct dw_mci_board),
			&exynos_device_dwmci);
#endif
	}

	if (npd) {
	if (!npd->init)
		npd->init = exynos_dwmci_init;
	if (!npd->get_bus_wd)
		npd->get_bus_wd = exynos_dwmci_get_bus_wd;
		if (!npd->set_io_timing)
			npd->set_io_timing = exynos_dwmci_set_io_timing;
	}
}

void __init s3c64xx_spi1_set_platdata(int (*cfg_gpio)(void), int src_clk_nr,
						int num_cs)
{
	/* Reject invalid configuration */
	if (!num_cs || src_clk_nr < 0) {
		pr_err("%s: Invalid SPI configuration\n", __func__);
		return;
	}

	pd.num_cs = num_cs;
	pd.src_clk_nr = src_clk_nr;
	pd.cfg_gpio = (cfg_gpio) ? cfg_gpio : s3c64xx_spi1_cfg_gpio;

	s3c_set_platdata(&pd, sizeof(pd), &s3c64xx_device_spi1);
}

void __init s3c24xx_fb_set_platdata(struct s3c2410fb_mach_info *pd)
{
	struct s3c2410fb_mach_info *npd;

	npd = s3c_set_platdata(pd, sizeof(*npd), &s3c_device_lcd);
	if (npd) {
		npd->displays = kmemdup(pd->displays,
			sizeof(struct s3c2410fb_display) * npd->num_displays,
			GFP_KERNEL);
		if (!npd->displays)
			printk(KERN_ERR "no memory for LCD display data\n");
	} else {
		printk(KERN_ERR "no memory for LCD platform data\n");
	}
}

void __init s5p_fimg2d_set_platdata(struct fimg2d_platdata *pd)
{
    struct fimg2d_platdata *npd;

    if (soc_is_exynos4210()) {
        s5p_fimg2d_resource[0].start = S5P_PA_FIMG2D_3X;
        s5p_fimg2d_resource[0].end = S5P_PA_FIMG2D_3X + SZ_4K - 1;
    }

    if (!pd)
        pd = &default_fimg2d_data;

    npd = s3c_set_platdata(pd, sizeof(struct fimg2d_platdata),
                           &s5p_device_fimg2d);
}

void __init s3c_i2c5_set_platdata(struct s3c2410_platform_i2c *pd)
{
	struct s3c2410_platform_i2c *npd;

	if (!pd) {
		pd = &touch_300k_i2c_data;
		pd->bus_num = 5;
	}

	npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c),
			       &s3c_device_i2c5);

	if (!npd->cfg_gpio)
		npd->cfg_gpio = s3c_i2c5_cfg_gpio;
}

void __init s3c_i2c7_set_platdata(struct s3c2410_platform_i2c *pd)
{
	struct s3c2410_platform_i2c *npd;

	if (!pd) {
		pd = &default_i2c_data;
		pd->bus_num = 7;
	}

	npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c),
			       &s3c_device_i2c7);

	if (!npd->cfg_gpio)
		npd->cfg_gpio = s3c_i2c7_cfg_gpio;
}

void __init s5p_ehci_set_platdata(struct s5p_ehci_platdata *pd)
{
	struct s5p_ehci_platdata *npd;

	npd = s3c_set_platdata(pd, sizeof(struct s5p_ehci_platdata),
			&s5p_device_ehci);

	if (!npd->phy_init)
		npd->phy_init = s5p_usb_phy_init;
	if (!npd->phy_exit)
		npd->phy_exit = s5p_usb_phy_exit;
	if (!npd->phy_suspend)
		npd->phy_suspend = s5p_usb_phy_suspend;
	if (!npd->phy_resume)
		npd->phy_resume = s5p_usb_phy_resume;
}