static void __init anw6410_machine_init(void)
{
s3c_fb_set_platdata(&anw6410_lcd_pdata);
gpio_request(S3C64XX_GPF(1), "panel power");
gpio_request(S3C64XX_GPF(4), "LCD backlight");
anw6410_dm9000_enable();
platform_add_devices(anw6410_devices, ARRAY_SIZE(anw6410_devices));
}
static void camif_get_gpios(int *gpio_start, int *gpio_reset)
{
#ifdef CONFIG_ARCH_S3C24XX
*gpio_start = S3C2410_GPJ(0);
*gpio_reset = S3C2410_GPJ(12);
#else
/* s3c64xx */
*gpio_start = S3C64XX_GPF(0);
*gpio_reset = S3C64XX_GPF(3);
#endif
}
static void crag6410_lcd_power_set(struct plat_lcd_data *pd, unsigned int power)
{
pr_debug("%s: setting power %d\n", __func__, power);
if (power) {
gpio_set_value(S3C64XX_GPB(0), 1);
msleep(1);
s3c_gpio_cfgpin(S3C64XX_GPF(14), S3C_GPIO_SFN(2));
} else {
gpio_direction_output(S3C64XX_GPF(14), 0);
gpio_set_value(S3C64XX_GPB(0), 0);
}
}
static int smdk6410_backlight_init(struct device *dev)
{
int ret;
ret = gpio_request(S3C64XX_GPF(15), "Backlight");
if (ret) {
printk(KERN_ERR "failed to request GPF for PWM-OUT1\n");
return ret;
}
/* Configure GPIO pin with S3C64XX_GPF15_PWM_TOUT1 */
s3c_gpio_cfgpin(S3C64XX_GPF(15), S3C_GPIO_SFN(2));
return 0;
}
static void __init smdk6410_machine_init(void)
{
s3c_i2c0_set_platdata(NULL);
s3c_i2c1_set_platdata(NULL);
s3c_fb_set_platdata(&smdk6410_lcd_pdata);
gpio_request(S3C64XX_GPN(5), "LCD power");
gpio_request(S3C64XX_GPF(13), "LCD power");
gpio_request(S3C64XX_GPF(15), "LCD power");
i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
platform_add_devices(smdk6410_devices, ARRAY_SIZE(smdk6410_devices));
}
static void smdk6410_lcd_power_set(struct plat_lcd_data *pd,
unsigned int power)
{
if (power) {
gpio_direction_output(S3C64XX_GPF(13), 1);
/* fire nRESET on power up */
gpio_direction_output(S3C64XX_GPN(5), 0);
msleep(10);
gpio_direction_output(S3C64XX_GPN(5), 1);
msleep(1);
} else {
gpio_direction_output(S3C64XX_GPF(13), 0);
}
}
static void s3c210_set_timer1(unsigned long Val)
{
#if 0
//#ifdef CONFIG_S3C210_PWM
s3c_gpio_cfgpin(S3C64XX_GPF(15),S3C64XX_GPF15_PWM_TOUT1);
pwm_config(beeper->pwm, beeper->step_ns*Val, beeper->period);
#else
unsigned long tcon;//用于存放时钟控制寄存器的数值
unsigned long tcnt;//用于存放TCNTB1的数值
unsigned long tcmp;//用于存放TCMPB1的数值
unsigned long tcfg1;//用于存放定时器配置寄存器1的数值
unsigned long tcfg0;//用于存放定时器配置寄存器0的数值
unsigned char i;
tcnt = 0xffffffff; /* 默认的TCTB1数值*/
/* 读取TCON，TCFG0以及TCFG1寄存器的数值*/
tcon = __raw_readl(S3C2410_TCON);
tcfg1 =__raw_readl(S3C2410_TCFG1);
tcfg0 =__raw_readl(S3C2410_TCFG0);
/*定时器输入频率 = PCLK / ( {预分频数值 + 1} ) / {分割数值}
*{预分频数值} = 1~255，由TCFG0配置寄存器来配置
*{分割数值} = 1, 2, 4, 8, 16, TCLK，由TCFG1配置寄存器来配置
*/
//配置GPF15为输出
for (i = 0; i < sizeof(gpio_table)/sizeof(unsigned long); i++)
{
s3c_gpio_cfgpin(gpio_table[i], gpio_cfg_table[i]);
s3c_gpio_setpull(gpio_table[i], S3C_GPIO_PULL_NONE);
}
//清零TCFG1[4:7]
tcfg1 &= ~S3C2410_TCFG1_MUX1_MASK;
//设置分割值为2
tcfg1 |= S3C2410_TCFG1_MUX1_DIV2;//set [4:7]== 1/2
//清零预分频位TCFG0[0:7]
tcfg0 &= ~S3C2410_TCFG_PRESCALER0_MASK;
//设置预分频数值，这里是254
// tcfg0 |= (PRESCALER) << 0;//backlight pwm0
//清零TCON[8:10]
tcon &= ~(7<<8); //set bit [8:10] to zero
//设置定时器工作模式为自动加载模式(auto-reload)
tcon |= S3C2410_TCON_T1RELOAD;
//将配置好的TCON，TCFG0，TCFG1的数值写回寄存器
__raw_writel(tcfg1, S3C2410_TCFG1);
// __raw_writel(tcfg0, S3C2410_TCFG0);//backlight pwm0 div
__raw_writel(tcon, S3C2410_TCON);
//准备更新TCMPB1数值，先置1 TCON[9]
tcon |= S3C2410_TCON_T1MANUALUPD;
__raw_writel(tcon, S3C2410_TCON);
//TCNTB1==200，改数值决定了PWM的频率
tcnt = 101*255;
__raw_writel(tcnt, S3C2410_TCNTB(1));
//改变TCMPB1的数值，改数值决定PWM的频宽
tcmp = Val*255;
__raw_writel(tcmp, S3C2410_TCMPB(1));
#endif
}
static void s3c210_beep_off(void)
{
#if 0
//#ifdef CONFIG_S3C210_PWM
s3c_gpio_cfgpin(S3C64XX_GPF(15),S3C64XX_GPF15_INPUT);
pwm_disable(beeper->pwm);
#else
unsigned long tcon;
int err;
//将GPD[1]引脚设置为输入
gpio_free(gpio_table [0]);
err = gpio_request(gpio_table[0], "GPD0_1");
if(err)
{
printk(KERN_ERR "failed to request GPD0_1 for LVDS PWDN pin\n");
//return err;
}
s3c_gpio_cfgpin(gpio_table [0],S3C_GPIO_SFN(0));
gpio_direction_output(gpio_table [0],0);
//s3c_gpio_setpin(gpio_table [0],0);
//将定时器控制寄存器中的TIMER1开始位设置为0
tcon = __raw_readl(S3C2410_TCON);
tcon &= ~S3C2410_TCON_T1START;
tcon &= ~S3C2410_TCON_T1MANUALUPD;//停止更新功能
__raw_writel(tcon, S3C2410_TCON); //stop the timer1
#endif
}
/* GPF1 = LCD panel power
* GPF4 = LCD backlight control
*/
static void anw6410_lcd_power_set(struct plat_lcd_data *pd,
unsigned int power)
{
if (power) {
anw6410_extdev_status |= (ANW6410_EN_LCD << 16);
__raw_writel(anw6410_extdev_status, ANW6410_VA_EXTDEV);
gpio_direction_output(S3C64XX_GPF(1), 1);
gpio_direction_output(S3C64XX_GPF(4), 1);
} else {
anw6410_extdev_status &= ~(ANW6410_EN_LCD << 16);
__raw_writel(anw6410_extdev_status, ANW6410_VA_EXTDEV);
gpio_direction_output(S3C64XX_GPF(1), 0);
gpio_direction_output(S3C64XX_GPF(4), 0);
}
}
static void __init hmt_machine_init(void)
{
s3c_i2c0_set_platdata(NULL);
s3c_fb_set_platdata(&hmt_lcd_pdata);
s3c_nand_set_platdata(&hmt_nand_info);
gpio_request(S3C64XX_GPC(7), "usb power");
gpio_direction_output(S3C64XX_GPC(7), 0);
gpio_request(S3C64XX_GPM(0), "usb power");
gpio_direction_output(S3C64XX_GPM(0), 1);
gpio_request(S3C64XX_GPK(7), "usb power");
gpio_direction_output(S3C64XX_GPK(7), 1);
gpio_request(S3C64XX_GPF(13), "usb power");
gpio_direction_output(S3C64XX_GPF(13), 1);
platform_add_devices(hmt_devices, ARRAY_SIZE(hmt_devices));
}
static void __init smdk6410_machine_init(void)
{
u32 cs1;
s3c_i2c0_set_platdata(NULL);
s3c_i2c1_set_platdata(NULL);
s3c_fb_set_platdata(&smdk6410_lcd_pdata);
samsung_keypad_set_platdata(&smdk6410_keypad_data);
s3c24xx_ts_set_platdata(&s3c_ts_platform);
/* configure nCS1 width to 16 bits */
cs1 = __raw_readl(S3C64XX_SROM_BW) &
~(S3C64XX_SROM_BW__CS_MASK << S3C64XX_SROM_BW__NCS1__SHIFT);
cs1 |= ((1 << S3C64XX_SROM_BW__DATAWIDTH__SHIFT) |
(1 << S3C64XX_SROM_BW__WAITENABLE__SHIFT) |
(1 << S3C64XX_SROM_BW__BYTEENABLE__SHIFT)) <<
S3C64XX_SROM_BW__NCS1__SHIFT;
__raw_writel(cs1, S3C64XX_SROM_BW);
/* set timing for nCS1 suitable for ethernet chip */
__raw_writel((0 << S3C64XX_SROM_BCX__PMC__SHIFT) |
(6 << S3C64XX_SROM_BCX__TACP__SHIFT) |
(4 << S3C64XX_SROM_BCX__TCAH__SHIFT) |
(1 << S3C64XX_SROM_BCX__TCOH__SHIFT) |
(0xe << S3C64XX_SROM_BCX__TACC__SHIFT) |
(4 << S3C64XX_SROM_BCX__TCOS__SHIFT) |
(0 << S3C64XX_SROM_BCX__TACS__SHIFT), S3C64XX_SROM_BC1);
gpio_request(S3C64XX_GPN(5), "LCD power");
gpio_request(S3C64XX_GPF(13), "LCD power");
gpio_request(S3C64XX_GPF(15), "LCD power");
i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
s3c_ide_set_platdata(&smdk6410_ide_pdata);
platform_add_devices(smdk6410_devices, ARRAY_SIZE(smdk6410_devices));
}
static void __init crag6410_machine_init(void)
{
/* Open drain IRQs need pullups */
s3c_gpio_setpull(S3C64XX_GPM(0), S3C_GPIO_PULL_UP);
s3c_gpio_setpull(S3C64XX_GPN(0), S3C_GPIO_PULL_UP);
gpio_request(S3C64XX_GPB(0), "LCD power");
gpio_direction_output(S3C64XX_GPB(0), 0);
gpio_request(S3C64XX_GPF(14), "LCD PWM");
gpio_direction_output(S3C64XX_GPF(14), 0); /* turn off */
gpio_request(S3C64XX_GPB(1), "SD power");
gpio_direction_output(S3C64XX_GPB(1), 0);
gpio_request(S3C64XX_GPF(10), "nRESETSEL");
gpio_direction_output(S3C64XX_GPF(10), 1);
s3c_sdhci0_set_platdata(&crag6410_hsmmc0_pdata);
s3c_sdhci2_set_platdata(&crag6410_hsmmc2_pdata);
s3c_i2c0_set_platdata(&i2c0_pdata);
s3c_i2c1_set_platdata(&i2c1_pdata);
s3c_fb_set_platdata(&crag6410_lcd_pdata);
dwc2_hsotg_set_platdata(&crag6410_hsotg_pdata);
i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
samsung_keypad_set_platdata(&crag6410_keypad_data);
s3c64xx_spi0_set_platdata(NULL, 0, 2);
pwm_add_table(crag6410_pwm_lookup, ARRAY_SIZE(crag6410_pwm_lookup));
platform_add_devices(crag6410_devices, ARRAY_SIZE(crag6410_devices));
gpio_led_register_device(-1, &gpio_leds_pdata);
regulator_has_full_constraints();
s3c64xx_pm_init();
}
static void backlight_ctrl(s32 value)
{
int err, ret;
if (value) {
/* backlight ON */
if (lcd_power == OFF) {
ret = lcd_power_ctrl(ON);
if (ret != 0) {
printk(KERN_ERR "lcd power on control is failed\n");
return;
}
}
if (gpio_is_valid(S3C64XX_GPF(15))) {
err = gpio_request(S3C64XX_GPF(15), "GPF");
if (err) {
printk(KERN_ERR "failed to request GPF for "
"lcd backlight control\n");
}
gpio_direction_output(S3C64XX_GPF(15), 1);
}
s3cfb_set_brightness((int)(value/3));
}
else {
ret = lcd_power_ctrl(OFF);
if (ret != 0) {
printk(KERN_ERR "lcd power off control is failed\n");
}
/* backlight OFF */
if (gpio_is_valid(S3C64XX_GPF(15))) {
err = gpio_request(S3C64XX_GPF(15), "GPF");
if (err) {
printk(KERN_ERR "failed to request GPF for "
"lcd backlight control\n");
}
gpio_direction_output(S3C64XX_GPF(15), 0);
}
}
gpio_free(S3C64XX_GPF(15));
}
/*
*函数用于在设定好定时器1的PWM模式后，
*开始生效定时器1
*/
static void s3c210_beep_start(void)
{
//#ifdef CONFIG_S3C210_PWM
#if 0
s3c_gpio_cfgpin(S3C64XX_GPF(15),S3C64XX_GPF15_PWM_TOUT1);
pwm_enable(beeper->pwm);
#else
unsigned long tcon;
unsigned char i;
for (i = 0; i < sizeof(gpio_table)/sizeof(unsigned long); i++)
{
s3c_gpio_cfgpin(gpio_table[i], gpio_cfg_table[i]);
s3c_gpio_setpull(gpio_table[i], S3C_GPIO_PULL_NONE);
}
tcon = __raw_readl(S3C2410_TCON);//读取时钟控制寄存器
tcon |= S3C2410_TCON_T1START;//开始位置1,让定时器开始工作 定时器1
tcon &= ~S3C2410_TCON_T1MANUALUPD;//之前已经设置好了TCNTB1 以及 TCMPB1，这里无须任何操作
__raw_writel(tcon, S3C2410_TCON);//将设置写回寄存器
#endif
}
static int smartq_bl_init(struct device *dev)
{
s3c_gpio_cfgpin(S3C64XX_GPF(15), S3C_GPIO_SFN(2));
return 0;
}
#ifdef CONFIG_SMDK6410_WM1190_EV1
{ I2C_BOARD_INFO("wm8350", 0x1a),
.platform_data = &smdk6410_wm8350_pdata,
.irq = S3C_EINT(12),
},
#endif
};
static struct i2c_board_info i2c_devs1[] __initdata = {
{ I2C_BOARD_INFO("24c128", 0x57), }, /* Samsung S524AD0XD1 */
};
/* LCD Backlight data */
static struct samsung_bl_gpio_info smdk6410_bl_gpio_info = {
.no = S3C64XX_GPF(15),
.func = S3C_GPIO_SFN(2),
};
static struct pwm_lookup smdk6410_pwm_lookup[] = {
PWM_LOOKUP("samsung-pwm", 1, "pwm-backlight.0", NULL, 78770,
PWM_POLARITY_NORMAL),
};
static struct platform_pwm_backlight_data smdk6410_bl_data = {
.enable_gpio = -1,
};
static struct dwc2_hsotg_plat smdk6410_hsotg_pdata;
static void __init smdk6410_map_io(void)
.get_config = s3c_gpio_getcfg_s3c24xx,
.set_pull = s3c_gpio_setpull_updown,
.get_pull = s3c_gpio_getpull_updown,
};
int s3c64xx_gpio2int_gpn(struct gpio_chip *chip, unsigned pin)
{
return IRQ_EINT(0) + pin;
}
static struct s3c_gpio_chip gpio_2bit[] = {
{
.base = S3C64XX_GPF_BASE,
.config = &gpio_2bit_cfg_eint11,
.chip = {
.base = S3C64XX_GPF(0),
.ngpio = S3C64XX_GPIO_F_NR,
.label = "GPF",
},
}, {
.base = S3C64XX_GPI_BASE,
.config = &gpio_2bit_cfg_noint,
.chip = {
.base = S3C64XX_GPI(0),
.ngpio = S3C64XX_GPIO_I_NR,
.label = "GPI",
},
}, {
.base = S3C64XX_GPJ_BASE,
.config = &gpio_2bit_cfg_noint,
.chip = {
static void smdk6410_backlight_exit(struct device *dev)
{
s3c_gpio_cfgpin(S3C64XX_GPF(15), S3C_GPIO_OUTPUT);
gpio_free(S3C64XX_GPF(15));
}
int s3cfb_set_gpio(void)
{
unsigned long val;
int i, err;
#if 0
/* See mach-smdk6410.c:smdk6410_map_io() - S3C64XX_MODEM_MIFPCON */
/* Must be '0' for Normal-path instead of By-pass */
writel(0x0, S3C_HOSTIFB_MIFPCON);
#endif
/* enable clock to LCD */
val = readl(S3C_HCLK_GATE);
val |= S3C_CLKCON_HCLK_LCD;
writel(val, S3C_HCLK_GATE);
/* select TFT LCD type (RGB I/F) */
val = readl(S3C64XX_SPCON);
val &= ~0x3;
val |= (1 << 0);
writel(val, S3C64XX_SPCON);
/* VD */
for (i = 0; i < 16; i++)
s3c_gpio_cfgpin(S3C64XX_GPI(i), S3C_GPIO_SFN(2));
for (i = 0; i < 12; i++)
s3c_gpio_cfgpin(S3C64XX_GPJ(i), S3C_GPIO_SFN(2));
/* backlight ON */
//printk("oPEN LCD BACKLIGHT1.\n");
if (gpio_is_valid(S3C64XX_GPF(14))) { //NOTE: orign GPF15 here
err = gpio_request(S3C64XX_GPF(14), "GPF");
if (err) {
printk(KERN_ERR "failed to request GPF for "
"lcd backlight control\n");
return err;
}
gpio_direction_output(S3C64XX_GPF(14), 1);
gpio_set_value(S3C64XX_GPF(14), 1);
}
//printk("oPEN LCD BACKLIGHT2.\n");
if (gpio_is_valid(S3C64XX_GPE(0))) {
err = gpio_request(S3C64XX_GPE(0), "GPE");
if (err) {
printk(KERN_ERR "failed to request GPE for "
"lcd reset control\n");
return err;
}
gpio_direction_output(S3C64XX_GPE(0), 1);
}
gpio_set_value(S3C64XX_GPE(0), 1);
gpio_free(S3C64XX_GPE(0));
/* module reset */
/*if (gpio_is_valid(S3C64XX_GPN(5))) {
err = gpio_request(S3C64XX_GPN(5), "GPN");
if (err) {
printk(KERN_ERR "failed to request GPN for "
"lcd reset control\n");
return err;
}
gpio_direction_output(S3C64XX_GPN(5), 1);
}
mdelay(100);
gpio_set_value(S3C64XX_GPN(5), 0);
mdelay(10);
gpio_set_value(S3C64XX_GPN(5), 1);
mdelay(10);
*/
#ifndef CONFIG_BACKLIGHT_PWM
gpio_free(S3C64XX_GPF(14));
#endif
//gpio_free(S3C64XX_GPN(5));
return 0;
}
s3c64xx_init_io(NULL, 0);
s3c24xx_init_clocks(12000000);
s3c24xx_init_uarts(crag6410_uartcfgs, ARRAY_SIZE(crag6410_uartcfgs));
/* LCD type and Bypass set by bootloader */
}
static struct s3c_sdhci_platdata crag6410_hsmmc2_pdata = {
.max_width = 4,
.cd_type = S3C_SDHCI_CD_PERMANENT,
};
static struct s3c_sdhci_platdata crag6410_hsmmc1_pdata = {
.max_width = 4,
.cd_type = S3C_SDHCI_CD_GPIO,
.ext_cd_gpio = S3C64XX_GPF(11),
};
static void crag6410_cfg_sdhci0(struct platform_device *dev, int width)
{
/* Set all the necessary GPG pins to special-function 2 */
s3c_gpio_cfgrange_nopull(S3C64XX_GPG(0), 2 + width, S3C_GPIO_SFN(2));
/* force card-detected for prototype 0 */
s3c_gpio_setpull(S3C64XX_GPG(6), S3C_GPIO_PULL_DOWN);
}
static struct s3c_sdhci_platdata crag6410_hsmmc0_pdata = {
.max_width = 4,
.cd_type = S3C_SDHCI_CD_INTERNAL,
.cfg_gpio = crag6410_cfg_sdhci0,
static void __init mini6410_machine_init(void)
{
u32 cs1;
s3c_i2c0_set_platdata(NULL);
#ifdef CONFIG_S3C_DEV_I2C1
s3c_i2c1_set_platdata(NULL);
#endif
s3c_fb_set_platdata(&mini6410_lcd_pdata);
#ifdef CONFIG_SAMSUNG_DEV_TS
s3c24xx_ts_set_platdata(&s3c_ts_platform);
#endif
#ifdef CONFIG_TOUCHSCREEN_MINI6410
s3c_ts_set_platdata(&s3c_ts_platform);
#endif
s3c_sdhci0_set_platdata(&mini6410_hsmmc0_pdata);
s3c_sdhci1_set_platdata(&mini6410_hsmmc1_pdata);
#ifdef CONFIG_MTD_NAND_S3C
s3c_device_nand.name = "s3c6410-nand";
#endif
s3c_nand_set_platdata(&mini6410_nand_info);
s3c64xx_ac97_setup_gpio(0);
/* configure nCS1 width to 16 bits */
cs1 = __raw_readl(S3C64XX_SROM_BW) &
~(S3C64XX_SROM_BW__CS_MASK << S3C64XX_SROM_BW__NCS1__SHIFT);
cs1 |= ((1 << S3C64XX_SROM_BW__DATAWIDTH__SHIFT) |
(1 << S3C64XX_SROM_BW__WAITENABLE__SHIFT) |
(1 << S3C64XX_SROM_BW__BYTEENABLE__SHIFT)) <<
S3C64XX_SROM_BW__NCS1__SHIFT;
__raw_writel(cs1, S3C64XX_SROM_BW);
/* set timing for nCS1 suitable for ethernet chip */
__raw_writel((0 << S3C64XX_SROM_BCX__PMC__SHIFT) |
(6 << S3C64XX_SROM_BCX__TACP__SHIFT) |
(4 << S3C64XX_SROM_BCX__TCAH__SHIFT) |
(1 << S3C64XX_SROM_BCX__TCOH__SHIFT) |
(0xe << S3C64XX_SROM_BCX__TACC__SHIFT) |
(4 << S3C64XX_SROM_BCX__TCOS__SHIFT) |
(0 << S3C64XX_SROM_BCX__TACS__SHIFT), S3C64XX_SROM_BC1);
gpio_request(S3C64XX_GPN(5), "LCD power");
gpio_request(S3C64XX_GPF(13), "LCD power");
gpio_request(S3C64XX_GPF(15), "LCD power");
if (ARRAY_SIZE(i2c_devs0)) {
i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
}
if (ARRAY_SIZE(i2c_devs1)) {
i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
}
#ifdef CONFIG_S3C64XX_DEV_FIMC0
s3c_fimc0_set_platdata(NULL);
#endif
#ifdef CONFIG_S3C64XX_DEV_FIMC1
s3c_fimc1_set_platdata(NULL);
#endif
platform_add_devices(mini6410_devices, ARRAY_SIZE(mini6410_devices));
platform_device_register_simple("GPIODEV", 0, &gpiodev_resource, 1); //GPIO resource MAP
if ((platform_device_register(&mini6410_leds))!=0)
printk( "Failed to register LEDs.\n");
else
printk( "LEDs initialized.\n");
#ifdef CONFIG_VIDEO_SAMSUNG
create_proc_read_entry("videomem", 0, NULL, s3c_media_read_proc, NULL);
#endif
}
#endif
#if defined(CONFIG_SPI_CNTRLR_0)
static struct s3c_spi_pdata s3c_slv_pdata_0[] __initdata = {
[0] = { /* Slave-0 */
.cs_level = CS_FLOAT,
.cs_pin = S3C64XX_GPC(3),
.cs_mode = S3C64XX_GPC_OUTPUT(3),
.cs_set = s3c_cs_set,
.cs_config = s3c_cs_config,
.cs_suspend = s3c_cs_suspend,
.cs_resume = s3c_cs_resume,
},
[1] = { /* Slave-1 */
.cs_level = CS_FLOAT,
.cs_pin = S3C64XX_GPF(13),
.cs_mode = S3C64XX_GPF_OUTPUT(13),
.cs_set = s3c_cs_setF13,
.cs_config = s3c_cs_configF13,
.cs_suspend = s3c_cs_suspend,
.cs_resume = s3c_cs_resume,
},
};
#endif
#if defined(CONFIG_SPI_CNTRLR_1)
static struct s3c_spi_pdata s3c_slv_pdata_1[] __initdata = {
[0] = { /* Slave-0 */
.cs_level = CS_FLOAT,
.cs_pin = S3C64XX_GPC(7),
.cs_mode = S3C64XX_GPC_OUTPUT(7),
