mango210.c 분석

/* linux/arch/arm/mach-s5pv210/mach-mango210.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/clk.h>

#include <linux/delay.h>

#include <linux/usb/ch9.h>

#include <linux/clk.h>

#include <linux/input.h>

#include <linux/irq.h>

#include <linux/skbuff.h>

#include <linux/console.h>

#include <linux/pwm_backlight.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/regs-gpio.h>

#include <mach/gpio-mango210.h>

#include <mach/param.h>

#include <mach/system.h>

#include <mach/ts.h>

#include <linux/usb/gadget.h>

#include <linux/notifier.h>

#include <linux/reboot.h>

#include <linux/wlan_plat.h>

#ifdef CONFIG_ANDROID_PMEM

#include <linux/android_pmem.h>

#include <plat/media.h>

#include <mach/media.h>

#endif

#include <media/noon130pc20_platform.h>

#include <linux/smsc911x.h>

#include <linux/vd5376.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 <mach/regs-mem.h>

#include <plat/sdhci.h>

#include <plat/fimc.h>

#include <plat/jpeg.h>

#include <plat/clock.h>

#include <plat/regs-otg.h>

#include <linux/mango_keys.h>

#include <linux/mango_keypad.h>

#include <linux/input.h>

#include <../../../drivers/video/samsung/s3cfb.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 KERNEL_REBOOT_MASK      0xFFFFFFFF

#define REBOOT_MODE_FAST_BOOT 7

static int mango210_notifier_call(struct notifier_block *this,

unsigned long code, void *_cmd)

{

int mode = REBOOT_MODE_NONE;

unsigned int temp;

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;

}

temp = __raw_readl(S5P_INFORM6);

temp |= KERNEL_REBOOT_MASK;

temp &= mode;

__raw_writel(temp, S5P_INFORM6);

return NOTIFY_DONE;

}

static struct notifier_block mango210_reboot_notifier = {

.notifier_call = mango210_notifier_call,

};

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

}

static void mango210_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 mango210_uartcfgs[] __initdata = {

{

.hwport = 0,

.flags = 0,

.ucon = S5PV210_UCON_DEFAULT,

.ulcon = S5PV210_ULCON_DEFAULT,

.ufcon = S5PV210_UFCON_DEFAULT,

},

#ifndef CONFIG_FIQ_DEBUGGER

{

.hwport = 1,

.flags = 0,

.ucon = S5PV210_UCON_DEFAULT,

.ulcon = S5PV210_ULCON_DEFAULT,

.ufcon = S5PV210_UFCON_DEFAULT,

},

#endif

{

.hwport = 2,

.flags = 0,

.ucon = S5PV210_UCON_DEFAULT,

.ulcon = S5PV210_ULCON_DEFAULT,

.ufcon = S5PV210_UFCON_DEFAULT,

},

{

.hwport = 3,

.flags = 0,

.ucon = S5PV210_UCON_DEFAULT,

.ulcon = S5PV210_ULCON_DEFAULT,

.ufcon = S5PV210_UFCON_DEFAULT,

},

};

#ifdef CONFIG_ANDROID_PMEM

#define  S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMC0 (6144 * SZ_1K)

#define  S5PV210_VIDEO_SAMSUNG_MEMSIZE_FIMC1 (9900 * 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 (4800 * SZ_1K)

#define  S5PV210_VIDEO_SAMSUNG_MEMSIZE_JPEG (8192 * SZ_1K)

static struct s5p_media_device mango210_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,

},

/* pmem */

[7] = {

.id = S5P_MDEV_PMEM,

.name = "pmem",

.memsize = CONFIG_ANDROID_PMEM_MEMSIZE_PMEM * SZ_1K,

.paddr = 0,

.bank = 0, //OneDRAM

},

[8] = {

.id = S5P_MDEV_PMEM_GPU1,

.name = "pmem_gpu1",

.memsize = CONFIG_ANDROID_PMEM_MEMSIZE_PMEM_GPU1 * SZ_1K,

.paddr = 0,

.bank = 0, //OneDRAM 

},

[9] = {

.id = S5P_MDEV_PMEM_ADSP,

.name = "pmem_adsp",

.memsize = CONFIG_ANDROID_PMEM_MEMSIZE_PMEM_ADSP * SZ_1K,

.paddr = 0,

.bank = 0, //OneDRAM

},

};

#endif

struct platform_device sec_device_dpram = {

.name = "dpram-device",

.id = -1,

};

#ifdef CONFIG_TOUCHSCREEN_S3C

static struct s3c_ts_mach_info s3c_ts_platform __initdata = {

.delay                  = 50000,

.presc                  = 49,

.oversampling_shift     = 2,

.resol_bit              = 12,

.s3c_adc_con            = ADC_TYPE_2,

};

#endif

#ifdef CONFIG_KEYPAD_MANGO

static struct mango_keypad_gpio mango_keypad_col_table[] = {

{

.gpio = S5PV210_GPH3(1),

.desc = "GPH3",

.config = (0x0 << 4),

.pull = S3C_GPIO_PULL_UP

},

{

.gpio = S5PV210_GPH3(0),

.desc = "GPH3",

.config = (0x0 << 0),

.pull = S3C_GPIO_PULL_UP,

},

{

.gpio = S5PV210_GPH2(7),

.desc = "GPH2",

.config = (0x0 << 28),

.pull = S3C_GPIO_PULL_UP,

},

{

.gpio = S5PV210_GPH2(6),

.desc = "GPH2",

.config = (0x0 << 24),

.pull = S3C_GPIO_PULL_UP,

},

};

static struct mango_keypad_gpio mango_keypad_row_table[] = {

{

.gpio = S5PV210_GPH2(5),

.desc = "GPH2",

.config = (0x1 << 20),

.pull = S3C_GPIO_PULL_NONE,

},

{

.gpio = S5PV210_GPH2(4),

.desc = "GPH2",

.config = (0x1 << 16),

.pull = S3C_GPIO_PULL_NONE,

},

{

.gpio = S5PV210_GPH2(3),

.desc = "GPH2",

.config = (0x1 << 12),

.pull = S3C_GPIO_PULL_NONE,

},

{

.gpio = S5PV210_GPH2(2),

.desc = "GPH2",

.config = (0x1 << 8),

.pull = S3C_GPIO_PULL_NONE,

},

};

