static int s3c_keypad_suspend(struct platform_device *dev, pm_message_t state)
{
#if defined(CONFIG_MACH_CHIEF) && !defined(CONFIG_TIKAL_MPCS)
struct s3c_keypad *s3c_keypad;
#endif
keyifcon = readl(key_base+S3C_KEYIFCON);
keyiffc = readl(key_base+S3C_KEYIFFC);
#if defined(CONFIG_TIKAL_MPCS)
enable_irq_wake(IRQ_KEYPAD);
keyled_timer_stop(); /* keypad_led */
#elif defined(CONFIG_MACH_STEALTHV)
if((during_call==1)&&(volume_key_wakeup==0)){
enable_irq_wake(IRQ_KEYPAD);
volume_key_wakeup=1;
}
else if((during_call==0)&&(volume_key_wakeup==1)){
disable_irq_wake(IRQ_KEYPAD);
volume_key_wakeup=0;
}
#else
s3c_pm_do_save(s3c_keypad_save, ARRAY_SIZE(s3c_keypad_save));
//writel(~(0xfffffff), KEYPAD_ROW_GPIOCON);
//writel(~(0xfffffff), KEYPAD_COL_GPIOCON);
disable_irq(IRQ_KEYPAD);
clk_disable(keypad_clock);
#if defined(CONFIG_MACH_CHIEF) && !defined(CONFIG_TIKAL_MPCS)
if((during_call == 1) && (volume_key_wakeup == 0)){
s3c_keypad= platform_get_drvdata(dev);
if(!s3c_keypad){
printk(KERN_INFO "failed to get drv data \n ");
return ;
}
volume_key_wakeup = 1;
s3c_keygpio_keysense_isr_setup((void * )s3c_keypad);
}
else if((during_call == 0) && (volume_key_wakeup == 1)){
disable_irq_wake(gpio_to_irq(S5PV210_GPH3(0)));
volume_key_wakeup = 0;
printk(KERN_INFO "%s:DISABLE IRQ \n ", __func__);
/* Set GPIO Port for keypad mode and pull-up disable*/
s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS);
}
else{
//set gpio during normal sleep
s3c_setup_keypad_cfg_gpio_sleep(KEYPAD_ROWS, KEYPAD_COLUMNS);
}
#endif //#if defined(CONFIG_MACH_CHIEF) && !defined(CONFIG_TIKAL_MPCS)
in_sleep = 1;
#endif
return 0;
}
static int s3c_keypad_resume(struct platform_device *dev)
{
//struct s3c_keypad *s3c_keypad = (struct s3c_keypad *) platform_get_drvdata(dev);
//struct input_dev *iDev = s3c_keypad->dev;
//unsigned int key_temp_data=0;
#if defined(CONFIG_MACH_CHIEF) && !defined(CONFIG_TIKAL_MPCS)
if(volume_key_wakeup == 1){
disable_irq_wake(gpio_to_irq(S5PV210_GPH3(0)));
volume_key_wakeup=0;
printk(KERN_INFO "%s:DISBALE IRQ \n ", __func__);
/* Set GPIO Port for keypad mode and pull-up disable*/
s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS);
}
#endif //#if defined(CONFIG_MACH_CHIEF) && !defined(CONFIG_TIKAL_MPCS)
#if defined(CONFIG_TIKAL_MPCS)
disable_irq_wake(IRQ_KEYPAD);
#else
printk(KERN_DEBUG "++++ %s\n", __FUNCTION__ );
clk_enable(keypad_clock);
#endif
writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON);
writel(keyiffc, key_base+S3C_KEYIFFC);
writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);
#if 0
key_temp_data = readl(key_base+S3C_KEYIFROW) & 0x01;
if (!key_temp_data){
input_report_key(iDev, 50, 1);
printk("key data is %d \n", key_temp_data);
input_report_key(iDev, 50, 0);
}
else {
/*send some event to android to start the full resume*/
input_report_key(iDev, KEYCODE_UNKNOWN, 1);//ENDCALL up event
udelay(5);
input_report_key(iDev, KEYCODE_UNKNOWN, 0);//ENDCALL down event
}
//printk("H3C %x H2C %x \n",readl(S5PC11X_GPH3CON),readl(S5PC11X_GPH2CON));
#endif
#if !defined(CONFIG_MACH_STEALTHV) && !defined(CONFIG_TIKAL_MPCS)
s3c_pm_do_restore(s3c_keypad_save, ARRAY_SIZE(s3c_keypad_save));
enable_irq(IRQ_KEYPAD);
printk(KERN_DEBUG "---- %s\n", __FUNCTION__ );
#endif
return 0;
}
static int s3c_keypad_resume(struct platform_device *dev)
{
printk("\n++++ %s ++++", __FUNCTION__ );
if(volume_key_wakeup==1){
disable_irq_wake(IRQ_KEYPAD);
printk(KERN_INFO "%s:DISBALE IRQ \n ", __func__);
volume_key_wakeup=0;
}
else{ /*Normal wake up configuration*/
s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS);
}
clk_enable(keypad_clock);
writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON);
writel(keyiffc, key_base+S3C_KEYIFFC);
writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);
return 0;
}
static int __init s3c_keypad_probe(struct platform_device *pdev)
{
struct resource *res, *keypad_mem, *keypad_irq;
struct input_dev *input_dev;
struct s3c_keypad *s3c_keypad;
int ret, size;
int key, code;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev, "no memory resource specified\n");
return -ENOENT;
}
size = (res->end - res->start) + 1;
keypad_mem = request_mem_region(res->start, size, pdev->name);
if (keypad_mem == NULL) {
dev_err(&pdev->dev, "failed to get memory region\n");
ret = -ENOENT;
goto err_req;
}
key_base = ioremap(res->start, size);
if (key_base == NULL) {
printk(KERN_ERR "Failed to remap register block\n");
ret = -ENOMEM;
goto err_map;
}
keypad_clock = clk_get(&pdev->dev, "keypad");
if (IS_ERR(keypad_clock)) {
dev_err(&pdev->dev, "failed to find keypad clock source\n");
ret = PTR_ERR(keypad_clock);
goto err_clk;
}
clk_enable(keypad_clock);
s3c_keypad = kzalloc(sizeof(struct s3c_keypad), GFP_KERNEL);
input_dev = input_allocate_device();
if (!s3c_keypad || !input_dev) {
ret = -ENOMEM;
goto err_alloc;
}
platform_set_drvdata(pdev, s3c_keypad);
s3c_keypad->dev = input_dev;
writel(KEYIFCON_INIT, key_base + S3C_KEYIFCON);
writel(KEYIFFC_DIV, key_base + S3C_KEYIFFC);
/* Set GPIO Port for keypad mode and pull-up disable */
s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS);
writel(KEYIFCOL_CLEAR, key_base + S3C_KEYIFCOL);
/* create and register the input driver */
set_bit(EV_KEY, input_dev->evbit);
/*Commenting the generation of repeat events */
//set_bit(EV_REP, input_dev->evbit);
s3c_keypad->nr_rows = KEYPAD_ROWS;
s3c_keypad->no_cols = KEYPAD_COLUMNS;
s3c_keypad->total_keys = MAX_KEYPAD_NR;
for (key = 0; key < s3c_keypad->total_keys; key++) {
code = s3c_keypad->keycodes[key] = keypad_keycode[key];
if (code <= 0)
continue;
set_bit(code & KEY_MAX, input_dev->keybit);
}
printk("%s, keypad row number is %d, column is %d",__FUNCTION__, s3c_keypad->nr_rows, s3c_keypad->no_cols);
set_bit(26 & KEY_MAX, input_dev->keybit);
input_dev->name = DEVICE_NAME;
input_dev->phys = "s3c-keypad/input0";
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0001;
input_dev->keycode = keypad_keycode;
keypad_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
ret = input_register_device(input_dev);
if (ret) {
printk("Unable to register s3c-keypad input device!!!\n");
goto out;
}
/* Scan timer init */
init_timer(&keypad_timer);
keypad_timer.function = keypad_timer_handler;
keypad_timer.data = (unsigned long)s3c_keypad;
/* For IRQ_KEYPAD */
if (keypad_irq == NULL) {
dev_err(&pdev->dev, "no irq resource specified\n");
ret = -ENOENT;
goto err_irq;
}
ret = request_irq(IRQ_KEYPAD, s3c_keypad_isr, IRQF_SAMPLE_RANDOM, //PREVIOUS OLD ONE
DEVICE_NAME, (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD) !!!\n");
ret = -EIO;
goto err_irq;
}
s3c_keygpio_isr_setup((void *)s3c_keypad);
printk(DEVICE_NAME " Initialized\n");
if (device_create_file(&pdev->dev, &dev_attr_key_pressed) < 0) {
printk("%s s3c_keypad_probe\n", __FUNCTION__);
pr_err("Failed to create device file(%s)!\n",
dev_attr_key_pressed.attr.name);
}
return 0;
out:
free_irq(keypad_irq->start, input_dev);
free_irq(keypad_irq->end, input_dev);
err_irq:
input_free_device(input_dev);
kfree(s3c_keypad);
err_alloc:
clk_disable(keypad_clock);
clk_put(keypad_clock);
err_clk:
iounmap(key_base);
err_map:
release_resource(keypad_mem);
kfree(keypad_mem);
err_req:
return ret;
}
static int __init s3c_keypad_probe(struct platform_device *pdev)
{
struct resource *res, *keypad_mem, *keypad_irq;
struct input_dev *input_dev;
struct s3c_keypad *s3c_keypad;
int ret, size;
int key, code;
struct class *key_class;
struct device *keypress;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev,"no memory resource specified\n");
return -ENOENT;
}
size = (res->end - res->start) + 1;
keypad_mem = request_mem_region(res->start, size, pdev->name);
if (keypad_mem == NULL) {
dev_err(&pdev->dev, "failed to get memory region\n");
ret = -ENOENT;
goto err_req;
}
key_base = ioremap(res->start, size);
if (key_base == NULL) {
printk(KERN_ERR "Failed to remap register block\n");
ret = -ENOMEM;
goto err_map;
}
keypad_clock = clk_get(&pdev->dev, "keypad");
if (IS_ERR(keypad_clock)) {
dev_err(&pdev->dev, "failed to find keypad clock source\n");
ret = PTR_ERR(keypad_clock);
goto err_clk;
}
clk_enable(keypad_clock);
s3c_keypad = kzalloc(sizeof(struct s3c_keypad), GFP_KERNEL);
input_dev = input_allocate_device();
g_dev = input_dev;
if (!s3c_keypad || !input_dev) {
ret = -ENOMEM;
goto err_alloc;
}
platform_set_drvdata(pdev, s3c_keypad);
s3c_keypad->dev = input_dev;
/* Set GPIO Port for keypad mode and pull-up disable*/
s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS);
writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON);
writel(KEYIFFC_DIV, key_base+S3C_KEYIFFC);
writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);
#if defined(CONFIG_MACH_CHIEF) && !defined(CONFIG_TIKAL_MPCS)
/* GPIO_CONTROL */
gpio_set_value(GPIO_KEYSCAN6, GPIO_LEVEL_LOW) ;
gpio_set_value(GPIO_KEYSCAN7, GPIO_LEVEL_LOW) ;
#endif
/* create and register the input driver */
set_bit(EV_KEY, input_dev->evbit);
/*Commenting the generation of repeat events*/
//set_bit(EV_REP, input_dev->evbit);
s3c_keypad->nr_rows = KEYPAD_ROWS;
s3c_keypad->no_cols = KEYPAD_COLUMNS;
s3c_keypad->total_keys = MAX_KEYPAD_NR;
for(key = 0; key < s3c_keypad->total_keys; key++){
code = s3c_keypad->keycodes[key] = keypad_keycode[key];
if(code<=0)
continue;
set_bit(code & KEY_MAX, input_dev->keybit);
}
//printk("%s, keypad row number is %d, column is %d",__FUNCTION__, s3c_keypad->nr_rows, s3c_keypad->no_cols);
#if defined(CONFIG_MACH_CHIEF) && !defined(CONFIG_TIKAL_MPCS)
input_set_capability(input_dev, EV_SW, SW_LID); // TODO:FORTE
#endif
input_dev->name = DEVICE_NAME;
input_dev->phys = "s3c-keypad/input0";
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0001;
input_dev->keycode = keypad_keycode;
ret = input_register_device(input_dev);
if (ret) {
printk("Unable to register s3c-keypad input device!!!\n");
goto err_regi;
}
/* keypad_led timer init */
#if defined(CONFIG_MACH_CHIEF) || defined(CONFIG_TIKAL_MPCS)
init_timer(&keyled_timer);
keyled_timer.function = keyled_timer_handler;
keyled_timer.data = (unsigned long)s3c_keypad;
#endif
#if defined(CONFIG_MACH_CHIEF) && !defined(CONFIG_TIKAL_MPCS)
//s3c_keygpio_isr_setup((void *)s3c_keypad);
#endif
/* For IRQ_KEYPAD */
keypad_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (keypad_irq == NULL) {
dev_err(&pdev->dev, "no irq resource specified\n");
ret = -ENOENT;
goto err_irq;
}
ret = request_irq(keypad_irq->start, s3c_keypad_isr, IRQF_SAMPLE_RANDOM,
DEVICE_NAME, (void *) s3c_keypad);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD) !!!\n");
ret = -EIO;
goto err_irq;
}
#if 0 /* gpio key use gpio-event.c */
s3c_keygpio_init((void *)s3c_keypad);
s3c_keygpio_isr_register((void *)s3c_keypad);
#endif
/* for 1-5 applicaion
/sys/devices/virtual/key/key/key
*/
key_class = class_create(THIS_MODULE,"key");
if(IS_ERR(key_class)){
printk("failed to keyclass\n");
goto out;
}
keypress = device_create(key_class, NULL, 0 , s3c_keypad, "key");
if(IS_ERR(keypress))
printk("failed to create a keypress device\n");
else{
if(device_create_file(keypress, &dev_attr_key)<0)
printk("failed to create device file key\n");
}
#if defined(CONFIG_MACH_CHIEF) && !defined(CONFIG_TIKAL_MPCS)
if (device_create_file(keypress, &dev_attr_key_pressed) < 0)
{
printk("fail to create device file key_pressed\n");
}
#endif
if (device_create_file(keypress, &dev_attr_brightness) < 0) {
printk("fail to create device file brightness\n");
}
if (device_create_file(keypress, &dev_attr_keywakeup) < 0) {
printk("fail to create device file keywakeup\n");
}
printk( DEVICE_NAME " Initialized\n");
return 0;
out:
free_irq(keypad_irq->start, input_dev);
err_irq:
err_regi:
input_free_device(input_dev);
kfree(s3c_keypad);
err_alloc:
clk_disable(keypad_clock);
clk_put(keypad_clock);
err_clk:
iounmap(key_base);
err_map:
release_resource(keypad_mem);
kfree(keypad_mem);
err_req:
return ret;
}
static int __init s3c_keypad_probe(struct platform_device *pdev)
{
struct resource *res, *keypad_mem, *keypad_irq;
struct input_dev *input_dev;
struct s3c_keypad *s3c_keypad;
int ret, size;
int key, code;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev, "no memory resource specified\n");
return -ENOENT;
}
size = (res->end - res->start) + 1;
keypad_mem = request_mem_region(res->start, size, pdev->name);
if (keypad_mem == NULL) {
dev_err(&pdev->dev, "failed to get memory region\n");
ret = -ENOENT;
goto err_req;
}
key_base = ioremap(res->start, size);
if (key_base == NULL) {
pr_err("Failed to remap register block\n");
ret = -ENOMEM;
goto err_map;
}
keypad_clock = clk_get(&pdev->dev, "keypad");
if (IS_ERR(keypad_clock)) {
dev_err(&pdev->dev, "failed to find keypad clock source\n");
ret = PTR_ERR(keypad_clock);
goto err_clk;
}
clk_enable(keypad_clock);
s3c_keypad = kzalloc(sizeof(struct s3c_keypad), GFP_KERNEL);
input_dev = input_allocate_device();
if (!s3c_keypad || !input_dev) {
ret = -ENOMEM;
goto err_alloc;
}
platform_set_drvdata(pdev, s3c_keypad);
s3c_keypad->dev = input_dev;
writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON);
writel(KEYIFFC_DIV, key_base+S3C_KEYIFFC);
/* Set GPIO Port for keypad mode and pull-up disable*/
#if defined(CONFIG_KEYPAD_S3C_MSM)
s3c_setup_keypad_cfg_gpio();
#else
s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS);
#endif
writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);
/* create and register the input driver */
set_bit(EV_KEY, input_dev->evbit);
s3c_keypad->nr_rows = KEYPAD_ROWS;
s3c_keypad->no_cols = KEYPAD_COLUMNS;
s3c_keypad->total_keys = MAX_KEYPAD_NR;
for (key = 0; key < s3c_keypad->total_keys; key++) {
code = s3c_keypad->keycodes[key] = keypad_keycode[key];
if (code <= 0)
continue;
set_bit(code & KEY_MAX, input_dev->keybit);
}
input_dev->name = DEVICE_NAME;
input_dev->phys = "s3c-keypad/input0";
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0001;
input_dev->keycode = keypad_keycode;
/* Scan timer init */
init_timer(&keypad_timer);
keypad_timer.function = keypad_timer_handler;
keypad_timer.data = (unsigned long)s3c_keypad;
/* For IRQ_KEYPAD */
keypad_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (keypad_irq == NULL) {
dev_err(&pdev->dev, "no irq resource specified\n");
ret = -ENOENT;
goto err_irq;
}
ret = request_irq(keypad_irq->start, s3c_keypad_isr, 0,
DEVICE_NAME, (void *) pdev);
if (ret) {
pr_err("request_irq failed (IRQ_KEYPAD)\n");
ret = -EIO;
goto err_irq;
}
ret = input_register_device(input_dev);
if (ret) {
pr_err("Unable to register s3c-keypad input device!!!\n");
goto out;
}
keypad_timer.expires = jiffies + (HZ/10);
if (is_timer_on == false) {
add_timer(&keypad_timer);
is_timer_on = true;
} else {
mod_timer(&keypad_timer, keypad_timer.expires);
}
pr_info(DEVICE_NAME " Initialized\n");
return 0;
out:
free_irq(keypad_irq->start, input_dev);
free_irq(keypad_irq->end, input_dev);
err_irq:
input_free_device(input_dev);
kfree(s3c_keypad);
err_alloc:
clk_disable(keypad_clock);
clk_put(keypad_clock);
err_clk:
iounmap(key_base);
err_map:
release_resource(keypad_mem);
kfree(keypad_mem);
err_req:
return ret;
}
static int __init s3c_keypad_probe(struct platform_device *pdev)
{
struct resource *res, *keypad_mem, *keypad_irq = NULL;
struct input_dev *input_dev;
struct s3c_keypad *s3c_keypad;
int ret, size, key;
struct s3c_keypad_extra *extra = NULL;
struct s3c_keypad_slide *slide = NULL;
struct s3c_keypad_special_key *special_key;
struct s3c_keypad_gpio_key *gpio_key;
int i;
char * input_dev_name;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev,"no memory resource specified\n");
return -ENOENT;
}
size = (res->end - res->start) + 1;
keypad_mem = request_mem_region(res->start, size, pdev->name);
if (keypad_mem == NULL) {
dev_err(&pdev->dev, "failed to get memory region\n");
ret = -ENOENT;
goto err_req;
}
key_base = ioremap(res->start, size);
if (key_base == NULL) {
printk(KERN_ERR "Failed to remap register block\n");
ret = -ENOMEM;
goto err_map;
}
keypad_clock = clk_get(&pdev->dev, "keypad");
if (IS_ERR(keypad_clock)) {
dev_err(&pdev->dev, "failed to find keypad clock source\n");
ret = PTR_ERR(keypad_clock);
goto err_clk;
}
clk_enable(keypad_clock);
s3c_keypad = kzalloc(sizeof(struct s3c_keypad), GFP_KERNEL);
input_dev = input_allocate_device();
input_dev_name = (char *)kmalloc(sizeof("s3c-keypad-revxxxx"), GFP_KERNEL);
if (!s3c_keypad || !input_dev || !input_dev_name) {
ret = -ENOMEM;
goto out;
}
platform_set_drvdata(pdev, s3c_keypad);
DPRINTK(": system_rev 0x%04x\n", system_rev);
for (i=0; i<sizeof(s3c_keypad_extra)/sizeof(struct s3c_keypad_extra); i++)
{
// if (s3c_keypad_extra[i].board_num == g_board_num) {
if (s3c_keypad_extra[i].board_num == system_rev) {
extra = &s3c_keypad_extra[i];
sprintf(input_dev_name, "%s%s%04x", DEVICE_NAME, "-rev", system_rev);
DPRINTK(": board rev 0x%04x is detected!\n", s3c_keypad_extra[i].board_num);
break;
}
}
if(!extra) {
extra = &s3c_keypad_extra[0];
sprintf(input_dev_name, "%s%s", DEVICE_NAME, "-rev0000"); //default revison
DPRINTK(": failed to detect board rev. set default rev00\n");
}
DPRINTK(": input device name: %s.\n", input_dev_name);
s3c_keypad->dev = input_dev;
fake_slide_dev = input_dev;
s3c_keypad->extra = extra;
slide = extra->slide;
special_key = extra->special_key;
gpio_key = extra->gpio_key;
writel(KEYIFCON_INIT, key_base+S3C_KEYIFCON);
writel(KEYIFFC_DIV, key_base+S3C_KEYIFFC);
/* Set GPIO Port for keypad mode and pull-up disable*/
s3c_setup_keypad_cfg_gpio(KEYPAD_ROWS, KEYPAD_COLUMNS);
writel(KEYIFCOL_CLEAR, key_base+S3C_KEYIFCOL);
for(key = 0; key < 64; key++){
input_set_capability(input_dev, EV_KEY, key+1);
}
for (i=0; i<extra->special_key_num; i++ ){
input_set_capability(input_dev, EV_KEY, (special_key+i)->keycode);
}
for (i=0; i<extra->gpio_key_num; i++ ){
input_set_capability(input_dev, EV_KEY, (gpio_key+i)->keycode);
}
if (extra->slide != NULL)
input_set_capability(input_dev, EV_SW, SW_LID);
input_dev->name = input_dev_name;
input_dev->phys = "s3c-keypad/input0";
input_dev->id.bustype = BUS_HOST;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0001;
/* Scan timer init */
init_timer(&keypad_timer);
keypad_timer.function = keypad_timer_handler;
keypad_timer.data = (unsigned long)s3c_keypad;
init_timer(&gpiokey_timer);
gpiokey_timer.function = gpiokey_timer_handler;
gpiokey_timer.data = (unsigned long)s3c_keypad;
/* For IRQ_KEYPAD */
keypad_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (keypad_irq == NULL) {
dev_err(&pdev->dev, "no irq resource specified\n");
ret = -ENOENT;
goto err_clk;
}
if (slide != NULL)
{
s3c_gpio_cfgpin(slide->gpio, S3C_GPIO_SFN(slide->gpio_af));
s3c_gpio_setpull(slide->gpio, S3C_GPIO_PULL_NONE);
set_irq_type(slide->eint, IRQ_TYPE_EDGE_BOTH);
ret = request_irq(slide->eint, slide_int_handler, IRQF_DISABLED,
"s3c_keypad gpio key", (void *)s3c_keypad);
if (ret) {
printk(KERN_ERR "request_irq(%d) failed (IRQ for SLIDE) !!!\n", slide->eint);
ret = -EIO;
goto err_irq;
}
}
for (i=0; i<extra->gpio_key_num; i++, gpio_key+=1)
{
s3c_gpio_cfgpin(gpio_key->gpio, S3C_GPIO_SFN(gpio_key->gpio_af));
s3c_gpio_setpull(gpio_key->gpio, S3C_GPIO_PULL_NONE);
set_irq_type(gpio_key->eint, IRQ_TYPE_EDGE_BOTH);
ret = request_irq(gpio_key->eint, gpio_int_handler, IRQF_DISABLED,
"s3c_keypad gpio key", (void *)s3c_keypad);
if (ret) {
printk(KERN_ERR "request_irq(%d) failed (IRQ for GPIO KEY) !!!\n", gpio_key->eint);
ret = -EIO;
goto err_irq;
}
}
ret = request_irq(keypad_irq->start, s3c_keypad_isr, IRQF_SAMPLE_RANDOM,
DEVICE_NAME, (void *) pdev);
if (ret) {
printk("request_irq failed (IRQ_KEYPAD) !!!\n");
ret = -EIO;
goto err_irq;
}
ret = input_register_device(input_dev);
if (ret) {
printk("Unable to register s3c-keypad input device!!!\n");
goto out;
}
keypad_timer.expires = jiffies + (HZ/10);
if (is_timer_on == FALSE) {
add_timer(&keypad_timer);
is_timer_on = TRUE;
} else {
mod_timer(&keypad_timer,keypad_timer.expires);
}
printk( DEVICE_NAME " Initialized\n");
return 0;
out:
input_free_device(input_dev);
kfree(s3c_keypad);
err_irq:
free_irq(keypad_irq->start, input_dev);
free_irq(keypad_irq->end, input_dev);
if (slide != NULL)
free_irq(extra->slide->eint, s3c_keypad);
gpio_key = extra->gpio_key;
for (i=0; i<extra->gpio_key_num; i++, gpio_key+=1)
free_irq(gpio_key->eint, s3c_keypad);
err_clk:
clk_disable(keypad_clock);
clk_put(keypad_clock);
err_map:
iounmap(key_base);
err_req:
release_resource(keypad_mem);
kfree(keypad_mem);
return ret;
}