int s5p_hpd_set_hdmiint(void)
{
/* EINT -> HDMI */
set_irq_type(IRQ_EINT13, IRQ_TYPE_NONE);
if (last_hpd_state)
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_UNPLUG);
else
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_PLUG);
atomic_set(&hdmi_status, HDMI_ON);
s3c_gpio_cfgpin(S5PV210_GPH1(5), S3C_GPIO_SFN(0x4));
s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_DOWN);
writel(readl(S5PV210_GPH1DRV)|0x3<<10, S5PV210_GPH1DRV);
s5p_hdmi_hpd_gen();
#ifdef CONFIG_MACH_MANGO210_EVT0
if (!s5p_hdmi_get_hpd_status())
#else
if (s5p_hdmi_get_hpd_status())
#endif
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_UNPLUG);
else
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_PLUG);
return 0;
}
int s5p_hpd_set_hdmiint(void)
{
/* EINT -> HDMI */
set_irq_type(IRQ_EINT13, IRQ_TYPE_NONE);
if (last_hpd_state)
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_UNPLUG);
else
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_PLUG);
atomic_set(&hdmi_status, HDMI_ON);
s3c_gpio_cfgpin(S5PV210_GPH1(5), S5PV210_GPH1_5_HDMI_HPD);
s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_DOWN);
s3c_gpio_set_drvstrength(S5PV210_GPH1(5), S3C_GPIO_DRVSTR_4X);
s5p_hdmi_hpd_gen();
if (s5p_hdmi_get_hpd_status())
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_UNPLUG);
else{
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_PLUG);
printk("\n++ %d",__LINE__);
}
return 0;
}
static int __init s5p_cec_probe(struct platform_device *pdev)
{
u8 *buffer;
int irq_num;
int ret;
s3c_gpio_cfgpin(S5PV210_GPH1(4), S3C_GPIO_SFN(0x4));
s3c_gpio_setpull(S5PV210_GPH1(4), S3C_GPIO_PULL_NONE);
/* get ioremap addr */
__s5p_cec_probe(pdev);
if (misc_register(&cec_misc_device)) {
printk(KERN_WARNING " Couldn't register device 10, %d.\n",
CEC_MINOR);
return -EBUSY;
}
irq_num = platform_get_irq(pdev, 0);
if (irq_num < 0) {
printk(KERN_ERR "failed to get %s irq resource\n", "cec");
ret = -ENOENT;
return ret;
}
ret = request_irq(irq_num, s5p_cec_irq_handler, IRQF_DISABLED,
pdev->name, &pdev->id);
if (ret != 0) {
printk(KERN_ERR "failed to install %s irq (%d)\n", "cec", ret);
return ret;
}
init_waitqueue_head(&cec_rx_struct.waitq);
spin_lock_init(&cec_rx_struct.lock);
init_waitqueue_head(&cec_tx_struct.waitq);
buffer = kmalloc(CEC_TX_BUFF_SIZE, GFP_KERNEL);
if (!buffer) {
printk(KERN_ERR " kmalloc() failed!\n");
misc_deregister(&cec_misc_device);
return -EIO;
}
cec_rx_struct.buffer = buffer;
cec_rx_struct.size = 0;
return 0;
}
/* Set for MIPI-CSI Camera module Power Enable */
static int mini210_mipi_cam_pwr_en(int enabled)
{
int err;
err = gpio_request(S5PV210_GPH1(2), "GPH1");
if (err)
printk(KERN_ERR "#### failed to request(GPH1)for CAM_2V8\n");
s3c_gpio_setpull(S5PV210_GPH1(2), S3C_GPIO_PULL_NONE);
gpio_direction_output(S5PV210_GPH1(2), enabled);
gpio_free(S5PV210_GPH1(2));
return 0;
}
static int smdkv210_mipi_cam_power(int onoff)
{
int err;
/* added for V210 CAM power */
err = gpio_request(S5PV210_GPH1(2), "GPH1");
if (err)
printk(KERN_ERR "#### failed to request(GPH1)for CAM_2V8\n");
s3c_gpio_setpull(S5PV210_GPH1(2), S3C_GPIO_PULL_NONE);
gpio_direction_output(S5PV210_GPH1(2), onoff);
gpio_free(S5PV210_GPH1(2));
return 0;
}
static int irq_eint(int irq)
{
if (gpio_get_value(S5PV210_GPH1(5))) {
if (g_last_hpd_state == HPD_HI)
return IRQ_HANDLED;
atomic_set(&g_hpd_struct.state, HPD_HI);
atomic_set(&g_poll_state, 1);
g_last_hpd_state = HPD_HI;
wake_up_interruptible(&g_hpd_struct.waitq);
} else {
if (g_last_hpd_state == HPD_LO)
return IRQ_HANDLED;
atomic_set(&g_hpd_struct.state, HPD_LO);
atomic_set(&g_poll_state, 1);
g_last_hpd_state = HPD_LO;
wake_up_interruptible(&g_hpd_struct.waitq);
}
schedule_work(&g_hpd_work);
HPDIFPRINTK("%s\n", atomic_read(&g_hpd_struct.state) == HPD_HI ?
"HPD HI" : "HPD LO");
return IRQ_HANDLED;
}
int irq_eint(int irq)
{
if (gpio_get_value(S5PV210_GPH1(5))) {
atomic_set(&hpd_struct.state, HPD_HI);
atomic_set(&poll_state, 1);
last_hpd_state = HPD_HI;
wake_up_interruptible(&hpd_struct.waitq);
} else {
atomic_set(&hpd_struct.state, HPD_LO);
atomic_set(&poll_state, 1);
last_hpd_state = HPD_LO;
wake_up_interruptible(&hpd_struct.waitq);
}
if (atomic_read(&hpd_struct.state))
set_irq_type(IRQ_EINT13, IRQ_TYPE_EDGE_FALLING);
else
set_irq_type(IRQ_EINT13, IRQ_TYPE_EDGE_RISING);
schedule_work(&hpd_work);
HPDIFPRINTK("%s\n", atomic_read(&hpd_struct.state) == HPD_HI ?
"HPD HI" : "HPD LO");
return IRQ_HANDLED;
}
irqreturn_t s5p_hpd_irq_handler(int irq)
{
int ret = IRQ_HANDLED;
unsigned long flags;
spin_lock_irqsave(&hpd_struct.lock, flags);
if (gpio_get_value(S5PV210_GPH1(5))) {
if (irq_event == EVENT_FALLING) {
mod_timer(&hpd_irq_check_timer, jiffies + HZ/20);
}
irq_event = EVENT_RISING;
} else {
irq_event = EVENT_FALLING;
del_timer(&hpd_irq_check_timer);
}
/* check HDMI status */
if (atomic_read(&hdmi_status)) {
/* HDMI on */
ret = irq_hdmi(irq);
HPDIFPRINTK("HDMI HPD interrupt\n");
} else {
/* HDMI off */
ret = irq_eint(irq);
HPDIFPRINTK("EINT HPD interrupt\n");
}
spin_unlock_irqrestore(&hpd_struct.lock, flags);
return ret;
}
int s5p_hpd_set_eint(void)
{
/* HDMI -> EINT */
atomic_set(&hdmi_status, HDMI_OFF);
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_PLUG);
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_UNPLUG);
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_PLUG);
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_UNPLUG);
s3c_gpio_cfgpin(S5PV210_GPH1(5), S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_DOWN);
writel(readl(S5PV210_GPH1DRV)|0x3<<10, S5PV210_GPH1DRV);
return 0;
}
static int __init s5p_hpd_probe(struct platform_device *pdev)
{
if (misc_register(&hpd_misc_device)) {
pr_err("%s::Couldn't register device 10, %d.\n", __func__,
HPD_MINOR);
return -EBUSY;
}
init_waitqueue_head(&g_hpd_struct.waitq);
spin_lock_init(&g_hpd_struct.lock);
atomic_set(&g_hpd_struct.state, -1);
atomic_set(&g_hdmi_status, HDMI_OFF);
s3c_gpio_cfgpin(S5PV210_GPH1(5), S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_DOWN);
writel(readl(S5PV210_GPH1DRV)|0x3<<10, S5PV210_GPH1DRV);
if (gpio_get_value(S5PV210_GPH1(5))) {
atomic_set(&g_hpd_struct.state, HPD_HI);
g_last_hpd_state = HPD_HI;
} else {
atomic_set(&g_hpd_struct.state, HPD_LO);
g_last_hpd_state = HPD_LO;
}
set_irq_type(IRQ_EINT13, IRQ_TYPE_EDGE_BOTH);
if (request_irq(IRQ_EINT13, s5p_hpd_irq_handler, IRQF_DISABLED,
"hpd", s5p_hpd_irq_handler)) {
pr_err("%s::failed to install %s irq\n", __func__, "hpd");
misc_deregister(&hpd_misc_device);
return -EIO;
}
if (s5p_hdmi_register_isr(s5p_hpd_irq_handler, (u8)HDMI_IRQ_HPD_PLUG) != 0)
pr_err("%s::s5p_hdmi_register_isr(HDMI_IRQ_HPD_PLUG) fail\n", __func__);
if (s5p_hdmi_register_isr(s5p_hpd_irq_handler, (u8)HDMI_IRQ_HPD_UNPLUG) != 0)
pr_err("%s::s5p_hdmi_register_isr(HDMI_IRQ_HPD_UNPLUG) fail\n", __func__);
return 0;
}
static int __init s5p_hpd_probe(struct platform_device *pdev)
{
if (misc_register(&hpd_misc_device)) {
printk(KERN_WARNING " Couldn't register device 10, %d.\n",
HPD_MINOR);
return -EBUSY;
}
init_waitqueue_head(&hpd_struct.waitq);
spin_lock_init(&hpd_struct.lock);
atomic_set(&hpd_struct.state, -1);
atomic_set(&hdmi_status, HDMI_OFF);
s3c_gpio_cfgpin(S5PV210_GPH1(5), S5PV210_GPH1_5_EXT_INT31_5);
s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_DOWN);
s3c_gpio_set_drvstrength(S5PV210_GPH1(5), S3C_GPIO_DRVSTR_4X);
if (gpio_get_value(S5PV210_GPH1(5))) {
atomic_set(&hpd_struct.state, HPD_HI);
last_hpd_state = HPD_HI;
irq_event = EVENT_RISING;
} else {
atomic_set(&hpd_struct.state, HPD_LO);
last_hpd_state = HPD_LO;
irq_event = EVENT_FALLING;
}
set_irq_type(IRQ_EINT13, IRQ_TYPE_EDGE_BOTH);
if (request_irq(IRQ_EINT13, s5p_hpd_irq_handler, IRQF_DISABLED,
"hpd", s5p_hpd_irq_handler)) {
printk(KERN_ERR "failed to install %s irq\n", "hpd");
misc_deregister(&hpd_misc_device);
return -EIO;
}
s5p_hdmi_register_isr((void *) s5p_hpd_irq_handler, (u8)HDMI_IRQ_HPD_PLUG);
s5p_hdmi_register_isr((void *) s5p_hpd_irq_handler, (u8)HDMI_IRQ_HPD_UNPLUG);
return 0;
}
int s5p_hpd_open(struct inode *inode, struct file *file)
{
#ifdef USEEXTINT
#else
/* adjust the duration of HPD detection */
s5p_tv_clk_gate(true);
hdmi_on = true;
s5p_hdmi_hpd_gen();
s3c_gpio_cfgpin(S5PV210_GPH1(5), S3C_GPIO_SFN(0x4));
s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_UP);
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_PLUG);
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_UNPLUG);
#endif
return 0;
}
static void hpd_irq_check_timer_func(unsigned long dummy)
{
unsigned long flags;
//printk("[TVOUT][%s:called]\n",__func__);
if (irq_event ==EVENT_RISING && !gpio_get_value(S5PV210_GPH1(5))) {
printk("[TVOUT][%s:re-call irq handler]\n",__func__);
//local_irq_save(flags);
s5p_hpd_irq_handler(IRQ_EINT13);
//local_irq_restore(flags);
}
}
static int __init s5p_hpd_probe(struct platform_device *pdev)
{
if (misc_register(&hpd_misc_device)) {
printk(KERN_WARNING " Couldn't register device 10, %d.\n", HPD_MINOR);
return -EBUSY;
}
init_waitqueue_head(&hpd_struct.waitq);
spin_lock_init(&hpd_struct.lock);
atomic_set(&hpd_struct.state, -1);
#ifdef USEEXTINT
s3c_gpio_cfgpin(S5PV210_GPH1(5), S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_UP);
if (gpio_get_value(S5PV210_GPH1(5)))
atomic_set(&hpd_struct.state, HPD_HI);
else
atomic_set(&hpd_struct.state, HPD_LO);
set_irq_type(IRQ_EINT13, IRQ_TYPE_EDGE_BOTH);
if (request_irq(IRQ_EINT13, s5p_hpd_irq_handler, IRQF_DISABLED, "hpd", s5p_hpd_irq_handler)){
printk(KERN_ERR "failed to install %s irq\n", "hpd");
misc_deregister(&hpd_misc_device);
return -EIO;
}
#else
/* must be checked */
s5p_hdmi_register_isr(s5p_hpd_irq_handler, (u8)HDMI_IRQ_HPD_PLUG);
s5p_hdmi_register_isr(s5p_hpd_irq_handler, (u8)HDMI_IRQ_HPD_UNPLUG);
#endif
return 0;
}
int s5p_hpd_set_eint(void)
{
/* HDMI -> EINT */
atomic_set(&hdmi_status, HDMI_OFF);
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_PLUG);
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_UNPLUG);
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_PLUG);
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_UNPLUG);
s3c_gpio_cfgpin(S5PV210_GPH1(5), S5PV210_GPH1_5_EXT_INT31_5);
s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_DOWN);
if (s5p_hpd_get_state())
set_irq_type(IRQ_EINT13, IRQ_TYPE_EDGE_FALLING);
else
set_irq_type(IRQ_EINT13, IRQ_TYPE_EDGE_RISING);
s3c_gpio_set_drvstrength(S5PV210_GPH1(5), S3C_GPIO_DRVSTR_4X);
printk("\n++ s5p_hpd_set_eint\n");
return 0;
}
static void gpiokeys_init(void)
{
s3c_gpio_cfgpin(S5PV210_GPH3(4), S3C_GPIO_SFN(0xf));
set_irq_type(IRQ_EINT(28), IRQ_TYPE_LEVEL_LOW);
s3c_gpio_cfgpin(S5PV210_GPH3(3), S3C_GPIO_SFN(0xf));
set_irq_type(IRQ_EINT(27), IRQ_TYPE_LEVEL_LOW);
//add by luis
s3c_gpio_cfgpin(S5PV210_GPH1(2), S3C_GPIO_SFN(0xf));
set_irq_type(IRQ_EINT(10), IRQ_TYPE_LEVEL_LOW);
s3c_gpio_cfgpin(S5PV210_GPH3(1), S3C_GPIO_SFN(0xf));
set_irq_type(IRQ_EINT(25), IRQ_TYPE_LEVEL_LOW);
s3c_gpio_cfgpin(S5PV210_GPH3(6), S3C_GPIO_SFN(0xf));
set_irq_type(IRQ_EINT(30), IRQ_TYPE_LEVEL_LOW);
s3c_gpio_cfgpin(S5PV210_GPH3(5), S3C_GPIO_SFN(0xf));
set_irq_type(IRQ_EINT(29), IRQ_TYPE_LEVEL_LOW);
//add by luis
}
int irq_eint(int irq)
{
// by pjlee : Interrupt Signal Change
#ifdef CONFIG_MACH_MANGO210_EVT0
if (!gpio_get_value(S5PV210_GPH1(5))) {
#else
if (gpio_get_value(S5PV210_GPH1(5))) {
#endif
if(last_hpd_state == HPD_HI)
return;
atomic_set(&hpd_struct.state, HPD_HI);
atomic_set(&poll_state, 1);
last_hpd_state = HPD_HI;
wake_up_interruptible(&hpd_struct.waitq);
} else {
if(last_hpd_state == HPD_LO)
return;
atomic_set(&hpd_struct.state, HPD_LO);
atomic_set(&poll_state, 1);
last_hpd_state = HPD_LO;
wake_up_interruptible(&hpd_struct.waitq);
}
schedule_work(&hpd_work);
HPDIFPRINTK("%s\n", atomic_read(&hpd_struct.state) == HPD_HI ?
"HPD HI" : "HPD LO");
return IRQ_HANDLED;
}
int irq_hdmi(int irq)
{
u8 flag;
int ret = IRQ_HANDLED;
/* read flag register */
flag = s5p_hdmi_get_interrupts();
#ifdef CONFIG_MACH_MANGO210_EVT0
if (!s5p_hdmi_get_hpd_status())
#else
if (s5p_hdmi_get_hpd_status())
#endif
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_PLUG);
else
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_UNPLUG);
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_UNPLUG);
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_PLUG);
/* is this our interrupt? */
if (!(flag & (1 << HDMI_IRQ_HPD_PLUG | 1 << HDMI_IRQ_HPD_UNPLUG))) {
ret = IRQ_NONE;
goto out;
}
if (flag == (1 << HDMI_IRQ_HPD_PLUG | 1 << HDMI_IRQ_HPD_UNPLUG)) {
HPDIFPRINTK("HPD_HI && HPD_LO\n");
#ifdef CONFIG_MACH_MANGO210_EVT0
if (last_hpd_state == HPD_HI && !s5p_hdmi_get_hpd_status())
#else
if (last_hpd_state == HPD_HI && s5p_hdmi_get_hpd_status())
#endif
flag = 1 << HDMI_IRQ_HPD_UNPLUG;
else
flag = 1 << HDMI_IRQ_HPD_PLUG;
}
if (flag & (1 << HDMI_IRQ_HPD_PLUG)) {
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_UNPLUG);
atomic_set(&hpd_struct.state, HPD_HI);
atomic_set(&poll_state, 1);
last_hpd_state = HPD_HI;
wake_up_interruptible(&hpd_struct.waitq);
s5p_hdcp_encrypt_stop(true);
HPDIFPRINTK("HPD_HI\n");
} else if (flag & (1 << HDMI_IRQ_HPD_UNPLUG)) {
s5p_hdcp_encrypt_stop(false);
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_PLUG);
atomic_set(&hpd_struct.state, HPD_LO);
atomic_set(&poll_state, 1);
last_hpd_state = HPD_LO;
wake_up_interruptible(&hpd_struct.waitq);
HPDIFPRINTK("HPD_LO\n");
}
schedule_work(&hpd_work);
out:
return IRQ_HANDLED;
}
#endif
#ifdef CONFIG_S3C_DEV_HSMMC2
static struct s3c_sdhci_platdata smdkc110_hsmmc2_pdata __initdata = {
.cd_type = S3C_SDHCI_CD_INTERNAL,
.wp_gpio = S5PV210_GPH3(1),
.has_wp_gpio = true,
#if defined(CONFIG_S5PV210_SD_CH2_8BIT)
.max_width = 8,
.host_caps = MMC_CAP_8_BIT_DATA,
#endif
};
#endif
#ifdef CONFIG_S3C_DEV_HSMMC3
static struct s3c_sdhci_platdata smdkc110_hsmmc3_pdata __initdata = {
.cd_type = S3C_SDHCI_CD_INTERNAL,
.wp_gpio = S5PV210_GPH1(0),
.has_wp_gpio = true,
};
#endif
static int __init smdkc110_bl_init(struct device *dev)
{
s3c_gpio_cfgpin(S5PV210_GPD0(3), S3C_GPIO_SFN(2));
return 0;
}
static struct platform_pwm_backlight_data smdkc110_backlight_data = {
.pwm_id = 3,
.max_brightness = 1000,
.dft_brightness = 600,
.pwm_period_ns = 1000000000 / (1000 * 20),
} else {
printk(KERN_ERR "no memory for ADC platform data\n");
}
}
#endif /* CONFIG_S5P_ADC */
/******************************************************************************
* gpio keypad
******************************************************************************/
//#ifdef CONFIG_KEYBOARD_GPIO
#include <linux/input.h>
#include <linux/gpio_keys.h>
static struct gpio_keys_button gpio_buttons[] = {
{
.gpio = S5PV210_GPH1(0),
.code = KEY_POWER,
.desc = "POWER",
.active_low = 1,
.wakeup = 1,
.debounce_interval = 5,
.can_disable = 1,
},
};
static struct gpio_keys_platform_data gpio_button_data = {
.buttons = gpio_buttons,
.nbuttons = ARRAY_SIZE(gpio_buttons),
};
{
.code = GPIO_KEY_VOLUP,
.gpio = S5PV210_GPH3(4),
.desc = "Volume up button",
.type = EV_KEY,
.active_low = 1,
.debounce_interval = 10,
.timer_interval = 10,
.longpress_time = 2000,
.key_status = "volup_key_status",
},
//add by luis
{ //key map define in framework /system/usr/keylayout/s3c-keypad.kl
.code = 5,
.gpio = S5PV210_GPH1(2),
.desc = "Serch button",
.type = EV_KEY,
.active_low = 1,
.debounce_interval = 10,
.timer_interval = 50,
.longpress_time = 1900,
.key_status = "serch_key_status",
},
{
.code = 34,
.gpio = S5PV210_GPH3(1),
.desc = "Back button",
.type = EV_KEY,
.active_low = 1,
/*
* HPD interrupt handler
*
* Handles interrupt requests from HPD hardware.
* Handler changes value of internal variable and notifies waiting thread.
*/
irqreturn_t s5p_hpd_irq_handler(int irq, void *pw)
{
#ifdef USEEXTINT
spin_lock_irq(&hpd_struct.lock);
if (gpio_get_value(S5PV210_GPH1(5))) {
if (atomic_read(&hpd_struct.state) == HPD_HI)
goto out;
atomic_set(&hpd_struct.state, HPD_HI);
} else {
if (atomic_read(&hpd_struct.state) == HPD_LO)
goto out;
atomic_set(&hpd_struct.state, HPD_LO);
}
if(atomic_read(&hpd_struct.state)){
set_irq_type(IRQ_EINT13, IRQ_TYPE_LEVEL_LOW);
}else{
set_irq_type(IRQ_EINT13, IRQ_TYPE_LEVEL_HIGH);
}
/* Send UEvent for HPD - added by jyg1004 */
schedule_work(&hpd_work);
spin_unlock_irq(&hpd_struct.lock);
HPDIFPRINTK("hpd_status = %d\n", atomic_read(&hpd_struct.state));
return IRQ_HANDLED;
out:
spin_unlock_irq(&hpd_struct.lock);
return IRQ_HANDLED;
#else
u8 flag;
int ret = IRQ_HANDLED;
/* read flag register */
flag = s5p_hdmi_get_interrupts();
/* is this our interrupt? */
if (!(flag & (1 << HDMI_IRQ_HPD_PLUG | 1 << HDMI_IRQ_HPD_UNPLUG))) {
ret = IRQ_NONE;
goto out;
}
/* workaround: ignore HPD IRQ caused by reseting HDCP engine */
if (s5p_hdmi_get_swhpd_status()) {
s5p_hdmi_swhpd_disable();
/* clear pending bit */
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_UNPLUG);
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_PLUG);
ret = IRQ_HANDLED;
goto out;
}
if (flag == (1 << HDMI_IRQ_HPD_PLUG | 1 << HDMI_IRQ_HPD_UNPLUG)) {
HPDIFPRINTK("HPD_HI && HPD_LO\n");
if (last_hpd_state == HPD_HI && s5p_hdmi_get_hpd_status())
//if ( last_hpd_state == HPD_HI )
flag = 1 << HDMI_IRQ_HPD_UNPLUG;
else
flag = 1 << HDMI_IRQ_HPD_PLUG;
}
if (flag & (1 << HDMI_IRQ_HPD_PLUG)) {
HPDIFPRINTK("HPD_HI\n");
/* clear pending bit */
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_PLUG);
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_UNPLUG);
atomic_set(&hpd_struct.state, HPD_HI);
// workaround: enable HDMI_IRQ_HPD_UNPLUG interrupt
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_PLUG);
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_UNPLUG);
last_hpd_state = HPD_HI;
wake_up_interruptible(&hpd_struct.waitq);
} else if (flag & (1 << HDMI_IRQ_HPD_UNPLUG)) {
HPDIFPRINTK("HPD_LO\n");
/* clear pending bit */
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_PLUG);
s5p_hdmi_clear_pending(HDMI_IRQ_HPD_UNPLUG);
atomic_set(&hpd_struct.state, HPD_LO);
// workaround: disable HDMI_IRQ_HPD_UNPLUG interrupt
last_hpd_state = HPD_LO;
s5p_hdmi_disable_interrupts(HDMI_IRQ_HPD_UNPLUG);
s5p_hdmi_enable_interrupts(HDMI_IRQ_HPD_PLUG);
wake_up_interruptible(&hpd_struct.waitq);
}
out:
return IRQ_HANDLED;
#endif
}
static int ams397g201_probe(struct device *dev)
{
int ret = 0;
struct regulator *r_lcd_1_8v, *r_lcd_3_0v, *r_lcd_1_1v;
lcd.bl_dev =backlight_device_register("s5p_bl",dev,&lcd,&s5p_bl_ops, NULL);
lcd.bl_dev->props.max_brightness = 255;
SetLDIEnabledFlag(1);
//For ESD test panel error
setup_timer(&polling_timer, polling_ESD_timer_func, 0);
mod_timer(&polling_timer,
jiffies + msecs_to_jiffies(5000));
#ifdef GAMMASET_CONTROL //for 1.9/2.2 gamma control from platform
gammaset_class = class_create(THIS_MODULE, "gammaset");
if (IS_ERR(gammaset_class))
pr_err("Failed to create class(gammaset_class)!\n");
switch_gammaset_dev = device_create(gammaset_class, NULL, 0, NULL, "switch_gammaset");
if (IS_ERR(switch_gammaset_dev))
pr_err("Failed to create device(switch_gammaset_dev)!\n");
if (device_create_file(switch_gammaset_dev, &dev_attr_gammaset_file_cmd) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_gammaset_file_cmd.attr.name);
if (device_create_file(switch_gammaset_dev, &dev_attr_lcd_update) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_lcd_update);
#endif
#ifdef ACL_ENABLE //ACL On,Off
acl_class = class_create(THIS_MODULE, "aclset");
if (IS_ERR(acl_class))
pr_err("Failed to create class(acl_class)!\n");
switch_aclset_dev = device_create(acl_class, NULL, 0, NULL, "switch_aclset");
if (IS_ERR(switch_aclset_dev))
pr_err("Failed to create device(switch_aclset_dev)!\n");
if (device_create_file(switch_aclset_dev, &dev_attr_aclset_file_cmd) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_aclset_file_cmd.attr.name);
#endif
#if 1
//TE interrupt pin ( GPF0_1 /GPF0_INT[1] ) enable filter
s3c_gpio_int_flt(S5PV210_GPA0(0),1);
#define IRQ_TE_INT (IRQ_EINT_GROUP10_BASE+1) /* F0_1 */
/* irq for TE signal *///sehun_test
if (request_irq(/*S3C_GPIOINT(F0,1)*/IRQ_TE_INT, ams397g201_te_interrupt, IRQF_TRIGGER_RISING | IRQF_SHARED,
"te_signal", dev)) {
dev_err(dev, "request_irq failed.\n");
goto err_te_irq;
}
#if 1
/* irq for ESD signal */
s3c_gpio_cfgpin(S5PV210_GPH1(2), S3C_GPIO_SFN(0xFF));
s3c_gpio_setpull(S5PV210_GPH1(2), S3C_GPIO_PULL_UP);
set_irq_type(LCD_ESD_INT, IRQ_TYPE_EDGE_RISING);
if( (ret = request_irq(LCD_ESD_INT, ams397g201_esd_irq_handler,IRQF_DISABLED , "LCD_ESD", NULL)) < 0 )
{
printk("%s, request_irq failed %d, ret= %d\n",__FUNCTION__, LCD_ESD_INT, ret );
}
disable_irq( LCD_ESD_INT);
mdelay(10);
//enable_irq( LCD_ESD_INT);
#endif
#endif
r_lcd_1_8v = regulator_get(dev, "vlcd");
if (IS_ERR(r_lcd_1_8v)) {
dev_err(dev, "failed to get regulator vlcd.\n");
return -EINVAL;
}
r_lcd_1_1v = regulator_get(dev, "VMIPI_1.8V");
if (IS_ERR(r_lcd_1_1v)) {
dev_err(dev, "failed to get regulator VMIPI_1.8V.\n");
return -EINVAL;
}
regulator_enable(r_lcd_1_1v);
r_lcd_1_1v = regulator_get(dev, "VMIPI_1.1V");
if (IS_ERR(r_lcd_1_1v)) {
dev_err(dev, "failed to get regulator VMIPI_1.1V.\n");
return -EINVAL;
}
regulator_enable(r_lcd_1_1v);
#if 0
ret = regulator_set_voltage(r_lcd_1_8v, 1800000, 1800000);
if(ret != 0) {
printk(KERN_ERR "%s: Cannot set VLCD_1.8V\n", __func__);
return -EINVAL;
}
ret = regulator_enable(r_lcd_1_8v);
if (ret < 0) {
printk(KERN_ERR "failed to enable regulator VLCD_1_8v.\n");
return ret;
}
#endif
r_lcd_3_0v = regulator_get(dev, "vcc_lcd");
if (IS_ERR(r_lcd_3_0v)) {
dev_err(dev, "failed to get regulator vcc_lcd.\n");
return -EINVAL;
}
#if 0
ret = regulator_set_voltage(r_lcd_3_0v, 3000000, 3000000);
if(ret != 0) {
printk(KERN_ERR "%s: Cannot set VLCD_3.0V\n", __func__);
return -EINVAL;
}
ret = regulator_enable(r_lcd_3_0v);
if (ret < 0) {
printk(KERN_ERR "failed to enable regulator VLCD_3_0v.\n");
return ret;
}
#endif
#if 0 //@@
/* lcd power on */
if (ddi_pd->lcd_power_on)
ddi_pd->lcd_power_on((void *) dev, 1);
else
dev_warn(dev, "lcd_power_on func is null.\n");
mdelay(60);
/* lcd reset */
if (ddi_pd->lcd_reset)
ddi_pd->lcd_reset();
else
dev_warn(dev, "lcd_reset func is null.\n");
#endif
dev_info(dev, "ams397g201 lcd panel driver based on mipi-dsi has been probed.\n");
err_te_irq:
return 0;
}
.ngpio = S5PV210_GPIO_G3_NR,
.label = "GPG3",
},
}, {
.base = S5PV210_GPH0_BASE,
.config = &gpio_cfg_noint,
.chip = {
.base = S5PV210_GPH0(0),
.ngpio = S5PV210_GPIO_H0_NR,
.label = "GPH0",
},
}, {
.base = S5PV210_GPH1_BASE,
.config = &gpio_cfg_noint,
.chip = {
.base = S5PV210_GPH1(0),
.ngpio = S5PV210_GPIO_H1_NR,
.label = "GPH1",
},
}, {
.base = S5PV210_GPH2_BASE,
.config = &gpio_cfg_noint,
.chip = {
.base = S5PV210_GPH2(0),
.ngpio = S5PV210_GPIO_H2_NR,
.label = "GPH2",
},
}, {
.base = S5PV210_GPH3_BASE,
.config = &gpio_cfg_noint,
.chip = {
static int s5p_cec_probe(struct platform_device *pdev)
{
struct s5p_platform_cec *pdata;
u8 *buffer;
int irq_num;
int ret;
/*
* CEC GPIO number is changed.
*/
#if 0
s3c_gpio_cfgpin(S5PV210_GPH1(4), S3C_GPIO_SFN(0x4));
s3c_gpio_setpull(S5PV210_GPH1(4), S3C_GPIO_PULL_NONE);
#endif
pdata = to_tvout_plat(&pdev->dev);
if (pdata->cfg_gpio)
pdata->cfg_gpio(pdev);
/* get ioremap addr */
s5p_cec_mem_probe(pdev);
if (misc_register(&cec_misc_device)) {
printk(KERN_WARNING " Couldn't register device 10, %d.\n",
CEC_MINOR);
return -EBUSY;
}
irq_num = platform_get_irq(pdev, 0);
if (irq_num < 0) {
printk(KERN_ERR "failed to get %s irq resource\n", "cec");
ret = -ENOENT;
return ret;
}
ret = request_irq(irq_num, s5p_cec_irq_handler, IRQF_DISABLED,
pdev->name, &pdev->id);
if (ret != 0) {
printk(KERN_ERR "failed to install %s irq (%d)\n", "cec", ret);
return ret;
}
init_waitqueue_head(&cec_rx_struct.waitq);
spin_lock_init(&cec_rx_struct.lock);
init_waitqueue_head(&cec_tx_struct.waitq);
buffer = kmalloc(CEC_TX_BUFF_SIZE, GFP_KERNEL);
if (!buffer) {
printk(KERN_ERR " kmalloc() failed!\n");
misc_deregister(&cec_misc_device);
return -EIO;
}
cec_rx_struct.buffer = buffer;
cec_rx_struct.size = 0;
TV_CLK_GET_WITH_ERR_CHECK(hdmi_cec_clk, pdev, "hdmicec");
return 0;
}
{ MAX8698_BUCK3, &mini210_buck3_data },
};
static struct max8698_platform_data mini210_max8698_pdata = {
.num_regulators = ARRAY_SIZE(mini210_regulators),
.regulators = mini210_regulators,
/* 1GHz default voltage */
.dvsarm1 = 0xa, /* 1.25v */
.dvsarm2 = 0x9, /* 1.20V */
.dvsarm3 = 0x6, /* 1.05V */
.dvsarm4 = 0x4, /* 0.95V */
.dvsint1 = 0x7, /* 1.10v */
.dvsint2 = 0x5, /* 1.00V */
.set1 = S5PV210_GPH1(6),
.set2 = S5PV210_GPH1(7),
.set3 = S5PV210_GPH0(4),
};
#endif
#if defined(CONFIG_S5PV210_SETUP_IDE)
static struct s3c_ide_platdata mini210_ide_pdata __initdata = {
.setup_gpio = s5pv210_ide_setup_gpio,
};
#endif
#ifdef CONFIG_KEYBOARD_GPIO
static struct gpio_keys_button gpio_buttons[] = {
{
.gpio = S5PV210_GPH2(0),
static int __init s5p_hpd_probe(struct platform_device *pdev)
{
if (misc_register(&hpd_misc_device)) {
printk(KERN_WARNING " Couldn't register device 10, %d.\n",
HPD_MINOR);
return -EBUSY;
}
init_waitqueue_head(&hpd_struct.waitq);
spin_lock_init(&hpd_struct.lock);
atomic_set(&hpd_struct.state, -1);
atomic_set(&hdmi_status, HDMI_OFF);
s3c_gpio_cfgpin(S5PV210_GPH1(5), S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(S5PV210_GPH1(5), S3C_GPIO_PULL_DOWN);
writel(readl(S5PV210_GPH1DRV)|0x3<<10, S5PV210_GPH1DRV);
// by pjlee : Interrupt Signal Change
#ifdef CONFIG_MACH_MANGO210_EVT0
if (!gpio_get_value(S5PV210_GPH1(5))) {
#else
if (gpio_get_value(S5PV210_GPH1(5))) {
#endif
atomic_set(&hpd_struct.state, HPD_HI);
last_hpd_state = HPD_HI;
} else {
atomic_set(&hpd_struct.state, HPD_LO);
last_hpd_state = HPD_LO;
}
set_irq_type(IRQ_EINT13, IRQ_TYPE_EDGE_BOTH);
if (request_irq(IRQ_EINT13, s5p_hpd_irq_handler, IRQF_DISABLED,
"hpd", s5p_hpd_irq_handler)) {
printk(KERN_ERR "failed to install %s irq\n", "hpd");
misc_deregister(&hpd_misc_device);
return -EIO;
}
s5p_hdmi_register_isr(s5p_hpd_irq_handler, (u8)HDMI_IRQ_HPD_PLUG);
s5p_hdmi_register_isr(s5p_hpd_irq_handler, (u8)HDMI_IRQ_HPD_UNPLUG);
return 0;
}
/*
* Remove
*/
static int s5p_hpd_remove(struct platform_device *pdev)
{
return 0;
}
#ifdef CONFIG_PM
/*
* Suspend
*/
int s5p_hpd_suspend(struct platform_device *dev, pm_message_t state)
{
return 0;
}
/*
* Resume
*/
int s5p_hpd_resume(struct platform_device *dev)
{
return 0;
}
#else
#define s5p_hpd_suspend NULL
#define s5p_hpd_resume NULL
#endif
static struct platform_driver s5p_hpd_driver = {
.probe = s5p_hpd_probe,
.remove = s5p_hpd_remove,
.suspend = s5p_hpd_suspend,
.resume = s5p_hpd_resume,
.driver = {
.name = "s5p-hpd",
.owner = THIS_MODULE,
},
};
static char banner[] __initdata =
"S5PC11X HPD Driver, (c) 2009 Samsung Electronics\n";
int __init s5p_hpd_init(void)
{
int ret;
printk(banner);
ret = platform_driver_register(&s5p_hpd_driver);
if (ret) {
printk(KERN_ERR "Platform Device Register Failed %d\n", ret);
return -1;
}
return 0;
}
{ MAX8698_BUCK2, &smdkv210_buck2_data },
{ MAX8698_BUCK3, &smdkv210_buck3_data },
};
static struct max8698_platform_data smdkv210_max8698_pdata = {
.num_regulators = ARRAY_SIZE(smdkv210_regulators),
.regulators = smdkv210_regulators,
/* 1GHz default voltage */
.dvsarm1 = 0xa, /* 1.25v */
.dvsarm2 = 0x9, /* 1.20V */
.dvsarm3 = 0x6, /* 1.05V */
.dvsarm4 = 0x4, /* 0.95V */
.dvsint1 = 0x7, /* 1.10v */
.dvsint2 = 0x5, /* 1.00V */
.set1 = S5PV210_GPH1(6),
.set2 = S5PV210_GPH1(7),
.set3 = S5PV210_GPH0(4),
};
#endif
static struct s3c_ide_platdata smdkv210_ide_pdata __initdata = {
.setup_gpio = s5pv210_ide_setup_gpio,
};
static uint32_t smdkv210_keymap[] __initdata = {
/* KEY(row, col, keycode) */
KEY(0, 3, KEY_1), KEY(0, 4, KEY_2), KEY(0, 5, KEY_3),
KEY(0, 6, KEY_4), KEY(0, 7, KEY_5),
KEY(1, 3, KEY_A), KEY(1, 4, KEY_B), KEY(1, 5, KEY_C),
KEY(1, 6, KEY_D), KEY(1, 7, KEY_E), KEY(7, 1, KEY_LEFTBRACE)
static int __init s5p_cec_probe(struct platform_device *pdev)
{
u8 *buffer;
int irq_num;
int ret = 0;
s3c_gpio_cfgpin(S5PV210_GPH1(4), S3C_GPIO_SFN(0x4));
s3c_gpio_setpull(S5PV210_GPH1(4), S3C_GPIO_PULL_NONE);
/* get ioremap addr */
ret = s5p_cec_probe_core(pdev);
if (ret != 0) {
pr_err("%s::s5p_cec_probe_core() fail\n", __func__);
goto err_s5p_cec_probe_core;
}
if (misc_register(&cec_misc_device)) {
pr_err("%s::Couldn't register device 10, %d.\n",
__func__, CEC_MINOR);
ret = -EBUSY;
goto err_misc_reg;
}
irq_num = platform_get_irq(pdev, 0);
if (irq_num < 0) {
pr_err("%s::failed to get %s irq resource\n",
__func__, "cec");
ret = -ENOENT;
goto err_req_fw;
}
ret = request_irq(irq_num, s5p_cec_irq_handler, IRQF_DISABLED,
pdev->name, &pdev->id);
if (ret != 0) {
pr_err("%s::failed to install %s irq (%d)\n",
__func__, "cec", ret);
goto err_req_fw;
}
init_waitqueue_head(&g_cec_rx_struct.waitq);
spin_lock_init(&g_cec_rx_struct.lock);
init_waitqueue_head(&g_cec_tx_struct.waitq);
buffer = kmalloc(CEC_TX_BUFF_SIZE, GFP_KERNEL);
if (!buffer) {
pr_err("%s::kmalloc(CEC_TX_BUFF_SIZE %d) failed!\n",
__func__, CEC_TX_BUFF_SIZE);
ret = -EIO;
goto err_kmalloc;
}
g_cec_rx_struct.buffer = buffer;
g_cec_rx_struct.size = 0;
return 0;
err_kmalloc:
free_irq(irq_num, NULL);
err_req_fw:
misc_deregister(&cec_misc_device);
err_misc_reg:
s5p_cec_release_core(pdev);
err_s5p_cec_probe_core:
return ret;
}