static struct mango_keypad_button mango_keypad_table[] = {

{

.code = KEY_1,

.type = EV_KEY,

},

{

.code = KEY_2,

.type = EV_KEY,

},

{

.code = KEY_3,

.type = EV_KEY,

},

{

.code = KEY_4,

.type = EV_KEY,

},

{

.code = KEY_5,

.type = EV_KEY,

},

{

.code = KEY_6,

.type = EV_KEY,

},

{

.code = KEY_7,

.type = EV_KEY,

},

{

.code = KEY_8,

.type = EV_KEY,

},

{

.code = KEY_9,

.type = EV_KEY,

},

{

.code = KEY_A,

.type = EV_KEY,

},

{

.code = KEY_B,

.type = EV_KEY,

},

{

.code = KEY_C,

.type = EV_KEY,

},

{

.code = KEY_D,

.type = EV_KEY,

},

{

.code = KEY_E,

.type = EV_KEY,

},

{

.code = KEY_F,

.type = EV_KEY,

},

{

.code = KEY_0,

.type = EV_KEY,

},

};

static struct mango_keypad_platform_data mango_keypad_data = {

.col_gpio = mango_keypad_col_table,

.row_gpio = mango_keypad_row_table,

.buttons = mango_keypad_table,

.ncol_gpio = ARRAY_SIZE(mango_keypad_col_table),

.nrow_gpio = ARRAY_SIZE(mango_keypad_row_table),

.nbuttons = ARRAY_SIZE(mango_keypad_table),

};

static struct platform_device mango_device_keypad = {

.name = "mango-keypad",

.dev = {

.platform_data = &mango_keypad_data,

},

};

#endif

#ifdef CONFIG_KEYBOARD_MANGO

static struct mango_keys_button mango_gpio_keys_table[] = {

{

.code = KEY_BACK,

.gpio = S5PV210_GPH0(1),

.active_low = 1,

.desc = "GPH0",

.type = EV_KEY,

.wakeup = 1,

// .debounce_interval = 5,

.irq = IRQ_EINT1,

.config = (0xf << 4),

.pull = S3C_GPIO_PULL_NONE,

.led_gpio = S5PV210_GPJ3(7),

.led_desc = "GPJ3",

.led_config = (0x1 << (4 * 7)),

.led_active_low = 1,

.long_code = KEY_HOME,

.long_interval = 200,

},

{

.code = KEY_MENU,

.gpio = S5PV210_GPH0(2),

.active_low = 1,

.desc = "GPH0",

.type = EV_KEY,

.wakeup = 1,

// .debounce_interval = 5,

.irq = IRQ_EINT2,

.config = (0xf<<8),

.pull = S3C_GPIO_PULL_NONE,

.led_gpio = S5PV210_GPJ4(0),

.led_desc = "GPJ4",

.led_config = (0x1 << (4 * 0)),

.led_active_low = 1,

.long_code = KEY_POWER,

.long_interval = 400,

},

};

static struct mango_keys_platform_data mango_gpio_keys_data = {

.buttons = mango_gpio_keys_table,

.nbuttons = ARRAY_SIZE(mango_gpio_keys_table),

.rep = 0,

};

static struct platform_device mango_device_gpiokeys = {

.name = "mango-keys",

.dev = {

.platform_data = &mango_gpio_keys_data,

},

};

#endif

#if defined(CONFIG_HAVE_PWM)

static struct platform_pwm_backlight_data mango_backlight_data = {

.pwm_id  = 0,

.max_brightness = 255,

.dft_brightness = 255,

// .pwm_period_ns  = 89284/2,

.pwm_period_ns  = 78770,

};

static struct platform_device mango_backlight_device = {

.name      = "pwm-backlight",

.id        = -1,

.dev        = {

.parent = &s3c_device_timer[0].dev,

.platform_data = &mango_backlight_data,

},

};

#endif

#ifdef CONFIG_BATTERY_MANGO_DUMMY

static struct platform_device mango_battery = {

.name = "dummy-battery",

};

#endif

#ifdef CONFIG_MOUSE_VD5376_FINGER

static struct vd5376_platform_data vd5376_table[] = {

{

.btn_gpio = S5PV210_GPH2(0),

.btn_desc = "GPH2",

.btn_irq = IRQ_EINT(16),

.btn_config = (0xf << 0),

.btn_active_low = 1,

.pd_gpio = S5PV210_GPH2(1),

.pd_desc = "GPH2",

.gpio = S5PV210_GPH2(2),

.desc = "GPH2",

.irq = IRQ_EINT(18),

.config = (0xf << 8),

.active_low = 1,

.delay = 20,

},

{

.btn_gpio = S5PV210_GPH2(3),

.btn_desc = "GPH2",

.btn_irq = IRQ_EINT(19),

.btn_config = (0xf << 12),

.btn_active_low = 1,

.pd_gpio = S5PV210_GPH2(4),

.pd_desc = "GPH2",

.gpio = S5PV210_GPH2(5),

.desc = "GPH2",

.irq = IRQ_EINT(21),

.config = (0xf << 20),

.active_low = 1,

.delay = 20,

},

};

struct vd5376_mouse_platform_data vd5376_mouse_data = {

.data = vd5376_table,

.ndatas = ARRAY_SIZE(vd5376_table),

.scan_ms = 50,

};

static struct platform_device vd5376_mouse_device = {

.name = "vd5376-mouse",

.dev = {

.platform_data = &vd5376_mouse_data,

},

};

#endif

static  struct  i2c_gpio_platform_data  i2c0_platdata = {

.sda_pin = GPIO_I2C_SDA0,

.scl_pin = GPIO_I2C_SCL0,

.udelay = 4,    /* 125KHz */

.sda_is_open_drain = 0,

.scl_is_open_drain = 0,

.scl_is_output_only = 0,

};

static struct platform_device s3c_gpio_device_i2c0 = {

.name = "i2c-gpio",

.id = 0,

.dev.platform_data = &i2c0_platdata,

};

static  struct  i2c_gpio_platform_data  i2c2_platdata = {

.sda_pin = GPIO_I2C_SDA2,

.scl_pin = GPIO_I2C_SCL2,

.udelay = 2,    /* 250KHz */

.sda_is_open_drain = 0,

.scl_is_open_drain = 0,

.scl_is_output_only = 0,

};

static struct platform_device s3c_gpio_device_i2c2 = {

.name = "i2c-gpio",

.id = 2,

.dev.platform_data = &i2c2_platdata,

};

/*

 * Guide for Camera Configuration for Crespo board

 * ITU CAM CH A: LSI noon130pc20

 */

/* External camera module setting */

static DEFINE_MUTEX(noon130pc20_lock);

static bool noon130pc20_powered_on;

static int noon130pc20_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 noon130pc20_power_on(void)

{

int err = 0;

int result;

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

/* CAM_VGA_nRST HIGH */

gpio_direction_output(GPIO_CAM_VGA_nRST, 0);

gpio_set_value(GPIO_CAM_VGA_nRST, 1);

mdelay(5);

return 0;

}

static int noon130pc20_power_off(void)

