s3c_setup_keypad_cfg_gpio_sleep(int rows, int columns)
{
unsigned int gpio;
unsigned int end;
/* set KBR */
end = S5PV210_GPH3(rows);
for (gpio = S5PV210_GPH3(0); gpio < end; gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT);
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
}
/* set KBC */
/* KEYPAD SCAN/COLUMN */
columns -= 2 ; /* except scan[6~7] */
end = S5PV210_GPH2(columns);
for (gpio = S5PV210_GPH2(0); gpio < end; gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT);
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP);
}
s3c_gpio_slp_cfgpin(GPIO_KEYSCAN6, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_KEYSCAN6, S3C_GPIO_PULL_NONE);
s3c_gpio_slp_cfgpin(GPIO_KEYSCAN7, S3C_GPIO_SLP_OUT1);
s3c_gpio_slp_setpull_updown(GPIO_KEYSCAN7, S3C_GPIO_PULL_NONE);
}
static void __init aquila_pmic_init(void)
{
s3c_gpio_cfgpin(S5PV210_GPH0(7), S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(S5PV210_GPH0(7), S3C_GPIO_PULL_UP);
s3c_gpio_cfgpin(S5PV210_GPH2(6), S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(S5PV210_GPH2(6), S3C_GPIO_PULL_UP);
}
static void __init aquila_pmic_init(void)
{
/* AP_PMIC_IRQ: EINT7 */
s3c_gpio_cfgpin(S5PV210_GPH0(7), S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(S5PV210_GPH0(7), S3C_GPIO_PULL_UP);
/* nPower: EINT22 */
s3c_gpio_cfgpin(S5PV210_GPH2(6), S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(S5PV210_GPH2(6), S3C_GPIO_PULL_UP);
}
int char_release(struct inode * inode, struct file * fb)
{
printk("close device! \n");
//delete_timer_api();
gpio_free (S5PV210_GPH2(0));
gpio_free (S5PV210_GPH2(1));
free_irq(160,NULL);
free_irq(161,NULL);
return 0;
}
static void
s3c_keygpio_init(struct s3c_keypad * s3c_keypad)
{
KEYGPIO_INFO * info_tbl = (KEYGPIO_INFO *)&s3c_keypad->keygpio_info_tbl[0];
int i;
/* set gpio, irq of gpio keys */
info_tbl[KEYGPIO_VOLUME_UP].irq = IRQ_EINT(24);
info_tbl[KEYGPIO_VOLUME_UP].gpio = S5PV210_GPH3(0);
info_tbl[KEYGPIO_VOLUME_UP].gpio_data = (S5PV210_GPH3_BASE + 0x04);
// info_tbl[KEYGPIO_VOLUME_UP].gpio_data = S5PV210_GPH3DAT;
info_tbl[KEYGPIO_VOLUME_UP].gpio_data_mask = (1 << 0);
info_tbl[KEYGPIO_VOLUME_UP].keycode = 115;
info_tbl[KEYGPIO_POWER].irq = IRQ_EINT(22);
info_tbl[KEYGPIO_POWER].gpio = S5PV210_GPH2(6);
info_tbl[KEYGPIO_POWER].gpio_data = (S5PV210_GPH2_BASE + 0x04);
// info_tbl[KEYGPIO_POWER].gpio_data = S5PV210_GPH2DAT;
info_tbl[KEYGPIO_POWER].gpio_data_mask = (1 << 6);
info_tbl[KEYGPIO_POWER].keycode = 116;
for(i=0; i < KEYGPIO_MAX; i++) {
KEYGPIO_INFO * info = &info_tbl[i];
int gpio = info->gpio;
info->prev_key_status = info->gpio_data_mask;
s3c_gpio_cfgpin(gpio, S3C_GPIO_INPUT);
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP);
}
}
void samsung_keypad_cfg_gpio(unsigned int rows, unsigned int cols)
{
#if 0
/* Set all the necessary GPH3 pins to special-function 3: KP_ROW[x] */
s3c_gpio_cfgrange_nopull(S5PV210_GPH3(0), rows, S3C_GPIO_SFN(3));
/* Set all the necessary GPH2 pins to special-function 3: KP_COL[x] */
s3c_gpio_cfgrange_nopull(S5PV210_GPH2(0), cols, S3C_GPIO_SFN(3));
#else
unsigned int gpio;
unsigned int end;
s3c_gpio_cfgpin(S5PV210_GPJ2(7), S3C_GPIO_SFN(3));
s3c_gpio_setpull(S5PV210_GPJ2(7), S3C_GPIO_PULL_UP);
end = S5PV210_GPJ3(rows -1);
for (gpio = S5PV210_GPJ3(0); gpio < end; gpio++)
{
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(3));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP);
}
s3c_gpio_cfgpin(S5PV210_GPJ1(5), S3C_GPIO_SFN(3));
s3c_gpio_setpull(S5PV210_GPJ1(5), S3C_GPIO_PULL_NONE);
end = S5PV210_GPJ2(cols -1);
for (gpio = S5PV210_GPJ2(0); gpio < end; gpio++)
{
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(3));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
}
#endif
}
void samsung_keypad_cfg_gpio(unsigned int rows, unsigned int cols)
{
/* Set all the necessary GPH3 pins to special-function 3: KP_ROW[x] */
s3c_gpio_cfgrange_nopull(S5PV210_GPH3(0), rows, S3C_GPIO_SFN(3));
/* Set all the necessary GPH2 pins to special-function 3: KP_COL[x] */
s3c_gpio_cfgrange_nopull(S5PV210_GPH2(0), cols, S3C_GPIO_SFN(3));
}
int char_open(struct inode * inode, struct file * fp)
{
int rc, irq;
printk("device open \n");
//printk("dev is 0x%x\n", inode->i_rdev);
//printk("major is %d\n", MAJOR(inode->i_rdev));
//printk("minor is %d\n", MINOR(inode->i_rdev));
printk("S5PV210 IRQ:%d--%d--%d\n",S5PV210_GPH2(0),IRQ_EINT(16),gpio_to_irq(S5PV210_GPH2(0)));
rc = gpio_request (S5PV210_GPH2(0), "K1"); // kiem tra xem chan co free khong
if (rc) { // =1
printk (KERN_ALERT "Unable to request pin %d\n",S5PV210_GPH2(0));
return -1;
}
rc = gpio_request (S5PV210_GPH2(1), "K2");
if (rc) { // =0
printk (KERN_ALERT "Unable to request pin %d\n",S5PV210_GPH2(1));
return -1;
}
//led_no = MINOR(inode->i_rdev);
//printk("Reg:%x<----\n",*portj);
irq = gpio_to_irq(S5PV210_GPH2(0)); //IRQ_EINT(16) lay so ngat
printk (KERN_ALERT "IRQ K1= %d\n", irq); // in ra so ngat
rc = request_irq(irq, k1_handler, IRQF_TRIGGER_FALLING, "mybtnk1", NULL); // dang ky interrupt
if(rc)
{
printk("register irq %d error",irq);
return -1;
}
irq = gpio_to_irq(S5PV210_GPH2(1)); //IRQ_EINT(17)
// irq = IRG_EINT(17)
printk (KERN_ALERT "IRQ K2= %d\n", irq);
rc = request_irq(irq, k2_handler, IRQF_TRIGGER_FALLING, "mybtnk2", NULL);
if(rc)
{
printk("register irq %d error",irq);
return -1;
}
// my_timer.function, my_timer.data
//setup_timer( &my_timer, my_timer_callback, 0 ); // chong doi
//printk("start timer at %ld\n",jiffies);
//mod_timer( &my_timer, jiffies + msecs_to_jiffies(1000) );
init_waitqueue_head(&wq);
//printk("Reg:%x<----\n",*portj);
return 0;
}
static ssize_t keyshort_test(struct device *dev, struct device_attribute *attr, char *buf)
{
int count;
int mask=0;
u32 col=0,cval=0,rval=0;
if(!gpio_get_value(S5PV210_GPH2(6)))//Power Key
{
mask |= 0x1;
}
if(!gpio_get_value(S5PV210_GPH3(3)))//Volume Up
{
mask |= 0x10;
}
if(HWREV >= 0x2) //yhkim change to 0x2 for Verizon ATLAS.
{
if(!gpio_get_value(S5PV210_GPH3(1)) ) //volume down
{
mask |= 0x100;
}
}
else
{
//for Volume Down
col = 1;
cval = KEYCOL_DMASK & ~((1 << col) | (1 << col+ 8)); // clear that column number and
writel(cval, key_base+S3C_KEYIFCOL); // make that Normal output.
// others shuld be High-Z output.
udelay(KEYPAD_DELAY);
rval = ~(readl(key_base+S3C_KEYIFROW)) & ((1<<KEYPAD_ROWS)-1) ;
writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);
//
if((rval&0x02))
{
mask |=0x100;
}
}
if(/*!gpio_get_value(GPIO_KBR0) || !gpio_get_value(GPIO_KBR1) || !gpio_get_value(GPIO_KBR2) || */ mask)
{
count = sprintf(buf,"PRESS\n");
printk("keyshort_test: PRESS\n",mask);
}
else
{
count = sprintf(buf,"RELEASE\n");
printk("keyshort_test: RELEASE \n");
}
return count;
}
void samsung_keypad_cfg_gpio(unsigned int rows, unsigned int cols)
{
/* hcj: the rows may need pullup */
/* Set all the necessary GPH3 pins to special-function 3: KP_ROW[x] */
// s3c_gpio_cfgrange_nopull(S5PV210_GPH3(0), rows, S3C_GPIO_SFN(3));
s3c_gpio_cfgall_range(S5PV210_GPH3(0), rows, S3C_GPIO_SFN(3), S3C_GPIO_PULL_UP);
/* Set all the necessary GPH2 pins to special-function 3: KP_COL[x] */
s3c_gpio_cfgrange_nopull(S5PV210_GPH2(0), cols, S3C_GPIO_SFN(3));
}
static void s3c_keypad_port_sleep(int rows, int columns)
{
s3c_gpio_cfgpin(S5PV210_GPH3(1), S3C_GPIO_INPUT);
s3c_gpio_setpull(S5PV210_GPH3(1), S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(S5PV210_GPH3(2), S3C_GPIO_INPUT);
s3c_gpio_setpull(S5PV210_GPH3(2), S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(S5PV210_GPH3(3), S3C_GPIO_INPUT);
s3c_gpio_setpull(S5PV210_GPH3(3), S3C_GPIO_PULL_NONE);
s3c_gpio_cfgpin(S5PV210_GPH2(2), S3C_GPIO_INPUT);
s3c_gpio_setpull(S5PV210_GPH2(2), S3C_GPIO_PULL_UP);
s3c_gpio_cfgpin(S5PV210_GPH2(3), S3C_GPIO_INPUT);
s3c_gpio_setpull(S5PV210_GPH2(3), S3C_GPIO_PULL_UP);
}
void s3c_setup_keypad_cfg_gpio(int rows, int columns)
{
unsigned int gpio;
unsigned int end;
end = S5PV210_GPH3(rows);
/* Set all the necessary GPH2 pins to special-function 0 */
for (gpio = S5PV210_GPH3(0); gpio < end; gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(3));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_UP);
}
end = S5PV210_GPH2(columns);
/* Set all the necessary GPK pins to special-function 0 */
for (gpio = S5PV210_GPH2(0); gpio < end; gpio++) {
s3c_gpio_cfgpin(gpio, S3C_GPIO_SFN(3));
s3c_gpio_setpull(gpio, S3C_GPIO_PULL_NONE);
}
}
static int __init jupiter_rfkill_probe(struct platform_device *pdev)
{
int rc = 0;
int irq,ret;
//Initialize wake locks
wake_lock_init(&rfkill_wake_lock, WAKE_LOCK_SUSPEND, "board-rfkill");
#ifdef BT_SLEEP_ENABLER
wake_lock_init(&bt_wake_lock, WAKE_LOCK_SUSPEND, "bt-rfkill");
#endif
//BT Host Wake IRQ
irq = IRQ_BT_HOST_WAKE;
s3c_gpio_cfgpin(GPIO_BT_HOST_WAKE, S3C_GPIO_SFN(GPIO_BT_HOST_WAKE_AF));
s3c_gpio_setpull(S5PV210_GPH2(5), S3C_GPIO_PULL_DOWN);
set_irq_type(IRQ_EINT(21), IRQ_TYPE_EDGE_BOTH);
set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
ret = request_irq(irq, bt_host_wake_irq_handler, 0, "bt_host_wake_irq_handler", NULL);
if(ret < 0)
printk(KERN_ERR "[BT] Request_irq failed \n");
// enable_irq(IRQ_BT_HOST_WAKE);
//RFKILL init - default to bluetooth off
//rfkill_switch_all(RFKILL_TYPE_BLUETOOTH, RFKILL_USER_STATE_SOFT_BLOCKED);
bt_rfk = rfkill_alloc(bt_name, &pdev->dev, RFKILL_TYPE_BLUETOOTH, &bt_rfkill_ops, NULL);
if (!bt_rfk)
return -ENOMEM;
rfkill_init_sw_state(bt_rfk, 0);
printk(KERN_DEBUG "[BT] rfkill_register(bt_rfk) \n");
rc = rfkill_register(bt_rfk);
if (rc)
{
printk ("***********ERROR IN REGISTERING THE RFKILL***********\n");
rfkill_destroy(bt_rfk);
}
rfkill_set_sw_state(bt_rfk, 1);
bluetooth_set_power(NULL, RFKILL_USER_STATE_SOFT_BLOCKED);
return rc;
}
void my_timer_callback( unsigned long data )
{
int tmp, down;
printk( "my_timer_callback called (%ld).\n", jiffies );
tmp = gpio_get_value(S5PV210_GPH2(key_no));
down = !tmp;
//printk("key:%x-%x<----\n",key[key_no],down+0x30);
if(key[key_no]!=(down+0x30))
{
btn_pressed = 1;
wake_up_interruptible(&wq);
}
else {init_timer_api(40);} //////////////
}
static int s3c_keygpio_isr_setup(void *pdev)
{
int ret;
//PWR key
s3c_gpio_setpull(S5PV210_GPH2(6), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(22), IRQ_TYPE_EDGE_BOTH);
// stk.lim: Add IRQF_DISABLED to eliminate any possible race
// regarding key status
ret = request_irq(IRQ_EINT(22), s3c_keygpio_isr, IRQF_DISABLED
| IRQF_SAMPLE_RANDOM, "key gpio", (void *)pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (gpio)) !!!\n");
ret = -EIO;
}
ret = enable_irq_wake(IRQ_EINT(22));
if (ret) {
printk(KERN_ERR"%s : Failed to enable power key irq wake\n", __func__);
}
return ret;
}
#include <mach/map.h>
#include <mach/gpio.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>
#define DEVICE_NAME "buttons"
struct button_desc {
int gpio;
int number;
char *name;
struct timer_list timer;
};
static struct button_desc buttons[] = {
{ S5PV210_GPH2(0), 0, "KEY0" },
{ S5PV210_GPH2(1), 1, "KEY1" },
{ S5PV210_GPH2(2), 2, "KEY2" },
{ S5PV210_GPH2(3), 3, "KEY3" },
{ S5PV210_GPH3(0), 4, "KEY4" },
{ S5PV210_GPH3(1), 5, "KEY5" },
{ S5PV210_GPH3(2), 6, "KEY6" },
{ S5PV210_GPH3(3), 7, "KEY7" },
};
static volatile char key_values[] = {
'0', '0', '0', '0', '0', '0', '0', '0'
};
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
.btn_gpio = S5PV210_GPH0(3),
.btn_desc = "GPH0",
.btn_irq = IRQ_EINT3,
.btn_config = (0xf << 12),
.btn_active_low = 1,
.pd_gpio = S5PV210_GPH0(5),
.pd_desc = "GPH0",
.gpio = S5PV210_GPH0(4),
.desc = "GPH0",
.irq = IRQ_EINT4,
.config = (0xf << 16),
.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 platform_device s3c_device_nand = {
.name = "webee210-nand",
.id = -1,
.num_resources = ARRAY_SIZE(s3c_nand_resource),
.resource = s3c_nand_resource,
};
//////////////////////////////////
/***********************Add by Webee********************************/
static struct gpio_keys_button webee210_buttons[] = {
{
.gpio = S5PV210_GPH2(0), /* S1 */
.code = KEY_A,
.desc = "Button 1",
.active_low = 1,
},
{
.gpio = S5PV210_GPH2(1), /* S2 */
.code = KEY_B,
.desc = "Button 2",
.active_low = 1,
},
{
.gpio = S5PV210_GPH2(2), /* S3 */
.code = KEY_C,
.desc = "Button 3",
.active_low = 1,
struct pin_desc{
unsigned int pin;
unsigned int key_val;
};
/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;
/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04, 0x05 */
/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84, 0x85 */
static unsigned char key_val;
struct pin_desc pins_desc[5] = {
{S5PV210_GPH2(3), 0x01},
{S5PV210_GPH3(0), 0x02},
{S5PV210_GPH3(1), 0x03},
{S5PV210_GPH3(2), 0x04},
{S5PV210_GPH3(3), 0x05},
};
//static atomic_t canopen = ATOMIC_INIT(1); //定义原子变量并初始化为1
static DECLARE_MUTEX(button_lock); //定义互斥锁
/*
* 确定按键值
*/
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
static int s3c_keygpio_isr_setup(void *pdev)
{
int ret;
#ifdef CONFIG_S5PV210_GARNETT_DELTA
//volume up
s3c_gpio_setpull(S5PV210_GPH3(3), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(27), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(27), s3c_keygpio_vol_up_isr, IRQF_SAMPLE_RANDOM,
"key vol up", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol up)) !!!\n");
ret = -EIO;
return ret;
}
#else
if(HWREV >= 0x2) //yhkim change to 0x2 for Verizon ATLAS.
{
//volume down
s3c_gpio_setpull(S5PV210_GPH3(1), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(25), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(25), s3c_keygpio_vol_down_isr, IRQF_SAMPLE_RANDOM,
"key vol down", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol down)) !!!\n");
ret = -EIO;
return ret;
}
//volume up
s3c_gpio_setpull(S5PV210_GPH3(3), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(27), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(27), s3c_keygpio_vol_up_isr, IRQF_SAMPLE_RANDOM,
"key vol up", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol up)) !!!\n");
ret = -EIO;
return ret;
}
}
else
{
//volume up
s3c_gpio_setpull(S5PV210_GPH3(3), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(27), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(27), s3c_keygpio_vol_up_isr, IRQF_SAMPLE_RANDOM,
"key vol up", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol up)) !!!\n");
ret = -EIO;
return ret;
}
}
#if 0 //yhkim :: Verizon Atlas did not have OK key.
//ok key
s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(29), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(29), s3c_keygpio_ok_isr, IRQF_DISABLED
| IRQF_SAMPLE_RANDOM, "key ok", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
#endif
//ok key
#if 0
s3c_gpio_setpull(S5PC11X_GPH3(0), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(24), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(24), s3c_keygpio_ok_isr, IRQF_SAMPLE_RANDOM,
"key ok", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
#endif
#endif
//PWR key
s3c_gpio_setpull(S5PV210_GPH2(6), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(22), IRQ_TYPE_EDGE_BOTH);
// stk.lim: Add IRQF_DISABLED to eliminate any possible race
// regarding key status
ret = request_irq(IRQ_EINT(22), s3c_keygpio_isr, IRQF_DISABLED
| IRQF_SAMPLE_RANDOM, "key gpio", (void *)pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (gpio)) !!!\n");
ret = -EIO;
}
return ret;
}
static int s3c_keygpio_isr_setup(void *pdev)
{
int ret;
#if defined(CONFIG_BEHOLD3_VER_B0)
//volume up
s3c_gpio_setpull(S5PV210_GPH3(3), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(27), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(27), s3c_keygpio_vol_up_isr, IRQF_SAMPLE_RANDOM,
"key vol up", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol up)) !!!\n");
ret = -EIO;
return ret;
}
// [[junghyunseok edit for fuel_int interrupt control of fuel_gauge 20100504
#elif defined(CONFIG_T959_VER_B0) || defined(CONFIG_T959_VER_B5)
//ok key
s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(29), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(29), s3c_keygpio_ok_isr, IRQF_SAMPLE_RANDOM,
"key ok", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
#elif defined(CONFIG_S5PC110_SIDEKICK_BOARD)
//ok key
s3c_gpio_setpull(S5PV210_GPH3(7), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(31), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(31), s3c_keygpio_ok_isr, IRQF_SAMPLE_RANDOM, "key ok", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
//volume down
s3c_gpio_setpull(GPIO_VOL_DOWN, S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT14, IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT14, s3c_keygpio_vol_down_isr, IRQF_SAMPLE_RANDOM,
"key vol down(14)", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol down(14))) !!!\n");
ret = -EIO;
return ret;
}
//volume up
s3c_gpio_setpull(GPIO_VOL_UP, S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(16), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(16), s3c_keygpio_vol_up_isr, IRQF_SAMPLE_RANDOM,
"key vol up(16)", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol up(16))) !!!\n");
ret = -EIO;
return ret;
}
#elif defined(CONFIG_S5PC110_KEPLER_BOARD)
#elif defined(CONFIG_S5PC110_FLEMING_BOARD)
s3c_gpio_cfgpin(S5PV210_GPH3(5),S3C_GPIO_SFN(3));
s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(29), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(29), s3c_keygpio_isr_cube_home, IRQF_SAMPLE_RANDOM,
"Cube Home Key", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (gpio)) !!!\n");
ret = -EIO;
return ret;
}
#else
//volume down
s3c_gpio_setpull(S5PV210_GPH3(1), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(25), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(25), s3c_keygpio_vol_down_isr, IRQF_SAMPLE_RANDOM,
"key vol down", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol down)) !!!\n");
ret = -EIO;
return ret;
}
//volume up
s3c_gpio_setpull(S5PV210_GPH3(2), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(26), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(26), s3c_keygpio_vol_up26_isr, IRQF_SAMPLE_RANDOM,
"key vol up(26)", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol up(26))) !!!\n");
ret = -EIO;
return ret;
}
//ok key
s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(29), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(29), s3c_keygpio_ok_isr, IRQF_DISABLED
| IRQF_SAMPLE_RANDOM, "key ok", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
//ok key
#if 0
s3c_gpio_setpull(S5PC11X_GPH3(0), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(24), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(24), s3c_keygpio_ok_isr, IRQF_SAMPLE_RANDOM,
"key ok", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
#endif
#endif
//PWR key
s3c_gpio_setpull(S5PV210_GPH2(6), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(22), IRQ_TYPE_EDGE_BOTH);
// stk.lim: Add IRQF_DISABLED to eliminate any possible race
// regarding key status
ret = request_irq(IRQ_EINT(22), s3c_keygpio_isr, IRQF_DISABLED
| IRQF_SAMPLE_RANDOM, "key gpio", (void *)pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (gpio)) !!!\n");
ret = -EIO;
}
return ret;
}
static int s3c_keygpio_isr_setup(void *pdev)
{
int ret;
#if defined(CONFIG_BEHOLD3_VER_B0)
//volume up
s3c_gpio_setpull(S5PV210_GPH3(3), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(27), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(27), s3c_keygpio_vol_up_isr, IRQF_SAMPLE_RANDOM,
"key vol up", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol up)) !!!\n");
ret = -EIO;
return ret;
}
// [[junghyunseok edit for fuel_int interrupt control of fuel_gauge 20100504
#elif defined(CONFIG_T959_VER_B0) || defined(CONFIG_T959_VER_B5) || defined(CONFIG_HAWK_VER_B0)|| defined (CONFIG_S5PC110_VIBRANTPLUS_BOARD)
//ok key
#if defined(CONFIG_HAWK_VER_B1_REAL_ADDED_FEATURE) //NAGSM_Android_HQ_KERNEL_CLEE_20100908 : Setup Hawk Real Board Rev 0.1
s3c_gpio_setpull(S5PV210_GPH3(0), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(24), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(24), s3c_keygpio_ok_isr, IRQF_SAMPLE_RANDOM,
"key ok", (void *) pdev);
#else
s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(29), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(29), s3c_keygpio_ok_isr, IRQF_SAMPLE_RANDOM,
"key ok", (void *) pdev);
#endif
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
#elif defined(CONFIG_S5PC110_KEPLER_BOARD)
#elif defined(CONFIG_S5PC110_FLEMING_BOARD)
s3c_gpio_cfgpin(S5PV210_GPH3(5),S3C_GPIO_SFN(3));
s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(29), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(29), s3c_keygpio_isr_cube_home, IRQF_SAMPLE_RANDOM,
"Cube Home Key", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (gpio)) !!!\n");
ret = -EIO;
return ret;
}
#else
//volume down
s3c_gpio_setpull(S5PV210_GPH3(1), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(25), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(25), s3c_keygpio_vol_down_isr, IRQF_SAMPLE_RANDOM,
"key vol down", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol down)) !!!\n");
ret = -EIO;
return ret;
}
//volume up
s3c_gpio_setpull(S5PV210_GPH3(2), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(26), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(26), s3c_keygpio_vol_up26_isr, IRQF_SAMPLE_RANDOM,
"key vol up(26)", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol up(26))) !!!\n");
ret = -EIO;
return ret;
}
//ok key
s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(29), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(29), s3c_keygpio_ok_isr, IRQF_DISABLED
| IRQF_SAMPLE_RANDOM, "key ok", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
//ok key
#if 0
s3c_gpio_setpull(S5PC11X_GPH3(0), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(24), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(24), s3c_keygpio_ok_isr, IRQF_SAMPLE_RANDOM,
"key ok", (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
#endif
#endif
#if defined(CONFIG_HAWK_VER_B1_REAL_ADDED_FEATURE) //NAGSM_Android_HQ_KERNEL_CLEE_20100908 : Setup Hawk Real Board Rev 0.1
#else
#if defined (CONFIG_S5PC110_HAWK_BOARD) // NAGSM_Android_HQ_KERNEL_MINJEONGKO_20100806 for hwak temp key ++
//NAGSM_Android_SEL_Kernel_Aakash_20101006
s3c_gpio_setpull(GPIO_MENUKEY_INT, S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_MENUKEY_INT, IRQ_TYPE_EDGE_BOTH);
s3c_gpio_cfgpin(GPIO_MENUKEY_INT, S3C_GPIO_SFN(0xf));
s3c_gpio_setpull(GPIO_BACKKEY_INT, S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_BACKKEY_INT, IRQ_TYPE_EDGE_BOTH);
s3c_gpio_cfgpin(GPIO_BACKKEY_INT, S3C_GPIO_SFN(0xf));
//NAGSM_Android_SEL_Kernel_Aakash_20101006
#if defined (CONFIG_HAWK_VER_B0_HW_FIX) // NAGSM_Android_HQ_KERNEL_CLEE_20100830 search key for hak dosirak 0.1
s3c_gpio_setpull(GPIO_SEARCHKEY_INT, S3C_GPIO_PULL_UP);
set_irq_type(IRQ_SEARCHKEY_INT, IRQ_TYPE_EDGE_BOTH);
#endif
//NAGSM_Android_SEL_Kernel_Aakash_20101006
gpio_request(GPIO_MENUKEY_INT, "GPIO_MENUKEY_INT");
gpio_request(GPIO_BACKKEY_INT, "GPIO_BACKKEY_INT");
//NAGSM_Android_SEL_Kernel_Aakash_20101006
if (request_irq(IRQ_MENUKEY_INT, menukey_interrupt, IRQF_SAMPLE_RANDOM, "key menu", (void *) pdev)) {
printk("%s Can't allocate irq ..\n", __FUNCTION__);
return -EBUSY;
}
if (request_irq(IRQ_BACKKEY_INT, backkey_interrupt, IRQF_SAMPLE_RANDOM, "key back", (void *) pdev)) {
printk("%s Can't allocate irq ..\n", __FUNCTION__);
return -EBUSY;
}
#if defined (CONFIG_HAWK_VER_B0_HW_FIX) // NAGSM_Android_HQ_KERNEL_CLEE_20100830 search key for hak dosirak 0.1
if (request_irq(IRQ_SEARCHKEY_INT, searchkey_interrupt, IRQF_SAMPLE_RANDOM, "key search", (void *) pdev)) {
printk("%s Can't allocate irq ..\n", __FUNCTION__);
return -EBUSY;
}
#endif
#endif // NAGSM_Android_HQ_KERNEL_MINJEONGKO_20100806 for hwak temp key --
#endif
//PWR key
#if defined(CONFIG_HAWK_VER_B1_REAL_ADDED_FEATURE) //NAGSM_Android_HQ_KERNEL_CLEE_20100908 : Setup Hawk Real Board Rev 0.1
s3c_gpio_setpull(S5PV210_GPH3(7), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(31), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(31), s3c_keygpio_isr, IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
"key gpio", (void *) pdev);
#else
s3c_gpio_setpull(S5PV210_GPH2(6), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(22), IRQ_TYPE_EDGE_BOTH);
// stk.lim: Add IRQF_DISABLED to eliminate any possible race
// regarding key status
ret = request_irq(IRQ_EINT(22), s3c_keygpio_isr, IRQF_DISABLED
| IRQF_SAMPLE_RANDOM, "key gpio", (void *)pdev);
#endif
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (gpio)) !!!\n");
ret = -EIO;
}
return ret;
}
static int s3c_keygpio_isr_setup(void *pdev)
{
int ret;
//volume down
s3c_gpio_setpull(S5PV210_GPH3(1), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(25), IRQ_TYPE_EDGE_BOTH);
ret =
request_irq(IRQ_EINT(25), s3c_keygpio_vol_down_isr,
IRQF_SAMPLE_RANDOM, "key vol down", (void *)pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key vol down)) !!!\n");
ret = -EIO;
return ret;
}
//volume up
s3c_gpio_setpull(S5PV210_GPH3(2), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(26), IRQ_TYPE_EDGE_BOTH);
ret =
request_irq(IRQ_EINT(26), s3c_keygpio_vol_up26_isr,
IRQF_SAMPLE_RANDOM, "key vol up(26)", (void *)pdev);
if (ret) {
printk
("request_irq failed (IRQ_KEYPAD (key vol up(26))) !!!\n");
ret = -EIO;
return ret;
}
//ok key
s3c_gpio_setpull(S5PV210_GPH3(5), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(29), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(29), s3c_keygpio_ok_isr, IRQF_DISABLED
| IRQF_SAMPLE_RANDOM, "key ok", (void *)pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
//ok key
#if 0
s3c_gpio_setpull(S5PC11X_GPH3(0), S3C_GPIO_PULL_UP);
set_irq_type(IRQ_EINT(24), IRQ_TYPE_EDGE_BOTH);
ret = request_irq(IRQ_EINT(24), s3c_keygpio_ok_isr, IRQF_SAMPLE_RANDOM,
"key ok", (void *)pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (key ok)) !!!\n");
ret = -EIO;
return ret;
}
#endif
//PWR key
s3c_gpio_setpull(S5PV210_GPH2(6), S3C_GPIO_PULL_NONE);
set_irq_type(IRQ_EINT(22), IRQ_TYPE_EDGE_BOTH);
// stk.lim: Add IRQF_DISABLED to eliminate any possible race
// regarding key status
ret = request_irq(IRQ_EINT(22), s3c_keygpio_isr, IRQF_DISABLED
| IRQF_SAMPLE_RANDOM, "key gpio", (void *)pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD (gpio)) !!!\n");
ret = -EIO;
}
return ret;
}
.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 = {
.base = S5PV210_GPH3(0),
.ngpio = S5PV210_GPIO_H3_NR,
.label = "GPH3",
},
}, {
.base = S5PV210_GPI_BASE,
.config = &gpio_cfg,
.chip = {
.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),
.code = 158,
.desc = "BACK",
.active_low = 1,
.wakeup = 0,
}, {
.gpio = S5PV210_GPH2(1),
.code = 102,
.desc = "HOME",
.active_low = 1,
.wakeup = 1,
}, {
.gpio = S5PV210_GPH2(2),
.code = 139,
.desc = "MENU",
.active_low = 1,
.initdata = &gpio_reg_gpa07,
},
[1] = { /*"VDD_CAM",*/
.gpio = S5PV210_GPB(3),
.name = "LDO_GPB(3)",
.type = GPIO_REGULATOR_VOLTAGE,
.initdata = &gpio_reg_gpb3,
},
[2] = { /*"VDD_5V",*/
.gpio = S5PV210_GPG1(6),
.name = "LDO_GPG1(6)",
.type = GPIO_REGULATOR_VOLTAGE,
.initdata = &gpio_reg_gpg16,
},
[3] = { /*"VDD_BT/VDD_WLAN",*/
.gpio = S5PV210_GPH2(6),
.pull = GPIO_PULL_DOWN,
.name = "LDO_GPH2(6)",
.type = GPIO_REGULATOR_VOLTAGE,
.initdata = &gpio_reg_gph26,
},
};
struct gpio_regulator_platform_data v210_gpio_regs_platform_data = {
.num_regulators = ARRAY_SIZE(v210_gpio_regulators),
.regulators = v210_gpio_regulators,
};
#endif
static ssize_t keyshort_test(struct device *dev, struct device_attribute *attr, char *buf)
{
struct s3c_keypad * s3c_keypad = dev_get_drvdata(dev);
KEYGPIO_INFO * info_tbl = (KEYGPIO_INFO *)&s3c_keypad->keygpio_info_tbl[0];
int count;
int mask=0;
u32 col=0;//,cval=0,rval=0;
int i;
int rval;
u32 press_mask;
/* check gpio keys */
for(i=0; i < KEYGPIO_MAX; i++) {
if( !gpio_get_value(info_tbl[i].gpio) )
mask |= (1 << i);
}
#ifndef CONFIG_MACH_CHIEF
/* check key scan */
keypad_scan();
for(col=0; col < KEYPAD_COLUMNS; col++) {
press_mask = keymask[col];
printk("[%d] press_mask (0x%x) \n", col, press_mask);
i = col * KEYPAD_ROWS;
while (press_mask) {
if (press_mask & 1) {
mask |= (1 << (i + KEYGPIO_MAX));
}
press_mask >>= 1;
i++;
}
}
#else
rval = ~readl(key_base+S3C_KEYIFROW) & 0x01/*0x007F*/ ; /* SENSE[0-6] ---> SENSE[0] for chief*/
writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL) ;
if (rval)
{
mask |= 0x100 ;
}
#endif
#ifdef CONFIG_MACH_STEALTHV
if (gpio_get_value(S5PV210_GPH2(6)) == 0) /* power key */
mask |= 1;
if (gpio_get_value(S5PV210_GPH3(0)) == 0) /* volume up key */
mask |= 1;
#endif
if(mask)
{
count = sprintf(buf,"PRESS\n");
printk("keyshort_test: PRESS 0x%x\n", mask);
}
else
{
count = sprintf(buf,"RELEASE\n");
printk("keyshort_test: RELEASE 0x%x\n", mask);
}
return count;
}
