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