{

int err;

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

/* CAM_VGA_nSTBY LOW */

gpio_direction_output(GPIO_CAM_VGA_nSTBY, 1);

gpio_set_value(GPIO_CAM_VGA_nSTBY, 0);

return err;

}

static int noon130pc20_power_en(int onoff)

{

int err = 0;

mutex_lock(&noon130pc20_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 != noon130pc20_powered_on) {

if (onoff)

err = noon130pc20_power_on();

else {

err = noon130pc20_power_off();

// s3c_i2c0_force_stop();

}

if (!err)

noon130pc20_powered_on = onoff;

}

mutex_unlock(&noon130pc20_lock);

return err;

}

static struct noon130pc20_platform_data noon130pc20_plat = {

.default_width = 640,

.default_height = 480,

.pixelformat = V4L2_PIX_FMT_YUYV,

.freq = 24000000,

.is_mipi = 0,

.cam_power = noon130pc20_power_en,

};

static struct i2c_board_info noon130pc20_i2c_info = {

I2C_BOARD_INFO("NOON130PC20", 0x20),

.platform_data = &noon130pc20_plat,

};

static struct s3c_platform_camera noon130pc20 = {

.id = CAMERA_PAR_A,

.type = CAM_TYPE_ITU,

.fmt = ITU_601_YCBCR422_8BIT,

.order422 = CAM_ORDER422_8BIT_YCBYCR,

.i2c_busnum = 0,

.info = &noon130pc20_i2c_info,

.pixelformat = V4L2_PIX_FMT_YUYV,

.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 = noon130pc20_power_en,

};

/* Interface setting */

static struct s3c_platform_fimc fimc_plat_lsi = {

.srclk_name = "mout_mpll",

.clk_name = "sclk_fimc",

.lclk_name = "sclk_fimc_lclk",

.clk_rate = 166750000,

.default_cam = CAMERA_PAR_A,

.camera = {

&noon130pc20,

&noon130pc20,

},

.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

#ifdef CONFIG_USB_SUPPORT

static void __init mango210_usb_host_set(void)

{

int err;

err = gpio_request(S5PV210_ETC2(7), "ETC2");

if (err)

printk(KERN_ERR "#### failed to request ETC2 for USB host\n");

s3c_gpio_setpull(S5PV210_ETC2(7), S3C_GPIO_PULL_DOWN);

gpio_free(S5PV210_ETC2(7));

}

#endif

#if defined(CONFIG_FB_S3C_LB070WV6) || defined(CONFIG_FB_S3C_LTN101NT05)

static struct s3c_platform_fb mango_fb_data __initdata = {

.hw_ver = 0x62,

.nr_wins = 5,

.default_win = CONFIG_FB_S3C_DEFAULT_WINDOW,

.swap = FB_SWAP_WORD | FB_SWAP_HWORD,

};

#endif

/* I2C0 */

static struct i2c_board_info i2c_devs0[] __initdata = {

#ifdef CONFIG_SND_SOC_WM8960

{

I2C_BOARD_INFO("wm8960", 0x1a),

},

#endif

#ifdef CONFIG_MOUSE_VD5376_FINGER

{

// I2C_BOARD_INFO("vd5376", 0x10),

I2C_BOARD_INFO("vd5376", 0x53),

.platform_data = &vd5376_table[0],

},

#endif

#ifdef CONFIG_SENSORS_BMA150

{

I2C_BOARD_INFO("bma150", 0x38),

},

#endif

#ifdef CONFIG_BMP085

{

I2C_BOARD_INFO("bmp085", 0x77),

},

#endif

};

/* I2C1 */

static struct i2c_board_info i2c_devs1[] __initdata = {

#ifdef CONFIG_VIDEO_TV20

{

I2C_BOARD_INFO("s5p_ddc", (0x74>>1)),

},

#endif

};

/* I2C2 */

static struct i2c_board_info i2c_devs2[] __initdata = {

#ifdef CONFIG_MOUSE_VD5376_FINGER

{

// I2C_BOARD_INFO("vd5376", 0x10),

I2C_BOARD_INFO("vd5376", 0x53),

.platform_data = &vd5376_table[1],

},

#endif

};

#if 0

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,

};

#endif

#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

#ifdef CONFIG_SMSC911X

static struct smsc911x_platform_config smsc911x_config = {

    .irq_polarity   = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,

    .irq_type       = SMSC911X_IRQ_TYPE_PUSH_PULL,

    .flags          = SMSC911X_USE_32BIT,

    .phy_interface  = PHY_INTERFACE_MODE_MII,

    .dev_addr = {0x00,0x09,0xc0,0xff,0xec,0x48},

};

static struct resource smsc911x_resources[] = {

[0] = {

.start = S5PV210_PA_SMSC9220,

.end   = S5PV210_PA_SMSC9220 + 0xFF,

.flags = IORESOURCE_MEM,

},

[1] = {

.start = IRQ_EINT11,

.end   = IRQ_EINT11,

.flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,

}

};

struct platform_device device_smsc911x = {

.name = "smsc911x",

.id =  0,

.num_resources = ARRAY_SIZE(smsc911x_resources),

.resource = smsc911x_resources,

.dev = {

.platform_data = &smsc911x_config,

}

};

static int __init ethaddr_setup(char *line)

{

        char *ep;

        int i;

        /* there should really be routines to do this stuff */

        for (i = 0; i < 6; i++) {

                smsc911x_config.dev_addr[i] = line ? simple_strtoul(line, &ep, 16) : 0;

                if (line)

                        line = (*ep) ? ep+1 : ep;

        }

        printk("crzteh ddddd User MAC address: %pM\n", smsc911x_config.dev_addr);

        return 0;

}

__setup("ethaddr=", ethaddr_setup);

static void __init smsc911x_set(void)

{

unsigned int tmp;

tmp = ((0<<28)|(4<<24)|(13<<16)|(1<<12)|(4<<8)|(6<<4)|(0<<0));

__raw_writel(tmp, (S5P_SROM_BW + 0x08));

tmp = __raw_readl(S5P_SROM_BW);

tmp &= ~(0xf << 4);

tmp |= (0x1 << 4) | (0x1 << 5);

__raw_writel(tmp, S5P_SROM_BW);

tmp = __raw_readl(S5PV210_MP01_BASE);

tmp &= ~(0xf << 4);

tmp |= (2 << 4);

__raw_writel(tmp, S5PV210_MP01_BASE);

}

#else

static void __init smsc911x_set(void) {}

#endif

#define S3C_GPIO_SETPIN_ZERO         0

#define S3C_GPIO_SETPIN_ONE          1

#define S3C_GPIO_SETPIN_NONE     2

static void mango210_power_off(void)

{

while (1) {

mdelay(1000);

}

}

