static int __devinit kp_probe(struct platform_device *pdev)
{
struct kp *kp;
struct input_dev *input_dev;
int i, ret;
struct adc_kp_platform_data *pdata = pdev->dev.platform_data;
s8 phys[32];
if (!pdata) {
dev_err(&pdev->dev, "platform data is required!\n");
return -EINVAL;
}
kp = kzalloc(sizeof(struct kp), GFP_KERNEL);
input_dev = input_allocate_device();
if (!kp || !input_dev) {
kfree(kp);
input_free_device(input_dev);
return -ENOMEM;
}
gp_kp=kp;
platform_set_drvdata(pdev, kp);
kp->input = input_dev;
for (i=0; i<SARADC_CHAN_NUM; i++) {
kp->cur_keycode[i] = 0;
kp->cur_keycode_status[i] = 0;
kp->tmp_code[i] = 0;
kp->count[i] = 0;
}
kp->flaga = kp->flagb = kp->flagx = kp->flagy = kp->flagl = kp->flagr = kp->flagl2 = kp->flagr2 = 0;
kp->circle_flag[0] = 0;
kp->circle_flag[1] ==0;
kp->old_x = (LCD_SCREEN_X+XCENTER)/2;
kp->old_y = LCD_SCREEN_Y/2;
INIT_WORK(&(kp->work_update), update_work_func);
setup_timer(&kp->timer, kp_timer_sr, kp) ;
mod_timer(&kp->timer, jiffies+msecs_to_jiffies(100));
/* setup input device */
set_bit(KEY_SPACE, input_dev->keybit);
set_bit(KEY_ENTER, input_dev->keybit);
set_bit(KEY_VOLUMEDOWN, input_dev->keybit);
set_bit(KEY_VOLUMEUP, input_dev->keybit);
set_bit(KEY_UP, input_dev->keybit);
set_bit(KEY_DOWN, input_dev->keybit);
set_bit(KEY_LEFT, input_dev->keybit);
set_bit(KEY_RIGHT, input_dev->keybit);
set_bit(BUTTON_A, input_dev->keybit);
set_bit(BUTTON_B, input_dev->keybit);
set_bit(BUTTON_X, input_dev->keybit);
set_bit(BUTTON_Y, input_dev->keybit);
set_bit(BUTTON_L, input_dev->keybit);
set_bit(BUTTON_R, input_dev->keybit);
set_bit(BUTTON_L2, input_dev->keybit);
set_bit(BUTTON_R2, input_dev->keybit);
set_bit(EV_REP, input_dev->evbit);
set_bit(EV_KEY, input_dev->evbit);
set_bit(EV_ABS, input_dev->evbit);
set_bit(BTN_TOUCH, input_dev->keybit);
set_bit(ABS_MT_TOUCH_MAJOR, input_dev->absbit);
set_bit(ABS_MT_WIDTH_MAJOR, input_dev->absbit);
set_bit(ABS_MT_POSITION_X, input_dev->absbit);
set_bit(ABS_MT_POSITION_Y, input_dev->absbit);
set_bit(ABS_MT_TRACKING_ID, input_dev->absbit);
input_set_abs_params(input_dev, ABS_X, 0, LCD_SCREEN_X, 0, 0);
input_set_abs_params(input_dev, ABS_Y, 0, LCD_SCREEN_Y, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, LCD_SCREEN_X, 0, 0);
input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, LCD_SCREEN_Y, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, TRACKING_ID, 0, 0);
kp->chan_num = 4;
kp->chan[2] = CHAN_6; //LEFT, RIGHT
kp->chan[3] = CHAN_5; //UP, DOWN
kp->chan[4] = CHAN_4; //KEY_SPACE,KEY_ENTER
sprintf(phys, "input/ts");
input_dev->name = "adc joystick";
input_dev->phys = phys;
input_dev->dev.parent = &pdev->dev;
input_dev->id.bustype = BUS_ISA;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x100;
/*
input_dev->id.bustype = BUS_ADB;
input_dev->id.vendor = 0x222a;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0001;
*/
input_dev->rep[REP_DELAY]=0xffffffff;
input_dev->rep[REP_PERIOD]=0xffffffff;
input_dev->keycodesize = sizeof(unsigned short);
input_dev->keycodemax = 0x1ff;
ret = input_register_device(kp->input);
if (ret < 0) {
printk(KERN_ERR "Unable to register keypad input device.\n");
kfree(kp);
input_free_device(input_dev);
return -EINVAL;
}
printk("adc joystick register input device completed.\r\n");
register_keypad_dev(gp_kp);
gpio_keys_init();
struct device *dev = &pdev->dev;
sysfs_create_group(&dev->kobj, &key_attr_group);
return 0;
}
static int __devinit adc_probe(struct platform_device *pdev)
{
struct kp *kp;
int i, ret;
s8 phys[32];
kp = kzalloc(sizeof(struct kp), GFP_KERNEL);
if (!kp) {
kfree(kp);
return -ENOMEM;
}
gp_kp=kp;
kp->stick_flag[0] = 0;
kp->stick_flag[1] = 0;
kp->view_oldx = 0;
kp->view_oldy = 0;
kp->left_center_count = 0;
kp->right_center_count = 0;
for (i=0; i<AXIS_NUM; i++) {
kp->js_value[i] = 0;
kp->js_flag[i] = 0;
kp->key_value[i] = 0;
kp->key_valid[i] = 0;
}
/************************************************************************************/
//register keytouch
kp->input_keytouch = input_allocate_device();
if (!kp->input_keytouch) {
printk("---------- allocate input_keytouch fail ------------\n");
kfree(kp);
input_free_device(kp->input_keytouch);
return -ENOMEM;
}
set_bit(BTN_TOUCH, kp->input_keytouch->keybit);
set_bit(EV_REP, kp->input_keytouch->evbit);
set_bit(EV_KEY, kp->input_keytouch->evbit);
set_bit(EV_ABS, kp->input_keytouch->evbit);
set_bit(EV_SYN, kp->input_keytouch->evbit);
set_bit(ABS_MT_TOUCH_MAJOR, kp->input_keytouch->absbit);
set_bit(ABS_MT_WIDTH_MAJOR, kp->input_keytouch->absbit);
set_bit(ABS_MT_POSITION_X, kp->input_keytouch->absbit);
set_bit(ABS_MT_POSITION_Y, kp->input_keytouch->absbit);
set_bit(ABS_MT_TRACKING_ID, kp->input_keytouch->absbit);
input_set_abs_params(kp->input_keytouch, ABS_MT_POSITION_X, 0, LCD_SCREEN_X, 0, 0);
input_set_abs_params(kp->input_keytouch, ABS_MT_POSITION_Y, 0, LCD_SCREEN_Y, 0, 0);
input_set_abs_params(kp->input_keytouch, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(kp->input_keytouch, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(kp->input_keytouch, ABS_MT_TRACKING_ID, 0, TRACKING_ID, 0, 0);
sprintf(phys, "input/ts");
kp->input_keytouch->name = "ADC keytouch";
kp->input_keytouch->phys = phys;
kp->input_keytouch->dev.parent = &pdev->dev;
kp->input_keytouch->id.bustype = BUS_ISA;
kp->input_keytouch->id.vendor = 0x0001;
kp->input_keytouch->id.product = 0x0001;
kp->input_keytouch->id.version = 0x100;
kp->input_keytouch->rep[REP_DELAY]=0xffffffff;
kp->input_keytouch->rep[REP_PERIOD]=0xffffffff;
kp->input_keytouch->keycodesize = sizeof(unsigned short);
kp->input_keytouch->keycodemax = 0x1ff;
ret = input_register_device(kp->input_keytouch);
if (ret < 0) {
printk(KERN_ERR "register input_keytouch device fail\n");
kfree(kp);
input_free_device(kp->input_keytouch);
return -EINVAL;
}
/************************************************************************************/
/************************************************************************************/
//register joystick
kp->input_joystick = input_allocate_device();
if (!kp->input_joystick) {
printk("---------- allocate input_joystick fail ------------\n");
kfree(kp);
input_free_device(kp->input_joystick);
return -ENOMEM;
}
for (i = 0; i < keynum; i++)
set_bit(gamekeys[i].code, kp->input_joystick->keybit);
//for hot key
set_bit(gamekeys[keynum].code, kp->input_joystick->keybit);
set_bit(EV_REP, kp->input_joystick->evbit);
set_bit(EV_KEY, kp->input_joystick->evbit);
set_bit(EV_ABS, kp->input_joystick->evbit);
set_bit(EV_SYN, kp->input_joystick->evbit);
input_set_abs_params(kp->input_joystick, ABS_X, -256, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_Y, -256, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_Z, -256, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_RZ, -256, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_BRAKE, 0, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_GAS, 0, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_RX, 0, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_RY, 0, 255, 0, 0);
#if DPAD_AXIS
input_set_abs_params(kp->input_joystick, ABS_HAT0X, -256, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_HAT0Y, -256, 255, 0, 0);
#endif
kp->input_joystick->name = "GPD-joy";
kp->input_joystick->rep[REP_DELAY]=0xffffffff;
kp->input_joystick->rep[REP_PERIOD]=0xffffffff;
kp->input_joystick->keycodesize = sizeof(unsigned short);
kp->input_joystick->keycodemax = 0x1ff;
ret = input_register_device(kp->input_joystick);
if (ret < 0) {
printk(KERN_ERR "register input_joystick device fail\n");
kfree(kp);
input_free_device(kp->input_joystick);
return -EINVAL;
}
/************************************************************************************/
platform_set_drvdata(pdev, kp);
gpio_init();
register_keypad_dev(gp_kp);
struct device *dev = &pdev->dev;
sysfs_create_group(&dev->kobj, &key_attr_group);
INIT_WORK(&(kp->work_update), update_work_func);
setup_timer(&kp->timer, kp_timer_sr, kp) ;
mod_timer(&kp->timer, jiffies+msecs_to_jiffies(100));
#ifdef CONFIG_HAS_EARLYSUSPEND
kp->adc_early_suspend.suspend = adc_early_suspend;
kp->adc_early_suspend.resume = adc_early_resume;
kp->adc_early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;;
register_early_suspend(&kp->adc_early_suspend);
#endif
return 0;
}
static int __init kp_probe(struct platform_device *pdev)
{
struct kp *kp;
struct input_dev *input_dev;
int i, j, ret;
struct adc_kp_platform_data *pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "platform data is required!\n");
return -EINVAL;
}
kp = kzalloc(sizeof(struct kp), GFP_KERNEL);
kp->led_control_param = kzalloc((sizeof(int)*pdata->led_control_param_num), GFP_KERNEL);
input_dev = input_allocate_device();
if (!kp ||!kp->led_control_param || !input_dev) {
kfree(kp->led_control_param);
kfree(kp);
input_free_device(input_dev);
return -ENOMEM;
}
gp_kp=kp;
platform_set_drvdata(pdev, kp);
kp->input = input_dev;
kp->cur_keycode = 0;
kp->tmp_code = 0;
kp->count = 0;
setup_timer(&kp->timer, kp_timer_sr, kp) ;
mod_timer(&kp->timer, jiffies+msecs_to_jiffies(100));
/* setup input device */
set_bit(EV_KEY, input_dev->evbit);
set_bit(EV_REP, input_dev->evbit);
kp->key = pdata->key;
kp->key_num = pdata->key_num;
if (pdata->led_control){
kp->led_control = pdata->led_control;
}
struct adc_key *key = pdata->key;
int new_chan_flag;
kp->chan_num = 0;
for (i=0; i<kp->key_num; i++) {
set_bit(key->code, input_dev->keybit);
/* search the key chan */
new_chan_flag = 1;
for (j=0; j<kp->chan_num; j++) {
if (key->chan == kp->chan[j]) {
new_chan_flag = 0;
break;
}
}
if (new_chan_flag) {
kp->chan[kp->chan_num] = key->chan;
printk(KERN_INFO "chan #%d used for ADC key\n", key->chan);
kp->chan_num++;
}
printk(KERN_INFO "%s key(%d) registed.\n", key->name, key->code);
key++;
}
input_dev->name = "adc_keypad";
input_dev->phys = "adc_keypad/input0";
input_dev->dev.parent = &pdev->dev;
input_dev->id.bustype = BUS_ISA;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0100;
input_dev->rep[REP_DELAY]=0xffffffff;
input_dev->rep[REP_PERIOD]=0xffffffff;
input_dev->keycodesize = sizeof(unsigned short);
input_dev->keycodemax = 0x1ff;
ret = input_register_device(kp->input);
if (ret < 0) {
printk(KERN_ERR "Unable to register keypad input device.\n");
kfree(kp->led_control_param);
kfree(kp);
input_free_device(input_dev);
return -EINVAL;
}
printk("adc keypad register input device completed.\r\n");
register_keypad_dev(gp_kp);
return 0;
}
static int kp_probe(struct platform_device *pdev)
{
struct kp *kp;
struct input_dev *input_dev;
int i, j, ret, key_size, name_len;
int new_chan_flag;
struct adc_key *key;
struct adc_kp_platform_data *pdata = NULL;
int *key_param = NULL;
int state = 0;
printk("==%s==\n", __func__);
#ifdef CONFIG_OF
if (!pdev->dev.of_node) {
printk("adc_key: pdev->dev.of_node == NULL!\n");
state = -EINVAL;
goto get_key_node_fail;
}
ret = of_property_read_u32(pdev->dev.of_node,"key_num",&key_size);
if (ret) {
printk("adc_key: faild to get key_num!\n");
state = -EINVAL;
goto get_key_node_fail;
}
ret = of_property_read_u32(pdev->dev.of_node,"name_len",&name_len);
if (ret) {
printk("adc_key: faild to get name_len!\n");
name_len = 20;
}
pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
if (!pdata) {
dev_err(&pdev->dev, "platform data is required!\n");
state = -EINVAL;
goto get_key_node_fail;
}
pdata->key = kzalloc(sizeof(*(pdata->key))*key_size, GFP_KERNEL);
if (!(pdata->key)) {
dev_err(&pdev->dev, "platform key is required!\n");
goto get_key_mem_fail;
}
pdata->key_num = key_size;
for (i=0; i<key_size; i++) {
ret = of_property_read_string_index(pdev->dev.of_node, "key_name", i, &(pdata->key[i].name));
//printk("adc_key: %d %s\n",i, (pdata->key[i].name));
if(ret < 0){
printk("adc_key: find key_name=%d finished\n", i);
break;
}
}
key_param = kzalloc(4*(sizeof(*key_param))*(pdata->key_num), GFP_KERNEL);
if(!key_param) {
printk("adc_key: key_param can not get mem\n");
goto get_param_mem_fail;
}
ret = of_property_read_u32_array(pdev->dev.of_node,"key_code",key_param, pdata->key_num);
if (ret) {
printk("adc_key: faild to get key_code!\n");
goto get_key_param_failed;
}
ret = of_property_read_u32_array(pdev->dev.of_node,"key_chan",key_param+pdata->key_num, pdata->key_num);
if (ret) {
printk("adc_key: faild to get key_chan!\n");
goto get_key_param_failed;
}
ret = of_property_read_u32_array(pdev->dev.of_node,"key_val",key_param+pdata->key_num*2, pdata->key_num);
if (ret) {
printk("adc_key: faild to get key_val!\n");
goto get_key_param_failed;
}
ret = of_property_read_u32_array(pdev->dev.of_node,"key_tolerance",key_param+pdata->key_num*3, pdata->key_num);
if (ret) {
printk("adc_key: faild to get tolerance!\n");
goto get_key_param_failed;
}
for (i=0; i<pdata->key_num; i++) {
pdata->key[i].code = *(key_param+i);
pdata->key[i].chan = *(key_param+pdata->key_num+i);
pdata->key[i].value = *(key_param+pdata->key_num*2+i);
pdata->key[i].tolerance = *(key_param+pdata->key_num*3+i);
}
#else
pdata = pdev->dev.platform_data;
#endif
kp = kzalloc(sizeof(struct kp), GFP_KERNEL);
input_dev = input_allocate_device();
if (!kp || !input_dev) {
kfree(kp);
input_free_device(input_dev);
state = -ENOMEM;
goto get_key_param_failed;
}
gp_kp=kp;
platform_set_drvdata(pdev, pdata);
kp->input = input_dev;
kp->report_code = 0;
kp->code = 0;
kp->poll_period = POLL_PERIOD_WHEN_KEY_UP;
kp->count = 0;
INIT_WORK(&(kp->work_update), update_work_func);
setup_timer(&kp->timer, kp_timer_sr, (unsigned int)kp) ;
mod_timer(&kp->timer, jiffies+msecs_to_jiffies(100));
/* setup input device */
set_bit(EV_KEY, input_dev->evbit);
set_bit(EV_REP, input_dev->evbit);
kp->key = pdata->key;
kp->key_num = pdata->key_num;
key = pdata->key;
kp->chan_num = 0;
for (i=0; i<kp->key_num; i++) {
set_bit(key->code, input_dev->keybit);
/* search the key chan */
new_chan_flag = 1;
for (j=0; j<kp->chan_num; j++) {
if (key->chan == kp->chan[j]) {
new_chan_flag = 0;
break;
}
}
if (new_chan_flag) {
kp->chan[kp->chan_num] = key->chan;
printk(KERN_INFO "chan #%d used for ADC key\n", key->chan);
kp->chan_num++;
}
printk(KERN_INFO "%s key(%d) registed.\n", key->name, key->code);
key++;
}
input_dev->name = "adc_keypad";
input_dev->phys = "adc_keypad/input0";
input_dev->dev.parent = &pdev->dev;
input_dev->id.bustype = BUS_ISA;
input_dev->id.vendor = 0x0001;
input_dev->id.product = 0x0001;
input_dev->id.version = 0x0100;
input_dev->rep[REP_DELAY]=0xffffffff;
input_dev->rep[REP_PERIOD]=0xffffffff;
input_dev->keycodesize = sizeof(unsigned short);
input_dev->keycodemax = 0x1ff;
ret = input_register_device(kp->input);
if (ret < 0) {
printk(KERN_ERR "Unable to register keypad input device.\n");
kfree(kp);
input_free_device(input_dev);
state = -EINVAL;
goto get_key_param_failed;
}
printk("adc keypad register input device completed.\n");
register_keypad_dev(gp_kp);
kfree(key_param);
#ifdef CONFIG_HAS_EARLYSUSPEND
kp->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
kp->early_suspend.suspend = kp_early_suspend;
kp->early_suspend.resume = kp_late_resume;
register_early_suspend(&kp->early_suspend);
#endif
return 0;
get_key_param_failed:
kfree(key_param);
get_param_mem_fail:
kfree(pdata->key);
get_key_mem_fail:
kfree(pdata);
get_key_node_fail:
return state;
}
static int __devinit adc_probe(struct platform_device *pdev)
{
struct kp *kp;
int i, ret;
s8 phys[32];
kp = kzalloc(sizeof(struct kp), GFP_KERNEL);
if (!kp) {
kfree(kp);
return -ENOMEM;
}
gp_kp=kp;
kp->circle_flag[0] = 0;
kp->circle_flag[1] = 0;
kp->old_x = 0;
kp->old_y = 0;
for (i=0; i<SARADC_CHAN_NUM; i++) {
kp->cur_keycode[i] = 0;
kp->cur_keycode_status[i] = 0;
kp->tmp_code[i] = 0;
kp->count[i] = 0;
kp->js_flag[i] = 0;
}
kp->chan_num = 4;
kp->chan[0] = CHAN_0;
kp->chan[1] = CHAN_1;
kp->chan[2] = CHAN_2; //LEFT, RIGHT
kp->chan[3] = CHAN_3; //UP, DOWN
kp->chan[4] = CHAN_4; //KEY_VOLUMEDOWN,KEY_VOLUMEUP, KEY_SPACE,KEY_ENTER
/************************************************************************************/
//register keytouch
kp->input_keytouch = input_allocate_device();
if (!kp->input_keytouch) {
printk("---------- allocate input_keytouch fail ------------\n");
kfree(kp);
input_free_device(kp->input_keytouch);
return -ENOMEM;
}
set_bit(BTN_TOUCH, kp->input_keytouch->keybit);
set_bit(EV_REP, kp->input_keytouch->evbit);
set_bit(EV_KEY, kp->input_keytouch->evbit);
set_bit(EV_ABS, kp->input_keytouch->evbit);
set_bit(EV_SYN, kp->input_keytouch->evbit);
set_bit(ABS_MT_TOUCH_MAJOR, kp->input_keytouch->absbit);
set_bit(ABS_MT_WIDTH_MAJOR, kp->input_keytouch->absbit);
set_bit(ABS_MT_POSITION_X, kp->input_keytouch->absbit);
set_bit(ABS_MT_POSITION_Y, kp->input_keytouch->absbit);
set_bit(ABS_MT_TRACKING_ID, kp->input_keytouch->absbit);
input_set_abs_params(kp->input_keytouch, ABS_MT_POSITION_X, 0, LCD_SCREEN_X, 0, 0);
input_set_abs_params(kp->input_keytouch, ABS_MT_POSITION_Y, 0, LCD_SCREEN_Y, 0, 0);
input_set_abs_params(kp->input_keytouch, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(kp->input_keytouch, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
input_set_abs_params(kp->input_keytouch, ABS_MT_TRACKING_ID, 0, TRACKING_ID, 0, 0);
sprintf(phys, "input/ts");
kp->input_keytouch->name = "ADC keytouch";
kp->input_keytouch->phys = phys;
kp->input_keytouch->dev.parent = &pdev->dev;
kp->input_keytouch->id.bustype = BUS_ISA;
kp->input_keytouch->id.vendor = 0x0001;
kp->input_keytouch->id.product = 0x0001;
kp->input_keytouch->id.version = 0x100;
kp->input_keytouch->rep[REP_DELAY]=0xffffffff;
kp->input_keytouch->rep[REP_PERIOD]=0xffffffff;
kp->input_keytouch->keycodesize = sizeof(unsigned short);
kp->input_keytouch->keycodemax = 0x1ff;
ret = input_register_device(kp->input_keytouch);
if (ret < 0) {
printk(KERN_ERR "register input_keytouch device fail\n");
kfree(kp);
input_free_device(kp->input_keytouch);
return -EINVAL;
}
/************************************************************************************/
/************************************************************************************/
//register joystick
kp->input_joystick = input_allocate_device();
if (!kp->input_joystick) {
printk("---------- allocate input_joystick fail ------------\n");
kfree(kp);
input_free_device(kp->input_joystick);
return -ENOMEM;
}
set_bit(KEY_VOLUMEDOWN, kp->input_joystick->keybit);
set_bit(KEY_VOLUMEUP, kp->input_joystick->keybit);
set_bit(BTN_START, kp->input_joystick->keybit);
set_bit(BTN_SELECT, kp->input_joystick->keybit);
for (i = 0; i < keynum; i++)
set_bit(gamekeys[i].code, kp->input_joystick->keybit);
set_bit(EV_REP, kp->input_joystick->evbit);
set_bit(EV_KEY, kp->input_joystick->evbit);
set_bit(EV_ABS, kp->input_joystick->evbit);
set_bit(EV_SYN, kp->input_joystick->evbit);
input_set_abs_params(kp->input_joystick, ABS_X, -256, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_Y, -256, 255, 0, 0);
//input_set_abs_params(kp->input_joystick, ABS_RX, -256, 255, 0, 0);
//input_set_abs_params(kp->input_joystick, ABS_RY, -256, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_Z, -256, 255, 0, 0);
input_set_abs_params(kp->input_joystick, ABS_RZ, -256, 255, 0, 0);
kp->input_joystick->name = "ADC joystick";
kp->input_joystick->rep[REP_DELAY]=0xffffffff;
kp->input_joystick->rep[REP_PERIOD]=0xffffffff;
kp->input_joystick->keycodesize = sizeof(unsigned short);
kp->input_joystick->keycodemax = 0x1ff;
ret = input_register_device(kp->input_joystick);
if (ret < 0) {
printk(KERN_ERR "register input_joystick device fail\n");
kfree(kp);
input_free_device(kp->input_joystick);
return -EINVAL;
}
/************************************************************************************/
platform_set_drvdata(pdev, kp);
gpio_init();
register_keypad_dev(gp_kp);
struct device *dev = &pdev->dev;
sysfs_create_group(&dev->kobj, &key_attr_group);
INIT_WORK(&(kp->work_update), update_work_func);
setup_timer(&kp->timer, kp_timer_sr, kp) ;
mod_timer(&kp->timer, jiffies+msecs_to_jiffies(100));
return 0;
}
