arch/arm/mach-s5pv210/mach-herring.c - kernel/samsung - Git at Google

 /* 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);