static struct platform_device watchdog_device = {

.name = "watchdog",

.id = -1,

};

static struct platform_device *mango210_devices[] __initdata = {

&watchdog_device,

#ifdef CONFIG_MTD_NAND

&s5pv210_device_nand,

#endif

#ifdef CONFIG_TOUCHSCREEN_S3C

&s3c_device_ts,

#endif

#ifdef CONFIG_FIQ_DEBUGGER

&s5pv210_device_fiqdbg_uart1,

#endif

#ifdef CONFIG_RTC_DRV_S3C

&s5p_device_rtc,

#endif

&s5pv210_device_iis0,

&s3c_device_wdt,

#ifdef CONFIG_FB_S3C

&s3c_device_fb,

#endif

#ifdef CONFIG_SMSC911X

&device_smsc911x,

#endif

#ifdef CONFIG_VIDEO_MFC50

&s3c_device_mfc,

#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_MOUSE_VD5376_FINGER

&vd5376_mouse_device,

#endif

&s3c_gpio_device_i2c0,

#if defined(CONFIG_S3C_DEV_I2C1)

&s3c_device_i2c1,

#endif

#if defined(CONFIG_S3C_DEV_I2C2)

&s3c_gpio_device_i2c2,

#endif

#ifdef CONFIG_USB

&s3c_device_usb_ehci,

&s3c_device_usb_ohci,

#endif

#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_HSMMC3

&s3c_device_hsmmc3,

#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_VIDEO_TV20

&s5p_device_tvout,

&s5p_device_cec,

&s5p_device_hpd,

#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_KEYBOARD_MANGO

&mango_device_gpiokeys,

#endif

#ifdef CONFIG_KEYPAD_MANGO

&mango_device_keypad,

#endif

#ifdef CONFIG_BATTERY_MANGO_DUMMY

&mango_battery,

#endif

#ifdef CONFIG_HAVE_PWM

&mango_backlight_device,

#endif

// &ram_console_device,

};

unsigned int HWREV;

EXPORT_SYMBOL(HWREV);

static void __init mango210_map_io(void)

{

s5p_init_io(NULL, 0, S5P_VA_CHIPID);

s3c24xx_init_clocks(24000000);

s3c24xx_init_uarts(mango210_uartcfgs, ARRAY_SIZE(mango210_uartcfgs));

#ifdef CONFIG_ANDROID_PMEM

s5p_reserve_bootmem(mango210_media_devs, ARRAY_SIZE(mango210_media_devs));

#endif

#ifdef CONFIG_MTD_NAND

s5pv210_device_nand.name = "s5pv210-nand";

#endif

}

//unsigned int pm_debug_scratchpad;

//static unsigned int ram_console_start;

//static unsigned int ram_console_size;

static void __init mango210_fixup(struct machine_desc *desc,

struct tag *tags, char **cmdline,

struct meminfo *mi)

{

mi->bank[0].start = 0x20000000;

mi->bank[0].size = 256 * SZ_1M;

mi->bank[0].node = 0;

mi->bank[1].start = 0x40000000;

mi->bank[1].size = 256 * SZ_1M;

mi->bank[1].node = 0;

mi->nr_banks = 2;

// ram_console_start = mi->bank[1].start;

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

#if 0

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;

}

#endif

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 (!try_acquire_console_sem()) {

release_console_sem();

return;

}

mdelay(50);

local_irq_disable();

if (try_acquire_console_sem())

pr_emerg("flush_console: console was locked! busting!\n");

else

pr_emerg("flush_console: console was locked!\n");

release_console_sem();

}

static void mango210_pm_restart(char mode, const char *cmd)

{

flush_console();

arm_machine_restart(mode, cmd);

}

#ifdef CONFIG_VIDEO_TV20

void s3c_set_qos()

{

/* VP QoS */

__raw_writel(0x00400001, S5P_VA_DMC0 + 0xC8);

__raw_writel(0x387F0022, S5P_VA_DMC0 + 0xCC);

/* MIXER QoS */

__raw_writel(0x00400001, S5P_VA_DMC0 + 0xD0);

__raw_writel(0x3FFF0062, S5P_VA_DMC0 + 0xD4);

/* LCD1 QoS */

__raw_writel(0x00800001, S5P_VA_DMC1 + 0x90);

__raw_writel(0x3FFF005B, S5P_VA_DMC1 + 0x94);

/* LCD2 QoS */

__raw_writel(0x00800001, S5P_VA_DMC1 + 0x98);

__raw_writel(0x3FFF015B, S5P_VA_DMC1 + 0x9C);

/* VP QoS */

__raw_writel(0x00400001, S5P_VA_DMC1 + 0xC8);

__raw_writel(0x387F002B, S5P_VA_DMC1 + 0xCC);

/* DRAM Controller QoS */

__raw_writel((__raw_readl(S5P_VA_DMC0)&~(0xFFF<<16)|(0x100<<16)),

S5P_VA_DMC0 + 0x0);

__raw_writel((__raw_readl(S5P_VA_DMC1)&~(0xFFF<<16)|(0x100<<16)),

S5P_VA_DMC1 + 0x0);

/* BUS QoS AXI_DSYS Control */

__raw_writel(0x00000007, S5P_VA_BUS_AXI_DSYS + 0x400);

__raw_writel(0x00000007, S5P_VA_BUS_AXI_DSYS + 0x420);

__raw_writel(0x00000030, S5P_VA_BUS_AXI_DSYS + 0x404);

__raw_writel(0x00000030, S5P_VA_BUS_AXI_DSYS + 0x424);

}

#endif

static void __init mango210_machine_init(void)

{

arm_pm_restart = mango210_pm_restart;

// setup_ram_console_mem();

// s3c_usb_set_serial();

platform_add_devices(mango210_devices, ARRAY_SIZE(mango210_devices));

/* Find out S5PC110 chip version */

_hw_version_check();

pm_power_off = mango210_power_off ;

#ifdef CONFIG_ANDROID_PMEM

android_pmem_set_platdata();

#endif

/* i2c */

s3c_i2c0_set_platdata(NULL);

// plat-samsung/dev-i2c0.c(58)

// S3C series device definition for i2c device 0

void __init s3c_i2c0_set_platdata(struct s3c2410_platform_i2c *pd)

{

        struct s3c2410_platform_i2c *npd;

        if (!pd)

                pd = &default_i2c_data0;

        npd = kmemdup(pd, sizeof(struct s3c2410_platform_i2c), GFP_KERNEL);

        if (!npd)

                printk(KERN_ERR "%s: no memory for platform data\n", __func__);

        else if (!npd->cfg_gpio)

                npd->cfg_gpio = s3c_i2c0_cfg_gpio;

        s3c_device_i2c0.dev.platform_data = npd;

}

#ifdef CONFIG_S3C_DEV_I2C1

s3c_i2c1_set_platdata(NULL);

// plat-samsung/dev-i2c1.c(59)

// s3c_i2c0_set_platdata와 내용 같음

#endif

#ifdef CONFIG_S3C_DEV_I2C2

s3c_i2c2_set_platdata(NULL);

// plat-samsung/dev-i2c2.c(59)

// s3c_i2c0_set_platdata와 내용 같음

#endif

/* H/W I2C lines */

i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));

