diff options
Diffstat (limited to 'arch/arm/mach-s5pv210/mach-herring.c')
| -rwxr-xr-x | arch/arm/mach-s5pv210/mach-herring.c | 6092 |
1 files changed, 6092 insertions, 0 deletions
diff --git a/arch/arm/mach-s5pv210/mach-herring.c b/arch/arm/mach-s5pv210/mach-herring.c new file mode 100755 index 0000000..993cb66 --- /dev/null +++ b/arch/arm/mach-s5pv210/mach-herring.c @@ -0,0 +1,6092 @@ +/* linux/arch/arm/mach-s5pv210/mach-herring.c + * + * Copyright (c) 2010 Samsung Electronics Co., Ltd. + * http://www.samsung.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. +*/ + +#include <linux/kernel.h> +#include <linux/types.h> +#include <linux/init.h> +#include <linux/serial_core.h> +#include <linux/gpio.h> +#include <linux/gpio_event.h> +#include <linux/videodev2.h> +#include <linux/i2c.h> +#include <linux/i2c-gpio.h> +#include <linux/regulator/consumer.h> +#include <linux/mfd/max8998.h> +#include <linux/i2c/ak8973.h> +#include <linux/clk.h> +#include <linux/delay.h> +#include <linux/usb/ch9.h> +#include <linux/spi/spi.h> +#include <linux/spi/spi_gpio.h> +#include <linux/clk.h> +#include <linux/usb/ch9.h> +#include <linux/input/cypress-touchkey.h> +#include <linux/input.h> +#include <linux/irq.h> +#include <linux/skbuff.h> +#include <linux/console.h> + +#include <asm/mach/arch.h> +#include <asm/mach/map.h> +#include <asm/setup.h> +#include <asm/mach-types.h> +#include <asm/system.h> + +#include <mach/map.h> +#include <mach/regs-clock.h> +#include <mach/gpio.h> +#include <mach/gpio-herring.h> +#include <mach/adc.h> +#include <mach/param.h> +#include <mach/system.h> + +#include <linux/usb/gadget.h> +#include <linux/fsa9480.h> +#include <linux/pn544.h> +#include <linux/notifier.h> +#include <linux/reboot.h> +#include <linux/wlan_plat.h> +#include <linux/mfd/wm8994/wm8994_pdata.h> + +#ifdef CONFIG_ANDROID_PMEM +#include <linux/android_pmem.h> +#endif +#include <plat/media.h> +#include <mach/media.h> + +#ifdef CONFIG_S5PV210_POWER_DOMAIN +#include <mach/power-domain.h> +#endif +#include <mach/cpu-freq-v210.h> + +#include <media/s5ka3dfx_platform.h> +#include <media/s5k4ecgx.h> + +#include <plat/regs-serial.h> +#include <plat/s5pv210.h> +#include <plat/devs.h> +#include <plat/cpu.h> +#include <plat/fb.h> +#include <plat/mfc.h> +#include <plat/iic.h> +#include <plat/pm.h> +#include <plat/s5p-time.h> + +#include <plat/sdhci.h> +#include <plat/fimc.h> +#include <plat/jpeg.h> +#include <plat/clock.h> +#include <plat/regs-otg.h> +#include <linux/gp2a.h> +#include <linux/kr3dm.h> +#include <linux/input/k3g.h> +#include <../../../drivers/video/samsung/s3cfb.h> +#include <linux/sec_jack.h> +#include <linux/input/mxt224.h> +#include <linux/max17040_battery.h> +#include <linux/mfd/max8998.h> +#include <linux/regulator/max8893.h> +#include <linux/wimax/samsung/wimax732.h> +#include <linux/switch.h> + +#include "herring.h" + +struct class *sec_class; +EXPORT_SYMBOL(sec_class); + +struct device *switch_dev; +EXPORT_SYMBOL(switch_dev); + +void (*sec_set_param_value)(int idx, void *value); +EXPORT_SYMBOL(sec_set_param_value); + +void (*sec_get_param_value)(int idx, void *value); +EXPORT_SYMBOL(sec_get_param_value); + +#define REBOOT_MODE_FAST_BOOT 7 + +#define PREALLOC_WLAN_SEC_NUM 4 +#define PREALLOC_WLAN_BUF_NUM 160 +#define PREALLOC_WLAN_SECTION_HEADER 24 + +#define WLAN_SECTION_SIZE_0 (PREALLOC_WLAN_BUF_NUM * 128) +#define WLAN_SECTION_SIZE_1 (PREALLOC_WLAN_BUF_NUM * 128) +#define WLAN_SECTION_SIZE_2 (PREALLOC_WLAN_BUF_NUM * 512) +#define WLAN_SECTION_SIZE_3 (PREALLOC_WLAN_BUF_NUM * 1024) + +#define WLAN_SKB_BUF_NUM 16 + +static struct sk_buff *wlan_static_skb[WLAN_SKB_BUF_NUM]; + +struct wifi_mem_prealloc { + void *mem_ptr; + unsigned long size; +}; + +static int herring_notifier_call(struct notifier_block *this, + unsigned long code, void *_cmd) +{ + int mode = REBOOT_MODE_NONE; + + if ((code == SYS_RESTART) && _cmd) { + if (!strcmp((char *)_cmd, "recovery")) + mode = REBOOT_MODE_RECOVERY; + else if (!strcmp((char *)_cmd, "bootloader")) + mode = REBOOT_MODE_FAST_BOOT; + else + mode = REBOOT_MODE_NONE; + } + __raw_writel(mode, S5P_INFORM6); + + return NOTIFY_DONE; +} + +static struct notifier_block herring_reboot_notifier = { + .notifier_call = herring_notifier_call, +}; + +static void gps_gpio_init(void) +{ + struct device *gps_dev; + + gps_dev = device_create(sec_class, NULL, 0, NULL, "gps"); + if (IS_ERR(gps_dev)) { + pr_err("Failed to create device(gps)!\n"); + goto err; + } + + gpio_request(GPIO_GPS_nRST, "GPS_nRST"); /* XMMC3CLK */ + s3c_gpio_setpull(GPIO_GPS_nRST, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_GPS_nRST, S3C_GPIO_OUTPUT); + gpio_direction_output(GPIO_GPS_nRST, 1); + + gpio_request(GPIO_GPS_PWR_EN, "GPS_PWR_EN"); /* XMMC3CLK */ + s3c_gpio_setpull(GPIO_GPS_PWR_EN, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_GPS_PWR_EN, S3C_GPIO_OUTPUT); + gpio_direction_output(GPIO_GPS_PWR_EN, 0); + + s3c_gpio_setpull(GPIO_GPS_RXD, S3C_GPIO_PULL_UP); + gpio_export(GPIO_GPS_nRST, 1); + gpio_export(GPIO_GPS_PWR_EN, 1); + + gpio_export_link(gps_dev, "GPS_nRST", GPIO_GPS_nRST); + gpio_export_link(gps_dev, "GPS_PWR_EN", GPIO_GPS_PWR_EN); + + err: + return; +} + +static void uart_switch_init(void) +{ + int ret; + struct device *uartswitch_dev; + + uartswitch_dev = device_create(sec_class, NULL, 0, NULL, "uart_switch"); + if (IS_ERR(uartswitch_dev)) { + pr_err("Failed to create device(uart_switch)!\n"); + return; + } + + ret = gpio_request(GPIO_UART_SEL, "UART_SEL"); + if (ret < 0) { + pr_err("Failed to request GPIO_UART_SEL!\n"); + return; + } + s3c_gpio_setpull(GPIO_UART_SEL, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_UART_SEL, S3C_GPIO_OUTPUT); + + gpio_direction_output(GPIO_UART_SEL, 1); + + gpio_export(GPIO_UART_SEL, 1); + + gpio_export_link(uartswitch_dev, "UART_SEL", GPIO_UART_SEL); + + if (herring_is_cdma_wimax_dev()) { + ret = gpio_request(GPIO_UART_SEL1, "UART_SEL1"); + if (ret < 0) { + pr_err("Failed to request GPIO_UART_SEL1!\n"); + gpio_free(GPIO_UART_SEL); + return; + } + + s3c_gpio_cfgpin(GPIO_UART_SEL1, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_UART_SEL1, S3C_GPIO_PULL_NONE); + gpio_direction_output(GPIO_UART_SEL1, 0); + + gpio_export(GPIO_UART_SEL1, 1); + gpio_export_link(uartswitch_dev, "UART_SEL1", GPIO_UART_SEL1); + } +} + +static void herring_switch_init(void) +{ + sec_class = class_create(THIS_MODULE, "sec"); + + if (IS_ERR(sec_class)) + pr_err("Failed to create class(sec)!\n"); + + switch_dev = device_create(sec_class, NULL, 0, NULL, "switch"); + + if (IS_ERR(switch_dev)) + pr_err("Failed to create device(switch)!\n"); +}; + +/* Following are default values for UCON, ULCON and UFCON UART registers */ +#define S5PV210_UCON_DEFAULT (S3C2410_UCON_TXILEVEL | \ + S3C2410_UCON_RXILEVEL | \ + S3C2410_UCON_TXIRQMODE | \ + S3C2410_UCON_RXIRQMODE | \ + S3C2410_UCON_RXFIFO_TOI | \ + S3C2443_UCON_RXERR_IRQEN) + +#define S5PV210_ULCON_DEFAULT S3C2410_LCON_CS8 + +#define S5PV210_UFCON_DEFAULT (S3C2410_UFCON_FIFOMODE | \ + S5PV210_UFCON_TXTRIG4 | \ + S5PV210_UFCON_RXTRIG4) + +static struct s3c2410_uartcfg herring_uartcfgs[] __initdata = { + { + .hwport = 0, + .flags = 0, + .ucon = S5PV210_UCON_DEFAULT, + .ulcon = S5PV210_ULCON_DEFAULT, + .ufcon = S5PV210_UFCON_DEFAULT, + .wake_peer = herring_bt_uart_wake_peer, + }, + { + .hwport = 1, + .flags = 0, + .ucon = S5PV210_UCON_DEFAULT, + .ulcon = S5PV210_ULCON_DEFAULT, + .ufcon = S5PV210_UFCON_DEFAULT, + }, +#ifndef CONFIG_FIQ_DEBUGGER + { + .hwport = 2, + .flags = 0, + .ucon = S5PV210_UCON_DEFAULT, + .ulcon = S5PV210_ULCON_DEFAULT, + .ufcon = S5PV210_UFCON_DEFAULT, + }, +#endif + { + .hwport = 3, + .flags = 0, + .ucon = S5PV210_UCON_DEFAULT, + .ulcon = S5PV210_ULCON_DEFAULT, + .ufcon = S5PV210_UFCON_DEFAULT, + }, +}; + +#define S5PV210_LCD_WIDTH 480 +#define S5PV210_LCD_HEIGHT 800 + +static struct s3cfb_lcd s6e63m0 = { + .width = S5PV210_LCD_WIDTH, + .height = S5PV210_LCD_HEIGHT, + .p_width = 52, + .p_height = 86, + .bpp = 24, + .freq = 60, + + .timing = { + .h_fp = 16, + .h_bp = 16, + .h_sw = 2, + .v_fp = 28, + .v_fpe = 1, + .v_bp = 1, + .v_bpe = 1, + .v_sw = 2, + }, + .polarity = { + .rise_vclk = 1, + .inv_hsync = 1, + .inv_vsync = 1, + .inv_vden = 1, + }, +}; + +static struct s3cfb_lcd nt35580 = { + .width = 480, + .height = 800, + .p_width = 52, + .p_height = 86, + .bpp = 24, + .freq = 60, + .timing = { + .h_fp = 10, + .h_bp = 20, + .h_sw = 10, + .v_fp = 6, + .v_fpe = 1, + .v_bp = 8, + .v_bpe = 1, + .v_sw = 2, + }, + .polarity = { + .rise_vclk = 1, + .inv_hsync = 1, + .inv_vsync = 1, + .inv_vden = 1, + }, +}; + +static struct s3cfb_lcd r61408 = { + .width = 480, + .height = 800, + .p_width = 52, + .p_height = 86, + .bpp = 24, + .freq = 60, + .timing = { + .h_fp = 100, + .h_bp = 2, + .h_sw = 2, + .v_fp = 8, + .v_fpe = 1, + .v_bp = 10, + .v_bpe = 1, + .v_sw = 2, + }, + .polarity = { + .rise_vclk = 1, + .inv_hsync = 1, + .inv_vsync = 1, + .inv_vden = 0, + }, +}; + +#define S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMC0 (6144 * SZ_1K) +#define S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMC1 (4 * SZ_1K) +#define S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMC2 (6144 * SZ_1K) +#define S5PV210_VIDEO_SAMSUNG_MEMSIZE_MFC0 (36864 * SZ_1K) +#define S5PV210_VIDEO_SAMSUNG_MEMSIZE_MFC1 (36864 * SZ_1K) +#define S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMD (S5PV210_LCD_WIDTH * \ + S5PV210_LCD_HEIGHT * 4 * \ + (CONFIG_FB_S3C_NR_BUFFERS + \ + (CONFIG_FB_S3C_NUM_OVLY_WIN * \ + CONFIG_FB_S3C_NUM_BUF_OVLY_WIN))) +#define S5PV210_VIDEO_SAMSUNG_MEMSIZE_JPEG (8192 * SZ_1K) + +static struct s5p_media_device herring_media_devs[] = { + [0] = { + .id = S5P_MDEV_MFC, + .name = "mfc", + .bank = 0, + .memsize = S5PV210_VIDEO_SAMSUNG_MEMSIZE_MFC0, + .paddr = 0, + }, + [1] = { + .id = S5P_MDEV_MFC, + .name = "mfc", + .bank = 1, + .memsize = S5PV210_VIDEO_SAMSUNG_MEMSIZE_MFC1, + .paddr = 0, + }, + [2] = { + .id = S5P_MDEV_FIMC0, + .name = "fimc0", + .bank = 1, + .memsize = S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMC0, + .paddr = 0, + }, + [3] = { + .id = S5P_MDEV_FIMC1, + .name = "fimc1", + .bank = 1, + .memsize = S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMC1, + .paddr = 0, + }, + [4] = { + .id = S5P_MDEV_FIMC2, + .name = "fimc2", + .bank = 1, + .memsize = S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMC2, + .paddr = 0, + }, + [5] = { + .id = S5P_MDEV_JPEG, + .name = "jpeg", + .bank = 0, + .memsize = S5PV210_VIDEO_SAMSUNG_MEMSIZE_JPEG, + .paddr = 0, + }, + [6] = { + .id = S5P_MDEV_FIMD, + .name = "fimd", + .bank = 1, + .memsize = S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMD, + .paddr = 0, + }, +}; + +#ifdef CONFIG_CPU_FREQ +static struct s5pv210_cpufreq_voltage smdkc110_cpufreq_volt[] = { + { + .freq = 1000000, + .varm = 1275000, + .vint = 1100000, + }, { + .freq = 800000, + .varm = 1200000, + .vint = 1100000, + }, { + .freq = 400000, + .varm = 1050000, + .vint = 1100000, + }, { + .freq = 200000, + .varm = 950000, + .vint = 1100000, + }, { + .freq = 100000, + .varm = 950000, + .vint = 1000000, + }, +}; + +static struct s5pv210_cpufreq_data smdkc110_cpufreq_plat = { + .volt = smdkc110_cpufreq_volt, + .size = ARRAY_SIZE(smdkc110_cpufreq_volt), +}; +#endif + +static struct regulator_consumer_supply ldo3_consumer[] = { + REGULATOR_SUPPLY("pd_io", "s3c-usbgadget") +}; + +static struct regulator_consumer_supply ldo7_consumer[] = { + { .supply = "vlcd", }, +}; + +static struct regulator_consumer_supply ldo8_consumer[] = { + REGULATOR_SUPPLY("pd_core", "s3c-usbgadget") +}; + +static struct regulator_consumer_supply ldo11_consumer[] = { + { .supply = "cam_af", }, +}; + +static struct regulator_consumer_supply ldo12_consumer[] = { + { .supply = "cam_sensor", }, +}; + +static struct regulator_consumer_supply ldo13_consumer[] = { + { .supply = "vga_vddio", }, +}; + +static struct regulator_consumer_supply ldo14_consumer[] = { + { .supply = "vga_dvdd", }, +}; + +static struct regulator_consumer_supply ldo15_consumer[] = { + { .supply = "cam_isp_host", }, +}; + +static struct regulator_consumer_supply ldo16_consumer[] = { + { .supply = "vga_avdd", }, +}; + +static struct regulator_consumer_supply ldo17_consumer[] = { + { .supply = "vcc_lcd", }, +}; + +static struct regulator_consumer_supply buck1_consumer[] = { + { .supply = "vddarm", }, +}; + +static struct regulator_consumer_supply buck2_consumer[] = { + { .supply = "vddint", }, +}; + +static struct regulator_consumer_supply buck4_consumer[] = { + { .supply = "cam_isp_core", }, +}; + +static struct regulator_init_data herring_ldo2_data = { + .constraints = { + .name = "VALIVE_1.2V", + .min_uV = 1200000, + .max_uV = 1200000, + .apply_uV = 1, + .always_on = 1, + .state_mem = { + .enabled = 1, + }, + }, +}; + +static struct regulator_init_data herring_ldo3_data = { + .constraints = { + .name = "VUSB_1.1V", + .min_uV = 1100000, + .max_uV = 1100000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo3_consumer), + .consumer_supplies = ldo3_consumer, +}; + +static struct regulator_init_data herring_ldo4_data = { + .constraints = { + .name = "VADC_3.3V", + .min_uV = 3300000, + .max_uV = 3300000, + .apply_uV = 1, + .always_on = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, +}; + +static struct regulator_init_data herring_ldo7_data = { + .constraints = { + .name = "VLCD_1.8V", + .min_uV = 1800000, + .max_uV = 1800000, + .apply_uV = 1, + .always_on = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo7_consumer), + .consumer_supplies = ldo7_consumer, +}; + +static struct regulator_init_data herring_ldo8_data = { + .constraints = { + .name = "VUSB_3.3V", + .min_uV = 3300000, + .max_uV = 3300000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo8_consumer), + .consumer_supplies = ldo8_consumer, +}; + +static struct regulator_init_data herring_ldo9_data = { + .constraints = { + .name = "VCC_2.8V_PDA", + .min_uV = 2800000, + .max_uV = 2800000, + .apply_uV = 1, + .always_on = 1, + }, +}; + +static struct regulator_init_data herring_ldo11_data = { + .constraints = { + .name = "CAM_AF_3.0V", + .min_uV = 3000000, + .max_uV = 3000000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo11_consumer), + .consumer_supplies = ldo11_consumer, +}; + +static struct regulator_init_data herring_ldo12_data = { + .constraints = { + .name = "CAM_SENSOR_CORE_1.2V", + .min_uV = 1200000, + .max_uV = 1200000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo12_consumer), + .consumer_supplies = ldo12_consumer, +}; + +static struct regulator_init_data herring_ldo13_data = { + .constraints = { + .name = "VGA_VDDIO_2.8V", + .min_uV = 2800000, + .max_uV = 2800000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo13_consumer), + .consumer_supplies = ldo13_consumer, +}; + +static struct regulator_init_data herring_ldo14_data = { + .constraints = { + .name = "VGA_DVDD_1.8V", + .min_uV = 1800000, + .max_uV = 1800000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo14_consumer), + .consumer_supplies = ldo14_consumer, +}; + +static struct regulator_init_data herring_ldo15_data = { + .constraints = { + .name = "CAM_ISP_HOST_2.8V", + .min_uV = 2800000, + .max_uV = 2800000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo15_consumer), + .consumer_supplies = ldo15_consumer, +}; + +static struct regulator_init_data herring_ldo16_data = { + .constraints = { + .name = "VGA_AVDD_2.8V", + .min_uV = 2800000, + .max_uV = 2800000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo16_consumer), + .consumer_supplies = ldo16_consumer, +}; + +static struct regulator_init_data herring_ldo17_data = { + .constraints = { + .name = "VCC_3.0V_LCD", + .min_uV = 3000000, + .max_uV = 3000000, + .apply_uV = 1, + .always_on = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(ldo17_consumer), + .consumer_supplies = ldo17_consumer, +}; + +static struct regulator_init_data herring_buck1_data = { + .constraints = { + .name = "VDD_ARM", + .min_uV = 750000, + .max_uV = 1500000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | + REGULATOR_CHANGE_STATUS, + .state_mem = { + .uV = 1250000, + .mode = REGULATOR_MODE_NORMAL, + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(buck1_consumer), + .consumer_supplies = buck1_consumer, +}; + +static struct regulator_init_data herring_buck2_data = { + .constraints = { + .name = "VDD_INT", + .min_uV = 750000, + .max_uV = 1500000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | + REGULATOR_CHANGE_STATUS, + .state_mem = { + .uV = 1100000, + .mode = REGULATOR_MODE_NORMAL, + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(buck2_consumer), + .consumer_supplies = buck2_consumer, +}; + +static struct regulator_init_data herring_buck3_data = { + .constraints = { + .name = "VCC_1.8V", + .min_uV = 1800000, + .max_uV = 1800000, + .apply_uV = 1, + .always_on = 1, + }, +}; + +static struct regulator_init_data herring_buck4_data = { + .constraints = { + .name = "CAM_ISP_CORE_1.2V", + .min_uV = 1200000, + .max_uV = 1200000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_STATUS, + .state_mem = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(buck4_consumer), + .consumer_supplies = buck4_consumer, +}; + +static struct max8998_regulator_data herring_regulators[] = { + { MAX8998_LDO2, &herring_ldo2_data }, + { MAX8998_LDO3, &herring_ldo3_data }, + { MAX8998_LDO4, &herring_ldo4_data }, + { MAX8998_LDO7, &herring_ldo7_data }, + { MAX8998_LDO8, &herring_ldo8_data }, + { MAX8998_LDO9, &herring_ldo9_data }, + { MAX8998_LDO11, &herring_ldo11_data }, + { MAX8998_LDO12, &herring_ldo12_data }, + { MAX8998_LDO13, &herring_ldo13_data }, + { MAX8998_LDO14, &herring_ldo14_data }, + { MAX8998_LDO15, &herring_ldo15_data }, + { MAX8998_LDO16, &herring_ldo16_data }, + { MAX8998_LDO17, &herring_ldo17_data }, + { MAX8998_BUCK1, &herring_buck1_data }, + { MAX8998_BUCK2, &herring_buck2_data }, + { MAX8998_BUCK3, &herring_buck3_data }, + { MAX8998_BUCK4, &herring_buck4_data }, +}; + +static struct max8998_regulator_data herring_cdma_wimax_regulators[] = { + { MAX8998_LDO2, &herring_ldo2_data }, + { MAX8998_LDO3, &herring_ldo3_data }, + { MAX8998_LDO4, &herring_ldo4_data }, + { MAX8998_LDO7, &herring_ldo7_data }, + { MAX8998_LDO8, &herring_ldo8_data }, + { MAX8998_LDO9, &herring_ldo9_data }, + { MAX8998_LDO11, &herring_ldo11_data }, + { MAX8998_LDO13, &herring_ldo13_data }, + { MAX8998_LDO14, &herring_ldo14_data }, + { MAX8998_LDO15, &herring_ldo15_data }, + { MAX8998_LDO16, &herring_ldo16_data }, + { MAX8998_LDO17, &herring_ldo17_data }, + { MAX8998_BUCK1, &herring_buck1_data }, + { MAX8998_BUCK2, &herring_buck2_data }, + { MAX8998_BUCK3, &herring_buck3_data }, + { MAX8998_BUCK4, &herring_buck4_data }, +}; + +static struct max8998_adc_table_data temper_table_oled[] = { + /* ADC, Temperature (C/10) */ + { 222, 700 }, + { 230, 690 }, + { 238, 680 }, + { 245, 670 }, + { 253, 660 }, + { 261, 650 }, + { 274, 640 }, + { 287, 630 }, + { 300, 620 }, + { 314, 610 }, + { 327, 600 }, + { 339, 590 }, + { 350, 580 }, + { 362, 570 }, + { 374, 560 }, + { 386, 550 }, + { 401, 540 }, + { 415, 530 }, + { 430, 520 }, + { 444, 510 }, + { 459, 500 }, + { 477, 490 }, + { 495, 480 }, + { 513, 470 }, + { 526, 460 }, + { 539, 450 }, + { 559, 440 }, + { 580, 430 }, + { 600, 420 }, + { 618, 410 }, + { 642, 400 }, + { 649, 390 }, + { 674, 380 }, + { 695, 370 }, + { 717, 360 }, + { 739, 350 }, + { 760, 340 }, + { 782, 330 }, + { 803, 320 }, + { 825, 310 }, + { 847, 300 }, + { 870, 290 }, + { 894, 280 }, + { 918, 270 }, + { 942, 260 }, + { 966, 250 }, + { 990, 240 }, + { 1014, 230 }, + { 1038, 220 }, + { 1062, 210 }, + { 1086, 200 }, + { 1110, 190 }, + { 1134, 180 }, + { 1158, 170 }, + { 1182, 160 }, + { 1206, 150 }, + { 1228, 140 }, + { 1251, 130 }, + { 1274, 120 }, + { 1297, 110 }, + { 1320, 100 }, + { 1341, 90 }, + { 1362, 80 }, + { 1384, 70 }, + { 1405, 60 }, + { 1427, 50 }, + { 1450, 40 }, + { 1474, 30 }, + { 1498, 20 }, + { 1514, 10 }, + { 1533, 0 }, + { 1544, (-10) }, + { 1567, (-20) }, + { 1585, (-30) }, + { 1604, (-40) }, + { 1623, (-50) }, + { 1641, (-60) }, + { 1659, (-70) }, + { 1678, (-80) }, + { 1697, (-90) }, + { 1715, (-100) }, +}; +static struct max8998_adc_table_data temper_table_tft[] = { + /* ADC, Temperature (C/10) */ + { 242, 700 }, + { 253, 690 }, + { 264, 680 }, + { 275, 670 }, + { 286, 660 }, + { 297, 650 }, + { 310, 640 }, + { 323, 630 }, + { 336, 620 }, + { 349, 610 }, + { 362, 600 }, + { 375, 590 }, + { 388, 580 }, + { 401, 570 }, + { 414, 560 }, + { 430, 550 }, + { 444, 540 }, + { 458, 530 }, + { 472, 520 }, + { 486, 510 }, + { 500, 500 }, + { 515, 490 }, + { 530, 480 }, + { 545, 470 }, + { 560, 460 }, + { 575, 450 }, + { 590, 440 }, + { 605, 430 }, + { 625, 420 }, + { 645, 410 }, + { 665, 400 }, + { 683, 390 }, + { 702, 380 }, + { 735, 370 }, + { 768, 360 }, + { 768, 350 }, + { 790, 340 }, + { 812, 330 }, + { 834, 320 }, + { 856, 310 }, + { 881, 300 }, + { 905, 290 }, + { 929, 280 }, + { 955, 270 }, + { 979, 260 }, + { 1002, 250 }, + { 1027, 240 }, + { 1053, 230 }, + { 1078, 220 }, + { 1105, 210 }, + { 1130, 200 }, + { 1151, 190 }, + { 1174, 180 }, + { 1195, 170 }, + { 1219, 160 }, + { 1237, 150 }, + { 1261, 140 }, + { 1285, 130 }, + { 1309, 120 }, + { 1331, 110 }, + { 1359, 100 }, + { 1381, 90 }, + { 1404, 80 }, + { 1426, 70 }, + { 1438, 60 }, + { 1470, 50 }, + { 1488, 40 }, + { 1506, 30 }, + { 1524, 20 }, + { 1532, 10 }, + { 1560, 0 }, + { 1586, (-10) }, + { 1604, (-20) }, + { 1614, (-30) }, + { 1622, (-40) }, + { 1630, (-50) }, + { 1648, (-60) }, + { 1666, (-70) }, + { 1684, (-80) }, + { 1702, (-90) }, + { 1720, (-100) }, +}; + +static struct max8998_adc_table_data temper_table_cdma_wimax_oled[] = { + /* ADC, Temperature (C/10) */ + { 116, 700 }, + { 122, 690 }, + { 128, 680 }, + { 134, 670 }, + { 140, 660 }, + { 146, 650 }, + { 152, 640 }, + { 158, 630 }, + { 164, 620 }, + { 170, 610 }, + { 176, 600 }, + { 182, 590 }, + { 188, 580 }, + { 194, 570 }, + { 200, 560 }, + { 206, 550 }, + { 212, 540 }, + { 218, 530 }, + { 222, 520 }, + { 230, 510 }, + { 238, 500 }, + { 245, 490 }, + { 260, 480 }, + { 290, 470 }, + { 325, 460 }, + { 360, 450 }, + { 395, 440 }, + { 430, 430 }, + { 465, 420 }, + { 500, 410 }, + { 535, 400 }, + { 575, 390 }, + { 615, 380 }, + { 642, 370 }, + { 695, 360 }, + { 717, 350 }, + { 737, 340 }, + { 760, 330 }, + { 782, 320 }, + { 803, 310 }, + { 825, 300 }, + { 847, 290 }, + { 870, 280 }, + { 900, 270 }, + { 942, 260 }, + { 966, 250 }, + { 990, 240 }, + { 1014, 230 }, + { 1038, 220 }, + { 1062, 210 }, + { 1086, 200 }, + { 1110, 190 }, + { 1134, 180 }, + { 1158, 170 }, + { 1182, 160 }, + { 1206, 150 }, + { 1228, 140 }, + { 1251, 130 }, + { 1274, 120 }, + { 1297, 110 }, + { 1320, 100 }, + { 1341, 90 }, + { 1362, 80 }, + { 1384, 70 }, + { 1405, 60 }, + { 1427, 50 }, + { 1450, 40 }, + { 1474, 30 }, + { 1498, 20 }, + { 1514, 10 }, + { 1533, 0 }, + { 1544, (-10) }, + { 1567, (-20) }, + { 1585, (-30) }, + { 1604, (-40) }, + { 1623, (-50) }, + { 1641, (-60) }, + { 1659, (-70) }, + { 1678, (-80) }, + { 1697, (-90) }, + { 1715, (-100) }, +}; + +struct max8998_charger_callbacks *callbacks; +static enum cable_type_t set_cable_status; + +static void max8998_charger_register_callbacks( + struct max8998_charger_callbacks *ptr) +{ + callbacks = ptr; + /* if there was a cable status change before the charger was + ready, send this now */ + if ((set_cable_status != 0) && callbacks && callbacks->set_cable) + callbacks->set_cable(callbacks, set_cable_status); +} + +static struct max8998_charger_data herring_charger = { + .register_callbacks = &max8998_charger_register_callbacks, +}; + +static void set_adc_table(void) +{ + if (!herring_is_tft_dev()) { + if (herring_is_cdma_wimax_dev()) { + herring_charger.adc_table = + temper_table_cdma_wimax_oled; + herring_charger.adc_array_size = + ARRAY_SIZE(temper_table_cdma_wimax_oled); + } else { + herring_charger.adc_table = temper_table_oled; + herring_charger.adc_array_size = + ARRAY_SIZE(temper_table_oled); + } + } else { + herring_charger.adc_table = temper_table_tft; + herring_charger.adc_array_size = + ARRAY_SIZE(temper_table_tft); + } +} + +static struct max8998_platform_data max8998_pdata = { + .num_regulators = ARRAY_SIZE(herring_regulators), + .regulators = herring_regulators, + .charger = &herring_charger, + /* Preloads must be in increasing order of voltage value */ + .buck1_voltage4 = 950000, + .buck1_voltage3 = 1050000, + .buck1_voltage2 = 1200000, + .buck1_voltage1 = 1275000, + .buck2_voltage2 = 1000000, + .buck2_voltage1 = 1100000, + .buck1_set1 = GPIO_BUCK_1_EN_A, + .buck1_set2 = GPIO_BUCK_1_EN_B, + .buck2_set3 = GPIO_BUCK_2_EN, + .buck1_default_idx = 1, + .buck2_default_idx = 0, +}; + +struct platform_device sec_device_dpram = { + .name = "dpram-device", + .id = -1, +}; + +static unsigned int lcd_type; +module_param_named(lcd_type, lcd_type, uint, 0444); +MODULE_PARM_DESC(lcd_type, "LCD type: default= sony, 1= hydis, 2= hitachi"); + +static void panel_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 ? */ +#ifdef CONFIG_FB_S3C_MDNIE + writel(0x1, S5P_MDNIE_SEL); +#else + writel(0x2, S5P_MDNIE_SEL); +#endif + + /* DISPLAY_CS */ + s3c_gpio_cfgpin(S5PV210_MP01(1), S3C_GPIO_SFN(1)); + /* DISPLAY_CLK */ + s3c_gpio_cfgpin(S5PV210_MP04(1), S3C_GPIO_SFN(1)); + /* DISPLAY_SO */ + s3c_gpio_cfgpin(S5PV210_MP04(2), S3C_GPIO_SFN(1)); + /* DISPLAY_SI */ + s3c_gpio_cfgpin(S5PV210_MP04(3), S3C_GPIO_SFN(1)); + + /* DISPLAY_CS */ + s3c_gpio_setpull(S5PV210_MP01(1), S3C_GPIO_PULL_NONE); + /* DISPLAY_CLK */ + s3c_gpio_setpull(S5PV210_MP04(1), S3C_GPIO_PULL_NONE); + /* DISPLAY_SO */ + s3c_gpio_setpull(S5PV210_MP04(2), S3C_GPIO_PULL_NONE); + /* DISPLAY_SI */ + s3c_gpio_setpull(S5PV210_MP04(3), S3C_GPIO_PULL_NONE); + + /* OLED_ID */ + if (herring_is_tft_dev()) { + s3c_gpio_cfgpin(GPIO_OLED_ID, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_OLED_ID, S3C_GPIO_PULL_DOWN); + } +} + +void lcd_cfg_gpio_early_suspend(void) +{ + int i; + + for (i = 0; i < 8; i++) { + s3c_gpio_cfgpin(S5PV210_GPF0(i), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPF0(i), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPF0(i), 0); + } + + for (i = 0; i < 8; i++) { + s3c_gpio_cfgpin(S5PV210_GPF1(i), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPF1(i), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPF1(i), 0); + } + + for (i = 0; i < 8; i++) { + s3c_gpio_cfgpin(S5PV210_GPF2(i), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPF2(i), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPF2(i), 0); + } + + for (i = 0; i < 4; i++) { + s3c_gpio_cfgpin(S5PV210_GPF3(i), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPF3(i), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPF3(i), 0); + } + /* drive strength to min */ + writel(0x00000000, S5P_VA_GPIO + 0x12c); /* GPF0DRV */ + writel(0x00000000, S5P_VA_GPIO + 0x14c); /* GPF1DRV */ + writel(0x00000000, S5P_VA_GPIO + 0x16c); /* GPF2DRV */ + writel(0x00000000, S5P_VA_GPIO + 0x18c); /* GPF3DRV */ + + /* OLED_DET */ + s3c_gpio_cfgpin(GPIO_OLED_DET, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_OLED_DET, S3C_GPIO_PULL_NONE); + gpio_set_value(GPIO_OLED_DET, 0); + + /* LCD_RST */ + s3c_gpio_cfgpin(GPIO_MLCD_RST, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_MLCD_RST, S3C_GPIO_PULL_NONE); + gpio_set_value(GPIO_MLCD_RST, 0); + + /* DISPLAY_CS */ + s3c_gpio_cfgpin(GPIO_DISPLAY_CS, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_DISPLAY_CS, S3C_GPIO_PULL_NONE); + gpio_set_value(GPIO_DISPLAY_CS, 0); + + /* DISPLAY_CLK */ + s3c_gpio_cfgpin(GPIO_DISPLAY_CLK, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_DISPLAY_CLK, S3C_GPIO_PULL_NONE); + gpio_set_value(GPIO_DISPLAY_CLK, 0); + + /* DISPLAY_SO */ + /* + s3c_gpio_cfgpin(S5PV210_MP04(2), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_MP04(2), S3C_GPIO_PULL_DOWN); + */ + + /* DISPLAY_SI */ + s3c_gpio_cfgpin(GPIO_DISPLAY_SI, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_DISPLAY_SI, S3C_GPIO_PULL_NONE); + gpio_set_value(GPIO_DISPLAY_SI, 0); + + /* OLED_ID */ + if (!herring_is_tft_dev()) { + s3c_gpio_cfgpin(GPIO_OLED_ID, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_OLED_ID, S3C_GPIO_PULL_DOWN); + /* gpio_set_value(GPIO_OLED_ID, 0); */ + } + + /* DIC_ID */ + s3c_gpio_cfgpin(GPIO_DIC_ID, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_DIC_ID, S3C_GPIO_PULL_DOWN); + /* gpio_set_value(GPIO_DIC_ID, 0); */ +} +EXPORT_SYMBOL(lcd_cfg_gpio_early_suspend); + +void lcd_cfg_gpio_late_resume(void) +{ + /* OLED_DET */ + s3c_gpio_cfgpin(GPIO_OLED_DET, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_OLED_DET, S3C_GPIO_PULL_NONE); + /* OLED_ID */ + if (!herring_is_tft_dev()) { + s3c_gpio_cfgpin(GPIO_OLED_ID, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_OLED_ID, S3C_GPIO_PULL_NONE); + /* gpio_set_value(GPIO_OLED_ID, 0); */ + } + /* DIC_ID */ + s3c_gpio_cfgpin(GPIO_DIC_ID, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_DIC_ID, S3C_GPIO_PULL_NONE); + /* gpio_set_value(GPIO_DIC_ID, 0); */ +} +EXPORT_SYMBOL(lcd_cfg_gpio_late_resume); + +static int panel_reset_lcd(struct platform_device *pdev) +{ + int err; + + err = gpio_request(S5PV210_MP05(5), "MLCD_RST"); + if (err) { + printk(KERN_ERR "failed to request MP0(5) for " + "lcd reset control\n"); + return err; + } + + gpio_direction_output(S5PV210_MP05(5), 1); + msleep(10); + + gpio_set_value(S5PV210_MP05(5), 0); + msleep(10); + + gpio_set_value(S5PV210_MP05(5), 1); + msleep(10); + + gpio_free(S5PV210_MP05(5)); + + return 0; +} + +static int panel_backlight_on(struct platform_device *pdev) +{ + return 0; +} + +static struct s3c_platform_fb tl2796_data __initdata = { + .hw_ver = 0x62, + .clk_name = "sclk_fimd", + .nr_wins = 5, + .default_win = CONFIG_FB_S3C_DEFAULT_WINDOW, + .swap = FB_SWAP_HWORD | FB_SWAP_WORD, + + .lcd = &s6e63m0, + .cfg_gpio = panel_cfg_gpio, + .backlight_on = panel_backlight_on, + .reset_lcd = panel_reset_lcd, +}; + +static struct s3c_platform_fb nt35580_data __initdata = { + .hw_ver = 0x62, + .clk_name = "sclk_fimd", + .nr_wins = 5, + .default_win = CONFIG_FB_S3C_DEFAULT_WINDOW, + .swap = FB_SWAP_HWORD | FB_SWAP_WORD, + + .lcd = &nt35580, + .cfg_gpio = panel_cfg_gpio, + .backlight_on = panel_backlight_on, + .reset_lcd = panel_reset_lcd, +}; + +static struct s3c_platform_fb r61408_data __initdata = { + .hw_ver = 0x62, + .clk_name = "sclk_fimd", + .nr_wins = 5, + .default_win = CONFIG_FB_S3C_DEFAULT_WINDOW, + .swap = FB_SWAP_HWORD | FB_SWAP_WORD, + + .lcd = &r61408, + .cfg_gpio = panel_cfg_gpio, + .backlight_on = panel_backlight_on, + .reset_lcd = panel_reset_lcd, +}; + +#define LCD_BUS_NUM 3 +#define DISPLAY_CS S5PV210_MP01(1) +#define SUB_DISPLAY_CS S5PV210_MP01(2) +#define DISPLAY_CLK S5PV210_MP04(1) +#define DISPLAY_SI S5PV210_MP04(3) + +static struct spi_board_info spi_board_info[] __initdata = { + { + .modalias = "tl2796", + .platform_data = &herring_panel_data, + .max_speed_hz = 1200000, + .bus_num = LCD_BUS_NUM, + .chip_select = 0, + .mode = SPI_MODE_3, + .controller_data = (void *)DISPLAY_CS, + }, +}; + +static struct spi_board_info spi_board_info_sony[] __initdata = { + { + .modalias = "nt35580", + .platform_data = &herring_sony_panel_data, + .max_speed_hz = 1200000, + .bus_num = LCD_BUS_NUM, + .chip_select = 0, + .mode = SPI_MODE_3, + .controller_data = (void *)DISPLAY_CS, + }, +}; + +static struct spi_board_info spi_board_info_hydis[] __initdata = { + { + .modalias = "nt35580", + .platform_data = &herring_hydis_panel_data, + .max_speed_hz = 1200000, + .bus_num = LCD_BUS_NUM, + .chip_select = 0, + .mode = SPI_MODE_3, + .controller_data = (void *)DISPLAY_CS, + }, +}; + +static struct spi_board_info spi_board_info_hitachi[] __initdata = { + { + .modalias = "nt35580", + .platform_data = &herring_hitachi_panel_data, + .max_speed_hz = 1200000, + .bus_num = LCD_BUS_NUM, + .chip_select = 0, + .mode = SPI_MODE_3, + .controller_data = (void *)DISPLAY_CS, + }, +}; + + +static struct spi_gpio_platform_data tl2796_spi_gpio_data = { + .sck = DISPLAY_CLK, + .mosi = DISPLAY_SI, + .miso = -1, + .num_chipselect = 2, +}; + +static struct platform_device s3c_device_spi_gpio = { + .name = "spi_gpio", + .id = LCD_BUS_NUM, + .dev = { + .parent = &s3c_device_fb.dev, + .platform_data = &tl2796_spi_gpio_data, + }, +}; + +static struct i2c_gpio_platform_data herring_i2c4_platdata = { + .sda_pin = GPIO_AP_SDA_18V, + .scl_pin = GPIO_AP_SCL_18V, + .udelay = 2, /* 250KHz */ + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c4_device = { + .name = "i2c-gpio", + .id = 4, + .dev.platform_data = &herring_i2c4_platdata, +}; + +static struct i2c_gpio_platform_data herring_i2c5_platdata = { + .sda_pin = GPIO_AP_SDA_28V, + .scl_pin = GPIO_AP_SCL_28V, + .udelay = 2, /* 250KHz */ + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c5_device = { + .name = "i2c-gpio", + .id = 5, + .dev.platform_data = &herring_i2c5_platdata, +}; + +static struct i2c_gpio_platform_data herring_i2c6_platdata = { + .sda_pin = GPIO_AP_PMIC_SDA, + .scl_pin = GPIO_AP_PMIC_SCL, + .udelay = 2, /* 250KHz */ + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c6_device = { + .name = "i2c-gpio", + .id = 6, + .dev.platform_data = &herring_i2c6_platdata, +}; + +static struct i2c_gpio_platform_data herring_i2c7_platdata = { + .sda_pin = GPIO_USB_SDA_28V, + .scl_pin = GPIO_USB_SCL_28V, + .udelay = 2, /* 250KHz */ + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c7_device = { + .name = "i2c-gpio", + .id = 7, + .dev.platform_data = &herring_i2c7_platdata, +}; + +static struct i2c_gpio_platform_data herring_i2c8_platdata = { + .sda_pin = GYRO_SDA_28V, + .scl_pin = GYRO_SCL_28V, + .udelay = 2, /* 250KHz */ + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c8_device = { + .name = "i2c-gpio", + .id = 8, + .dev.platform_data = &herring_i2c8_platdata, +}; + +static struct i2c_gpio_platform_data herring_i2c9_platdata = { + .sda_pin = FUEL_SDA_18V, + .scl_pin = FUEL_SCL_18V, + .udelay = 2, /* 250KHz */ + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c9_device = { + .name = "i2c-gpio", + .id = 9, + .dev.platform_data = &herring_i2c9_platdata, +}; + +static struct i2c_gpio_platform_data herring_i2c10_platdata = { + .sda_pin = _3_TOUCH_SDA_28V, + .scl_pin = _3_TOUCH_SCL_28V, + .udelay = 0, /* 250KHz */ + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c10_device = { + .name = "i2c-gpio", + .id = 10, + .dev.platform_data = &herring_i2c10_platdata, +}; + +static struct i2c_gpio_platform_data herring_i2c11_platdata = { + .sda_pin = GPIO_ALS_SDA_28V, + .scl_pin = GPIO_ALS_SCL_28V, + .udelay = 2, /* 250KHz */ + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c11_device = { + .name = "i2c-gpio", + .id = 11, + .dev.platform_data = &herring_i2c11_platdata, +}; + +static struct i2c_gpio_platform_data herring_i2c12_platdata = { + .sda_pin = GPIO_MSENSE_SDA_28V, + .scl_pin = GPIO_MSENSE_SCL_28V, + .udelay = 0, /* 250KHz */ + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c12_device = { + .name = "i2c-gpio", + .id = 12, + .dev.platform_data = &herring_i2c12_platdata, +}; + +static struct i2c_gpio_platform_data herring_i2c14_platdata = { + .sda_pin = NFC_SDA_18V, + .scl_pin = NFC_SCL_18V, + .udelay = 2, + .sda_is_open_drain = 0, + .scl_is_open_drain = 0, + .scl_is_output_only = 0, +}; + +static struct platform_device herring_i2c14_device = { + .name = "i2c-gpio", + .id = 14, + .dev.platform_data = &herring_i2c14_platdata, +}; + +/* max8893 wimax PMIC */ +static struct i2c_gpio_platform_data herring_i2c15_platdata = { + .sda_pin = GPIO_WIMAX_PM_SDA, + .scl_pin = GPIO_WIMAX_PM_SCL, +}; + +static struct platform_device herring_i2c15_device = { + .name = "i2c-gpio", + .id = 15, + .dev.platform_data = &herring_i2c15_platdata, +}; + +static struct regulator_init_data herring_max8893_buck_data = { + .constraints = { + .name = "max8893_buck", + .min_uV = 1200000, + .max_uV = 1200000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | + REGULATOR_CHANGE_STATUS, + }, +}; + +static struct regulator_init_data herring_max8893_ldo1_data = { + .constraints = { + .name = "max8893_ldo1", + .min_uV = 2800000, + .max_uV = 2800000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | + REGULATOR_CHANGE_STATUS, + }, +}; + +static struct regulator_init_data herring_max8893_ldo2_data = { + .constraints = { + .name = "max8893_ldo2", + .min_uV = 2800000, + .max_uV = 2800000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | + REGULATOR_CHANGE_STATUS, + }, +}; + +static struct regulator_init_data herring_max8893_ldo3_data = { + .constraints = { + .name = "max8893_ldo3", + .min_uV = 3300000, + .max_uV = 3300000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | + REGULATOR_CHANGE_STATUS, + }, +}; + +static struct regulator_init_data herring_max8893_ldo4_data = { + .constraints = { + .name = "max8893_ldo4", + .min_uV = 2900000, + .max_uV = 2900000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | + REGULATOR_CHANGE_STATUS, + }, +}; + +static struct regulator_init_data herring_max8893_ldo5_data = { + .constraints = { + .name = "max8893_ldo5", + .min_uV = 2800000, + .max_uV = 2800000, + .apply_uV = 1, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | + REGULATOR_CHANGE_STATUS, + }, +}; + +static struct max8893_subdev_data herring_max8893_subdev_data[] = { + { + .id = MAX8893_BUCK, + .initdata = &herring_max8893_buck_data, + }, + { + .id = MAX8893_LDO1, + .initdata = &herring_max8893_ldo1_data, + }, + { + .id = MAX8893_LDO2, + .initdata = &herring_max8893_ldo2_data, + }, + { + .id = MAX8893_LDO3, + .initdata = &herring_max8893_ldo3_data, + }, + { + .id = MAX8893_LDO4, + .initdata = &herring_max8893_ldo4_data, + }, + { + .id = MAX8893_LDO5, + .initdata = &herring_max8893_ldo5_data, + }, +}; + +static struct max8893_platform_data herring_max8893_pdata = { + .num_subdevs = ARRAY_SIZE(herring_max8893_subdev_data), + .subdevs = herring_max8893_subdev_data, +}; + +static struct i2c_board_info i2c_devs15[] __initdata = { + { + I2C_BOARD_INFO("max8893", 0x3E), + .platform_data = &herring_max8893_pdata, + }, +}; + +static struct wimax_cfg wimax_config; + +static unsigned int wimax_sdio_on_table[][4] = { + {GPIO_WIMAX_SDIO_CLK, 2, GPIO_LEVEL_NONE, S3C_GPIO_PULL_UP}, + {GPIO_WIMAX_SDIO_CMD, 2, GPIO_LEVEL_NONE, S3C_GPIO_PULL_UP}, + {GPIO_WIMAX_SDIO_D0, 2, GPIO_LEVEL_NONE, S3C_GPIO_PULL_UP}, + {GPIO_WIMAX_SDIO_D1, 2, GPIO_LEVEL_NONE, S3C_GPIO_PULL_UP}, + {GPIO_WIMAX_SDIO_D2, 2, GPIO_LEVEL_NONE, S3C_GPIO_PULL_UP}, + {GPIO_WIMAX_SDIO_D3, 2, GPIO_LEVEL_NONE, S3C_GPIO_PULL_UP}, +}; + +static unsigned int wimax_sdio_off_table[][4] = { + {GPIO_WIMAX_SDIO_CLK, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, + {GPIO_WIMAX_SDIO_CMD, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, + {GPIO_WIMAX_SDIO_D0, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, + {GPIO_WIMAX_SDIO_D1, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, + {GPIO_WIMAX_SDIO_D2, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, + {GPIO_WIMAX_SDIO_D3, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, +}; + +static int wimax_sdio_en(int onoff) +{ + u32 i; + u32 sdio; + unsigned int (*wimax_gpio_table)[4]; + + wimax_gpio_table = onoff ? wimax_sdio_on_table : wimax_sdio_off_table; + + for (i = 0; i < ARRAY_SIZE(wimax_sdio_on_table); i++) { + sdio = wimax_gpio_table[i][0]; + s3c_gpio_cfgpin(sdio, + S3C_GPIO_SFN(wimax_gpio_table[i][1])); + s3c_gpio_setpull(sdio, wimax_gpio_table[i][3]); + s3c_gpio_set_drvstrength(sdio, S3C_GPIO_DRVSTR_2X); + + if (wimax_gpio_table[i][2] != GPIO_LEVEL_NONE) + gpio_set_value(sdio, wimax_gpio_table[i][2]); + } + return 0; +} + +static void wimax_deinit_gpios(void); +/* signal wimax modem to wakeup if asleep */ +static void wimax_wakeup_assert(int enable) +{ + if (herring_is_cdma_wimax_rev(0) || herring_is_cdma_wimax_rev(1)) + gpio_set_value(GPIO_WIMAX_WAKEUP, !enable); + else + gpio_set_value(GPIO_USB_SEL, !enable); +} + +static int get_wimax_sleep_mode(void) +{ + return gpio_get_value(GPIO_WIMAX_IF_MODE1); +} + +static int is_wimax_active(void) +{ + return gpio_get_value(GPIO_WIMAX_CON0); +} + +/* signal AP is active*/ +static void signal_ap_active(int enable) +{ + gpio_set_value(GPIO_WIMAX_CON1, enable); +} + +/* switch USB path to AP */ +void switch_usb_ap(void) +{ + gpio_set_value(GPIO_USB_HS_SEL, 1); + msleep(10); +} + +/* switch USB path to WiMAX */ +void switch_usb_wimax(void) +{ + gpio_set_value(GPIO_USB_HS_SEL, 0); + msleep(10); +} + +void wimax_init_gpios(void) +{ + s3c_gpio_cfgpin(GPIO_WIMAX_RESET_N, S3C_GPIO_OUTPUT); + gpio_set_value(GPIO_WIMAX_RESET_N, 0); + + s3c_gpio_cfgpin(GPIO_WIMAX_DBGEN_28V, S3C_GPIO_OUTPUT); + gpio_set_value(GPIO_WIMAX_DBGEN_28V, 0); + + s3c_gpio_cfgpin(GPIO_WIMAX_I2C_CON, S3C_GPIO_OUTPUT); + gpio_set_value(GPIO_WIMAX_I2C_CON, 1); + msleep(10); + + if (herring_is_cdma_wimax_rev(0) || herring_is_cdma_wimax_rev(1)) { + s3c_gpio_setpull(GPIO_USB_SEL, S3C_GPIO_PULL_UP); + s3c_gpio_cfgpin(GPIO_WIMAX_WAKEUP, S3C_GPIO_OUTPUT); + } else { + /* g_pdata->wimax_int set Input and Pull up */ + s3c_gpio_setpull(GPIO_WIMAX_WAKEUP, S3C_GPIO_PULL_UP); + s3c_gpio_cfgpin(GPIO_USB_SEL, S3C_GPIO_OUTPUT); + } + wimax_wakeup_assert(0); + + /* + * IDLE, VI setting pin: high for suspend idle, + * low for suspend vi + */ + s3c_gpio_cfgpin(GPIO_WIMAX_IF_MODE1, S3C_GPIO_OUTPUT); + gpio_set_value(GPIO_WIMAX_IF_MODE1, 1); + + s3c_gpio_cfgpin(GPIO_WIMAX_IF_MODE0, S3C_GPIO_OUTPUT); + + /* IDLE, VI interrupt for WiMAX */ + s3c_gpio_cfgpin(GPIO_WIMAX_CON2, S3C_GPIO_OUTPUT); + gpio_set_value(GPIO_WIMAX_CON2, 1);/* active low interrupt */ + + /* PDA Active */ + s3c_gpio_cfgpin(GPIO_WIMAX_CON1, S3C_GPIO_OUTPUT); + s3c_gpio_set_drvstrength(GPIO_WIMAX_CON1, S3C_GPIO_DRVSTR_2X); + signal_ap_active(1); + +} + +static void hw_set_wimax_mode(void) +{ + bool legacy_rev; + + legacy_rev = herring_is_cdma_wimax_rev(0) || + herring_is_cdma_wimax_rev(1); + + switch (wimax_config.wimax_mode) { + case SDIO_MODE: + pr_debug("SDIO MODE"); + if (legacy_rev) + gpio_set_value(GPIO_WIMAX_WAKEUP, 1); + else + gpio_set_value(GPIO_USB_SEL, 1); + gpio_set_value(GPIO_WIMAX_IF_MODE0, 1); + break; + case WTM_MODE: + case AUTH_MODE: + if (legacy_rev) + gpio_set_value(GPIO_WIMAX_WAKEUP, 0); + else + gpio_set_value(GPIO_USB_SEL, 0); + gpio_set_value(GPIO_WIMAX_IF_MODE0, 0); + break; + case DM_MODE: + pr_debug("DM MODE"); + if (legacy_rev) + gpio_set_value(GPIO_WIMAX_WAKEUP, 1); + else + gpio_set_value(GPIO_USB_SEL, 1); + gpio_set_value(GPIO_WIMAX_IF_MODE0, 0); + break; + case USB_MODE: + case USIM_RELAY_MODE: + pr_debug("USB MODE"); + if (legacy_rev) + gpio_set_value(GPIO_WIMAX_WAKEUP, 0); + else + gpio_set_value(GPIO_USB_SEL, 0); + gpio_set_value(GPIO_WIMAX_IF_MODE0, 1); + break; + } +} + +void wimax_hsmmc_presence_check(void) +{ + sdhci_s3c_force_presence_change(&s3c_device_hsmmc2); +} + +int gpio_wimax_power(int enable) +{ + if (!enable) + goto wimax_power_off; + + if (gpio_get_value(GPIO_WIMAX_EN)) { + pr_debug("Already Wimax powered ON"); + return WIMAX_ALREADY_POWER_ON; + } + /* wait for sdio remove complete*/ + while (!wimax_config.card_removed) + msleep(100); + + pr_debug("Wimax power ON"); + + wimax_sdio_en(1); + wimax_init_gpios(); + + if (wimax_config.wimax_mode != SDIO_MODE) + switch_usb_wimax(); + + gpio_set_value(GPIO_WIMAX_I2C_CON, 1); + msleep(10); + + gpio_set_value(GPIO_WIMAX_EN, 1); + + msleep(10); + pr_debug("RESET"); + + gpio_set_value(GPIO_WIMAX_RESET_N, 1); + + /* Delay important for bootloader initialization */ + msleep(1800); + + /*Dont force detect if the card is already detected*/ + if (wimax_config.card_removed) + wimax_hsmmc_presence_check(); + + return WIMAX_POWER_SUCCESS; + +wimax_power_off: + /*Wait for modem to flush EEPROM data*/ + msleep(500); + wimax_deinit_gpios(); + + pr_debug("Wimax power OFF"); + + /*Dont force detect if the card is already detected as removed*/ + if (!wimax_config.card_removed) + wimax_hsmmc_presence_check(); + + /*Not critial, just some safty margin*/ + msleep(300); + wimax_sdio_en(0); + + return WIMAX_POWER_SUCCESS; +} + +static struct wimax732_platform_data wimax732_pdata = { + .power = gpio_wimax_power, + .set_mode = hw_set_wimax_mode, + .signal_ap_active = signal_ap_active, + .get_sleep_mode = get_wimax_sleep_mode, + .is_modem_awake = is_wimax_active, + .wakeup_assert = wimax_wakeup_assert, + .g_cfg = &wimax_config, + .wimax_int = GPIO_USB_SEL, /* GPIO_USB_SEL,*/ +}; + +static struct platform_device s3c_device_cmc732 = { + .name = "wimax732_driver", + .id = 1, + .dev.platform_data = &wimax732_pdata, +}; + +void wimax_deinit_gpios(void) +{ + /* Disable WiMAX JTAG for freerun */ + s3c_gpio_cfgpin(GPIO_WIMAX_DBGEN_28V, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_WIMAX_DBGEN_28V, S3C_GPIO_PULL_NONE); + + /* g_pdata->wimax_int set Output low */ + s3c_gpio_cfgpin(GPIO_USB_SEL, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_USB_SEL, S3C_GPIO_PULL_NONE); + + /* MODE pin */ + s3c_gpio_cfgpin(GPIO_WIMAX_WAKEUP, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_WIMAX_WAKEUP, S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(GPIO_WIMAX_IF_MODE0, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_WIMAX_IF_MODE0, S3C_GPIO_PULL_NONE); + + /* WiMAX active */ + s3c_gpio_cfgpin(GPIO_WIMAX_CON0, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_WIMAX_CON0, S3C_GPIO_PULL_NONE); + + /* IDLE, VI setting pin: high for suspend idle, + low for suspend vi */ + s3c_gpio_cfgpin(GPIO_WIMAX_IF_MODE1, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_WIMAX_IF_MODE1, S3C_GPIO_PULL_NONE); + + /* IDLE, VI interrupt for WiMAX */ + s3c_gpio_cfgpin(GPIO_WIMAX_CON2, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_WIMAX_CON2, S3C_GPIO_PULL_NONE); + + /* PDA Active */ + s3c_gpio_cfgpin(GPIO_WIMAX_CON1, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_WIMAX_CON1, S3C_GPIO_PULL_NONE); + + /* power related */ + s3c_gpio_cfgpin(GPIO_WIMAX_RESET_N, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_WIMAX_RESET_N, S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(GPIO_WIMAX_EN, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_WIMAX_EN, S3C_GPIO_PULL_NONE); + + /* EEPROM switch to WiMAX */ + s3c_gpio_cfgpin(GPIO_WIMAX_I2C_CON, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_WIMAX_I2C_CON, S3C_GPIO_PULL_NONE); + + gpio_set_value(GPIO_WIMAX_EN, 0); + s3c_gpio_cfgpin(GPIO_WIMAX_I2C_CON, S3C_GPIO_INPUT); + + s3c_gpio_cfgpin(GPIO_UART_SEL, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_UART_SEL, S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(GPIO_UART_SEL1, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_UART_SEL1, S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(GPIO_USB_HS_SEL, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_USB_HS_SEL, S3C_GPIO_PULL_NONE); + switch_usb_ap(); + + if (herring_is_cdma_wimax_rev(0) || herring_is_cdma_wimax_rev(1)) + wimax732_pdata.wimax_int = GPIO_USB_SEL; + else + wimax732_pdata.wimax_int = GPIO_WIMAX_WAKEUP; +} + +static void touch_keypad_gpio_init(void) +{ + int ret = 0; + + ret = gpio_request(_3_GPIO_TOUCH_EN, "TOUCH_EN"); + if (ret) + printk(KERN_ERR "Failed to request gpio touch_en.\n"); +} + +static void touch_keypad_onoff(int onoff) +{ + gpio_direction_output(_3_GPIO_TOUCH_EN, onoff); + + if (onoff == TOUCHKEY_OFF) + msleep(30); + else + msleep(50); +} + +static const int touch_keypad_code[] = { + KEY_MENU, + KEY_HOME, + KEY_BACK, + KEY_SEARCH +}; + +static struct touchkey_platform_data touchkey_data = { + .keycode_cnt = ARRAY_SIZE(touch_keypad_code), + .keycode = touch_keypad_code, + .touchkey_onoff = touch_keypad_onoff, + .fw_name = "cypress-touchkey.bin", + .scl_pin = _3_TOUCH_SCL_28V, + .sda_pin = _3_TOUCH_SDA_28V, + .en_pin = _3_GPIO_TOUCH_EN, +}; + +static struct gpio_event_direct_entry herring_keypad_key_map[] = { + { + .gpio = S5PV210_GPH2(6), + .code = KEY_POWER, + }, + { + .gpio = S5PV210_GPH3(1), + .code = KEY_VOLUMEDOWN, + }, + { + .gpio = S5PV210_GPH3(2), + .code = KEY_VOLUMEUP, + } +}; + +static struct gpio_event_input_info herring_keypad_key_info = { + .info.func = gpio_event_input_func, + .info.no_suspend = true, + .debounce_time.tv64 = 5 * NSEC_PER_MSEC, + .type = EV_KEY, + .keymap = herring_keypad_key_map, + .keymap_size = ARRAY_SIZE(herring_keypad_key_map) +}; + +static struct gpio_event_info *herring_input_info[] = { + &herring_keypad_key_info.info, +}; + + +static struct gpio_event_platform_data herring_input_data = { + .names = { + "herring-keypad", + NULL, + }, + .info = herring_input_info, + .info_count = ARRAY_SIZE(herring_input_info), +}; + +static struct platform_device herring_input_device = { + .name = GPIO_EVENT_DEV_NAME, + .id = 0, + .dev = { + .platform_data = &herring_input_data, + }, +}; + +#ifdef CONFIG_S5P_ADC +static struct s3c_adc_mach_info s3c_adc_platform __initdata = { + /* s5pc110 support 12-bit resolution */ + .delay = 10000, + .presc = 65, + .resolution = 12, +}; +#endif + +/* in revisions before 0.9, there is a common mic bias gpio */ + +static DEFINE_SPINLOCK(mic_bias_lock); +static bool wm8994_mic_bias; +static bool jack_mic_bias; +static void set_shared_mic_bias(void) +{ + gpio_set_value(GPIO_MICBIAS_EN, wm8994_mic_bias || jack_mic_bias); +} + +static void wm8994_set_mic_bias(bool on) +{ + if (system_rev < 0x09) { + unsigned long flags; + spin_lock_irqsave(&mic_bias_lock, flags); + wm8994_mic_bias = on; + set_shared_mic_bias(); + spin_unlock_irqrestore(&mic_bias_lock, flags); + } else + gpio_set_value(GPIO_MICBIAS_EN, on); +} + +static void sec_jack_set_micbias_state(bool on) +{ + if (system_rev < 0x09) { + unsigned long flags; + spin_lock_irqsave(&mic_bias_lock, flags); + jack_mic_bias = on; + set_shared_mic_bias(); + spin_unlock_irqrestore(&mic_bias_lock, flags); + } else + gpio_set_value(GPIO_EAR_MICBIAS_EN, on); +} + +static struct wm8994_platform_data wm8994_pdata = { + .ldo = GPIO_CODEC_LDO_EN, + .ear_sel = GPIO_EAR_SEL, + .set_mic_bias = wm8994_set_mic_bias, +}; + +/* + * Guide for Camera Configuration for Crespo board + * ITU CAM CH A: LSI s5k4ecgx + */ +static DEFINE_MUTEX(s5k4ecgx_lock); +static struct regulator *cam_isp_core_regulator; +static struct regulator *cam_isp_host_regulator; +static struct regulator *cam_af_regulator; +static bool s5k4ecgx_powered_on; +static int s5k4ecgx_regulator_init(void) +{ + if (IS_ERR_OR_NULL(cam_isp_core_regulator)) { + cam_isp_core_regulator = regulator_get(NULL, "cam_isp_core"); + if (IS_ERR_OR_NULL(cam_isp_core_regulator)) { + pr_err("failed to get cam_isp_core regulator"); + return -EINVAL; + } + } + if (IS_ERR_OR_NULL(cam_isp_host_regulator)) { + cam_isp_host_regulator = regulator_get(NULL, "cam_isp_host"); + if (IS_ERR_OR_NULL(cam_isp_host_regulator)) { + pr_err("failed to get cam_isp_host regulator"); + return -EINVAL; + } + } + if (IS_ERR_OR_NULL(cam_af_regulator)) { + cam_af_regulator = regulator_get(NULL, "cam_af"); + if (IS_ERR_OR_NULL(cam_af_regulator)) { + pr_err("failed to get cam_af regulator"); + return -EINVAL; + } + } + pr_debug("cam_isp_core_regulator = %p\n", cam_isp_core_regulator); + pr_debug("cam_isp_host_regulator = %p\n", cam_isp_host_regulator); + pr_debug("cam_af_regulator = %p\n", cam_af_regulator); + return 0; +} + +static void s5k4ecgx_init(void) +{ + /* CAM_IO_EN - GPB(7) */ + if (gpio_request(GPIO_GPB7, "GPB7") < 0) + pr_err("failed gpio_request(GPB7) for camera control\n"); + /* CAM_MEGA_nRST - GPJ1(5) */ + if (gpio_request(GPIO_CAM_MEGA_nRST, "GPJ1") < 0) + pr_err("failed gpio_request(GPJ1) for camera control\n"); + /* CAM_MEGA_EN - GPJ0(6) */ + if (gpio_request(GPIO_CAM_MEGA_EN, "GPJ0") < 0) + pr_err("failed gpio_request(GPJ0) for camera control\n"); + /* FLASH_EN - GPJ1(2) */ + if (gpio_request(GPIO_FLASH_EN, "GPIO_FLASH_EN") < 0) + pr_err("failed gpio_request(GPIO_FLASH_EN)\n"); + /* FLASH_EN_SET - GPJ1(0) */ + if (gpio_request(GPIO_CAM_FLASH_EN_SET, "GPIO_CAM_FLASH_EN_SET") < 0) + pr_err("failed gpio_request(GPIO_CAM_FLASH_EN_SET)\n"); +} + +static int s5k4ecgx_ldo_en(bool en) +{ + int err = 0; + int result; + + if (IS_ERR_OR_NULL(cam_isp_core_regulator) || + IS_ERR_OR_NULL(cam_isp_host_regulator) || + IS_ERR_OR_NULL(cam_af_regulator)) { + pr_err("Camera regulators not initialized\n"); + return -EINVAL; + } + + if (!en) + goto off; + + /* Turn CAM_ISP_CORE_1.2V(VDD_REG) on */ + err = regulator_enable(cam_isp_core_regulator); + if (err) { + pr_err("Failed to enable regulator cam_isp_core\n"); + goto off; + } + mdelay(1); + + /* Turn CAM_SENSOR_A_2.8V(VDDA) on */ + gpio_set_value(GPIO_GPB7, 1); + mdelay(1); + + /* Turn CAM_ISP_HOST_2.8V(VDDIO) on */ + err = regulator_enable(cam_isp_host_regulator); + if (err) { + pr_err("Failed to enable regulator cam_isp_core\n"); + goto off; + } + udelay(50); + + /* Turn CAM_AF_2.8V or 3.0V on */ + err = regulator_enable(cam_af_regulator); + if (err) { + pr_err("Failed to enable regulator cam_isp_core\n"); + goto off; + } + udelay(50); + return 0; + +off: + result = err; + err = regulator_disable(cam_af_regulator); + if (err) { + pr_err("Failed to disable regulator cam_isp_core\n"); + result = err; + } + err = regulator_disable(cam_isp_host_regulator); + if (err) { + pr_err("Failed to disable regulator cam_isp_core\n"); + result = err; + } + gpio_set_value(GPIO_GPB7, 0); + err = regulator_disable(cam_isp_core_regulator); + if (err) { + pr_err("Failed to disable regulator cam_isp_core\n"); + result = err; + } + return result; +} + +static int s5k4ecgx_power_on(void) +{ + /* LDO on */ + int err; + + /* can't do this earlier because regulators aren't available in + * early boot + */ + if (s5k4ecgx_regulator_init()) { + pr_err("Failed to initialize camera regulators\n"); + return -EINVAL; + } + + err = s5k4ecgx_ldo_en(true); + if (err) + return err; + mdelay(66); + + /* MCLK on - default is input, to save power when camera not on */ + s3c_gpio_cfgpin(GPIO_CAM_MCLK, S3C_GPIO_SFN(GPIO_CAM_MCLK_AF)); + mdelay(1); + + /* CAM_MEGA_EN - GPJ1(2) LOW */ + gpio_set_value(GPIO_CAM_MEGA_EN, 1); + mdelay(1); + + /* CAM_MEGA_nRST - GPJ1(5) LOW */ + gpio_set_value(GPIO_CAM_MEGA_nRST, 1); + mdelay(1); + + return 0; +} + +static int s5k4ecgx_power_off(void) +{ + /* CAM_MEGA_nRST - GPJ1(5) LOW */ + gpio_set_value(GPIO_CAM_MEGA_nRST, 0); + udelay(60); + + /* Mclk disable - set to input function to save power */ + s3c_gpio_cfgpin(GPIO_CAM_MCLK, 0); + udelay(10); + + /* CAM_MEGA_EN - GPJ1(2) LOW */ + gpio_set_value(GPIO_CAM_MEGA_EN, 0); + udelay(10); + + s5k4ecgx_ldo_en(false); + mdelay(1); + + return 0; +} + +static int s5k4ecgx_power_en(int onoff) +{ + int err = 0; + mutex_lock(&s5k4ecgx_lock); + /* we can be asked to turn off even if we never were turned + * on if something odd happens and we are closed + * by camera framework before we even completely opened. + */ + if (onoff != s5k4ecgx_powered_on) { + if (onoff) + err = s5k4ecgx_power_on(); + else + err = s5k4ecgx_power_off(); + if (!err) + s5k4ecgx_powered_on = onoff; + } + mutex_unlock(&s5k4ecgx_lock); + return err; +} + +#define FLASH_MOVIE_MODE_CURRENT_50_PERCENT 7 + +#define FLASH_TIME_LATCH_US 500 +#define FLASH_TIME_EN_SET_US 1 + +/* The AAT1274 uses a single wire interface to write data to its + * control registers. An incoming value is written by sending a number + * of rising edges to EN_SET. Data is 4 bits, or 1-16 pulses, and + * addresses are 17 pulses or more. Data written without an address + * controls the current to the LED via the default address 17. */ +static void aat1274_write(int value) +{ + while (value--) { + gpio_set_value(GPIO_CAM_FLASH_EN_SET, 0); + udelay(FLASH_TIME_EN_SET_US); + gpio_set_value(GPIO_CAM_FLASH_EN_SET, 1); + udelay(FLASH_TIME_EN_SET_US); + } + udelay(FLASH_TIME_LATCH_US); + /* At this point, the LED will be on */ +} + +static int aat1274_flash(int enable) +{ + /* Turn main flash on or off by asserting a value on the EN line. */ + gpio_set_value(GPIO_FLASH_EN, !!enable); + + return 0; +} + +static int aat1274_af_assist(int enable) +{ + /* Turn assist light on or off by asserting a value on the EN_SET + * line. The default illumination level of 1/7.3 at 100% is used */ + gpio_set_value(GPIO_CAM_FLASH_EN_SET, !!enable); + if (!enable) + gpio_set_value(GPIO_FLASH_EN, 0); + + return 0; +} + +static int aat1274_torch(int enable) +{ + /* Turn torch mode on or off by writing to the EN_SET line. A level + * of 1/7.3 and 50% is used (half AF assist brightness). */ + if (enable) { + aat1274_write(FLASH_MOVIE_MODE_CURRENT_50_PERCENT); + } else { + gpio_set_value(GPIO_CAM_FLASH_EN_SET, 0); + gpio_set_value(GPIO_FLASH_EN, 0); + } + + return 0; +} + +static struct s5k4ecgx_platform_data s5k4ecgx_plat = { + .default_width = 640, + .default_height = 480, + .pixelformat = V4L2_PIX_FMT_UYVY, + .freq = 24000000, + .flash_onoff = &aat1274_flash, + .af_assist_onoff = &aat1274_af_assist, + .torch_onoff = &aat1274_torch, +}; + +static struct i2c_board_info s5k4ecgx_i2c_info = { + I2C_BOARD_INFO("S5K4ECGX", 0x5A>>1), + .platform_data = &s5k4ecgx_plat, +}; + +static struct s3c_platform_camera s5k4ecgx = { + .id = CAMERA_PAR_A, + .type = CAM_TYPE_ITU, + .fmt = ITU_601_YCBCR422_8BIT, + .order422 = CAM_ORDER422_8BIT_CBYCRY, + .i2c_busnum = 0, + .info = &s5k4ecgx_i2c_info, + .pixelformat = V4L2_PIX_FMT_UYVY, + .srclk_name = "xusbxti", + .clk_name = "sclk_cam", + .clk_rate = 24000000, + .line_length = 1920, + .width = 640, + .height = 480, + .window = { + .left = 0, + .top = 0, + .width = 640, + .height = 480, + }, + + /* Polarity */ + .inv_pclk = 0, + .inv_vsync = 1, + .inv_href = 0, + .inv_hsync = 0, + + .initialized = 0, + .cam_power = s5k4ecgx_power_en, +}; + + +/* External camera module setting */ +static DEFINE_MUTEX(s5ka3dfx_lock); +static struct regulator *s5ka3dfx_vga_avdd; +static struct regulator *s5ka3dfx_vga_vddio; +static struct regulator *s5ka3dfx_cam_isp_host; +static struct regulator *s5ka3dfx_vga_dvdd; +static bool s5ka3dfx_powered_on; + +static int s5ka3dfx_request_gpio(void) +{ + int err; + + /* CAM_VGA_nSTBY - GPB(0) */ + err = gpio_request(GPIO_CAM_VGA_nSTBY, "GPB0"); + if (err) { + pr_err("Failed to request GPB0 for camera control\n"); + return -EINVAL; + } + + /* CAM_VGA_nRST - GPB(2) */ + err = gpio_request(GPIO_CAM_VGA_nRST, "GPB2"); + if (err) { + pr_err("Failed to request GPB2 for camera control\n"); + gpio_free(GPIO_CAM_VGA_nSTBY); + return -EINVAL; + } + + return 0; +} + +static int s5ka3dfx_power_init(void) +{ + if (IS_ERR_OR_NULL(s5ka3dfx_vga_avdd)) + s5ka3dfx_vga_avdd = regulator_get(NULL, "vga_avdd"); + + if (IS_ERR_OR_NULL(s5ka3dfx_vga_avdd)) { + pr_err("Failed to get regulator vga_avdd\n"); + return -EINVAL; + } + + if (IS_ERR_OR_NULL(s5ka3dfx_vga_vddio)) + s5ka3dfx_vga_vddio = regulator_get(NULL, "vga_vddio"); + + if (IS_ERR_OR_NULL(s5ka3dfx_vga_vddio)) { + pr_err("Failed to get regulator vga_vddio\n"); + return -EINVAL; + } + + if (IS_ERR_OR_NULL(s5ka3dfx_cam_isp_host)) + s5ka3dfx_cam_isp_host = regulator_get(NULL, "cam_isp_host"); + + if (IS_ERR_OR_NULL(s5ka3dfx_cam_isp_host)) { + pr_err("Failed to get regulator cam_isp_host\n"); + return -EINVAL; + } + + if (IS_ERR_OR_NULL(s5ka3dfx_vga_dvdd)) + s5ka3dfx_vga_dvdd = regulator_get(NULL, "vga_dvdd"); + + if (IS_ERR_OR_NULL(s5ka3dfx_vga_dvdd)) { + pr_err("Failed to get regulator vga_dvdd\n"); + return -EINVAL; + } + + return 0; +} + +static int s5ka3dfx_power_on(void) +{ + int err = 0; + int result; + + if (s5ka3dfx_power_init()) { + pr_err("Failed to get all regulator\n"); + return -EINVAL; + } + + /* Turn VGA_AVDD_2.8V on */ + err = regulator_enable(s5ka3dfx_vga_avdd); + if (err) { + pr_err("Failed to enable regulator vga_avdd\n"); + return -EINVAL; + } + msleep(3); + + /* Turn VGA_VDDIO_2.8V on */ + err = regulator_enable(s5ka3dfx_vga_vddio); + if (err) { + pr_err("Failed to enable regulator vga_vddio\n"); + goto off_vga_vddio; + } + udelay(20); + + /* Turn VGA_DVDD_1.8V on */ + err = regulator_enable(s5ka3dfx_vga_dvdd); + if (err) { + pr_err("Failed to enable regulator vga_dvdd\n"); + goto off_vga_dvdd; + } + udelay(100); + + /* CAM_VGA_nSTBY HIGH */ + gpio_direction_output(GPIO_CAM_VGA_nSTBY, 0); + gpio_set_value(GPIO_CAM_VGA_nSTBY, 1); + + udelay(10); + + /* Mclk enable */ + s3c_gpio_cfgpin(GPIO_CAM_MCLK, S3C_GPIO_SFN(0x02)); + udelay(430); + + /* Turn CAM_ISP_HOST_2.8V on */ + err = regulator_enable(s5ka3dfx_cam_isp_host); + if (err) { + pr_err("Failed to enable regulator cam_isp_host\n"); + goto off_cam_isp_host; + } + udelay(150); + + /* CAM_VGA_nRST HIGH */ + gpio_direction_output(GPIO_CAM_VGA_nRST, 0); + gpio_set_value(GPIO_CAM_VGA_nRST, 1); + mdelay(5); + + return 0; +off_cam_isp_host: + s3c_gpio_cfgpin(GPIO_CAM_MCLK, 0); + udelay(1); + gpio_direction_output(GPIO_CAM_VGA_nSTBY, 1); + gpio_set_value(GPIO_CAM_VGA_nSTBY, 0); + udelay(1); + err = regulator_disable(s5ka3dfx_vga_dvdd); + if (err) { + pr_err("Failed to disable regulator vga_dvdd\n"); + result = err; + } +off_vga_dvdd: + err = regulator_disable(s5ka3dfx_vga_vddio); + if (err) { + pr_err("Failed to disable regulator vga_vddio\n"); + result = err; + } +off_vga_vddio: + err = regulator_disable(s5ka3dfx_vga_avdd); + if (err) { + pr_err("Failed to disable regulator vga_avdd\n"); + result = err; + } + + return result; +} + +static int s5ka3dfx_power_off(void) +{ + int err; + + if (!s5ka3dfx_vga_avdd || !s5ka3dfx_vga_vddio || + !s5ka3dfx_cam_isp_host || !s5ka3dfx_vga_dvdd) { + pr_err("Faild to get all regulator\n"); + return -EINVAL; + } + + /* Turn CAM_ISP_HOST_2.8V off */ + err = regulator_disable(s5ka3dfx_cam_isp_host); + if (err) { + pr_err("Failed to disable regulator cam_isp_host\n"); + return -EINVAL; + } + + /* CAM_VGA_nRST LOW */ + gpio_direction_output(GPIO_CAM_VGA_nRST, 1); + gpio_set_value(GPIO_CAM_VGA_nRST, 0); + udelay(430); + + /* Mclk disable */ + s3c_gpio_cfgpin(GPIO_CAM_MCLK, 0); + + udelay(1); + + /* Turn VGA_VDDIO_2.8V off */ + err = regulator_disable(s5ka3dfx_vga_vddio); + if (err) { + pr_err("Failed to disable regulator vga_vddio\n"); + return -EINVAL; + } + + /* Turn VGA_DVDD_1.8V off */ + err = regulator_disable(s5ka3dfx_vga_dvdd); + if (err) { + pr_err("Failed to disable regulator vga_dvdd\n"); + return -EINVAL; + } + + /* CAM_VGA_nSTBY LOW */ + gpio_direction_output(GPIO_CAM_VGA_nSTBY, 1); + gpio_set_value(GPIO_CAM_VGA_nSTBY, 0); + + udelay(1); + + /* Turn VGA_AVDD_2.8V off */ + err = regulator_disable(s5ka3dfx_vga_avdd); + if (err) { + pr_err("Failed to disable regulator vga_avdd\n"); + return -EINVAL; + } + + return err; +} + +static int s5ka3dfx_power_en(int onoff) +{ + int err = 0; + mutex_lock(&s5ka3dfx_lock); + /* we can be asked to turn off even if we never were turned + * on if something odd happens and we are closed + * by camera framework before we even completely opened. + */ + if (onoff != s5ka3dfx_powered_on) { + if (onoff) + err = s5ka3dfx_power_on(); + else { + err = s5ka3dfx_power_off(); + s3c_i2c0_force_stop(); + } + if (!err) + s5ka3dfx_powered_on = onoff; + } + mutex_unlock(&s5ka3dfx_lock); + + return err; +} + +static struct s5ka3dfx_platform_data s5ka3dfx_plat = { + .default_width = 640, + .default_height = 480, + .pixelformat = V4L2_PIX_FMT_UYVY, + .freq = 24000000, + .is_mipi = 0, + + .cam_power = s5ka3dfx_power_en, +}; + +static struct i2c_board_info s5ka3dfx_i2c_info = { + I2C_BOARD_INFO("S5KA3DFX", 0xc4>>1), + .platform_data = &s5ka3dfx_plat, +}; + +static struct s3c_platform_camera s5ka3dfx = { + .id = CAMERA_PAR_A, + .type = CAM_TYPE_ITU, + .fmt = ITU_601_YCBCR422_8BIT, + .order422 = CAM_ORDER422_8BIT_CBYCRY, + .i2c_busnum = 0, + .info = &s5ka3dfx_i2c_info, + .pixelformat = V4L2_PIX_FMT_UYVY, + .srclk_name = "xusbxti", + .clk_name = "sclk_cam", + .clk_rate = 24000000, + .line_length = 480, + .width = 640, + .height = 480, + .window = { + .left = 0, + .top = 0, + .width = 640, + .height = 480, + }, + + /* Polarity */ + .inv_pclk = 0, + .inv_vsync = 1, + .inv_href = 0, + .inv_hsync = 0, + + .initialized = 0, + .cam_power = s5ka3dfx_power_en, +}; + +/* Interface setting */ +static struct s3c_platform_fimc fimc_plat_lsi = { + .srclk_name = "mout_mpll", + .clk_name = "sclk_fimc", + .lclk_name = "fimc", + .clk_rate = 166750000, + .default_cam = CAMERA_PAR_A, + .camera = { + &s5k4ecgx, + &s5ka3dfx, + }, + .hw_ver = 0x43, +}; + +#ifdef CONFIG_VIDEO_JPEG_V2 +static struct s3c_platform_jpeg jpeg_plat __initdata = { + .max_main_width = 800, + .max_main_height = 480, + .max_thumb_width = 320, + .max_thumb_height = 240, +}; +#endif + +static struct k3g_platform_data k3g_pdata = { + .axis_map_x = 1, + .axis_map_y = 1, + .axis_map_z = 1, + .negate_x = 0, + .negate_y = 0, + .negate_z = 0, +}; + +/* I2C0 */ +static struct i2c_board_info i2c_devs0[] __initdata = { + { + I2C_BOARD_INFO("k3g", 0x69), + .platform_data = &k3g_pdata, + }, +}; + +static struct i2c_board_info i2c_devs4[] __initdata = { + { + I2C_BOARD_INFO("wm8994-samsung", (0x34>>1)), + .platform_data = &wm8994_pdata, + }, +}; + +static struct akm8973_platform_data akm8973_pdata = { + .reset_line = GPIO_MSENSE_nRST, + .reset_asserted = GPIO_LEVEL_LOW, + .gpio_data_ready_int = GPIO_MSENSE_IRQ, +}; + +static struct kr3dm_platform_data kr3dm_data = { + .gpio_acc_int = GPIO_ACC_INT, +}; + +/* I2C1 */ +static struct i2c_board_info i2c_devs1[] __initdata = { + { + I2C_BOARD_INFO("ak8973", 0x1c), + .platform_data = &akm8973_pdata, + }, + { + I2C_BOARD_INFO("kr3dm", 0x09), + .platform_data = &kr3dm_data, + }, +}; + +static void mxt224_power_on(void) +{ + gpio_direction_output(GPIO_TOUCH_EN, 1); + + mdelay(40); +} + +static void mxt224_power_off(void) +{ + gpio_direction_output(GPIO_TOUCH_EN, 0); +} + +#define MXT224_MAX_MT_FINGERS 5 + +static u8 t7_config[] = {GEN_POWERCONFIG_T7, + 64, 255, 50}; +static u8 t8_config[] = {GEN_ACQUISITIONCONFIG_T8, + 7, 0, 5, 0, 0, 0, 9, 35}; +static u8 t9_config[] = {TOUCH_MULTITOUCHSCREEN_T9, + 139, 0, 0, 19, 11, 0, 32, 25, 2, 1, 25, 3, 1, + 46, MXT224_MAX_MT_FINGERS, 5, 14, 10, 255, 3, + 255, 3, 18, 18, 10, 10, 141, 65, 143, 110, 18}; +static u8 t18_config[] = {SPT_COMCONFIG_T18, + 0, 1}; +static u8 t20_config[] = {PROCI_GRIPFACESUPPRESSION_T20, + 7, 0, 0, 0, 0, 0, 0, 80, 40, 4, 35, 10}; +static u8 t22_config[] = {PROCG_NOISESUPPRESSION_T22, + 5, 0, 0, 0, 0, 0, 0, 3, 30, 0, 0, 29, 34, 39, + 49, 58, 3}; +static u8 t28_config[] = {SPT_CTECONFIG_T28, + 1, 0, 3, 16, 63, 60}; +static u8 end_config[] = {RESERVED_T255}; + +static const u8 *mxt224_config[] = { + t7_config, + t8_config, + t9_config, + t18_config, + t20_config, + t22_config, + t28_config, + end_config, +}; + +static struct mxt224_platform_data mxt224_data = { + .max_finger_touches = MXT224_MAX_MT_FINGERS, + .gpio_read_done = GPIO_TOUCH_INT, + .config = mxt224_config, + .min_x = 0, + .max_x = 1023, + .min_y = 0, + .max_y = 1023, + .min_z = 0, + .max_z = 255, + .min_w = 0, + .max_w = 30, + .power_on = mxt224_power_on, + .power_off = mxt224_power_off, +}; + +/* I2C2 */ +static struct i2c_board_info i2c_devs2[] __initdata = { + { + I2C_BOARD_INFO(MXT224_DEV_NAME, 0x4a), + .platform_data = &mxt224_data, + .irq = IRQ_EINT_GROUP(18, 5), + }, +}; + +static void mxt224_init(void) +{ + if (!herring_is_tft_dev()) + return; + mxt224_data.max_y = 950; + t9_config[8] = 45; + t9_config[9] = 3; + t9_config[23] = 0; + t9_config[24] = 0; + t9_config[27] = 0; + t9_config[28] = 0; + t9_config[29] = 0; + t9_config[30] = 0; +} + +static ssize_t herring_virtual_keys_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + return sprintf(buf, + __stringify(EV_KEY) ":" __stringify(KEY_BACK) ":71:839:73:62" + ":" __stringify(EV_KEY) ":" + __stringify(KEY_MENU) ":183:839:73:62" + ":" __stringify(EV_KEY) ":" + __stringify(KEY_SEARCH) ":294:839:73:62" + ":" __stringify(EV_KEY) ":" + __stringify(KEY_HOME) ":406:839:73:62" + "\n"); +} + +static struct kobj_attribute herring_virtual_keys_attr = { + .attr = { + .name = "virtualkeys.mxt224_ts_input", + .mode = S_IRUGO, + }, + .show = &herring_virtual_keys_show, +}; + +static struct attribute *herring_properties_attrs[] = { + &herring_virtual_keys_attr.attr, + NULL, +}; + +static struct attribute_group herring_properties_attr_group = { + .attrs = herring_properties_attrs, +}; + +static void herring_virtual_keys_init(void) +{ + struct kobject *properties_kobj; + int ret; + + properties_kobj = kobject_create_and_add("board_properties", NULL); + if (properties_kobj) + ret = sysfs_create_group(properties_kobj, + &herring_properties_attr_group); + if (!properties_kobj || ret) + pr_err("failed to create board_properties\n"); +} + +/* I2C2 */ +static struct i2c_board_info i2c_devs10[] __initdata = { + { + I2C_BOARD_INFO(CYPRESS_TOUCHKEY_DEV_NAME, 0x20), + .platform_data = &touchkey_data, + .irq = (IRQ_EINT_GROUP22_BASE + 1), + }, +}; + +static struct i2c_board_info i2c_devs5[] __initdata = { + { + I2C_BOARD_INFO("kr3dm", 0x09), + .platform_data = &kr3dm_data, + }, +}; + +static struct i2c_board_info i2c_devs8[] __initdata = { + { + I2C_BOARD_INFO("k3g", 0x69), + .platform_data = &k3g_pdata, + .irq = -1, + }, +}; + +static void k3g_irq_init(void) +{ + i2c_devs0[0].irq = (system_rev >= 0x0A) ? IRQ_EINT(29) : -1; +} + + +static void fsa9480_usb_cb(bool attached) +{ + struct usb_gadget *gadget = platform_get_drvdata(&s3c_device_usbgadget); + + if (gadget) { + if (attached) + usb_gadget_vbus_connect(gadget); + else + usb_gadget_vbus_disconnect(gadget); + } + + set_cable_status = attached ? CABLE_TYPE_USB : CABLE_TYPE_NONE; + if (callbacks && callbacks->set_cable) + callbacks->set_cable(callbacks, set_cable_status); +} + +static void fsa9480_charger_cb(bool attached) +{ + set_cable_status = attached ? CABLE_TYPE_AC : CABLE_TYPE_NONE; + if (callbacks && callbacks->set_cable) + callbacks->set_cable(callbacks, set_cable_status); +} + +static struct switch_dev switch_dock = { + .name = "dock", +}; + +static void fsa9480_deskdock_cb(bool attached) +{ + struct usb_gadget *gadget = platform_get_drvdata(&s3c_device_usbgadget); + + if (attached) + switch_set_state(&switch_dock, 1); + else + switch_set_state(&switch_dock, 0); + + if (gadget) { + if (attached) + usb_gadget_vbus_connect(gadget); + else + usb_gadget_vbus_disconnect(gadget); + } + + set_cable_status = attached ? CABLE_TYPE_USB : CABLE_TYPE_NONE; + if (callbacks && callbacks->set_cable) + callbacks->set_cable(callbacks, set_cable_status); +} + +static void fsa9480_cardock_cb(bool attached) +{ + if (attached) + switch_set_state(&switch_dock, 2); + else + switch_set_state(&switch_dock, 0); +} + +static void fsa9480_reset_cb(void) +{ + int ret; + + /* for CarDock, DeskDock */ + ret = switch_dev_register(&switch_dock); + if (ret < 0) + pr_err("Failed to register dock switch. %d\n", ret); +} + +static struct fsa9480_platform_data fsa9480_pdata = { + .usb_cb = fsa9480_usb_cb, + .charger_cb = fsa9480_charger_cb, + .deskdock_cb = fsa9480_deskdock_cb, + .cardock_cb = fsa9480_cardock_cb, + .reset_cb = fsa9480_reset_cb, +}; + +static struct i2c_board_info i2c_devs7[] __initdata = { + { + I2C_BOARD_INFO("fsa9480", 0x4A >> 1), + .platform_data = &fsa9480_pdata, + .irq = IRQ_EINT(23), + }, +}; + +static struct i2c_board_info i2c_devs6[] __initdata = { +#ifdef CONFIG_REGULATOR_MAX8998 + { + /* The address is 0xCC used since SRAD = 0 */ + I2C_BOARD_INFO("max8998", (0xCC >> 1)), + .platform_data = &max8998_pdata, + .irq = IRQ_EINT7, + }, { + I2C_BOARD_INFO("rtc_max8998", (0x0D >> 1)), + }, +#endif +}; + +static struct pn544_i2c_platform_data pn544_pdata = { + .irq_gpio = NFC_IRQ, + .ven_gpio = NFC_EN, + .firm_gpio = NFC_FIRM, +}; + +static struct i2c_board_info i2c_devs14[] __initdata = { + { + I2C_BOARD_INFO("pn544", 0x2b), + .irq = IRQ_EINT(12), + .platform_data = &pn544_pdata, + }, +}; + +static int max17040_power_supply_register(struct device *parent, + struct power_supply *psy) +{ + herring_charger.psy_fuelgauge = psy; + return 0; +} + +static void max17040_power_supply_unregister(struct power_supply *psy) +{ + herring_charger.psy_fuelgauge = NULL; +} + +static struct max17040_platform_data max17040_pdata = { + .power_supply_register = max17040_power_supply_register, + .power_supply_unregister = max17040_power_supply_unregister, + .rcomp_value = 0xD700, +}; + +static struct i2c_board_info i2c_devs9[] __initdata = { + { + I2C_BOARD_INFO("max17040", (0x6D >> 1)), + .platform_data = &max17040_pdata, + }, +}; + +static void gp2a_gpio_init(void) +{ + int ret = gpio_request(GPIO_PS_ON, "gp2a_power_supply_on"); + if (ret) + printk(KERN_ERR "Failed to request gpio gp2a power supply.\n"); +} + +static int gp2a_power(bool on) +{ + /* this controls the power supply rail to the gp2a IC */ + gpio_direction_output(GPIO_PS_ON, on); + return 0; +} + +static int gp2a_light_adc_value(void) +{ + return s3c_adc_get_adc_data(9); +} + +static struct gp2a_platform_data gp2a_pdata = { + .power = gp2a_power, + .p_out = GPIO_PS_VOUT, + .light_adc_value = gp2a_light_adc_value, + .light_adc_max = 4095, + .light_adc_fuzz = 64, +}; + +static struct i2c_board_info i2c_devs11[] __initdata = { + { + I2C_BOARD_INFO("gp2a", (0x88 >> 1)), + .platform_data = &gp2a_pdata, + }, +}; + +static struct i2c_board_info i2c_devs12[] __initdata = { + { + I2C_BOARD_INFO("ak8973", 0x1c), + .platform_data = &akm8973_pdata, + }, +}; + +static struct resource ram_console_resource[] = { + { + .flags = IORESOURCE_MEM, + } +}; + +static struct platform_device ram_console_device = { + .name = "ram_console", + .id = -1, + .num_resources = ARRAY_SIZE(ram_console_resource), + .resource = ram_console_resource, +}; + +#ifdef CONFIG_ANDROID_PMEM +static struct android_pmem_platform_data pmem_pdata = { + .name = "pmem", + .no_allocator = 1, + .cached = 1, + .start = 0, + .size = 0, +}; + +static struct android_pmem_platform_data pmem_gpu1_pdata = { + .name = "pmem_gpu1", + .no_allocator = 1, + .cached = 1, + .buffered = 1, + .start = 0, + .size = 0, +}; + +static struct android_pmem_platform_data pmem_adsp_pdata = { + .name = "pmem_adsp", + .no_allocator = 1, + .cached = 1, + .buffered = 1, + .start = 0, + .size = 0, +}; + +static struct platform_device pmem_device = { + .name = "android_pmem", + .id = 0, + .dev = { .platform_data = &pmem_pdata }, +}; + +static struct platform_device pmem_gpu1_device = { + .name = "android_pmem", + .id = 1, + .dev = { .platform_data = &pmem_gpu1_pdata }, +}; + +static struct platform_device pmem_adsp_device = { + .name = "android_pmem", + .id = 2, + .dev = { .platform_data = &pmem_adsp_pdata }, +}; + +static void __init android_pmem_set_platdata(void) +{ + pmem_pdata.start = (u32)s5p_get_media_memory_bank(S5P_MDEV_PMEM, 0); + pmem_pdata.size = (u32)s5p_get_media_memsize_bank(S5P_MDEV_PMEM, 0); + + pmem_gpu1_pdata.start = + (u32)s5p_get_media_memory_bank(S5P_MDEV_PMEM_GPU1, 0); + pmem_gpu1_pdata.size = + (u32)s5p_get_media_memsize_bank(S5P_MDEV_PMEM_GPU1, 0); + + pmem_adsp_pdata.start = + (u32)s5p_get_media_memory_bank(S5P_MDEV_PMEM_ADSP, 0); + pmem_adsp_pdata.size = + (u32)s5p_get_media_memsize_bank(S5P_MDEV_PMEM_ADSP, 0); +} +#endif + +struct platform_device sec_device_battery = { + .name = "sec-battery", + .id = -1, +}; + +static struct platform_device sec_device_rfkill = { + .name = "bt_rfkill", + .id = -1, +}; + +static struct platform_device sec_device_btsleep = { + .name = "bt_sleep", + .id = -1, +}; + +static struct sec_jack_zone sec_jack_zones[] = { + { + /* adc == 0, unstable zone, default to 3pole if it stays + * in this range for a half second (20ms delays, 25 samples) + */ + .adc_high = 0, + .delay_ms = 20, + .check_count = 25, + .jack_type = SEC_HEADSET_3POLE, + }, + { + /* 0 < adc <= 1000, unstable zone, default to 3pole if it stays + * in this range for a second (10ms delays, 100 samples) + */ + .adc_high = 1000, + .delay_ms = 10, + .check_count = 100, + .jack_type = SEC_HEADSET_3POLE, + }, + { + /* 1000 < adc <= 2000, unstable zone, default to 4pole if it + * stays in this range for a second (10ms delays, 100 samples) + */ + .adc_high = 2000, + .delay_ms = 10, + .check_count = 100, + .jack_type = SEC_HEADSET_4POLE, + }, + { + /* 2000 < adc <= 3700, 4 pole zone, default to 4pole if it + * stays in this range for 200ms (20ms delays, 10 samples) + */ + .adc_high = 3700, + .delay_ms = 20, + .check_count = 10, + .jack_type = SEC_HEADSET_4POLE, + }, + { + /* adc > 3700, unstable zone, default to 3pole if it stays + * in this range for a second (10ms delays, 100 samples) + */ + .adc_high = 0x7fffffff, + .delay_ms = 10, + .check_count = 100, + .jack_type = SEC_HEADSET_3POLE, + }, +}; + +/* To support 3-buttons earjack */ +static struct sec_jack_buttons_zone sec_jack_buttons_zones[] = { + { + /* 0 <= adc <=110, stable zone */ + .code = KEY_MEDIA, + .adc_low = 0, + .adc_high = 110, + }, + { + /* 130 <= adc <= 365, stable zone */ + .code = KEY_PREVIOUSSONG, + .adc_low = 130, + .adc_high = 365, + }, + { + /* 385 <= adc <= 870, stable zone */ + .code = KEY_NEXTSONG, + .adc_low = 385, + .adc_high = 870, + }, +}; + +static int sec_jack_get_adc_value(void) +{ + return s3c_adc_get_adc_data(3); +} + +struct sec_jack_platform_data sec_jack_pdata = { + .set_micbias_state = sec_jack_set_micbias_state, + .get_adc_value = sec_jack_get_adc_value, + .zones = sec_jack_zones, + .num_zones = ARRAY_SIZE(sec_jack_zones), + .buttons_zones = sec_jack_buttons_zones, + .num_buttons_zones = ARRAY_SIZE(sec_jack_buttons_zones), + .det_gpio = GPIO_DET_35, + .send_end_gpio = GPIO_EAR_SEND_END, +}; + +static struct platform_device sec_device_jack = { + .name = "sec_jack", + .id = 1, /* will be used also for gpio_event id */ + .dev.platform_data = &sec_jack_pdata, +}; + + +#define S3C_GPIO_SETPIN_ZERO 0 +#define S3C_GPIO_SETPIN_ONE 1 +#define S3C_GPIO_SETPIN_NONE 2 + +struct gpio_init_data { + uint num; + uint cfg; + uint val; + uint pud; + uint drv; +}; + +static struct gpio_init_data herring_init_gpios[] = { + { + .num = S5PV210_GPB(0), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPB(1), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + + }, { + .num = S5PV210_GPB(2), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPB(3), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPB(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPB(5), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPB(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPB(7), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPC0(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPC0(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPC0(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPC0(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPC0(4), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPC1(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPC1(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPC1(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPC1(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPC1(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPD0(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPD0(1), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPD0(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPD0(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPD1(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPD1(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPD1(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPD1(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPD1(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPD1(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPE0(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE0(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE0(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE0(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE0(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE0(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE0(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE0(7), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + + { + .num = S5PV210_GPE1(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE1(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE1(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE1(3), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPE1(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPF3(4), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPF3(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPG0(0), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG0(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG0(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG0(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG0(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG0(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG0(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPG1(0), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG1(1), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG1(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG1(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG1(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG1(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG1(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPG2(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG2(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG2(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG2(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG2(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG2(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG2(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPG3(0), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG3(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG3(2), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG3(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG3(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG3(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPG3(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPH0(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH0(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH0(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH0(3), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH0(4), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH0(5), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { /* GPIO_DET_35 - 3.5" ear jack */ + .num = S5PV210_GPH0(6), + .cfg = S3C_GPIO_SFN(GPIO_DET_35_AF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH0(7), + .cfg = S3C_GPIO_SFN(0xF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPH1(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH1(1), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH1(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH1(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { /* NFC_IRQ */ + .num = S5PV210_GPH1(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { /* NFC_EN */ + .num = S5PV210_GPH1(5), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { /* NFC_FIRM */ + .num = S5PV210_GPH1(6), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH1(7), + .cfg = S3C_GPIO_SFN(0xF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPH2(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH2(1), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH2(2), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH2(3), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH2(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH2(5), + .cfg = S3C_GPIO_SFN(0xF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH2(6), + .cfg = S3C_GPIO_SFN(0xF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH2(7), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPH3(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_UP, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH3(1), + .cfg = S3C_GPIO_SFN(0xF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH3(2), + .cfg = S3C_GPIO_SFN(0xF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH3(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH3(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH3(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { /* GPIO_EAR_SEND_END */ + .num = S5PV210_GPH3(6), + .cfg = S3C_GPIO_SFN(GPIO_EAR_SEND_END_AF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPH3(7), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPI(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPI(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPI(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPI(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPI(4), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPI(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPI(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPJ0(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ0(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ0(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ0(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ0(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ0(5), + .cfg = S3C_GPIO_SFN(0xF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ0(6), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ0(7), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPJ1(0), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ1(1), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ1(2), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ1(3), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ1(4), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ1(5), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPJ2(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ2(1), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ2(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ2(3), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ2(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ2(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ2(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ2(7), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPJ3(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ3(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ3(2), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { /* GPIO_EAR_ADC_SEL */ + .num = S5PV210_GPJ3(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ3(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ3(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ3(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ3(7), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_GPJ4(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ4(1), + .cfg = S3C_GPIO_SFN(0xF), + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ4(2), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ4(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_GPJ4(4), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_MP01(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP01(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP01(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_MP02(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP02(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP02(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_MP03(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP03(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP03(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP03(7), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_MP04(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP04(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { /* NFC_SCL_18V - has external pull up resistor */ + .num = S5PV210_MP04(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { /* NFC_SDA_18V - has external pull up resistor */ + .num = S5PV210_MP04(5), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP04(6), + .cfg = S3C_GPIO_OUTPUT, + .val = S3C_GPIO_SETPIN_ZERO, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP04(7), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, + + { + .num = S5PV210_MP05(0), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP05(1), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP05(2), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP05(3), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_NONE, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP05(4), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, { + .num = S5PV210_MP05(6), + .cfg = S3C_GPIO_INPUT, + .val = S3C_GPIO_SETPIN_NONE, + .pud = S3C_GPIO_PULL_DOWN, + .drv = S3C_GPIO_DRVSTR_1X, + }, +}; + +void s3c_config_gpio_table(void) +{ + u32 i, gpio; + + for (i = 0; i < ARRAY_SIZE(herring_init_gpios); i++) { + gpio = herring_init_gpios[i].num; + if (system_rev <= 0x07 && gpio == S5PV210_GPJ3(3)) { + s3c_gpio_cfgpin(gpio, S3C_GPIO_OUTPUT); + gpio_set_value(gpio, S3C_GPIO_SETPIN_ONE); + } else if (gpio <= S5PV210_MP05(7)) { + s3c_gpio_cfgpin(gpio, herring_init_gpios[i].cfg); + s3c_gpio_setpull(gpio, herring_init_gpios[i].pud); + + if (herring_init_gpios[i].val != S3C_GPIO_SETPIN_NONE) + gpio_set_value(gpio, herring_init_gpios[i].val); + + s3c_gpio_set_drvstrength(gpio, + herring_init_gpios[i].drv); + } + } + + if (herring_is_cdma_wimax_dev()) { + /* WiMAX_I2C_CON */ + gpio = S5PV210_GPC1(1); + s3c_gpio_cfgpin(gpio, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP); + gpio_set_value(gpio, S3C_GPIO_SETPIN_ONE); + s3c_gpio_set_drvstrength(gpio, S3C_GPIO_DRVSTR_4X); + + gpio = S5PV210_GPC1(3); + s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP); + gpio_set_value(gpio, S3C_GPIO_SETPIN_NONE); + s3c_gpio_set_drvstrength(gpio, S3C_GPIO_DRVSTR_4X); + + gpio = S5PV210_GPC1(4); + s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP); + gpio_set_value(gpio, S3C_GPIO_SETPIN_NONE); + s3c_gpio_set_drvstrength(gpio, S3C_GPIO_DRVSTR_4X); + + gpio = S5PV210_GPG2(0); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE); + gpio = S5PV210_GPG2(1); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE); + gpio = S5PV210_GPG2(3); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE); + gpio = S5PV210_GPG2(4); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE); + gpio = S5PV210_GPG2(5); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE); + gpio = S5PV210_GPG2(6); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE); + + /* WIMAX_EN */ + gpio = S5PV210_GPH1(0); + s3c_gpio_cfgpin(gpio, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE); + gpio_set_value(gpio, S3C_GPIO_SETPIN_ZERO); + s3c_gpio_set_drvstrength(gpio, S3C_GPIO_DRVSTR_1X); + + /* GPIO_CP_RST, CDMA modem specific setting */ + gpio = S5PV210_GPH3(7); + s3c_gpio_cfgpin(gpio, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_DOWN); + gpio_set_value(gpio, S3C_GPIO_SETPIN_ZERO); + s3c_gpio_set_drvstrength(gpio, S3C_GPIO_DRVSTR_4X); + + gpio = S5PV210_MP05(2); + s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP); + gpio_set_value(gpio, S3C_GPIO_SETPIN_NONE); + s3c_gpio_set_drvstrength(gpio, S3C_GPIO_DRVSTR_4X); + + gpio = S5PV210_MP05(3); + s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT); + s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP); + gpio_set_value(gpio, S3C_GPIO_SETPIN_NONE); + s3c_gpio_set_drvstrength(gpio, S3C_GPIO_DRVSTR_4X); + } +} + +#define S5PV210_PS_HOLD_CONTROL_REG (S3C_VA_SYS+0xE81C) +static void herring_power_off(void) +{ + int phone_wait_cnt = 0; + + if (herring_is_cdma_wimax_dev()) { + /* confirm phone is powered-off */ + while (1) { + if (gpio_get_value(GPIO_PHONE_ACTIVE)) { + pr_info("%s: Try to Turn Phone Off by CP_RST\n", + __func__); + gpio_set_value(GPIO_CP_RST, 0); + if (phone_wait_cnt > 1) { + pr_info("%s: PHONE OFF Fail\n", + __func__); + break; + } + phone_wait_cnt++; + mdelay(100); + } else { + pr_info("%s: PHONE OFF Success\n", __func__); + break; + } + } + } + + while (1) { + /* Check reboot charging */ + if (set_cable_status) { + /* watchdog reset */ + pr_info("%s: charger connected, rebooting\n", __func__); + writel(3, S5P_INFORM6); + arch_reset('r', NULL); + pr_crit("%s: waiting for reset!\n", __func__); + while (1); + } + + /* wait for power button release */ + if (gpio_get_value(GPIO_nPOWER)) { + pr_info("%s: set PS_HOLD low\n", __func__); + + /* PS_HOLD high PS_HOLD_CONTROL, R/W, 0xE010_E81C */ + writel(readl(S5PV210_PS_HOLD_CONTROL_REG) & 0xFFFFFEFF, + S5PV210_PS_HOLD_CONTROL_REG); + + pr_crit("%s: should not reach here!\n", __func__); + } + + /* if power button is not released, wait and check TA again */ + pr_info("%s: PowerButton is not released.\n", __func__); + mdelay(1000); + } +} + +/* this table only for B4 board */ +static unsigned int herring_sleep_gpio_table[][3] = { + { S5PV210_GPA0(0), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA0(1), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA0(2), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA0(3), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA0(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPA0(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA0(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPA0(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPA1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPA1(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPA1(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPB(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(1), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(3), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(5), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPB(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPC0(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC0(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC0(4), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPC1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC1(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC1(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC1(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPD0(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPD0(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPD0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPD1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD1(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD1(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD1(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPD1(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPE0(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPE1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE1(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE1(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPE1(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPF0(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(4), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(6), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPF1(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(4), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(6), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPF2(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(4), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(6), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPF3(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(4), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPG0(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG0(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG0(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG0(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG0(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPG1(0), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG1(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG1(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG1(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG1(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG1(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPG2(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG2(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG2(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG2(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG2(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG2(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG2(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPG3(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(1), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(2), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(3), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(4), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(5), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(6), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + + /* Alive part ending and off part start*/ + { S5PV210_GPI(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPJ0(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ0(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ0(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ0(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ0(6), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ0(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPJ1(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(4), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPJ2(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(3), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ2(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(7), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPJ3(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ3(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ3(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ3(3), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ3(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ3(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ3(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ3(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPJ4(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ4(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ4(2), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ4(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ4(4), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + /* memory part */ + { S5PV210_MP01(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP01(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_MP01(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP01(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP01(4), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_MP01(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP01(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP01(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_MP02(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP02(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP02(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP02(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_MP03(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP03(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP03(2), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_MP03(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_MP03(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP03(5), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_MP03(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP03(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_MP04(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP04(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_MP04(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP04(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_MP04(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP04(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP04(6), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_MP04(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_MP05(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP05(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP05(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP05(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP05(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP05(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_MP05(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP05(7), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + { S5PV210_MP06(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_MP07(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + /* Memory part ending and off part ending */ +}; + +static unsigned int herring_cdma_wimax_sleep_gpio_table[][3] = { + { S5PV210_GPA0(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA0(1), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA0(3), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA0(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPA0(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPA0(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPA0(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPA1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPA1(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPA1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPA1(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPB(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(3), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(5), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPB(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPB(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPC0(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC0(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPC0(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + /*WIMAX PMIC SDA*/ + { S5PV210_GPC1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + /*Wimax eeprom switch*/ + { S5PV210_GPC1(1), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + /*WIMAX PMIC SCL*/ + { S5PV210_GPC1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + /*WIMAX EEPROM I2C LINES*/ + { S5PV210_GPC1(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPC1(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + /*WIMAX DBGEN*/ + { S5PV210_GPD0(0), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPD0(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + /*WIMAX RESET_N*/ + { S5PV210_GPD0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_UP}, + + { S5PV210_GPD1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD1(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD1(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPD1(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPD1(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPE0(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE0(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + + { S5PV210_GPE1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE1(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPE1(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPE1(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPF0(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(4), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(6), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF0(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPF1(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(4), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(6), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF1(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + + { S5PV210_GPF2(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(4), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(6), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF2(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPF3(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(4), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPF3(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + + { S5PV210_GPG0(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG0(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG0(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG0(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG0(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPG1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG1(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG1(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG1(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG1(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG1(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG1(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + /*wimax SDIO pins*/ + { S5PV210_GPG2(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG2(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG2(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPG2(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG2(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG2(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG2(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPG3(0), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(2), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPG3(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + /*WIMAX*/ + { S5PV210_GPH1(0), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPH1(2), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPH2(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPH3(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_UP}, + { S5PV210_GPH3(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + /* Alive part ending and off part start*/ + { S5PV210_GPI(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPI(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPJ0(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ0(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ0(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ0(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ0(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ0(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ0(6), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ0(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPJ1(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(4), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ1(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPJ2(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPJ2(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ2(7), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + { S5PV210_GPJ3(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ3(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ3(2), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ3(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ3(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ3(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ3(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ3(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_GPJ4(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ4(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_GPJ4(2), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ4(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_GPJ4(4), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + /* memory part */ + { S5PV210_MP01(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP01(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + /*WIMAX*/ + { S5PV210_MP01(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + { S5PV210_MP01(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP01(4), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_MP01(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP01(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP01(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_MP02(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP02(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP02(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP02(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_MP03(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP03(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP03(2), S3C_GPIO_SLP_OUT1, S3C_GPIO_PULL_NONE}, + { S5PV210_MP03(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP03(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP03(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP03(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP03(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + /*WIMAX*/ + { S5PV210_MP04(0), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + { S5PV210_MP04(1), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + /*WIMAX*/ + { S5PV210_MP04(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_MP04(3), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + { S5PV210_MP04(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP04(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP04(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + /*WIMAX*/ + { S5PV210_MP04(7), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + { S5PV210_MP05(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP05(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP05(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + { S5PV210_MP05(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_NONE}, + + /*WIMAX*/ + { S5PV210_MP05(4), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + { S5PV210_MP05(5), S3C_GPIO_SLP_OUT0, S3C_GPIO_PULL_NONE}, + + /*WIMAX*/ + { S5PV210_MP05(6), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + { S5PV210_MP05(7), S3C_GPIO_SLP_PREV, S3C_GPIO_PULL_NONE}, + + { S5PV210_MP06(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP06(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + { S5PV210_MP07(0), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(1), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(2), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(3), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(4), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(5), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(6), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + { S5PV210_MP07(7), S3C_GPIO_SLP_INPUT, S3C_GPIO_PULL_DOWN}, + + /* Memory part ending and off part ending */ +}; + +void s3c_config_sleep_gpio_table(int array_size, unsigned int (*gpio_table)[3]) +{ + u32 i, gpio; + + for (i = 0; i < array_size; i++) { + gpio = gpio_table[i][0]; + s3c_gpio_slp_cfgpin(gpio, gpio_table[i][1]); + s3c_gpio_slp_setpull_updown(gpio, gpio_table[i][2]); + } +} + +void s3c_config_cdma_wimax_sleep_gpio(void) +{ + s3c_gpio_cfgpin(S5PV210_GPH0(0), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH0(0), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH0(1), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH0(1), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH0(2), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH0(2), S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(S5PV210_GPH0(3), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH0(3), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH0(3), 0); + + s3c_gpio_cfgpin(S5PV210_GPH0(4), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH0(4), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH0(4), 0); + + s3c_gpio_cfgpin(S5PV210_GPH0(5), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH0(5), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH0(5), 0); + + s3c_gpio_cfgpin(S5PV210_GPH1(0), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH1(0), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH1(0), 0); + + s3c_gpio_cfgpin(S5PV210_GPH1(1), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH1(1), S3C_GPIO_PULL_DOWN); + gpio_set_value(S5PV210_GPH1(1), 0); + + s3c_gpio_cfgpin(S5PV210_GPH1(2), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH1(2), S3C_GPIO_PULL_UP); + gpio_set_value(S5PV210_GPH1(2), 0); + + s3c_gpio_cfgpin(S5PV210_GPH1(4), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH1(4), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH1(5), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_DOWN); + gpio_set_value(S5PV210_GPH1(5), 0); + + s3c_gpio_cfgpin(S5PV210_GPH1(6), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH1(6), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH1(7), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH1(7), S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(S5PV210_GPH2(0), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH2(0), S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(S5PV210_GPH2(2), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH2(2), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH2(2), 0); + + s3c_gpio_cfgpin(S5PV210_GPH2(6), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH2(6), S3C_GPIO_PULL_UP); + + s3c_gpio_cfgpin(S5PV210_GPH2(3), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH2(3), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH2(3), 0); + + s3c_gpio_cfgpin(S5PV210_GPH3(0), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH3(0), S3C_GPIO_PULL_UP); + + s3c_gpio_cfgpin(S5PV210_GPH3(3), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH3(3), S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(S5PV210_GPH3(4), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH3(4), S3C_GPIO_PULL_UP); + + s3c_gpio_cfgpin(S5PV210_GPH3(5), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH3(7), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH3(7), S3C_GPIO_PULL_UP); + gpio_set_value(S5PV210_GPH3(7), 1); + +} + +void s3c_config_gsm_sleep_gpio(void) +{ + /* setting the alive mode registers */ + s3c_gpio_cfgpin(S5PV210_GPH0(1), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH0(1), S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(S5PV210_GPH0(3), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH0(3), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH0(3), 0); + + s3c_gpio_cfgpin(S5PV210_GPH0(4), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH0(4), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH0(4), 0); + + s3c_gpio_cfgpin(S5PV210_GPH0(5), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH0(5), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH0(5), 0); + + s3c_gpio_cfgpin(S5PV210_GPH1(0), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH1(0), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH1(1), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH1(1), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH1(1), 0); + + s3c_gpio_cfgpin(S5PV210_GPH1(2), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH1(2), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH1(4), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH1(4), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH1(5), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH1(5), 0); + + s3c_gpio_cfgpin(S5PV210_GPH1(6), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH1(6), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH1(7), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH1(7), S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(S5PV210_GPH2(0), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH2(0), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH2(2), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH2(2), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH2(2), 0); + + s3c_gpio_cfgpin(S5PV210_GPH2(3), S3C_GPIO_OUTPUT); + s3c_gpio_setpull(S5PV210_GPH2(3), S3C_GPIO_PULL_NONE); + gpio_set_value(S5PV210_GPH2(3), 0); + + s3c_gpio_cfgpin(S5PV210_GPH3(0), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH3(0), S3C_GPIO_PULL_UP); + + s3c_gpio_cfgpin(S5PV210_GPH3(3), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH3(3), S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(S5PV210_GPH3(4), S3C_GPIO_INPUT); + s3c_gpio_setpull(S5PV210_GPH3(4), S3C_GPIO_PULL_DOWN); +} + +void s3c_config_sleep_gpio(void) +{ + if (herring_is_cdma_wimax_dev()) + s3c_config_cdma_wimax_sleep_gpio(); + else + s3c_config_gsm_sleep_gpio(); +} +EXPORT_SYMBOL(s3c_config_sleep_gpio); + +static unsigned int wlan_sdio_on_table[][4] = { + {GPIO_WLAN_SDIO_CLK, GPIO_WLAN_SDIO_CLK_AF, GPIO_LEVEL_NONE, + S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_CMD, GPIO_WLAN_SDIO_CMD_AF, GPIO_LEVEL_NONE, + S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_D0, GPIO_WLAN_SDIO_D0_AF, GPIO_LEVEL_NONE, + S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_D1, GPIO_WLAN_SDIO_D1_AF, GPIO_LEVEL_NONE, + S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_D2, GPIO_WLAN_SDIO_D2_AF, GPIO_LEVEL_NONE, + S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_D3, GPIO_WLAN_SDIO_D3_AF, GPIO_LEVEL_NONE, + S3C_GPIO_PULL_NONE}, +}; + +static unsigned int wlan_sdio_off_table[][4] = { + {GPIO_WLAN_SDIO_CLK, 1, GPIO_LEVEL_LOW, S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_CMD, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_D0, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_D1, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_D2, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, + {GPIO_WLAN_SDIO_D3, 0, GPIO_LEVEL_NONE, S3C_GPIO_PULL_NONE}, +}; + +static int wlan_power_en(int onoff) +{ + if (onoff) { + s3c_gpio_cfgpin(GPIO_WLAN_HOST_WAKE, + S3C_GPIO_SFN(GPIO_WLAN_HOST_WAKE_AF)); + s3c_gpio_setpull(GPIO_WLAN_HOST_WAKE, S3C_GPIO_PULL_DOWN); + + s3c_gpio_cfgpin(GPIO_WLAN_WAKE, + S3C_GPIO_SFN(GPIO_WLAN_WAKE_AF)); + s3c_gpio_setpull(GPIO_WLAN_WAKE, S3C_GPIO_PULL_NONE); + gpio_set_value(GPIO_WLAN_WAKE, GPIO_LEVEL_LOW); + + s3c_gpio_cfgpin(GPIO_WLAN_nRST, + S3C_GPIO_SFN(GPIO_WLAN_nRST_AF)); + s3c_gpio_setpull(GPIO_WLAN_nRST, S3C_GPIO_PULL_NONE); + gpio_set_value(GPIO_WLAN_nRST, GPIO_LEVEL_HIGH); + s3c_gpio_slp_cfgpin(GPIO_WLAN_nRST, S3C_GPIO_SLP_OUT1); + s3c_gpio_slp_setpull_updown(GPIO_WLAN_nRST, S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_WLAN_BT_EN, S3C_GPIO_PULL_NONE); + gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_HIGH); + s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT1); + s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, + S3C_GPIO_PULL_NONE); + + msleep(200); + } else { + gpio_set_value(GPIO_WLAN_nRST, GPIO_LEVEL_LOW); + s3c_gpio_slp_cfgpin(GPIO_WLAN_nRST, S3C_GPIO_SLP_OUT0); + s3c_gpio_slp_setpull_updown(GPIO_WLAN_nRST, S3C_GPIO_PULL_NONE); + + if (gpio_get_value(GPIO_BT_nRST) == 0) { + gpio_set_value(GPIO_WLAN_BT_EN, GPIO_LEVEL_LOW); + s3c_gpio_slp_cfgpin(GPIO_WLAN_BT_EN, S3C_GPIO_SLP_OUT0); + s3c_gpio_slp_setpull_updown(GPIO_WLAN_BT_EN, + S3C_GPIO_PULL_NONE); + } + } + return 0; +} + +static int wlan_reset_en(int onoff) +{ + gpio_set_value(GPIO_WLAN_nRST, + onoff ? GPIO_LEVEL_HIGH : GPIO_LEVEL_LOW); + return 0; +} + +static int wlan_carddetect_en(int onoff) +{ + u32 i; + u32 sdio; + + if (onoff) { + for (i = 0; i < ARRAY_SIZE(wlan_sdio_on_table); i++) { + sdio = wlan_sdio_on_table[i][0]; + s3c_gpio_cfgpin(sdio, + S3C_GPIO_SFN(wlan_sdio_on_table[i][1])); + s3c_gpio_setpull(sdio, wlan_sdio_on_table[i][3]); + if (wlan_sdio_on_table[i][2] != GPIO_LEVEL_NONE) + gpio_set_value(sdio, wlan_sdio_on_table[i][2]); + } + } else { + for (i = 0; i < ARRAY_SIZE(wlan_sdio_off_table); i++) { + sdio = wlan_sdio_off_table[i][0]; + s3c_gpio_cfgpin(sdio, + S3C_GPIO_SFN(wlan_sdio_off_table[i][1])); + s3c_gpio_setpull(sdio, wlan_sdio_off_table[i][3]); + if (wlan_sdio_off_table[i][2] != GPIO_LEVEL_NONE) + gpio_set_value(sdio, wlan_sdio_off_table[i][2]); + } + } + udelay(5); + + sdhci_s3c_force_presence_change(&s3c_device_hsmmc3); + msleep(500); /* wait for carddetect */ + return 0; +} + +static struct resource wifi_resources[] = { + [0] = { + .name = "bcm4329_wlan_irq", + .start = IRQ_EINT(20), + .end = IRQ_EINT(20), + .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL, + }, +}; + +static struct wifi_mem_prealloc wifi_mem_array[PREALLOC_WLAN_SEC_NUM] = { + {NULL, (WLAN_SECTION_SIZE_0 + PREALLOC_WLAN_SECTION_HEADER)}, + {NULL, (WLAN_SECTION_SIZE_1 + PREALLOC_WLAN_SECTION_HEADER)}, + {NULL, (WLAN_SECTION_SIZE_2 + PREALLOC_WLAN_SECTION_HEADER)}, + {NULL, (WLAN_SECTION_SIZE_3 + PREALLOC_WLAN_SECTION_HEADER)} +}; + +static void *herring_mem_prealloc(int section, unsigned long size) +{ + if (section == PREALLOC_WLAN_SEC_NUM) + return wlan_static_skb; + + if ((section < 0) || (section > PREALLOC_WLAN_SEC_NUM)) + return NULL; + + if (wifi_mem_array[section].size < size) + return NULL; + + return wifi_mem_array[section].mem_ptr; +} + +int __init herring_init_wifi_mem(void) +{ + int i; + int j; + + for (i = 0 ; i < WLAN_SKB_BUF_NUM ; i++) { + wlan_static_skb[i] = dev_alloc_skb( + ((i < (WLAN_SKB_BUF_NUM / 2)) ? 4096 : 8192)); + + if (!wlan_static_skb[i]) + goto err_skb_alloc; + } + + for (i = 0 ; i < PREALLOC_WLAN_SEC_NUM ; i++) { + wifi_mem_array[i].mem_ptr = + kmalloc(wifi_mem_array[i].size, GFP_KERNEL); + + if (!wifi_mem_array[i].mem_ptr) + goto err_mem_alloc; + } + return 0; + + err_mem_alloc: + pr_err("Failed to mem_alloc for WLAN\n"); + for (j = 0 ; j < i ; j++) + kfree(wifi_mem_array[j].mem_ptr); + + i = WLAN_SKB_BUF_NUM; + + err_skb_alloc: + pr_err("Failed to skb_alloc for WLAN\n"); + for (j = 0 ; j < i ; j++) + dev_kfree_skb(wlan_static_skb[j]); + + return -ENOMEM; +} + +/* Customized Locale table : OPTIONAL feature */ +#define WLC_CNTRY_BUF_SZ 4 +typedef struct cntry_locales_custom { + char iso_abbrev[WLC_CNTRY_BUF_SZ]; + char custom_locale[WLC_CNTRY_BUF_SZ]; + int custom_locale_rev; +} cntry_locales_custom_t; + +static cntry_locales_custom_t herring_wlan_translate_custom_table[] = { +/* Table should be filled out based on custom platform regulatory requirement */ + {"", "XY", 4}, /* universal */ + {"US", "US", 69}, /* input ISO "US" to : US regrev 69 */ + {"CA", "US", 69}, /* input ISO "CA" to : US regrev 69 */ + {"EU", "EU", 5}, /* European union countries */ + {"AT", "EU", 5}, + {"BE", "EU", 5}, + {"BG", "EU", 5}, + {"CY", "EU", 5}, + {"CZ", "EU", 5}, + {"DK", "EU", 5}, + {"EE", "EU", 5}, + {"FI", "EU", 5}, + {"FR", "EU", 5}, + {"DE", "EU", 5}, + {"GR", "EU", 5}, + {"HU", "EU", 5}, + {"IE", "EU", 5}, + {"IT", "EU", 5}, + {"LV", "EU", 5}, + {"LI", "EU", 5}, + {"LT", "EU", 5}, + {"LU", "EU", 5}, + {"MT", "EU", 5}, + {"NL", "EU", 5}, + {"PL", "EU", 5}, + {"PT", "EU", 5}, + {"RO", "EU", 5}, + {"SK", "EU", 5}, + {"SI", "EU", 5}, + {"ES", "EU", 5}, + {"SE", "EU", 5}, + {"GB", "EU", 5}, /* input ISO "GB" to : EU regrev 05 */ + {"IL", "IL", 0}, + {"CH", "CH", 0}, + {"TR", "TR", 0}, + {"NO", "NO", 0}, + {"KR", "XY", 3}, + {"AU", "XY", 3}, + {"CN", "XY", 3}, /* input ISO "CN" to : XY regrev 03 */ + {"TW", "XY", 3}, + {"AR", "XY", 3}, + {"MX", "XY", 3} +}; + +static void *herring_wlan_get_country_code(char *ccode) +{ + int size = ARRAY_SIZE(herring_wlan_translate_custom_table); + int i; + + if (!ccode) + return NULL; + + for (i = 0; i < size; i++) + if (strcmp(ccode, herring_wlan_translate_custom_table[i].iso_abbrev) == 0) + return &herring_wlan_translate_custom_table[i]; + return &herring_wlan_translate_custom_table[0]; +} + + +static struct wifi_platform_data wifi_pdata = { + .set_power = wlan_power_en, + .set_reset = wlan_reset_en, + .set_carddetect = wlan_carddetect_en, + .mem_prealloc = herring_mem_prealloc, + .get_country_code = herring_wlan_get_country_code, +}; + +static struct platform_device sec_device_wifi = { + .name = "bcm4329_wlan", + .id = 1, + .num_resources = ARRAY_SIZE(wifi_resources), + .resource = wifi_resources, + .dev = { + .platform_data = &wifi_pdata, + }, +}; + +static struct platform_device watchdog_device = { + .name = "watchdog", + .id = -1, +}; + +static struct platform_device *herring_devices[] __initdata = { + &watchdog_device, +#ifdef CONFIG_FIQ_DEBUGGER + &s5pv210_device_fiqdbg_uart2, +#endif + &s5p_device_onenand, +#ifdef CONFIG_RTC_DRV_S3C + &s5p_device_rtc, +#endif + &herring_input_device, + + &s5pv210_device_iis0, + &s3c_device_wdt, + +#ifdef CONFIG_FB_S3C + &s3c_device_fb, +#endif + +#ifdef CONFIG_VIDEO_MFC50 + &s3c_device_mfc, +#endif +#ifdef CONFIG_S5P_ADC + &s3c_device_adc, +#endif +#ifdef CONFIG_VIDEO_FIMC + &s3c_device_fimc0, + &s3c_device_fimc1, + &s3c_device_fimc2, +#endif + +#ifdef CONFIG_VIDEO_JPEG_V2 + &s3c_device_jpeg, +#endif + + &s3c_device_g3d, + &s3c_device_lcd, + +#ifdef CONFIG_FB_S3C_TL2796 + &s3c_device_spi_gpio, +#endif + &sec_device_jack, + + &s3c_device_i2c0, +#if defined(CONFIG_S3C_DEV_I2C1) + &s3c_device_i2c1, +#endif + +#if defined(CONFIG_S3C_DEV_I2C2) + &s3c_device_i2c2, +#endif + &herring_i2c4_device, + &herring_i2c6_device, + &herring_i2c7_device, + &herring_i2c8_device, /* gyro sensor */ + &herring_i2c9_device, /* max1704x:fuel_guage */ + &herring_i2c11_device, /* optical sensor */ + &herring_i2c12_device, /* magnetic sensor */ + &herring_i2c14_device, /* nfc sensor */ +#ifdef CONFIG_USB_GADGET + &s3c_device_usbgadget, +#endif +#ifdef CONFIG_USB_ANDROID + &s3c_device_android_usb, +#ifdef CONFIG_USB_ANDROID_MASS_STORAGE + &s3c_device_usb_mass_storage, +#endif +#ifdef CONFIG_USB_ANDROID_RNDIS + &s3c_device_rndis, +#endif +#endif + +#ifdef CONFIG_S3C_DEV_HSMMC + &s3c_device_hsmmc0, +#endif +#ifdef CONFIG_S3C_DEV_HSMMC1 + &s3c_device_hsmmc1, +#endif +#ifdef CONFIG_S3C_DEV_HSMMC2 + &s3c_device_hsmmc2, +#endif +#ifdef CONFIG_S3C_DEV_HSMMC3 + &s3c_device_hsmmc3, +#endif + + &sec_device_battery, + &herring_i2c10_device, + +#ifdef CONFIG_S5PV210_POWER_DOMAIN + &s5pv210_pd_audio, + &s5pv210_pd_cam, + &s5pv210_pd_tv, + &s5pv210_pd_lcd, + &s5pv210_pd_g3d, + &s5pv210_pd_mfc, +#endif + +#ifdef CONFIG_ANDROID_PMEM + &pmem_device, + &pmem_gpu1_device, + &pmem_adsp_device, +#endif + +#ifdef CONFIG_HAVE_PWM + &s3c_device_timer[0], + &s3c_device_timer[1], + &s3c_device_timer[2], + &s3c_device_timer[3], +#endif + +#ifdef CONFIG_CPU_FREQ + &s5pv210_device_cpufreq, +#endif + + &sec_device_rfkill, + &sec_device_btsleep, + &ram_console_device, + &sec_device_wifi, + &samsung_asoc_dma, +}; + +unsigned int HWREV; +EXPORT_SYMBOL(HWREV); + +static void __init herring_map_io(void) +{ + s5p_init_io(NULL, 0, S5P_VA_CHIPID); + s3c24xx_init_clocks(24000000); + s5pv210_gpiolib_init(); + s3c24xx_init_uarts(herring_uartcfgs, ARRAY_SIZE(herring_uartcfgs)); +#ifndef CONFIG_S5P_HIGH_RES_TIMERS + s5p_set_timer_source(S5P_PWM3, S5P_PWM4); +#endif + s5p_reserve_bootmem(herring_media_devs, + ARRAY_SIZE(herring_media_devs), S5P_RANGE_MFC); +#ifdef CONFIG_MTD_ONENAND + s5p_device_onenand.name = "s5pc110-onenand"; +#endif +} + +unsigned int pm_debug_scratchpad; + +static unsigned int ram_console_start; +static unsigned int ram_console_size; + +static void __init herring_fixup(struct machine_desc *desc, + struct tag *tags, char **cmdline, + struct meminfo *mi) +{ + mi->bank[0].start = 0x30000000; + mi->bank[0].size = 80 * SZ_1M; + + mi->bank[1].start = 0x40000000; + mi->bank[1].size = 256 * SZ_1M; + + mi->bank[2].start = 0x50000000; + /* 1M for ram_console buffer */ + mi->bank[2].size = 127 * SZ_1M; + mi->nr_banks = 3; + + ram_console_start = mi->bank[2].start + mi->bank[2].size; + ram_console_size = SZ_1M - SZ_4K; + + pm_debug_scratchpad = ram_console_start + ram_console_size; +} + +/* this function are used to detect s5pc110 chip version temporally */ +int s5pc110_version ; + +void _hw_version_check(void) +{ + void __iomem *phy_address ; + int temp; + + phy_address = ioremap(0x40, 1); + + temp = __raw_readl(phy_address); + + if (temp == 0xE59F010C) + s5pc110_version = 0; + else + s5pc110_version = 1; + + printk(KERN_INFO "S5PC110 Hardware version : EVT%d\n", + s5pc110_version); + + iounmap(phy_address); +} + +/* + * Temporally used + * return value 0 -> EVT 0 + * value 1 -> evt 1 + */ + +int hw_version_check(void) +{ + return s5pc110_version ; +} +EXPORT_SYMBOL(hw_version_check); + +static void herring_init_gpio(void) +{ + s3c_config_gpio_table(); + s3c_config_sleep_gpio_table(ARRAY_SIZE(herring_sleep_gpio_table), + herring_sleep_gpio_table); + if (herring_is_cdma_wimax_dev()) + s3c_config_sleep_gpio_table( + ARRAY_SIZE(herring_cdma_wimax_sleep_gpio_table), + herring_cdma_wimax_sleep_gpio_table); + +} + +static void __init fsa9480_gpio_init(void) +{ + if (herring_is_cdma_wimax_dev()) { + s3c_gpio_cfgpin(GPIO_USB_HS_SEL, S3C_GPIO_OUTPUT); + gpio_set_value(GPIO_USB_HS_SEL, 1); + } else { + s3c_gpio_cfgpin(GPIO_USB_SEL, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_USB_SEL, S3C_GPIO_PULL_NONE); + } + + s3c_gpio_cfgpin(GPIO_UART_SEL, S3C_GPIO_OUTPUT); + s3c_gpio_setpull(GPIO_UART_SEL, S3C_GPIO_PULL_NONE); + + s3c_gpio_cfgpin(GPIO_JACK_nINT, S3C_GPIO_SFN(0xf)); + s3c_gpio_setpull(GPIO_JACK_nINT, S3C_GPIO_PULL_NONE); +} + +static void __init setup_ram_console_mem(void) +{ + ram_console_resource[0].start = ram_console_start; + ram_console_resource[0].end = ram_console_start + ram_console_size - 1; +} + +static void __init sound_init(void) +{ + u32 reg; + + reg = __raw_readl(S5P_OTHERS); + reg &= ~(0x3 << 8); + reg |= 3 << 8; + __raw_writel(reg, S5P_OTHERS); + + reg = __raw_readl(S5P_CLK_OUT); + reg &= ~(0x1f << 12); + reg |= 19 << 12; + __raw_writel(reg, S5P_CLK_OUT); + + reg = __raw_readl(S5P_CLK_OUT); + reg &= ~0x1; + reg |= 0x1; + __raw_writel(reg, S5P_CLK_OUT); + + gpio_request(GPIO_MICBIAS_EN, "micbias_enable"); +} + +static s8 accel_rotation_wimax_rev0[9] = { + 0, -1, 0, + -1, 0, 0, + 0, 0, -1, +}; + +static void __init accel_init(void) +{ + if (herring_is_cdma_wimax_rev0()) + kr3dm_data.rotation = accel_rotation_wimax_rev0; +} + +static bool console_flushed; + +static void flush_console(void) +{ + if (console_flushed) + return; + + console_flushed = true; + + printk("\n"); + pr_emerg("Restarting %s\n", linux_banner); + if (!is_console_locked()) + return; + + mdelay(50); + + local_irq_disable(); + if (!console_trylock()) + pr_emerg("flush_console: console was locked! busting!\n"); + else + pr_emerg("flush_console: console was locked!\n"); + console_unlock(); +} + +static void herring_pm_restart(char mode, const char *cmd) +{ + flush_console(); + + /* On a normal reboot, INFORM6 will contain a small integer + * reason code from the notifier hook. On a panic, it will + * contain the 0xee we set at boot. Write 0xbb to differentiate + * a watchdog-timeout-and-reboot (0xee) from a controlled reboot + * (0xbb) + */ + if (__raw_readl(S5P_INFORM6) == 0xee) + __raw_writel(0xbb, S5P_INFORM6); + + arm_machine_restart(mode, cmd); +} + +static void __init herring_machine_init(void) +{ + arm_pm_restart = herring_pm_restart; + + setup_ram_console_mem(); + platform_add_devices(herring_devices, ARRAY_SIZE(herring_devices)); + if (!herring_is_tft_dev()) + platform_device_register(&herring_i2c5_device); + + /* Find out S5PC110 chip version */ + _hw_version_check(); + + pm_power_off = herring_power_off ; + + s3c_gpio_cfgpin(GPIO_HWREV_MODE0, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_HWREV_MODE0, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_HWREV_MODE1, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_HWREV_MODE1, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_HWREV_MODE2, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_HWREV_MODE2, S3C_GPIO_PULL_NONE); + HWREV = gpio_get_value(GPIO_HWREV_MODE0); + HWREV = HWREV | (gpio_get_value(GPIO_HWREV_MODE1) << 1); + HWREV = HWREV | (gpio_get_value(GPIO_HWREV_MODE2) << 2); + s3c_gpio_cfgpin(GPIO_HWREV_MODE3, S3C_GPIO_INPUT); + s3c_gpio_setpull(GPIO_HWREV_MODE3, S3C_GPIO_PULL_NONE); + HWREV = HWREV | (gpio_get_value(GPIO_HWREV_MODE3) << 3); + printk(KERN_INFO "HWREV is 0x%x\n", HWREV); + + /*initialise the gpio's*/ + herring_init_gpio(); + +#ifdef CONFIG_ANDROID_PMEM + android_pmem_set_platdata(); +#endif + + /* headset/earjack detection */ + if (system_rev >= 0x09) + gpio_request(GPIO_EAR_MICBIAS_EN, "ear_micbias_enable"); + + gpio_request(GPIO_TOUCH_EN, "touch en"); + + /* i2c */ + s3c_i2c0_set_platdata(NULL); +#ifdef CONFIG_S3C_DEV_I2C1 + s3c_i2c1_set_platdata(NULL); +#endif + +#ifdef CONFIG_S3C_DEV_I2C2 + s3c_i2c2_set_platdata(NULL); +#endif + k3g_irq_init(); + set_adc_table(); + accel_init(); + /* H/W I2C lines */ + if (system_rev >= 0x05) { + /* gyro sensor */ + if (herring_is_cdma_wimax_dev() && herring_is_cdma_wimax_rev0()) + i2c_register_board_info(5, i2c_devs0, + ARRAY_SIZE(i2c_devs0)); + else + i2c_register_board_info(0, i2c_devs0, + ARRAY_SIZE(i2c_devs0)); + /* magnetic and accel sensor */ + i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1)); + } + mxt224_init(); + i2c_register_board_info(2, i2c_devs2, ARRAY_SIZE(i2c_devs2)); + + /* wm8994 codec */ + sound_init(); + i2c_register_board_info(4, i2c_devs4, ARRAY_SIZE(i2c_devs4)); + /* accel sensor for rev04 */ + if (system_rev == 0x04) + i2c_register_board_info(5, i2c_devs5, ARRAY_SIZE(i2c_devs5)); + + if (herring_is_cdma_wimax_dev()) { + struct max8998_platform_data *pdata = + (struct max8998_platform_data *)&max8998_pdata; + pdata->num_regulators = + ARRAY_SIZE(herring_cdma_wimax_regulators); + pdata->regulators = herring_cdma_wimax_regulators; + } + + i2c_register_board_info(6, i2c_devs6, ARRAY_SIZE(i2c_devs6)); + if (!herring_is_tft_dev()) { + /* Touch Key */ + touch_keypad_gpio_init(); + i2c_register_board_info(10, i2c_devs10, ARRAY_SIZE(i2c_devs10)); + } else { + herring_virtual_keys_init(); + } + /* FSA9480 */ + fsa9480_gpio_init(); + i2c_register_board_info(7, i2c_devs7, ARRAY_SIZE(i2c_devs7)); + + /* gyro sensor for rev04 */ + if (system_rev == 0x04) + i2c_register_board_info(8, i2c_devs8, ARRAY_SIZE(i2c_devs8)); + + i2c_register_board_info(9, i2c_devs9, ARRAY_SIZE(i2c_devs9)); + /* optical sensor */ + gp2a_gpio_init(); + i2c_register_board_info(11, i2c_devs11, ARRAY_SIZE(i2c_devs11)); + /* magnetic sensor for rev04 */ + if (system_rev == 0x04) + i2c_register_board_info(12, i2c_devs12, ARRAY_SIZE(i2c_devs12)); + + /* nfc sensor */ + i2c_register_board_info(14, i2c_devs14, ARRAY_SIZE(i2c_devs14)); + + /* max8893 wimax PMIC */ + if (herring_is_cdma_wimax_dev()) { + platform_device_register(&herring_i2c15_device); + i2c_register_board_info(15, i2c_devs15, ARRAY_SIZE(i2c_devs15)); + } + + if (!herring_is_tft_dev()) { + spi_register_board_info(spi_board_info, + ARRAY_SIZE(spi_board_info)); + s3cfb_set_platdata(&tl2796_data); + } else { + switch (lcd_type) { + case 1: + spi_register_board_info(spi_board_info_hydis, + ARRAY_SIZE(spi_board_info_hydis)); + s3cfb_set_platdata(&nt35580_data); + break; + case 2: + spi_register_board_info(spi_board_info_hitachi, + ARRAY_SIZE(spi_board_info_hitachi)); + s3cfb_set_platdata(&r61408_data); + break; + default: + spi_register_board_info(spi_board_info_sony, + ARRAY_SIZE(spi_board_info_sony)); + s3cfb_set_platdata(&nt35580_data); + break; + } + } + +#if defined(CONFIG_S5P_ADC) + s3c_adc_set_platdata(&s3c_adc_platform); +#endif + +#if defined(CONFIG_PM) + s3c_pm_init(); +#endif + + s5ka3dfx_request_gpio(); + + s5k4ecgx_init(); + +#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); +#endif + +#ifdef CONFIG_VIDEO_JPEG_V2 + s3c_jpeg_set_platdata(&jpeg_plat); +#endif + +#ifdef CONFIG_VIDEO_MFC50 + /* mfc */ + s3c_mfc_set_platdata(NULL); +#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_S3C_DEV_HSMMC3 + s5pv210_default_sdhci3(); +#endif +#ifdef CONFIG_S5PV210_SETUP_SDHCI + s3c_sdhci_set_platdata(); +#endif + +#ifdef CONFIG_CPU_FREQ + s5pv210_cpufreq_set_platdata(&smdkc110_cpufreq_plat); +#endif + + regulator_has_full_constraints(); + + register_reboot_notifier(&herring_reboot_notifier); + + herring_switch_init(); + + gps_gpio_init(); + + uart_switch_init(); + + herring_init_wifi_mem(); + + if (herring_is_cdma_wimax_dev()) + platform_device_register(&s3c_device_cmc732); + + /* 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); +} + +#ifdef CONFIG_USB_SUPPORT +/* Initializes OTG Phy. */ +void otg_phy_init(void) +{ + /* USB PHY0 Enable */ + writel(readl(S5P_USB_PHY_CONTROL) | (0x1<<0), + S5P_USB_PHY_CONTROL); + writel((readl(S3C_USBOTG_PHYPWR) & ~(0x3<<3) & ~(0x1<<0)) | (0x1<<5), + S3C_USBOTG_PHYPWR); + writel((readl(S3C_USBOTG_PHYCLK) & ~(0x5<<2)) | (0x3<<0), + S3C_USBOTG_PHYCLK); + writel((readl(S3C_USBOTG_RSTCON) & ~(0x3<<1)) | (0x1<<0), + S3C_USBOTG_RSTCON); + msleep(1); + writel(readl(S3C_USBOTG_RSTCON) & ~(0x7<<0), + S3C_USBOTG_RSTCON); + msleep(1); + + /* rising/falling time */ + writel(readl(S3C_USBOTG_PHYTUNE) | (0x1<<20), + S3C_USBOTG_PHYTUNE); + + /* set DC level as 0xf (24%) */ + writel(readl(S3C_USBOTG_PHYTUNE) | 0xf, S3C_USBOTG_PHYTUNE); +} +EXPORT_SYMBOL(otg_phy_init); + +/* USB Control request data struct must be located here for DMA transfer */ +struct usb_ctrlrequest usb_ctrl __attribute__((aligned(64))); + +/* OTG PHY Power Off */ +void otg_phy_off(void) +{ + writel(readl(S3C_USBOTG_PHYPWR) | (0x3<<3), + S3C_USBOTG_PHYPWR); + writel(readl(S5P_USB_PHY_CONTROL) & ~(1<<0), + S5P_USB_PHY_CONTROL); +} +EXPORT_SYMBOL(otg_phy_off); + +void usb_host_phy_init(void) +{ + struct clk *otg_clk; + + otg_clk = clk_get(NULL, "otg"); + clk_enable(otg_clk); + + if (readl(S5P_USB_PHY_CONTROL) & (0x1<<1)) + return; + + __raw_writel(__raw_readl(S5P_USB_PHY_CONTROL) | (0x1<<1), + S5P_USB_PHY_CONTROL); + __raw_writel((__raw_readl(S3C_USBOTG_PHYPWR) + & ~(0x1<<7) & ~(0x1<<6)) | (0x1<<8) | (0x1<<5), + S3C_USBOTG_PHYPWR); + __raw_writel((__raw_readl(S3C_USBOTG_PHYCLK) & ~(0x1<<7)) | (0x3<<0), + S3C_USBOTG_PHYCLK); + __raw_writel((__raw_readl(S3C_USBOTG_RSTCON)) | (0x1<<4) | (0x1<<3), + S3C_USBOTG_RSTCON); + __raw_writel(__raw_readl(S3C_USBOTG_RSTCON) & ~(0x1<<4) & ~(0x1<<3), + S3C_USBOTG_RSTCON); +} +EXPORT_SYMBOL(usb_host_phy_init); + +void usb_host_phy_off(void) +{ + __raw_writel(__raw_readl(S3C_USBOTG_PHYPWR) | (0x1<<7)|(0x1<<6), + S3C_USBOTG_PHYPWR); + __raw_writel(__raw_readl(S5P_USB_PHY_CONTROL) & ~(1<<1), + S5P_USB_PHY_CONTROL); +} +EXPORT_SYMBOL(usb_host_phy_off); +#endif + +MACHINE_START(HERRING, "herring") + .boot_params = S5P_PA_SDRAM + 0x100, + .fixup = herring_fixup, + .init_irq = s5pv210_init_irq, + .map_io = herring_map_io, + .init_machine = herring_machine_init, +#ifdef CONFIG_S5P_HIGH_RES_TIMERS + .timer = &s5p_systimer, +#else + .timer = &s5p_timer, +#endif +MACHINE_END + +void s3c_setup_uart_cfg_gpio(unsigned char port) +{ + switch (port) { + case 0: + s3c_gpio_cfgpin(GPIO_BT_RXD, S3C_GPIO_SFN(GPIO_BT_RXD_AF)); + s3c_gpio_setpull(GPIO_BT_RXD, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_BT_TXD, S3C_GPIO_SFN(GPIO_BT_TXD_AF)); + s3c_gpio_setpull(GPIO_BT_TXD, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_BT_CTS, S3C_GPIO_SFN(GPIO_BT_CTS_AF)); + s3c_gpio_setpull(GPIO_BT_CTS, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_BT_RTS, S3C_GPIO_SFN(GPIO_BT_RTS_AF)); + s3c_gpio_setpull(GPIO_BT_RTS, S3C_GPIO_PULL_NONE); + s3c_gpio_slp_cfgpin(GPIO_BT_RXD, S3C_GPIO_SLP_PREV); + s3c_gpio_slp_setpull_updown(GPIO_BT_RXD, S3C_GPIO_PULL_NONE); + s3c_gpio_slp_cfgpin(GPIO_BT_TXD, S3C_GPIO_SLP_PREV); + s3c_gpio_slp_setpull_updown(GPIO_BT_TXD, S3C_GPIO_PULL_NONE); + s3c_gpio_slp_cfgpin(GPIO_BT_CTS, S3C_GPIO_SLP_PREV); + s3c_gpio_slp_setpull_updown(GPIO_BT_CTS, S3C_GPIO_PULL_NONE); + s3c_gpio_slp_cfgpin(GPIO_BT_RTS, S3C_GPIO_SLP_PREV); + s3c_gpio_slp_setpull_updown(GPIO_BT_RTS, S3C_GPIO_PULL_NONE); + break; + case 1: + s3c_gpio_cfgpin(GPIO_GPS_RXD, S3C_GPIO_SFN(GPIO_GPS_RXD_AF)); + s3c_gpio_setpull(GPIO_GPS_RXD, S3C_GPIO_PULL_UP); + s3c_gpio_cfgpin(GPIO_GPS_TXD, S3C_GPIO_SFN(GPIO_GPS_TXD_AF)); + s3c_gpio_setpull(GPIO_GPS_TXD, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_GPS_CTS, S3C_GPIO_SFN(GPIO_GPS_CTS_AF)); + s3c_gpio_setpull(GPIO_GPS_CTS, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_GPS_RTS, S3C_GPIO_SFN(GPIO_GPS_RTS_AF)); + s3c_gpio_setpull(GPIO_GPS_RTS, S3C_GPIO_PULL_NONE); + break; + case 2: + s3c_gpio_cfgpin(GPIO_AP_RXD, S3C_GPIO_SFN(GPIO_AP_RXD_AF)); + s3c_gpio_setpull(GPIO_AP_RXD, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_AP_TXD, S3C_GPIO_SFN(GPIO_AP_TXD_AF)); + s3c_gpio_setpull(GPIO_AP_TXD, S3C_GPIO_PULL_NONE); + break; + case 3: + s3c_gpio_cfgpin(GPIO_FLM_RXD, S3C_GPIO_SFN(GPIO_FLM_RXD_AF)); + s3c_gpio_setpull(GPIO_FLM_RXD, S3C_GPIO_PULL_NONE); + s3c_gpio_cfgpin(GPIO_FLM_TXD, S3C_GPIO_SFN(GPIO_FLM_TXD_AF)); + s3c_gpio_setpull(GPIO_FLM_TXD, S3C_GPIO_PULL_NONE); + break; + default: + break; + } +} +EXPORT_SYMBOL(s3c_setup_uart_cfg_gpio); |