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;
}
void __init s5p_usbgadget_set_platdata(struct s5p_usbgadget_platdata *pd)
{
struct s5p_usbgadget_platdata *npd;
if (!pd)
pd = &default_gadget_pd;
npd = s3c_set_platdata(pd, sizeof(struct s5p_usbgadget_platdata),
&s3c_device_usbgadget);
if(!npd->phy_power)
npd->phy_power = s5p_usb_phy_power;
if (!npd->phy_init)
npd->phy_init = s5p_usb_phy_init;
if (!npd->phy_exit)
npd->phy_exit = s5p_usb_phy_exit;
}
void touch_s3c_i2c5_set_platdata(struct s3c2410_platform_i2c *pd, int check_value)
{
struct s3c2410_platform_i2c *npd;
if(check_value==0) // 100k
pd = &touch_100k_i2c_data;
else // 350k
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 s5p_i2c_hdmiphy_set_platdata(struct s3c2410_platform_i2c *pd)
{
if (!pd) {
pd = &default_i2c_data;
if (soc_is_exynos4210())
pd->bus_num = 8;
else if (soc_is_s5pv210())
pd->bus_num = 3;
else if (soc_is_exynos5250())
pd->bus_num = 8;
else
pd->bus_num = 0;
}
s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c),
&s5p_device_i2c_hdmiphy);
}
void __init s3c_nand_set_platdata(struct s3c2410_platform_nand *nand)
{
struct s3c2410_platform_nand *npd;
int size;
int ret;
/* note, if we get a failure in allocation, we simply drop out of the
* function. If there is so little memory available at initialisation
* time then there is little chance the system is going to run.
*/
npd = s3c_set_platdata(nand, sizeof(struct s3c2410_platform_nand),
&s3c_device_nand);
if (!npd)
return;
/* now see if we need to copy any of the nand set data */
size = sizeof(struct s3c2410_nand_set) * npd->nr_sets;
if (size) {
struct s3c2410_nand_set *from = npd->sets;
struct s3c2410_nand_set *to;
int i;
to = kmemdup(from, size, GFP_KERNEL);
npd->sets = to; /* set, even if we failed */
if (!to) {
printk(KERN_ERR "%s: no memory for sets\n", __func__);
return;
}
for (i = 0; i < npd->nr_sets; i++) {
ret = s3c_nand_copy_set(to);
if (ret) {
printk(KERN_ERR "%s: failed to copy set %d\n",
__func__, i);
return;
}
to++;
}
}
}
void __init s5p_hdmi_set_platdata(struct i2c_board_info *hdmiphy_info,
struct i2c_board_info *mhl_info, int mhl_bus)
{
struct s5p_hdmi_platform_data *pd = &s5p_hdmi_def_platdata;
if (soc_is_exynos4210())
pd->hdmiphy_bus = 8;
else if (soc_is_s5pv210())
pd->hdmiphy_bus = 3;
else
pd->hdmiphy_bus = 0;
pd->hdmiphy_info = hdmiphy_info;
pd->mhl_info = mhl_info;
pd->mhl_bus = mhl_bus;
s3c_set_platdata(pd, sizeof(struct s5p_hdmi_platform_data),
&s5p_device_hdmi);
}
void __init s3c64xx_spi2_set_platdata(int (*cfg_gpio)(void), int src_clk_nr,
int num_cs)
{
struct s3c64xx_spi_info pd;
/* 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_spi2_cfg_gpio;
#ifdef CONFIG_PL330_DMA
pd.filter = pl330_filter;
#endif
s3c_set_platdata(&pd, sizeof(pd), &s3c64xx_device_spi2);
}
static void __init jet_machine_init(void)
{
s3c_pm_init();
s3c_init_gpio(jet_gpio_table, ARRAY_SIZE(jet_gpio_table));
/* Register I2C devices */
s3c_i2c0_set_platdata(&jet_misc_i2c);
i2c_register_board_info(jet_misc_i2c.bus_num, jet_misc_i2c_devs,
ARRAY_SIZE(jet_misc_i2c_devs));
s3c_i2c1_set_platdata(&jet_cam_i2c);
i2c_register_board_info(jet_cam_i2c.bus_num, jet_cam_i2c_devs,
ARRAY_SIZE(jet_cam_i2c_devs));
i2c_register_board_info(jet_pmic_i2c.id, jet_pmic_i2c_devs,
ARRAY_SIZE(jet_pmic_i2c_devs));
i2c_register_board_info(jet_audio_i2c.id, jet_audio_i2c_devs,
ARRAY_SIZE(jet_audio_i2c_devs));
i2c_register_board_info(jet_touch_i2c.id, jet_touch_i2c_devs,
ARRAY_SIZE(jet_touch_i2c_devs));
s3c_fb_set_platdata(&jet_lcd_pdata);
s3c_sdhci0_set_platdata(&jet_hsmmc0_pdata);
s3c_sdhci2_set_platdata(&jet_hsmmc2_pdata);
samsung_keypad_set_platdata(&jet_keypad_pdata);
s3c_set_platdata(&jet_onenand_pdata, sizeof(jet_onenand_pdata),
&s3c_device_onenand);
/* Register platform devices */
platform_add_devices(jet_devices, ARRAY_SIZE(jet_devices));
platform_add_devices(jet_mod_devices, ARRAY_SIZE(jet_mod_devices));
#ifdef CONFIG_ANDROID_PMEM
/* Register PMEM devices */
jet_add_mem_devices();
#endif
regulator_has_full_constraints();
}
void __init s3c64xx_spi2_set_platdata(struct s3c64xx_spi_info *pd,
int src_clk_nr, int num_cs)
{
if (!pd) {
pr_err("%s:Need to pass platform data\n", __func__);
return;
}
/* 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;
if (!pd->cfg_gpio)
pd->cfg_gpio = s3c64xx_spi2_cfg_gpio;
s3c_set_platdata(pd, sizeof(*pd), &s3c64xx_device_spi2);
}
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;
#if defined(CONFIG_LINK_DEVICE_HSIC) || defined(CONFIG_LINK_DEVICE_USB)
if (!npd->noti_host_states)
npd->noti_host_states = set_host_states;
if (!npd->get_cp_active_state)
npd->get_cp_active_state = get_cp_active_state;
#endif
}
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_res[0].start = gpio_to_irq(npd->gpio_host_detect);
s5p_usbswitch_res[0].end = gpio_to_irq(npd->gpio_host_detect);
s5p_usbswitch_res[0].flags = IORESOURCE_IRQ;
s5p_usbswitch_res[1].start = gpio_to_irq(npd->gpio_device_detect);
s5p_usbswitch_res[1].end = gpio_to_irq(npd->gpio_device_detect);
s5p_usbswitch_res[1].flags = IORESOURCE_IRQ;
s5p_usbswitch_res[2].start = gpio_to_irq(npd->gpio_drd_host_detect);
s5p_usbswitch_res[2].end = gpio_to_irq(npd->gpio_drd_host_detect);
s5p_usbswitch_res[2].flags = IORESOURCE_IRQ;
s5p_usbswitch_res[3].start = gpio_to_irq(npd->gpio_drd_device_detect);
s5p_usbswitch_res[3].end = gpio_to_irq(npd->gpio_drd_device_detect);
s5p_usbswitch_res[3].flags = IORESOURCE_IRQ;
#ifdef CONFIG_USB_EHCI_S5P
npd->ehci_dev = &s5p_device_ehci.dev;
#endif
#ifdef CONFIG_USB_OHCI_S5P
npd->ohci_dev = &s5p_device_ohci.dev;
#endif
#ifdef CONFIG_USB_XHCI_EXYNOS
npd->xhci_dev = &exynos_device_xhci.dev;
#endif
#ifdef CONFIG_USB_S3C_OTGD
npd->s3c_udc_dev = &s3c_device_usbgadget.dev;
#endif
#ifdef CONFIG_EXYNOS_DEV_SS_UDC
npd->exynos_udc_dev = &exynos_device_ss_udc.dev;
#endif
}
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;
#if defined(CONFIG_MACH_DELOSLTE_KOR_SKT)
/* Sqrxtune [13:11] 6b100 : -5% */
npd->phy_tune_mask |= (0x7 << 11);
npd->phy_tune |= (0x4 << 11);
#else
/* Sqrxtune [13:11] 6b110 : -15% */
npd->phy_tune_mask |= (0x7 << 11);
npd->phy_tune |= (0x6 << 11);
#endif
/* Txvreftune [ 3: 0] 9b1001 : +12% */
npd->phy_tune_mask |= (0xf);
npd->phy_tune |= (0x9);
}
void __init s3c64xx_spi2_set_platdata(int (*cfg_gpio)(void), int src_clk_nr,
int num_cs)
{
struct s3c64xx_spi_info pd;
/* 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_spi2_cfg_gpio;
pd.dma_tx = (void *)DMACH_SPI2_TX;
pd.dma_rx = (void *)DMACH_SPI2_RX;
#if defined(CONFIG_PL330_DMA)
pd.filter = pl330_filter;
#elif defined(CONFIG_S3C64XX_PL080)
pd.filter = pl08x_filter_id;
#endif
s3c_set_platdata(&pd, sizeof(pd), &s3c64xx_device_spi2);
}
void __init s3c24xx_ts_set_platdata(struct s3c2410_ts_mach_info *hard_s3c2410ts_info)
{
s3c_set_platdata(hard_s3c2410ts_info,
sizeof(struct s3c2410_ts_mach_info), &s3c_device_ts);
}
void __init s3c24xx_mci_set_platdata(struct s3c24xx_mci_pdata *pdata)
{
s3c_set_platdata(pdata, sizeof(struct s3c24xx_mci_pdata),
&s3c_device_sdi);
}
void __init s3c64xx_onenand1_set_platdata(struct onenand_platform_data *pdata)
{
s3c_set_platdata(pdata, sizeof(struct onenand_platform_data),
&s3c64xx_device_onenand1);
}