// drivers/i2c/i2c-boardinfo.c (63)

//  * Systems using the Linux I2C driver stack can declare tables of board info

// * while they initialize.  This should be done in board-specific init code

// * near arch_initcall() time, or equivalent, before any I2C adapter driver is

// * registered.

int __init

i2c_register_board_info(int busnum,

        struct i2c_board_info const *info, unsigned len)

{

        int status;

        down_write(&__i2c_board_lock);

        /* dynamic bus numbers will be assigned after the last static one */

        if (busnum >= __i2c_first_dynamic_bus_num)

                __i2c_first_dynamic_bus_num = busnum + 1;

        for (status = 0; len; len--, info++) {

                struct i2c_devinfo      *devinfo;

                devinfo = kzalloc(sizeof(*devinfo), GFP_KERNEL);

                if (!devinfo) {

                        pr_debug("i2c-core: can't register boardinfo!\n");

                        status = -ENOMEM;

                        break;

                }

                devinfo->busnum = busnum;

                devinfo->board_info = *info;

                list_add_tail(&devinfo->list, &__i2c_board_list);

        }

        up_write(&__i2c_board_lock);

        return status;

}

--------------------------------------------------------------------------

// i2c_dev0

/* I2C0 */

static struct i2c_board_info i2c_devs0[] __initdata = {

#ifdef CONFIG_SND_SOC_WM8960

        {

                I2C_BOARD_INFO("wm8960", 0x1a),

        },

#endif

#ifdef CONFIG_MOUSE_VD5376_FINGER

        {

//              I2C_BOARD_INFO("vd5376", 0x10),

                I2C_BOARD_INFO("vd5376", 0x53),

                .platform_data = &vd5376_table[0],

        },

#endif

#ifdef CONFIG_SENSORS_BMA150

// 3-AXIS ACCELEROMETER DIGITAL I/F, 가속도 센서

        {

                I2C_BOARD_INFO("bma150", 0x38),

        },

#endif

#ifdef CONFIG_BMP085

// Barometric Pressure/Altitude sensor

        {

                I2C_BOARD_INFO("bmp085", 0x77),

        },

#endif

};

i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));

i2c_register_board_info(2, i2c_devs2, ARRAY_SIZE(i2c_devs2));

#if defined(CONFIG_FB_S3C_LB070WV6) || defined(CONFIG_FB_S3C_LTN101NT05)

s3cfb_set_platdata(&mango_fb_data);

// arch/arm/plat-s5p/devs.c(338)

// CONFIG_S5P_DEV_FB

// depends on FB_S3C

// Device Drivers - Graphics support - Support for frame buffer.. - S3C Framebuffer support

void __init s3cfb_set_platdata(struct s3c_platform_fb *pd)

{

        struct s3c_platform_fb *npd;

        int i;

        if (!pd)

                pd = &default_fb_data;

        npd = kmemdup(pd, sizeof(struct s3c_platform_fb), GFP_KERNEL);

        if (!npd)

                printk(KERN_ERR "%s: no memory for platform data\n", __func__);

        else {

                for (i = 0; i < npd->nr_wins; i++)

                        npd->nr_buffers[i] = 1;

                npd->nr_buffers[npd->default_win] = CONFIG_FB_S3C_NR_BUFFERS;

                s3cfb_get_clk_name(npd->clk_name);

#if defined(CONFIG_MACH_MANGO210)

                npd->cfg_gpio = s3cfb_cfg_gpio;

                npd->backlight_on = s3cfb_backlight_on;

                npd->backlight_off = s3cfb_backlight_off;

                npd->lcd_on = s3cfb_lcd_on;

                npd->lcd_off = s3cfb_lcd_off;

                npd->clk_on = s3cfb_clk_on;

                npd->clk_off = s3cfb_clk_off;

#else

                npd->backlight_onoff = NULL;

                npd->clk_on = s3cfb_clk_on;

                npd->clk_off = s3cfb_clk_off;

#endif

                /* starting physical address of memory region */

                npd->pmem_start = s5p_get_media_memory_bank(S5P_MDEV_FIMD, 1);

                /* size of memory region */

                npd->pmem_size = s5p_get_media_memsize_bank(S5P_MDEV_FIMD, 1);

                s3c_device_fb.dev.platform_data = npd;

        }

}

#endif

#if defined(CONFIG_TOUCHSCREEN_S3C)

s3c_ts_set_platdata(&s3c_ts_platform);

// arch/arm/plat-s5p/dev-ts.c(50)

// * S3C series device definition for hsmmc devices

void __init s3c_ts_set_platdata(struct s3c_ts_mach_info *pd)

{

        struct s3c_ts_mach_info *npd;

        npd = kmalloc(sizeof(*npd), GFP_KERNEL);

        if (npd) {

                memcpy(npd, pd, sizeof(*npd));

                s3c_device_ts.dev.platform_data = npd;

        } else {

                printk(KERN_ERR "no memory for Touchscreen platform data\n");

        }

}

#endif

#if defined(CONFIG_PM)

s3c_pm_init();

// plat-samsung/pm.c(456)

// S3C Power Managment functions

// This should be called from the board specific initialisation if the board supprots it.

int __init s3c_pm_init(void)

{

        printk("S3C Power Management, Copyright 2004 Simtec Electronics\n");

        pmstats_init();

        suspend_set_ops(&s3c_pm_ops);

        return 0;

}

--------------------------------------------------------------------------

void __init pmstats_init(void)

{

//      pr_info("pmstats at %08x\n", pm_debug_scratchpad);

//      if (pm_debug_scratchpad)

//              pmstats = ioremap(pm_debug_scratchpad, 4096);

//      else

                pmstats = kzalloc(4096, GFP_ATOMIC);

        if (!memcmp(pmstats->magic, PMSTATS_MAGIC, 16)) {

                pmstats_last = kzalloc(4096, GFP_ATOMIC);

                if (pmstats_last)

                        memcpy(pmstats_last, pmstats, 4096);        }

        memset(pmstats, 0, 4096);

        memcpy(pmstats->magic, PMSTATS_MAGIC, 16);

        debugfs_create_file("pmstats", 0444, NULL, pmstats, &pmstats_ops);

        if (pmstats_last)

                debugfs_create_file("pmstats_last", 0444, NULL, pmstats_last, &p

mstats_ops);

}

