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,