ssize_t Device_Write(struct file *filp, const char *buffer, size_t length, loff_t *offset)
{
static int i;
int ret;
ret = gpio_request(S5PV210_GPH0(5), "GPH05");
printk(Kernel_Alert "GPIO request failed for GPH0 %d\n", ret);
ret = gpio_request(S5PV210_GPB(4), "GPB");
printk(Kernel_Alert "GPIO request failed for GPB4 %d\n", ret);
ret = gpio_request(S5PV210_GPB(5), "GPB");
printk(Kernel_Alert "GPIO request failed for GPB5 %d\n", ret);
ret = gpio_request(S5PV210_GPB(6), "GPB");
printk(Kernel_Alert "GPIO request failed for GPB6 %d\n", ret);
ret = gpio_request(S5PV210_GPB(7), "GPB");
printk(Kernel_Alert "GPIO request failed for GPB7 %d\n", ret);
gpio_set_value(GPIO_LED_Strip1, 0);
mdelay(600);
gpio_set_value(GPIO_LED_Strip1, 1);
mdelay(600);
return 0;
}
int s3cfb_backlight_on(struct platform_device *pdev)
{
int err;
err = gpio_request(S5PV210_GPB(2), "GPB");
if (err) {
printk(KERN_ERR "failed to request GPB for "
"lcd backlight control\n");
return err;
}
#ifdef CONFIG_TYPE_PROTO3
err = gpio_request(S5PV210_GPD0(1), "GPD0");
if (err) {
printk(KERN_ERR "failed to request GPD0 for "
"lcd backlight control\n");
return err;
}
#endif
gpio_direction_output(S5PV210_GPB(2), 1); /* LED_EN (SPI1_MOSI) */
#ifdef CONFIG_TYPE_PROTO3
/* LCD_PWR_EN is only for Proto3 */
gpio_direction_output(S5PV210_GPD0(1), 1);
mdelay(10);
#endif
gpio_free(S5PV210_GPB(2));
#ifdef CONFIG_TYPE_PROTO3
gpio_free(S5PV210_GPD0(1));
#endif
return 0;
}
int s3cfb_backlight_on(struct platform_device *pdev)
{
int err;
err = gpio_request(S5PV210_GPD0(0), "GPD0");
if (err) {
printk(KERN_ERR "failed to request GPD0 for "
"lcd backlight control\n");
return err;
}
err = gpio_request(S5PV210_GPB(2), "GPB");
if (err) {
printk(KERN_ERR "failed to request GPB for "
"lcd backlight control\n");
return err;
}
gpio_direction_output(S5PV210_GPD0(0), 1); /* BL pwm High */
gpio_direction_output(S5PV210_GPB(2), 1); /* LED_EN (SPI1_MOSI) */
gpio_free(S5PV210_GPD0(0));
gpio_free(S5PV210_GPB(2));
return 0;
}
int s3cfb_backlight_off(struct platform_device *pdev)
{
#if !defined(CONFIG_BACKLIGHT_PWM)
int err;
err = gpio_request(S5PV210_GPD0(0), "GPD0");
if (err) {
printk(KERN_ERR "failed to request GPD0 for "
"lcd backlight control\n");
return err;
}
err = gpio_request(S5PV210_GPB(2), "GPB");
if (err) {
printk(KERN_ERR "failed to request GPB for "
"lcd LED_EN control\n");
return err;
}
gpio_direction_output(S5PV210_GPD0(3), 0);
gpio_direction_output(S5PV210_GPB(2), 0);
gpio_free(S5PV210_GPD0(0));
gpio_free(S5PV210_GPB(2));
#endif
return 0;
}
int s3c64xx_spi1_cfg_gpio(struct platform_device *dev)
{
s3c_gpio_cfgpin(S5PV210_GPB(4), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PV210_GPB(4), S3C_GPIO_PULL_UP);
s3c_gpio_cfgall_range(S5PV210_GPB(6), 2,
S3C_GPIO_SFN(2), S3C_GPIO_PULL_UP);
return 0;
}
int s3c64xx_spi1_cfg_gpio(void)
{
s3c_gpio_cfgpin(S5PV210_GPB(4), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PV210_GPB(4), S3C_GPIO_PULL_UP);
s3c_gpio_cfgall_range(S5PV210_GPB(6), 2,
S3C_GPIO_SFN(2), S3C_GPIO_PULL_UP);
return 0;
}
static int lms350df_reset_lcd(struct platform_device *pdev)
{
int err;
err = gpio_request(S5PV210_GPB(6), "GPB6");
if (err) {
printk(KERN_ERR "failed to request GPB6 for "
"lcd reset control\n");
return err;
}
gpio_direction_output(S5PV210_GPB(6), 1); mdelay(10);
gpio_set_value(S5PV210_GPB(6), 0); mdelay(10);
gpio_set_value(S5PV210_GPB(6), 1); mdelay(10);
gpio_free(S5PV210_GPB(6));
return 0;
}
void s3cfb_cfg_gpio(struct platform_device *pdev)
{
int i;
for (i = 0; i < 8; i++) {
s3c_gpio_cfgpin(S5PV210_GPF0(i), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PV210_GPF0(i), S3C_GPIO_PULL_NONE);
}
for (i = 0; i < 8; i++) {
s3c_gpio_cfgpin(S5PV210_GPF1(i), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PV210_GPF1(i), S3C_GPIO_PULL_NONE);
}
for (i = 0; i < 8; i++) {
s3c_gpio_cfgpin(S5PV210_GPF2(i), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PV210_GPF2(i), S3C_GPIO_PULL_NONE);
}
for (i = 0; i < 4; i++) {
s3c_gpio_cfgpin(S5PV210_GPF3(i), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PV210_GPF3(i), S3C_GPIO_PULL_NONE);
}
/* mDNIe SEL: why we shall write 0x2 ? */
writel(0x2, S5P_MDNIE_SEL);
/* drive strength to max */
writel(0xffffffff, S5P_VA_GPIO + 0x12c);
writel(0xffffffff, S5P_VA_GPIO + 0x14c);
writel(0xffffffff, S5P_VA_GPIO + 0x16c);
writel(0x000000ff, S5P_VA_GPIO + 0x18c);
s3c_gpio_cfgpin(S5PV210_GPB(4), S3C_GPIO_SFN(1));
s3c_gpio_cfgpin(S5PV210_GPB(5), S3C_GPIO_SFN(1));
s3c_gpio_cfgpin(S5PV210_GPB(6), S3C_GPIO_SFN(1));
s3c_gpio_cfgpin(S5PV210_GPB(7), S3C_GPIO_SFN(1));
s3c_gpio_setpull(S5PV210_GPB(4), S3C_GPIO_PULL_NONE);
s3c_gpio_setpull(S5PV210_GPB(5), S3C_GPIO_PULL_NONE);
s3c_gpio_setpull(S5PV210_GPB(6), S3C_GPIO_PULL_NONE);
s3c_gpio_setpull(S5PV210_GPB(7), S3C_GPIO_PULL_NONE);
gpio_request(S5PV210_GPH0(5), "GPH0");
gpio_direction_output(S5PV210_GPH0(5), 1);
}
static int lte480wv_backlight_on(struct platform_device *pdev)
{
int err;
#if defined (CONFIG_FB_S3C_TL2796)
err = gpio_request(S5PV210_GPB(4), "GPB");
if (err) {
printk(KERN_ERR "failed to request GPB(4) for "
"LVDS PWDN pin\n");
return err;
}
gpio_direction_output(S5PV210_GPB(4), 1);
gpio_set_value(S5PV210_GPB(4), 1);
gpio_free(S5PV210_GPB(4));
mdelay(100);
#endif
err = gpio_request(S5PV210_GPD0(3), "GPD0");
if (err) {
printk(KERN_ERR "failed to request GPD0 for "
"lcd backlight control\n");
return err;
}
gpio_direction_output(S5PV210_GPD0(3), 1);
s3c_gpio_cfgpin(S5PV210_GPD0(3), S5PV210_GPD_0_3_TOUT_3);
gpio_free(S5PV210_GPD0(3));
#if defined (CONFIG_FB_S3C_TL2796)
err = gpio_request(S5PV210_GPB(5), "GPB");
if (err) {
printk(KERN_ERR "failed to request GPB(5) for "
"LED_EN pin\n");
return err;
}
gpio_direction_output(S5PV210_GPB(5), 1);
gpio_set_value(S5PV210_GPB(5), 1);
gpio_free(S5PV210_GPB(5));
#endif
return 0;
}
/* Since we emulate multi-cs capability, we do not touch the CS.
* The emulated CS is toggled by board specific mechanism, as it can
* be either some immediate GPIO or some signal out of some other
* chip in between ... or some yet another way.
* We simply do not assume anything about CS.
*/
static int s5pv210_spi_cfg_gpio(struct platform_device *pdev)
{
switch (pdev->id) {
case 0:
s3c_gpio_cfgpin(S5PV210_GPB(0), S3C_GPIO_SFN(2));
s3c_gpio_cfgpin(S5PV210_GPB(1), S3C_GPIO_SFN(2));
s3c_gpio_cfgpin(S5PV210_GPB(2), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PV210_GPB(0), S3C_GPIO_PULL_UP);
s3c_gpio_setpull(S5PV210_GPB(1), S3C_GPIO_PULL_UP);
s3c_gpio_setpull(S5PV210_GPB(2), S3C_GPIO_PULL_UP);
break;
case 1:
s3c_gpio_cfgpin(S5PV210_GPB(4), S3C_GPIO_SFN(2));
s3c_gpio_cfgpin(S5PV210_GPB(5), S3C_GPIO_SFN(2));
s3c_gpio_cfgpin(S5PV210_GPB(6), S3C_GPIO_SFN(2));
s3c_gpio_setpull(S5PV210_GPB(4), S3C_GPIO_PULL_UP);
s3c_gpio_setpull(S5PV210_GPB(5), S3C_GPIO_PULL_UP);
s3c_gpio_setpull(S5PV210_GPB(6), S3C_GPIO_PULL_UP);
break;
default:
dev_err(&pdev->dev, "Invalid SPI Controller number!");
return -EINVAL;
}
return 0;
}
.enabled = 0,
},
},
.num_consumer_supplies = ARRAY_SIZE(gpio_reg_gph26_consumers),
.consumer_supplies = gpio_reg_gph26_consumers,
};
static struct gpio_regulator v210_gpio_regulators [] = {
[0] = { /*"VDD_GPS",*/
.gpio = S5PV210_GPA0(7),
.name = "LDO_GPA0(7)",
.type = GPIO_REGULATOR_VOLTAGE,
.initdata = &gpio_reg_gpa07,
},
[1] = { /*"VDD_CAM",*/
.gpio = S5PV210_GPB(3),
.name = "LDO_GPB(3)",
.type = GPIO_REGULATOR_VOLTAGE,
.initdata = &gpio_reg_gpb3,
},
[2] = { /*"VDD_5V",*/
.gpio = S5PV210_GPG1(6),
.name = "LDO_GPG1(6)",
.type = GPIO_REGULATOR_VOLTAGE,
.initdata = &gpio_reg_gpg16,
},
[3] = { /*"VDD_BT/VDD_WLAN",*/
.gpio = S5PV210_GPH2(6),
.pull = GPIO_PULL_DOWN,
.name = "LDO_GPH2(6)",
.type = GPIO_REGULATOR_VOLTAGE,
.microvolts = 5000000,
.init_data = &smdkv210_b_pwr_5v_data,
.gpio = -1,
};
static struct platform_device smdkv210_b_pwr_5v = {
.name = "reg-fixed-voltage",
.id = -1,
.dev = {
.platform_data = &smdkv210_b_pwr_5v_pdata,
},
};
#endif
#ifdef CONFIG_TOUCHSCREEN_EGALAX
static struct i2c_gpio_platform_data i2c5_platdata = {
.sda_pin = S5PV210_GPB(6),
.scl_pin = S5PV210_GPB(7),
.udelay = 2,
.sda_is_open_drain = 0,
.scl_is_open_drain = 0,
.scl_is_output_only = 0.
};
//static struct platform_device s3c_device_i2c5 = {
struct platform_device s3c_device_i2c5 = {
.name = "i2c-gpio",
.id = 5,
.dev.platform_data = &i2c5_platdata,
};
static struct i2c_board_info i2c_devs5[] __initdata = {
static void __init mini210_machine_init(void)
{
arm_pm_restart = smdkc110_pm_restart;
s3c_pm_init();
mini210_wifi_init();
#ifdef CONFIG_DM9000
mini210_dm9000_init();
#endif
platform_add_devices(mini210_devices, ARRAY_SIZE(mini210_devices));
#ifdef CONFIG_ANDROID_PMEM
android_pmem_set_platdata();
#endif
#ifdef CONFIG_KEYBOARD_SAMSUNG
samsung_keypad_set_platdata(&mini210_keypad_data);
#endif
#ifdef CONFIG_TOUCHSCREEN_S3C2410
s3c24xx_ts_set_platdata(&s3c_ts_platform);
#endif
s3c_i2c0_set_platdata(NULL);
s3c_i2c1_set_platdata(NULL);
#ifdef CONFIG_TOUCHSCREEN_GOODIX
if (mini210_get_ctp() == CTP_GT80X) {
i2c2_data.frequency = 260*1000;
}
#endif
s3c_i2c2_set_platdata(&i2c2_data);
i2c_register_board_info(0, mini210_i2c_devs0,
ARRAY_SIZE(mini210_i2c_devs0));
i2c_register_board_info(1, mini210_i2c_devs1,
ARRAY_SIZE(mini210_i2c_devs1));
i2c_register_board_info(2, mini210_i2c_devs2,
ARRAY_SIZE(mini210_i2c_devs2));
#ifdef CONFIG_TOUCHSCREEN_EGALAX
i2c_register_board_info(5, i2c_devs5, ARRAY_SIZE(i2c_devs5));
#endif
#ifdef CONFIG_S5PV210_SETUP_IDE
s3c_ide_set_platdata(&mini210_ide_pdata);
#endif
#ifdef CONFIG_FB_S3C_MINI210
{
struct s3cfb_lcd *mlcd = mini210_get_lcd();
if (!(mlcd->args & 0x0f)) {
if (readl(S5PV210_GPF0_BASE + 0x184) & 0x10)
mlcd->args |= (1 << 7);
}
mini210_fb_data.lcd = mlcd;
s3c_fb_set_platdata(&mini210_fb_data);
}
#endif
#ifdef CONFIG_S3C_DEV_HSMMC
s3c_sdhci0_set_platdata(&mini210_hsmmc0_pdata);
#endif
#ifdef CONFIG_S3C_DEV_HSMMC1
s3c_sdhci1_set_platdata(&mini210_hsmmc1_pdata);
#endif
#ifdef CONFIG_S3C_DEV_HSMMC2
s3c_sdhci2_set_platdata(&mini210_hsmmc2_pdata);
#endif
#ifdef CONFIG_S3C_DEV_HSMMC3
s3c_sdhci3_set_platdata(&mini210_hsmmc3_pdata);
#endif
#ifdef CONFIG_VIDEO_FIMC
/* fimc */
s3c_fimc0_set_platdata(&fimc_plat_lsi);
s3c_fimc1_set_platdata(&fimc_plat_lsi);
s3c_fimc2_set_platdata(&fimc_plat_lsi);
#ifdef CONFIG_VIDEO_S5K4BA
#ifdef CAM_ITU_CH_A
smdkv210_cam0_power(1);
#else
smdkv210_cam1_power(1);
#endif
#endif
#endif
#ifdef CONFIG_VIDEO_FIMC_MIPI
s3c_csis_set_platdata(NULL);
#endif
#ifdef CONFIG_VIDEO_JPEG_V2
s3c_jpeg_set_platdata(&jpeg_plat);
#endif
#ifdef CONFIG_VIDEO_MFC50
/* mfc */
s3c_mfc_set_platdata(NULL);
#endif
/* spi */
#ifdef CONFIG_SPI_S3C64XX
if (!gpio_request(S5PV210_GPB(1), "SPI_CS0")) {
gpio_direction_output(S5PV210_GPB(1), 1);
s3c_gpio_cfgpin(S5PV210_GPB(1), S3C_GPIO_SFN(1));
s3c_gpio_setpull(S5PV210_GPB(1), S3C_GPIO_PULL_UP);
s5pv210_spi_set_info(0, S5PV210_SPI_SRCCLK_PCLK,
ARRAY_SIZE(smdk_spi0_csi));
}
if (!gpio_request(S5PV210_GPB(5), "SPI_CS1")) {
gpio_direction_output(S5PV210_GPB(5), 1);
s3c_gpio_cfgpin(S5PV210_GPB(5), S3C_GPIO_SFN(1));
s3c_gpio_setpull(S5PV210_GPB(5), S3C_GPIO_PULL_UP);
s5pv210_spi_set_info(1, S5PV210_SPI_SRCCLK_PCLK,
ARRAY_SIZE(smdk_spi1_csi));
}
spi_register_board_info(s3c_spi_devs, ARRAY_SIZE(s3c_spi_devs));
#endif
mini210_otg_init();
mini210_ehci_init();
mini210_ohci_init();
clk_xusbxti.rate = 24000000;
regulator_has_full_constraints();
mini210_setup_clocks();
/* write something into the INFORM6 register that we can use to
* differentiate an unclear reboot from a clean reboot (which
* writes a small integer code to INFORM6).
*/
__raw_writel(0xee, S5P_INFORM6);
}
.ngpio = S5PV210_GPIO_A0_NR,
.label = "GPA0",
},
}, {
.base = S5PV210_GPA1_BASE,
.config = &gpio_cfg,
.chip = {
.base = S5PV210_GPA1(0),
.ngpio = S5PV210_GPIO_A1_NR,
.label = "GPA1",
},
}, {
.base = S5PV210_GPB_BASE,
.config = &gpio_cfg,
.chip = {
.base = S5PV210_GPB(0),
.ngpio = S5PV210_GPIO_B_NR,
.label = "GPB",
},
}, {
.base = S5PV210_GPC0_BASE,
.config = &gpio_cfg,
.chip = {
.base = S5PV210_GPC0(0),
.ngpio = S5PV210_GPIO_C0_NR,
.label = "GPC0",
},
}, {
.base = S5PV210_GPC1_BASE,
.config = &gpio_cfg,
.chip = {
#include <linux/types.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/ioctl.h>
#include <linux/cdev.h>
#include <linux/delay.h>
#include <mach/gpio.h>
#include <mach/regs-gpio.h>
#include <plat/gpio-cfg.h>
#define DEVICE_NAME "leds"
static int led_gpios[] = {
S5PV210_GPB(0),
S5PV210_GPB(2),
S5PV210_GPB(1),
S5PV210_GPB(3),
S5PV210_GPH0(7),
S5PV210_GPH0(5),
};
#define LED_NUM ARRAY_SIZE(led_gpios)
static long gzsd210_leds_ioctl(struct file *filp, unsigned int cmd,
unsigned long arg)
{
switch(cmd) {
case 0:
static void __init smdkv210_machine_init(void)
{
/* Find out S5PC110 chip version */
_hw_version_check();
#ifdef CONFIG_ANDROID_PMEM
android_pmem_set_platdata();
#endif
/* i2c */
s3c_i2c0_set_platdata(NULL);
s3c_i2c1_set_platdata(NULL);
s3c_i2c2_set_platdata(NULL);
i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
i2c_register_board_info(2, i2c_devs2, ARRAY_SIZE(i2c_devs2));
#if defined(CONFIG_HKDKC110_BOARD) && defined(CONFIG_INPUT_YAMAHA_SENSORS) && !defined(CONFIG_INPUT_BMA150_SENSOR)
// i2c-gpio sda/scl set pull-up yas529,bma150,ish1000
gpio_request(GPIO_SENSORS_SDA, "GPB2");
s3c_gpio_setpull(GPIO_SENSORS_SDA, S3C_GPIO_PULL_UP);
gpio_direction_input(GPIO_SENSORS_SDA);
gpio_free(GPIO_SENSORS_SDA);
gpio_request(GPIO_SENSORS_SCL, "GPB2");
s3c_gpio_setpull(GPIO_SENSORS_SCL, S3C_GPIO_PULL_UP);
gpio_direction_input(GPIO_SENSORS_SCL);
gpio_free(GPIO_SENSORS_SCL);
// BMA150 CS PIN --> HIGH
gpio_request(S5PV210_GPB(1), "GPB2");
s3c_gpio_setpull(S5PV210_GPB(1), S3C_GPIO_PULL_NONE);
gpio_direction_output(S5PV210_GPB(1), 1);
gpio_free(S5PV210_GPB(1));
i2c_register_board_info(4, i2c_devs4, ARRAY_SIZE(i2c_devs4));
#endif
/* to support system shut down */
pm_power_off = smdkv210_power_off;
#ifdef CONFIG_FB_S3C_LP101WH1
s3cfb_set_platdata(&lp101wh1_data);
#endif
#ifdef CONFIG_FB_S3C_LMS350DF
s3cfb_set_platdata(&lms350df_data);
#endif
#if defined(CONFIG_PM)
s3c_pm_init();
#endif
#ifdef CONFIG_VIDEO_FIMC
/* fimc */
s3c_fimc0_set_platdata(&fimc_plat);
s3c_fimc1_set_platdata(&fimc_plat);
s3c_fimc2_set_platdata(&fimc_plat);
#endif
/* 5V */
hkdkc110_5V_power(1);
#ifdef CONFIG_VIDEO_MFC50
/* mfc */
s3c_mfc_set_platdata(NULL);
#endif
#ifdef CONFIG_VIDEO_TV20
s3c_set_qos();
#endif
#ifdef CONFIG_S3C_DEV_HSMMC
s5pv210_default_sdhci0();
#endif
#ifdef CONFIG_S3C_DEV_HSMMC1
s5pv210_default_sdhci1();
#endif
#ifdef CONFIG_S3C_DEV_HSMMC2
s5pv210_default_sdhci2();
#endif
#ifdef CONFIG_S5PV210_SETUP_SDHCI
s3c_sdhci_set_platdata();
#endif
platform_add_devices(smdkv210_devices, ARRAY_SIZE(smdkv210_devices));
#if defined(CONFIG_HAVE_PWM)
smdk_backlight_register();
#endif
}
.swap = FB_SWAP_WORD | FB_SWAP_HWORD,
.lcd = <e480wv,
.cfg_gpio = lte480wv_cfg_gpio,
.backlight_on = lte480wv_backlight_on,
.backlight_onoff = lte480wv_backlight_off,
.reset_lcd = lte480wv_reset_lcd,
};
#endif
#ifdef CONFIG_S3C64XX_DEV_SPI
#define SMDK_MMCSPI_CS 0
static struct s3c64xx_spi_csinfo smdk_spi0_csi[] = {
[SMDK_MMCSPI_CS] = {
.line = S5PV210_GPB(1),
.set_level = gpio_set_value,
.fb_delay = 0x0,
},
};
static struct s3c64xx_spi_csinfo smdk_spi1_csi[] = {
[SMDK_MMCSPI_CS] = {
.line = S5PV210_GPB(5),
.set_level = gpio_set_value,
.fb_delay = 0x0,
},
};
static struct spi_board_info s3c_spi_devs[] __initdata = {
[0] = {
.id = 2,
.dev = {
.platform_data = &mmc2_fixed_voltage_config,
},
};
static void goni_setup_sdhci(void)
{
s3c_sdhci0_set_platdata(&goni_hsmmc0_data);
s3c_sdhci1_set_platdata(&goni_hsmmc1_data);
s3c_sdhci2_set_platdata(&goni_hsmmc2_data);
};
static struct noon010pc30_platform_data noon010pc30_pldata = {
.clk_rate = 16000000UL,
.gpio_nreset = S5PV210_GPB(2), /* CAM_CIF_NRST */
.gpio_nstby = S5PV210_GPB(0), /* CAM_CIF_NSTBY */
};
static struct i2c_board_info noon010pc30_board_info = {
I2C_BOARD_INFO("NOON010PC30", 0x60 >> 1),
.platform_data = &noon010pc30_pldata,
};
static struct s5p_fimc_isp_info goni_camera_sensors[] = {
{
.mux_id = 0,
.flags = V4L2_MBUS_PCLK_SAMPLE_FALLING |
V4L2_MBUS_VSYNC_ACTIVE_LOW,
.bus_type = FIMC_ITU_601,
.board_info = &noon010pc30_board_info,
static void __init smdkc110_machine_init(void)
{
struct clk *arm_clk;
arm_clk = clk_get(NULL, "fclk");
if (arm_clk == NULL) {
memcpy(&max8698_platform_default_data, &max8698_platform_data_1,
sizeof(struct max8698_platform_data));
printk(KERN_ERR "get fclk clock failed\n");
} else {
printk(KERN_INFO "arm_clk = %lu\n", arm_clk->rate);
switch (arm_clk->rate) {
case 800*1000*1000:
memcpy(&max8698_platform_default_data,
&max8698_platform_data_0,
sizeof(struct max8698_platform_data));
break;
case 1000*1000*1000:
memcpy(&max8698_platform_default_data,
&max8698_platform_data_1,
sizeof(struct max8698_platform_data));
break;
default:
printk(KERN_ERR "Set to default voltage value\n");
memcpy(&max8698_platform_default_data,
&max8698_platform_data_1,
sizeof(struct max8698_platform_data));
break;
}
clk_put(arm_clk);
}
#ifdef CONFIG_DM9000
smdkv210_dm9000_set();
#endif
s3c_pm_init();
s3c_i2c0_set_platdata(NULL);
s3c_i2c1_set_platdata(NULL);
s3c_i2c2_set_platdata(NULL);
i2c_register_board_info(0, smdkc110_i2c_devs0,
ARRAY_SIZE(smdkc110_i2c_devs0));
i2c_register_board_info(1, smdkc110_i2c_devs1,
ARRAY_SIZE(smdkc110_i2c_devs1));
i2c_register_board_info(2, smdkc110_i2c_devs2,
ARRAY_SIZE(smdkc110_i2c_devs2));
s3c_ide_set_platdata(&smdkc110_ide_pdata);
#ifdef CONFIG_S3C64XX_DEV_SPI
if (!gpio_request(S5PV210_GPB(1), "SPI_CS0")) {
gpio_direction_output(S5PV210_GPB(1), 1);
s3c_gpio_cfgpin(S5PV210_GPB(1), S3C_GPIO_SFN(1));
s3c_gpio_setpull(S5PV210_GPB(1), S3C_GPIO_PULL_UP);
s5pv210_spi_set_info(0, S5PV210_SPI_SRCCLK_PCLK,
ARRAY_SIZE(smdk_spi0_csi));
}
if (!gpio_request(S5PV210_GPB(5), "SPI_CS1")) {
gpio_direction_output(S5PV210_GPB(5), 1);
s3c_gpio_cfgpin(S5PV210_GPB(5), S3C_GPIO_SFN(1));
s3c_gpio_setpull(S5PV210_GPB(5), S3C_GPIO_PULL_UP);
s5pv210_spi_set_info(1, S5PV210_SPI_SRCCLK_PCLK,
ARRAY_SIZE(smdk_spi1_csi));
}
spi_register_board_info(s3c_spi_devs, ARRAY_SIZE(s3c_spi_devs));
#endif
#ifdef CONFIG_S3C_DEV_HSMMC
s3c_sdhci0_set_platdata(&smdkc110_hsmmc0_pdata);
#endif
#ifdef CONFIG_S3C_DEV_HSMMC1
s3c_sdhci1_set_platdata(&smdkc110_hsmmc1_pdata);
#endif
#ifdef CONFIG_S3C_DEV_HSMMC2
s3c_sdhci2_set_platdata(&smdkc110_hsmmc2_pdata);
#endif
#ifdef CONFIG_S3C_DEV_HSMMC3
s3c_sdhci3_set_platdata(&smdkc110_hsmmc3_pdata);
#endif
#ifdef CONFIG_S3C_DEV_HWMON
s3c_hwmon_set_platdata(&smdkc110_hwmon_pdata);
#endif
#ifdef CONFIG_TOUCHSCREEN_S3C2410
#ifdef CONFIG_S3C_DEV_ADC
s3c24xx_ts_set_platdata(&s3c_ts_platform);
#endif
#ifdef CONFIG_S3C_DEV_ADC1
s3c24xx_ts1_set_platdata(&s3c_ts_platform);
#endif
#endif
#if defined(CONFIG_VIDEO_TV20) || defined(CONFIG_VIDEO_TVOUT)
s5p_hdmi_hpd_set_platdata(&hdmi_hpd_data);
s5p_hdmi_cec_set_platdata(&hdmi_cec_data);
#endif
platform_add_devices(smdkc110_devices, ARRAY_SIZE(smdkc110_devices));
}
if(pull == CS_HIGH){
s3c_gpio_setpull(pin, S3C_GPIO_PULL_UP);
s3c_gpio_setpin(pin, 0);
}
else{
s3c_gpio_setpull(pin, S3C_GPIO_PULL_DOWN);
s3c_gpio_setpin(pin, 1);
}
}
#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 = S5PV210_GPB(1),
.cs_mode = S5PV210_GPB_OUTPUT(1),
.cs_set = s3c_cs_set,
.cs_config = s3c_cs_config,
.cs_suspend = s3c_cs_suspend,
.cs_resume = s3c_cs_resume,
},
#if 0
[1] = { /* Slave-1 */
.cs_level = CS_FLOAT,
.cs_pin = S5PV210_GPA1(1),
.cs_mode = S5PV210_GPA1_OUTPUT(1),
.cs_set = s3c_cs_set,
.cs_config = s3c_cs_config,
.cs_suspend = s3c_cs_suspend,
.cs_resume = s3c_cs_resume,
.gpio = -EINVAL,
.init_data = &mini210_b_pwr_5v_data,
};
static struct platform_device mini210_b_pwr_5v = {
.name = "reg-fixed-voltage",
.id = -1,
.dev = {
.platform_data = &mini210_b_pwr_5v_pdata,
},
};
#endif
#ifdef CONFIG_TOUCHSCREEN_EGALAX
static struct i2c_gpio_platform_data i2c5_platdata = {
.sda_pin = S5PV210_GPB(6),
.scl_pin = S5PV210_GPB(7),
.udelay = 2,
.sda_is_open_drain = 0,
.scl_is_open_drain = 0,
.scl_is_output_only = 0.
};
struct platform_device s3c_device_i2c5 = {
.name = "i2c-gpio",
.id = 5,
.dev.platform_data = &i2c5_platdata,
};
static struct i2c_board_info i2c_devs5[] __initdata = {
{
void EXT_LED_Off(int num){
////int led_pos[] = {0, 3, 1, 2, 4, 7, 5, 6}; //hw
//int led_pos[] = {0, 2, 3, 1, 4, 6, 7, 5}; //sw apping
int gpio_pos[] = {4, 6, 7, 5, 4, 6, 7, 5}; //sw apping
int pos;
printk("[LED_DD]==>LED_OFF(%d)\n", num);
if(num == 8) {
//led0, led1, led2, led3
//Outp32(GPBDAT,(Inp32(GPBDAT) |= (0x000000F0)));
s3c_gpio_setpin(LED_D0, 1);
s3c_gpio_setpin(LED_D1, 1);
s3c_gpio_setpin(LED_D2, 1);
s3c_gpio_setpin(LED_D3, 1);
//low(right) 4 led activate
//Outp32(GPA0DAT,(Inp32(GPA0DAT) &= (~0x00000004)));
//Outp32(GPA0DAT,(Inp32(GPA0DAT) |= (0x00000004)));
//Outp32(GPA0DAT,(Inp32(GPA0DAT) &= (~0x00000004)));
s3c_gpio_setpin(LED_C1, 0);
s3c_gpio_setpin(LED_C1, 1);
s3c_gpio_setpin(LED_C1, 0);
//led4, led5, led6, led7
//Outp32(GPBDAT,(Inp32(GPBDAT) |= (0x000000F0)));
s3c_gpio_setpin(LED_D0, 1);
s3c_gpio_setpin(LED_D1, 1);
s3c_gpio_setpin(LED_D2, 1);
s3c_gpio_setpin(LED_D3, 1);
//high(left) 4 led activate
//Outp32(GPBDAT,(Inp32(GPBDAT) &= (~0x00000002)));
//Outp32(GPBDAT,(Inp32(GPBDAT) |= (0x00000002)));
//Outp32(GPBDAT,(Inp32(GPBDAT) &= (~0x00000002)));
s3c_gpio_setpin(LED_C0, 0);
s3c_gpio_setpin(LED_C0, 1);
s3c_gpio_setpin(LED_C0, 0);
return;
}
//pos = led_pos[num];
pos = gpio_pos[num];
printk("[LED_DD]==>LED_OFF(%d, %d)\n", num, pos);
if(num < 0 || num > 8) {
printk("[LED_DD]Invalid Led Num!!\n");
} else {
s3c_gpio_setpin(S5PV210_GPB(pos), 1);
if(num < 4) {
//led_num off
//Outp32(GPBDAT,(Inp32(GPBDAT) |= (1 << (pos + 4))));
//low(right) 4 led activate
//Outp32(GPA0DAT,(Inp32(GPA0DAT) &= (~0x00000004)));
//Outp32(GPA0DAT,(Inp32(GPA0DAT) |= (0x00000004)));
//Outp32(GPA0DAT,(Inp32(GPA0DAT) &= (~0x00000004)));
s3c_gpio_setpin(LED_C1, 0);
s3c_gpio_setpin(LED_C1, 1);
s3c_gpio_setpin(LED_C1, 0);
} else if(num < 8) {
//led_num off
//Outp32(GPBDAT,(Inp32(GPBDAT) |= (1 << (pos ))));
//s3c_gpio_setpin(S5PV210_GPB(pos), 1);
//high(left) 4 led activate
//Outp32(GPBDAT,(Inp32(GPBDAT) &= (~0x00000002)));
//Outp32(GPBDAT,(Inp32(GPBDAT) |= (0x00000002)));
//Outp32(GPBDAT,(Inp32(GPBDAT) &= (~0x00000002)));
s3c_gpio_setpin(LED_C0, 0);
s3c_gpio_setpin(LED_C0, 1);
s3c_gpio_setpin(LED_C0, 0);
}
}
}
#include <linux/platform_device.h>
#include <linux/i2c.h>
#include <linux/i2c-algo-bit.h>
#include <linux/i2c-gpio.h>
#include <mach/map.h>
#include <plat/devs.h>
#include <plat/cpu.h>
#include <asm/mach/irq.h>
#include <mach/gpio.h>
#include <plat/gpio-cfg.h>
/* For HDMI */
static struct i2c_gpio_platform_data gpioi2c3_platdata = {
.sda_pin = S5PV210_GPB(1),
.scl_pin = S5PV210_GPB(0),
.udelay = 0,
.timeout = 0,
.sda_is_open_drain = 0,
.scl_is_open_drain = 0,
.scl_is_output_only = 0,
};
struct platform_device gpioi2c3_device =
{
.name = "i2c-gpio",
.id = 3,
.dev =
{
.platform_data = &gpioi2c3_platdata,