--------------------------------------------------------------------------

// kernel/power/suspend.c(42)

// CONFIG_SUSPEND

// Suspend to RAM and standby functionality

void suspend_set_ops(struct platform_suspend_ops *ops)

{

        mutex_lock(&pm_mutex);

        suspend_ops = ops;

        mutex_unlock(&pm_mutex);

}

--------------------------------------------------------------------------

// fs/debugfs/inode.c(219)

// CONFIG_DEBUG_FS

// debugfs는 파일 시스템 복구 명령어이다.

struct dentry *debugfs_create_file(const char *name, mode_t mode,

                                   struct dentry *parent, void *data,

                                   const struct file_operations *fops)

{

        struct dentry *dentry = NULL;

        int error;

        pr_debug("debugfs: creating file '%s'\n",name);

        error = simple_pin_fs(&debug_fs_type, &debugfs_mount,

                              &debugfs_mount_count);

        if (error)

                goto exit;

        error = debugfs_create_by_name(name, mode, parent, &dentry,

                                       data, fops);

        if (error) {

                dentry = NULL;

                simple_release_fs(&debugfs_mount, &debugfs_mount_count);

                goto exit;

        }

exit:

        return dentry;

}

EXPORT_SYMBOL_GPL(debugfs_create_file);

#endif

noon130pc20_request_gpio();

// NOON130PC20 Camera Sensor

static int noon130pc20_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;

}

// drivers/media/video/noon130pc20.c

// CONFIG_VIDEO_NOON130PC20

// include/linux/videodev2_samsung.h

// CONFIG_VIDEO_SAMSUNG_V4L2

//

#ifdef CONFIG_VIDEO_SAMSUNG_V4L2

#include <linux/videodev2_samsung.h>

#endif

#ifdef CONFIG_VIDEO_FIMC

/* fimc */

s3c_fimc0_set_platdata(&fimc_plat_lsi);

// arch/arm/plat-s5p/devs.c:406

// Samsung Camera Interface

// Device Drivers - Multimedia support - video capture adapters

void __init s3c_fimc0_set_platdata(struct s3c_platform_fimc *pd)

{

        struct s3c_platform_fimc *npd;

        if (!pd)

                pd = &default_fimc0_data;

        npd = kmemdup(pd, sizeof(struct s3c_platform_fimc), GFP_KERNEL);

        if (!npd)

                printk(KERN_ERR "%s: no memory for platform data\n", __func__);

        else {

                if (!npd->cfg_gpio)

                        npd->cfg_gpio = s3c_fimc0_cfg_gpio;

                if (!npd->clk_on)

                        npd->clk_on = s3c_fimc_clk_on;

                if (!npd->clk_off)

                        npd->clk_off = s3c_fimc_clk_off;

                npd->hw_ver = 0x45;

                /* starting physical address of memory region */

                npd->pmem_start = s5p_get_media_memory_bank(S5P_MDEV_FIMC0, 1);

                /* size of memory region */

                npd->pmem_size = s5p_get_media_memsize_bank(S5P_MDEV_FIMC0, 1);

                s3c_device_fimc0.dev.platform_data = npd;

        }

}

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

// arch/arm/plat-s5p/devs.c:615

// Samsung JPEG driver

// Device Drivers - Multimedia support - Video capture adapters

void __init s3c_jpeg_set_platdata(struct s3c_platform_jpeg *pd)

{

        struct s3c_platform_jpeg *npd;

        if (!pd)

                pd = &default_jpeg_data;

        npd = kmemdup(pd, sizeof(struct s3c_platform_jpeg), GFP_KERNEL);

        if (!npd)

                printk(KERN_ERR "%s: no memory for platform data\n", __func__);

        else

                s3c_device_jpeg.dev.platform_data = npd;

}

#endif

#ifdef CONFIG_VIDEO_MFC50

/* mfc */

s3c_mfc_set_platdata(NULL);

// arch/arm/plat-s5p/dev-mfc.c:54

// Samsung MFC (Multi Format Codec - FIMV 5.0) Driver 

// Device Drivers - Multimedia support - Video capture adapters

void __init s3c_mfc_set_platdata(struct s3c_platform_mfc *pd)

{

        s3c_mfc_pdata.buf_phy_base[0] =

                (u32)s5p_get_media_memory_bank(S5P_MDEV_MFC, 0);

        s3c_mfc_pdata.buf_phy_size[0] =

                (u32)s5p_get_media_memsize_bank(S5P_MDEV_MFC, 0);

        s3c_mfc_pdata.buf_phy_base[1] =

                (u32)s5p_get_media_memory_bank(S5P_MDEV_MFC, 1);

        s3c_mfc_pdata.buf_phy_size[1] =

                (u32)s5p_get_media_memsize_bank(S5P_MDEV_MFC, 1);

}

#endif

#ifdef CONFIG_VIDEO_TV20

// s3c_set_qos();

// mach-mango210.c:1238 

void s3c_set_qos()

{

        /* VP QoS */

        __raw_writel(0x00400001, S5P_VA_DMC0 + 0xC8);

        __raw_writel(0x387F0022, S5P_VA_DMC0 + 0xCC);

        /* MIXER QoS */

        __raw_writel(0x00400001, S5P_VA_DMC0 + 0xD0);

        __raw_writel(0x3FFF0062, S5P_VA_DMC0 + 0xD4);

        /* LCD1 QoS */

        __raw_writel(0x00800001, S5P_VA_DMC1 + 0x90);

        __raw_writel(0x3FFF005B, S5P_VA_DMC1 + 0x94);

        /* LCD2 QoS */

        __raw_writel(0x00800001, S5P_VA_DMC1 + 0x98);

        __raw_writel(0x3FFF015B, S5P_VA_DMC1 + 0x9C);

        /* VP QoS */

        __raw_writel(0x00400001, S5P_VA_DMC1 + 0xC8);

        __raw_writel(0x387F002B, S5P_VA_DMC1 + 0xCC);

        /* DRAM Controller QoS */

        __raw_writel((__raw_readl(S5P_VA_DMC0)&~(0xFFF<<16)|(0x100<<16)),

                        S5P_VA_DMC0 + 0x0);

        __raw_writel((__raw_readl(S5P_VA_DMC1)&~(0xFFF<<16)|(0x100<<16)),

                        S5P_VA_DMC1 + 0x0);

        /* BUS QoS AXI_DSYS Control */

        __raw_writel(0x00000007, S5P_VA_BUS_AXI_DSYS + 0x400);

        __raw_writel(0x00000007, S5P_VA_BUS_AXI_DSYS + 0x420);

        __raw_writel(0x00000030, S5P_VA_BUS_AXI_DSYS + 0x404);

        __raw_writel(0x00000030, S5P_VA_BUS_AXI_DSYS + 0x424);

}

// drivers/media/video/samsung/tv20/s5p_tvout.c ?? Makefile 설정은 되어있는데 파일이 없음..?

// Samsung TV Driver

// Device Drivers - Multimedia support - Video capture adapters

#endif

#ifdef CONFIG_S3C_DEV_HSMMC

s5pv210_default_sdhci0();

// arch/arm/plat-samsung/include/plat/sdhci.h:258

// arch/arm/mach-s5pv210/Kconfig

// 

#ifdef CONFIG_S3C_DEV_HSMMC

static inline void s5pv210_default_sdhci0(void)

{

        s3c_hsmmc0_def_platdata.clocks = s5pv210_hsmmc_clksrcs;

        s3c_hsmmc0_def_platdata.cfg_gpio = s5pv210_setup_sdhci0_cfg_gpio;

        s3c_hsmmc0_def_platdata.cfg_card = s5pv210_setup_sdhci_cfg_card;

        s3c_hsmmc0_def_platdata.adjust_cfg_card = s5pv210_adjust_sdhci_cfg_card;

}

#else

static inline void s5pv210_default_sdhci0(void) { }

#endif /* CONFIG_S3C_DEV_HSMMC */

#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();

// arch/arm/mach-s5pv210/setup-sdhci.c:310

// arch/arm/mach-s5pv210/Kconfig

//

void s3c_sdhci_set_platdata(void)

{

#if defined(CONFIG_S3C_DEV_HSMMC)

        s3c_sdhci0_set_platdata(&hsmmc0_platdata);

#endif

#if defined(CONFIG_S3C_DEV_HSMMC2)

        if (machine_is_herring()) {

                hsmmc2_platdata.ext_cd = IRQ_EINT(28);

                hsmmc2_platdata.cfg_ext_cd = universal_sdhci2_cfg_ext_cd;

                hsmmc2_platdata.detect_ext_cd = universal_sdhci2_detect_ext_cd;

        }

        s3c_sdhci2_set_platdata(&hsmmc2_platdata);

#endif

#if defined(CONFIG_S3C_DEV_HSMMC3)

        if (machine_is_herring())

                hsmmc3_platdata.built_in = 1;

        s3c_sdhci3_set_platdata(&hsmmc3_platdata);

#endif

};

#endif

#ifdef CONFIG_SMSC911X

smsc911x_set();

// mach-mango210.c:966

// 

static void __init smsc911x_set(void)

{

        unsigned int tmp;

        tmp = ((0<<28)|(4<<24)|(13<<16)|(1<<12)|(4<<8)|(6<<4)|(0<<0));

        __raw_writel(tmp, (S5P_SROM_BW + 0x08));

        tmp = __raw_readl(S5P_SROM_BW);

        tmp &= ~(0xf << 4);

        tmp |= (0x1 << 4) | (0x1 << 5);

        __raw_writel(tmp, S5P_SROM_BW);

        tmp = __raw_readl(S5PV210_MP01_BASE);

        tmp &= ~(0xf << 4);

        tmp |= (2 << 4);

        __raw_writel(tmp, S5PV210_MP01_BASE);

}

#else

static void __init smsc911x_set(void) {}

#endif

// drivers/net/smsc911x.c

// CONFIG_SMSC911X

// SMSC LAN911x/LAN921x families embedded ethernet support

// Device Drivers - Network device support - Ethernet 10 or 100

#endif

#ifdef CONFIG_USB_SUPPORT

mango210_usb_host_set();

// mach-mango210.c

// USB support

// Device Drivers - USB support

#ifdef CONFIG_USB_SUPPORT

static void __init mango210_usb_host_set(void)

{

        int err;

        err = gpio_request(S5PV210_ETC2(7), "ETC2");

        if (err)

                printk(KERN_ERR "#### failed to request ETC2 for USB host\n");

        s3c_gpio_setpull(S5PV210_ETC2(7), S3C_GPIO_PULL_DOWN);

        gpio_free(S5PV210_ETC2(7));

}

#endif

// drivers/usb/

#endif

register_reboot_notifier(&mango210_reboot_notifier);

// kernel/notifier.c:538

// 

// register_reboot_notifier - Register function to be called at reboot time

int register_reboot_notifier(struct notifier_block *nb)

{

        return blocking_notifier_chain_register(&reboot_notifier_list, nb);

}

EXPORT_SYMBOL(register_reboot_notifier);

----------------------------------------------------------------------

int blocking_notifier_chain_register(struct blocking_notifier_head *nh,

                struct notifier_block *n)

{

        int ret;

        /*

         * This code gets used during boot-up, when task switching is

         * not yet working and interrupts must remain disabled.  At

         * such times we must not call down_write().

         */

        if (unlikely(system_state == SYSTEM_BOOTING))

                return notifier_chain_register(&nh->head, n);

        down_write(&nh->rwsem);

        ret = notifier_chain_register(&nh->head, n);

        up_write(&nh->rwsem);

        return ret;

}

EXPORT_SYMBOL_GPL(blocking_notifier_chain_register);

mango210_switch_init();

// mach-mango210.c:150

//

//

static void mango210_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");

};

uart_switch_init();

// mach-mango210.c:125

// 

//

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

}

------------------------------------------------------------------------

------------------------------------------------------------------------

// drivers/gpio/gpiolib.c:1156

// CONFIG_GPIOLIB

// Device Drivers - GPIO Support

int gpio_request(unsigned gpio, const char *label)

{

struct gpio_desc *desc;

struct gpio_chip *chip;

int status = -EINVAL;

unsigned long flags;

spin_lock_irqsave(&gpio_lock, flags);

if (!gpio_is_valid(gpio))

goto done;

desc = &gpio_desc[gpio];

chip = desc->chip;

if (chip == NULL)

goto done;

if (!try_module_get(chip->owner))

goto done;

/* NOTE:  gpio_request() can be called in early boot,

* before IRQs are enabled, for non-sleeping (SOC) GPIOs.

*/

if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {

desc_set_label(desc, label ? : "?");

status = 0;

} else {

status = -EBUSY;

module_put(chip->owner);

goto done;

}

if (chip->request) {

/* chip->request may sleep */

spin_unlock_irqrestore(&gpio_lock, flags);

status = chip->request(chip, gpio - chip->base);

spin_lock_irqsave(&gpio_lock, flags);

if (status < 0) {

desc_set_label(desc, NULL);

module_put(chip->owner);

clear_bit(FLAG_REQUESTED, &desc->flags);

}

}

done:

if (status)

pr_debug("gpio_request: gpio-%d (%s) status %d\n",

gpio, label ? : "?", status);

spin_unlock_irqrestore(&gpio_lock, flags);

return status;

}

EXPORT_SYMBOL_GPL(gpio_request);

---------------------------------------------------------------

int gpio_direction_output(unsigned gpio, int value)

{

unsigned long flags;

struct gpio_chip *chip;

struct gpio_desc *desc = &gpio_desc[gpio];

int status = -EINVAL;

spin_lock_irqsave(&gpio_lock, flags);

if (!gpio_is_valid(gpio))

goto fail;

chip = desc->chip;

if (!chip || !chip->set || !chip->direction_output)

goto fail;

gpio -= chip->base;

if (gpio >= chip->ngpio)

goto fail;

status = gpio_ensure_requested(desc, gpio);

if (status < 0)

goto fail;

/* now we know the gpio is valid and chip won't vanish */

spin_unlock_irqrestore(&gpio_lock, flags);

might_sleep_if(extra_checks && chip->can_sleep);

if (status) {

status = chip->request(chip, gpio);

if (status < 0) {

pr_debug("GPIO-%d: chip request fail, %d\n",

chip->base + gpio, status);

/* and it's not available to anyone else ...

* gpio_request() is the fully clean solution.

*/

goto lose;

}

}

status = chip->direction_output(chip, gpio, value);

if (status == 0)

set_bit(FLAG_IS_OUT, &desc->flags);

lose:

return status;

fail:

spin_unlock_irqrestore(&gpio_lock, flags);

if (status)

pr_debug("%s: gpio-%d status %d\n",

__func__, gpio, status);

return status;

}

EXPORT_SYMBOL_GPL(gpio_direction_output);

---------------------------------------------------------------

int gpio_export(unsigned gpio, bool direction_may_change)

{

unsigned long flags;

struct gpio_desc *desc;

int status = -EINVAL;

const char *ioname = NULL;

/* can't export until sysfs is available ... */

if (!gpio_class.p) {

pr_debug("%s: called too early!\n", __func__);

return -ENOENT;

}

if (!gpio_is_valid(gpio))

goto done;

mutex_lock(&sysfs_lock);

spin_lock_irqsave(&gpio_lock, flags);

desc = &gpio_desc[gpio];

if (test_bit(FLAG_REQUESTED, &desc->flags)

&& !test_bit(FLAG_EXPORT, &desc->flags)) {

status = 0;

if (!desc->chip->direction_input

|| !desc->chip->direction_output)

direction_may_change = false;

}

spin_unlock_irqrestore(&gpio_lock, flags);

if (desc->chip->names && desc->chip->names[gpio - desc->chip->base])

ioname = desc->chip->names[gpio - desc->chip->base];

if (status == 0) {

struct device *dev;

dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),

desc, ioname ? ioname : "gpio%u", gpio);

if (!IS_ERR(dev)) {

status = sysfs_create_group(&dev->kobj,

&gpio_attr_group);

if (!status && direction_may_change)

status = device_create_file(dev,

&dev_attr_direction);

if (!status && gpio_to_irq(gpio) >= 0

&& (direction_may_change

|| !test_bit(FLAG_IS_OUT,

&desc->flags)))

status = device_create_file(dev,

&dev_attr_edge);

if (status != 0)

device_unregister(dev);

} else

status = PTR_ERR(dev);

if (status == 0)

set_bit(FLAG_EXPORT, &desc->flags);

}

mutex_unlock(&sysfs_lock);

done:

if (status)

pr_debug("%s: gpio%d status %d\n", __func__, gpio, status);

return status;

}

EXPORT_SYMBOL_GPL(gpio_export);

---------------------------------------------------------------

---------------------------------------------------------------

// arch/arm/plat-samsung/gpio-config.c:225

// 

// * S3C series GPIO configuration core

int s3c_gpio_setpull(unsigned int pin, s3c_gpio_pull_t pull)

{

        struct s3c_gpio_chip *chip = s3c_gpiolib_getchip(pin);

        unsigned long flags;

        int offset, ret;

        if (!chip)

                return -EINVAL;

        offset = pin - chip->chip.base;

        s3c_gpio_lock(chip, flags);

        ret = s3c_gpio_do_setpull(chip, offset, pull);

        s3c_gpio_unlock(chip, flags);

        return ret;

}

EXPORT_SYMBOL(s3c_gpio_setpull);

---------------------------------------------------------------

int s3c_gpio_cfgpin(unsigned int pin, unsigned int config)

{

        struct s3c_gpio_chip *chip = s3c_gpiolib_getchip(pin);

        unsigned long flags;

        int offset;

        int ret;

        if (!chip)

                return -EINVAL;

        offset = pin - chip->chip.base;

        s3c_gpio_lock(chip, flags);

        ret = s3c_gpio_do_setcfg(chip, offset, config);

        s3c_gpio_unlock(chip, flags);

        return ret;

}

EXPORT_SYMBOL(s3c_gpio_cfgpin);

---------------------------------------------------------------

}

#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 6 (6%) */

writel((readl(S3C_USBOTG_PHYTUNE) & ~(0xf)) | (0x1<<2) | (0x1<<1),

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(MANGO210, "MANGO210")

/* Maintainer: Kukjin Kim <kgene.kim@samsung.com> */

.phys_io = S3C_PA_UART & 0xfff00000,

.io_pg_offst = (((u32)S3C_VA_UART) >> 18) & 0xfffc,

.boot_params = S5P_PA_SDRAM + 0x100,

.fixup = mango210_fixup,

.init_irq = s5pv210_init_irq,

.map_io = mango210_map_io,

.init_machine = mango210_machine_init,

#if defined(CONFIG_S5P_HIGH_RES_TIMERS)

.timer = &s5p_systimer,

#else

.timer = &s3c24xx_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_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);

s3c_gpio_cfgpin(GPIO_AP_CTS, S3C_GPIO_SFN(GPIO_AP_CTS_AF));

s3c_gpio_setpull(GPIO_AP_CTS, S3C_GPIO_PULL_NONE);

s3c_gpio_cfgpin(GPIO_AP_RTS, S3C_GPIO_SFN(GPIO_AP_RTS_AF));

s3c_gpio_setpull(GPIO_AP_RTS, S3C_GPIO_PULL_NONE);

break;

case 2:

s3c_gpio_cfgpin(GPIO_GPS_RXD, S3C_GPIO_SFN(GPIO_GPS_RXD_AF));

s3c_gpio_setpull(GPIO_GPS_RXD, S3C_GPIO_PULL_NONE);

s3c_gpio_cfgpin(GPIO_GPS_TXD, S3C_GPIO_SFN(GPIO_GPS_TXD_AF));

s3c_gpio_setpull(GPIO_GPS_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);