static bool udraw_setup_pen(struct udraw *udraw, struct hid_device *hdev) { struct input_dev *input_dev; input_dev = allocate_and_setup(hdev, DEVICE_NAME " Pen"); if (!input_dev) return false; input_dev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY); input_set_abs_params(input_dev, ABS_X, 0, RES_X, 1, 0); input_abs_set_res(input_dev, ABS_X, RES_X / WIDTH); input_set_abs_params(input_dev, ABS_Y, 0, RES_Y, 1, 0); input_abs_set_res(input_dev, ABS_Y, RES_Y / HEIGHT); input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_PRESSURE, 0, 0); set_bit(BTN_TOUCH, input_dev->keybit); set_bit(BTN_TOOL_PEN, input_dev->keybit); set_bit(INPUT_PROP_POINTER, input_dev->propbit); udraw->pen_input_dev = input_dev; return true; }
static bool udraw_setup_touch(struct udraw *udraw, struct hid_device *hdev) { struct input_dev *input_dev; input_dev = allocate_and_setup(hdev, DEVICE_NAME " Touchpad"); if (!input_dev) return false; input_dev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY); input_set_abs_params(input_dev, ABS_X, 0, RES_X, 1, 0); input_abs_set_res(input_dev, ABS_X, RES_X / WIDTH); input_set_abs_params(input_dev, ABS_Y, 0, RES_Y, 1, 0); input_abs_set_res(input_dev, ABS_Y, RES_Y / HEIGHT); set_bit(BTN_TOUCH, input_dev->keybit); set_bit(BTN_TOOL_FINGER, input_dev->keybit); set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit); set_bit(INPUT_PROP_POINTER, input_dev->propbit); udraw->touch_input_dev = input_dev; return true; }
static int uibc_kbd_dev_open(struct inode *inode, struct file *file) { int TPD_RES_X, TPD_RES_Y; PR_DEBUG("*** uibckeyboard uibc_kbd_dev_open ***\n"); #ifdef LCM_ROTATE TPD_RES_Y = DISP_GetScreenWidth(); TPD_RES_X = DISP_GetScreenHeight(); #else TPD_RES_X = DISP_GetScreenWidth(); TPD_RES_Y = DISP_GetScreenHeight(); #endif uibckbd = kzalloc(sizeof(struct uibckeyboard), GFP_KERNEL); uibc_input_dev = input_allocate_device(); if (!uibckbd || !uibc_input_dev) goto fail; memcpy(uibckbd->keymap, uibc_keycode, sizeof(uibc_keycode)); uibckbd->input = uibc_input_dev; set_bit(INPUT_PROP_DIRECT, uibc_input_dev->propbit); set_bit(EV_ABS, uibc_input_dev->evbit); set_bit(EV_KEY, uibc_input_dev->evbit); set_bit(EV_REL, uibc_input_dev->evbit); set_bit(REL_X, uibc_input_dev->relbit); set_bit(REL_Y, uibc_input_dev->relbit); set_bit(ABS_X, uibc_input_dev->absbit); set_bit(ABS_Y, uibc_input_dev->absbit); set_bit(ABS_MT_TRACKING_ID, uibc_input_dev->absbit); set_bit(ABS_MT_POSITION_X, uibc_input_dev->absbit); set_bit(ABS_MT_POSITION_Y, uibc_input_dev->absbit); input_set_abs_params(uibc_input_dev, ABS_MT_POSITION_X, 0, TPD_RES_X, 0, 0); input_set_abs_params(uibc_input_dev, ABS_MT_POSITION_Y, 0, TPD_RES_Y, 0, 0); input_set_abs_params(uibc_input_dev, ABS_X, 0, TPD_RES_X, 0, 0); input_set_abs_params(uibc_input_dev, ABS_Y, 0, TPD_RES_Y, 0, 0); input_abs_set_res(uibc_input_dev, ABS_X, TPD_RES_X); input_abs_set_res(uibc_input_dev, ABS_Y, TPD_RES_Y); uibc_input_dev->name = UIBC_KBD_NAME; uibc_input_dev->keycode = uibckbd->keymap; uibc_input_dev->keycodesize = sizeof(unsigned short); uibc_input_dev->id.bustype = BUS_HOST; return 0; fail: input_free_device(uibc_input_dev); kfree(uibckbd); return -EINVAL; }
static void set_abs(struct input_dev *input, unsigned int code, struct hid_field *field, int snratio) { int fmin = field->logical_minimum; int fmax = field->logical_maximum; int fuzz = snratio ? (fmax - fmin) / snratio : 0; input_set_abs_params(input, code, fmin, fmax, fuzz, 0); input_abs_set_res(input, code, hidinput_calc_abs_res(field, code)); }
static void virtinput_cfg_abs(struct virtio_input *vi, int abs) { u32 mi, ma, re, fu, fl; virtinput_cfg_select(vi, VIRTIO_INPUT_CFG_ABS_INFO, abs); virtio_cread(vi->vdev, struct virtio_input_config, u.abs.min, &mi); virtio_cread(vi->vdev, struct virtio_input_config, u.abs.max, &ma); virtio_cread(vi->vdev, struct virtio_input_config, u.abs.res, &re); virtio_cread(vi->vdev, struct virtio_input_config, u.abs.fuzz, &fu); virtio_cread(vi->vdev, struct virtio_input_config, u.abs.flat, &fl); input_set_abs_params(vi->idev, abs, mi, ma, fu, fl); input_abs_set_res(vi->idev, abs, re); }
/* touch panel probe */ static int tpd_probe(struct platform_device *pdev) { int touch_type = 1; // 0:R-touch, 1: Cap-touch int i=0; TPD_DMESG("enter %s, %d\n", __FUNCTION__, __LINE__); /* Select R-Touch */ // if(g_tpd_drv == NULL||tpd_load_status == 0) #if 0 if(g_tpd_drv == NULL) { g_tpd_drv = &tpd_driver_list[0]; /* touch_type:0: r-touch, 1: C-touch */ touch_type = 0; TPD_DMESG("Generic touch panel driver\n"); } #ifdef CONFIG_HAS_EARLYSUSPEND MTK_TS_early_suspend_handler.suspend = g_tpd_drv->suspend; MTK_TS_early_suspend_handler.resume = g_tpd_drv->resume; register_early_suspend(&MTK_TS_early_suspend_handler); #endif #endif /*Begin lenovo-sw wengjun1 add for tp info struct. 2014-1-15*/ tpd_info_t = (struct tpd_version_info*)kmalloc(sizeof(struct tpd_version_info), GFP_KERNEL); /*End lenovo-sw wengjun1 add for tp info struct. 2014-1-15*/ if (misc_register(&tpd_misc_device)) { printk("mtk_tpd: tpd_misc_device register failed\n"); } if((tpd=(struct tpd_device*)kmalloc(sizeof(struct tpd_device), GFP_KERNEL))==NULL) return -ENOMEM; memset(tpd, 0, sizeof(struct tpd_device)); /* allocate input device */ if((tpd->dev=input_allocate_device())==NULL) { kfree(tpd); return -ENOMEM; } //TPD_RES_X = simple_strtoul(LCM_WIDTH, NULL, 0); //TPD_RES_Y = simple_strtoul(LCM_HEIGHT, NULL, 0); TPD_RES_X = DISP_GetScreenWidth(); TPD_RES_Y = DISP_GetScreenHeight(); printk("mtk_tpd: TPD_RES_X = %d, TPD_RES_Y = %d\n", TPD_RES_X, TPD_RES_Y); tpd_mode = TPD_MODE_NORMAL; tpd_mode_axis = 0; tpd_mode_min = TPD_RES_Y/2; tpd_mode_max = TPD_RES_Y; tpd_mode_keypad_tolerance = TPD_RES_X*TPD_RES_X/1600; /* struct input_dev dev initialization and registration */ tpd->dev->name = TPD_DEVICE; set_bit(EV_ABS, tpd->dev->evbit); set_bit(EV_KEY, tpd->dev->evbit); /*Lenovo-sw wengjun1 remove unused attributes*/ #ifndef LENOVO_TP_OPTIMIZED set_bit(ABS_X, tpd->dev->absbit); set_bit(ABS_Y, tpd->dev->absbit); set_bit(ABS_PRESSURE, tpd->dev->absbit); set_bit(BTN_TOUCH, tpd->dev->keybit); #endif /*Lenovo-sw remove end*/ set_bit(INPUT_PROP_DIRECT, tpd->dev->propbit); #if 1 for(i = 1; i < TP_DRV_MAX_COUNT; i++) { /* add tpd driver into list */ if(tpd_driver_list[i].tpd_device_name != NULL) { tpd_driver_list[i].tpd_local_init(); //msleep(1); if(tpd_load_status ==1) { TPD_DMESG("[mtk-tpd]tpd_probe, tpd_driver_name=%s\n", tpd_driver_list[i].tpd_device_name); g_tpd_drv = &tpd_driver_list[i]; break; } } } if(g_tpd_drv == NULL) { if(tpd_driver_list[0].tpd_device_name != NULL) { g_tpd_drv = &tpd_driver_list[0]; /* touch_type:0: r-touch, 1: C-touch */ touch_type = 0; g_tpd_drv->tpd_local_init(); TPD_DMESG("[mtk-tpd]Generic touch panel driver\n"); } else { TPD_DMESG("[mtk-tpd]cap touch and Generic touch both are not loaded!!\n"); return 0; } } #ifdef CONFIG_HAS_EARLYSUSPEND MTK_TS_early_suspend_handler.suspend = g_tpd_drv->suspend; MTK_TS_early_suspend_handler.resume = g_tpd_drv->resume; //liangzhiqiang add for tp wakeup if(lct_tp_early_suspend == 0) { MTK_TS_early_suspend_handler.level = EARLY_SUSPEND_LEVEL_DISABLE_FB+10; } register_early_suspend(&MTK_TS_early_suspend_handler); #endif #endif //#ifdef TPD_TYPE_CAPACITIVE /* TPD_TYPE_CAPACITIVE handle */ if(touch_type == 1){ set_bit(ABS_MT_TRACKING_ID, tpd->dev->absbit); set_bit(ABS_MT_TOUCH_MAJOR, tpd->dev->absbit); /*Lenovo-sw wengjun1 remove unused attributes*/ #ifndef LENOVO_TP_OPTIMIZED set_bit(ABS_MT_TOUCH_MINOR, tpd->dev->absbit); #endif /*Lenovo-sw remove end*/ set_bit(ABS_MT_POSITION_X, tpd->dev->absbit); set_bit(ABS_MT_POSITION_Y, tpd->dev->absbit); #if 0 // linux kernel update from 2.6.35 --> 3.0 tpd->dev->absmax[ABS_MT_POSITION_X] = TPD_RES_X; tpd->dev->absmin[ABS_MT_POSITION_X] = 0; tpd->dev->absmax[ABS_MT_POSITION_Y] = TPD_RES_Y; tpd->dev->absmin[ABS_MT_POSITION_Y] = 0; tpd->dev->absmax[ABS_MT_TOUCH_MAJOR] = 100; tpd->dev->absmin[ABS_MT_TOUCH_MINOR] = 0; #else input_set_abs_params(tpd->dev, ABS_MT_POSITION_X, 0, TPD_RES_X, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_POSITION_Y, 0, TPD_RES_Y, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MAJOR, 0, 100, 0, 0); /*Lenovo-sw wengjun1 remove unused attributes*/ #ifndef LENOVO_TP_OPTIMIZED input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MINOR, 0, 100, 0, 0); #endif /*Lenovo-sw remove end*/ #endif TPD_DMESG("Cap touch panel driver\n"); } //#endif #if 0 //linux kernel update from 2.6.35 --> 3.0 tpd->dev->absmax[ABS_X] = TPD_RES_X; tpd->dev->absmin[ABS_X] = 0; tpd->dev->absmax[ABS_Y] = TPD_RES_Y; tpd->dev->absmin[ABS_Y] = 0; tpd->dev->absmax[ABS_PRESSURE] = 255; tpd->dev->absmin[ABS_PRESSURE] = 0; #else /*Lenovo-sw wengjun1 remove unused attributes*/ #ifndef LENOVO_TP_OPTIMIZED input_set_abs_params(tpd->dev, ABS_X, 0, TPD_RES_X, 0, 0); input_set_abs_params(tpd->dev, ABS_Y, 0, TPD_RES_Y, 0, 0); input_abs_set_res(tpd->dev, ABS_X, TPD_RES_X); input_abs_set_res(tpd->dev, ABS_Y, TPD_RES_Y); input_set_abs_params(tpd->dev, ABS_PRESSURE, 0, 255, 0, 0); #endif /*Lenovo-sw remove end*/ #endif if(input_register_device(tpd->dev)) TPD_DMESG("input_register_device failed.(tpd)\n"); else tpd_register_flag = 1; /* init R-Touch */ #if 0 if(touch_type == 0) { g_tpd_drv->tpd_local_init(); } #endif //lenovo-wengjun1 #if 1 //defined(LENOVO_PRODUCT_DEVICE==S960) //#if(LENOVO_PRODUCT_DEVICE == 920) //if(g_tpd_drv->tpd_have_button) #else if(g_tpd_drv->tpd_have_button) #endif { tpd_button_init(); } if (g_tpd_drv->attrs.num) tpd_create_attributes(&pdev->dev, &g_tpd_drv->attrs); #if 1 if(device_create_file(&pdev->dev, &dev_attr_tpd_fw_version)) { TPD_DMESG("create fw_version file error--Liu\n"); } if(device_create_file(&pdev->dev, &dev_attr_tpd_fw_vendor_info)) { TPD_DMESG("create touch_info file error--Liu\n"); } if(device_create_file(&pdev->dev, &dev_attr_tpd_fw_chip_info)) { TPD_DMESG("create touch_info file error--Liu\n"); } #endif return 0; }
/* touch panel probe */ static int tpd_probe(struct platform_device *pdev) { int touch_type = 1; // 0:R-touch, 1: Cap-touch int i=0; TPD_DMESG("enter %s, %d\n", __FUNCTION__, __LINE__); /* Select R-Touch */ // if(g_tpd_drv == NULL||tpd_load_status == 0) #if 0 if(g_tpd_drv == NULL) { g_tpd_drv = &tpd_driver_list[0]; /* touch_type:0: r-touch, 1: C-touch */ touch_type = 0; TPD_DMESG("Generic touch panel driver\n"); } #ifdef CONFIG_HAS_EARLYSUSPEND MTK_TS_early_suspend_handler.suspend = g_tpd_drv->suspend; MTK_TS_early_suspend_handler.resume = g_tpd_drv->resume; register_early_suspend(&MTK_TS_early_suspend_handler); #endif #endif if (misc_register(&tpd_misc_device)) { printk("mtk_tpd: tpd_misc_device register failed\n"); } if((tpd=(struct tpd_device*)kmalloc(sizeof(struct tpd_device), GFP_KERNEL))==NULL) return -ENOMEM; memset(tpd, 0, sizeof(struct tpd_device)); /* allocate input device */ if((tpd->dev=input_allocate_device())==NULL) { kfree(tpd); return -ENOMEM; } TPD_RES_X = simple_strtoul(LCM_WIDTH, NULL, 0); TPD_RES_Y = simple_strtoul(LCM_HEIGHT, NULL, 0); printk("mtk_tpd: TPD_RES_X = %d, TPD_RES_Y = %d\n", TPD_RES_X, TPD_RES_Y); tpd_mode = TPD_MODE_NORMAL; tpd_mode_axis = 0; tpd_mode_min = TPD_RES_Y/2; tpd_mode_max = TPD_RES_Y; tpd_mode_keypad_tolerance = TPD_RES_X*TPD_RES_X/1600; /* struct input_dev dev initialization and registration */ tpd->dev->name = TPD_DEVICE; set_bit(EV_ABS, tpd->dev->evbit); set_bit(EV_KEY, tpd->dev->evbit); set_bit(ABS_X, tpd->dev->absbit); set_bit(ABS_Y, tpd->dev->absbit); set_bit(ABS_PRESSURE, tpd->dev->absbit); set_bit(BTN_TOUCH, tpd->dev->keybit); set_bit(INPUT_PROP_DIRECT, tpd->dev->propbit); #if 1 for(i = 1; i < TP_DRV_MAX_COUNT; i++) { /* add tpd driver into list */ if(tpd_driver_list[i].tpd_device_name != NULL) { tpd_driver_list[i].tpd_local_init(); //msleep(1); if(tpd_load_status ==1) { TPD_DMESG("[mtk-tpd]tpd_probe, tpd_driver_name=%s\n", tpd_driver_list[i].tpd_device_name); g_tpd_drv = &tpd_driver_list[i]; break; } } } if(g_tpd_drv == NULL) { if(tpd_driver_list[0].tpd_device_name != NULL) { g_tpd_drv = &tpd_driver_list[0]; /* touch_type:0: r-touch, 1: C-touch */ touch_type = 0; g_tpd_drv->tpd_local_init(); TPD_DMESG("[mtk-tpd]Generic touch panel driver\n"); } else { TPD_DMESG("[mtk-tpd]cap touch and Generic touch both are not loaded!!\n"); return 0; } } #ifdef CONFIG_HAS_EARLYSUSPEND MTK_TS_early_suspend_handler.suspend = g_tpd_drv->suspend; MTK_TS_early_suspend_handler.resume = g_tpd_drv->resume; register_early_suspend(&MTK_TS_early_suspend_handler); #endif #endif //#ifdef TPD_TYPE_CAPACITIVE /* TPD_TYPE_CAPACITIVE handle */ if(touch_type == 1){ #if 0 // defined (TINNO_ANDROID_S8121) || (TINNO_ANDROID_S9091) set_bit(ABS_MT_PRESSURE, tpd->dev->absbit); set_bit(ABS_MT_WIDTH_MAJOR, tpd->dev->absbit); set_bit(ABS_MT_WIDTH_MINOR, tpd->dev->absbit); set_bit(ABS_MT_TOUCH_MINOR, tpd->dev->absbit); #endif set_bit(ABS_MT_TRACKING_ID, tpd->dev->absbit); set_bit(ABS_MT_TOUCH_MAJOR, tpd->dev->absbit); set_bit(ABS_MT_TOUCH_MINOR, tpd->dev->absbit); set_bit(ABS_MT_POSITION_X, tpd->dev->absbit); set_bit(ABS_MT_POSITION_Y, tpd->dev->absbit); #if 0 // linux kernel update from 2.6.35 --> 3.0 tpd->dev->absmax[ABS_MT_POSITION_X] = TPD_RES_X; tpd->dev->absmin[ABS_MT_POSITION_X] = 0; tpd->dev->absmax[ABS_MT_POSITION_Y] = TPD_RES_Y; tpd->dev->absmin[ABS_MT_POSITION_Y] = 0; tpd->dev->absmax[ABS_MT_TOUCH_MAJOR] = 100; tpd->dev->absmin[ABS_MT_TOUCH_MINOR] = 0; #else input_set_abs_params(tpd->dev, ABS_MT_POSITION_X, 0, TPD_RES_X, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_POSITION_Y, 0, TPD_RES_Y, 0, 0); #if 0 // defined (TINNO_ANDROID_S8121) || (TINNO_ANDROID_S9091) input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MAJOR, 0, 112, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MINOR, 0, 112, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MAJOR, 0, 112, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MINOR, 0, 112, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_PRESSURE, 0, 112, 0, 0); #else input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MAJOR, 0, 100, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MINOR, 0, 100, 0, 0); #endif #endif TPD_DMESG("Cap touch panel driver\n"); } //#endif #if 0 //linux kernel update from 2.6.35 --> 3.0 tpd->dev->absmax[ABS_X] = TPD_RES_X; tpd->dev->absmin[ABS_X] = 0; tpd->dev->absmax[ABS_Y] = TPD_RES_Y; tpd->dev->absmin[ABS_Y] = 0; tpd->dev->absmax[ABS_PRESSURE] = 255; tpd->dev->absmin[ABS_PRESSURE] = 0; #else input_set_abs_params(tpd->dev, ABS_X, 0, TPD_RES_X, 0, 0); input_set_abs_params(tpd->dev, ABS_Y, 0, TPD_RES_Y, 0, 0); input_abs_set_res(tpd->dev, ABS_X, TPD_RES_X); input_abs_set_res(tpd->dev, ABS_Y, TPD_RES_Y); input_set_abs_params(tpd->dev, ABS_PRESSURE, 0, 255, 0, 0); #endif if(input_register_device(tpd->dev)) TPD_DMESG("input_register_device failed.(tpd)\n"); else tpd_register_flag = 1; /* init R-Touch */ #if 0 if(touch_type == 0) { g_tpd_drv->tpd_local_init(); } #endif if(g_tpd_drv->tpd_have_button) { tpd_button_init(); } #if 1 // defined (TINNO_ANDROID_S8121) || (TINNO_ANDROID_S9091) if(device_create_file(&pdev->dev, &dev_attr_tpd_fw_version)) { TPD_DMESG("create fw_version file error--Liu\n"); } if(device_create_file(&pdev->dev, &dev_attr_tpd_fw_vendor_info)) { TPD_DMESG("create touch_info file error--Liu\n"); } if(device_create_file(&pdev->dev, &dev_attr_tpd_fw_chip_info)) { TPD_DMESG("create touch_info file error--Liu\n"); } #endif return 0; }
static int rmi_f12_probe(struct rmi_function *fn) { struct f12_data *f12; int retval; struct input_dev *input_dev; struct rmi_device *rmi_dev = fn->rmi_dev; struct rmi_driver_data *driver_data = dev_get_drvdata(&rmi_dev->dev); struct rmi_device_platform_data *pdata = to_rmi_platform_data(rmi_dev); unsigned long input_flags; int res_x, res_y; f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data), GFP_KERNEL); if (!f12) return -ENOMEM; fn->data = f12; retval = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr, &f12->info, sizeof(f12->info)); if (retval < 0) { dev_err(&fn->dev, "Failed to read general info register, code %d\n", retval); goto error_free_data; } if (!f12->info.has_register_descriptors) { dev_err(&fn->dev, "Behavior of F12 without register descriptors is undefined.\n"); retval = -ENODEV; goto error_free_data; } retval = rmi_read_descriptors(fn, &f12->desc, fn->fd.query_base_addr + 1); if (retval) return retval; if (!rmi_has_register(&f12->desc.data, F12_FINGER_DATA_REG)) { dev_err(&fn->dev, "Finger data registers are missing!\n"); retval = -ENODEV; goto error_free_data; } f12->buf_size = rmi_register_size(&f12->desc.data, F12_FINGER_DATA_REG); f12->object_buf = devm_kzalloc(&fn->dev, f12->buf_size * sizeof(u8), GFP_KERNEL); if (!f12->object_buf) { retval = -ENOMEM; goto error_free_data; } f12->max_objects = rmi_register_subpackets(&f12->desc.data, F12_FINGER_DATA_REG); f12->object_address = fn->fd.data_base_addr + rmi_register_offset(&f12->desc.data, F12_FINGER_DATA_REG); f12->has_ACM25 = false; if (rmi_has_register(&f12->desc.data, F12_FINGER_ACM_REG)) { f12->has_ACM25 = true; } #if 1 if (f12->has_ACM25) { pr_debug("acm25 is on\n"); } else { pr_debug("acm25 is off\n"); } #endif read_sensor_tuning(fn); if (f12->info.has_dribble) { enable_dribble(fn); } else { dev_err(&fn->dev, "No dribble support!\n"); } f12->sensor_type = pdata->f12_sensor_data->sensor_type; if (pdata->unified_input_device) { f12->rmi_input = driver_data->rmi_input; input_dev = f12->rmi_input->input_dev; rmi_touchpad_create(f12->rmi_input, f12->max_objects, f12->x_max, f12->y_max); } else { f12->rmi_input = rmi_input_dev_alloc(&rmi_dev->dev, driver_data, "%s/input0", f12); if (f12->rmi_input) { dev_err(&fn->dev, "Error in setting input device.\n"); goto error_free_data; } input_dev = f12->rmi_input->input_dev; } set_bit(EV_SYN, input_dev->evbit); set_bit(EV_ABS, input_dev->evbit); input_set_capability(input_dev, EV_KEY, BTN_TOUCH); if (f12->sensor_type == rmi_sensor_touchpad) input_flags = INPUT_PROP_POINTER; else input_flags = INPUT_PROP_DIRECT; set_bit(input_flags, input_dev->propbit); #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 0)) input_mt_init_slots(input_dev, f12->max_objects, 0); #else input_mt_init_slots(input_dev, f12->max_objects); #endif input_set_abs_params(input_dev, ABS_X, 0, f12->x_max, 0, 0); input_set_abs_params(input_dev, ABS_Y, 0, f12->y_max, 0, 0); input_set_abs_params(input_dev, ABS_PRESSURE, 0, DEFAULT_MAX_ABS_MT_PRESSURE, 0, 0); input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, f12->x_max, 0, 0); input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, f12->y_max, 0, 0); input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, DEFAULT_MAX_ABS_MT_PRESSURE, 0, 0); input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, DEFAULT_MAX_ABS_MT_TOUCH, 0, 0); input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0, DEFAULT_MAX_ABS_MT_TOUCH, 0, 0); input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, DEFAULT_MAX_ABS_MT_ORIENTATION, 0, 0); input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, DEFAULT_MIN_ABS_MT_TRACKING_ID, f12->max_objects, 0, 0); if (pdata->f12_sensor_data->x_mm && pdata->f12_sensor_data->y_mm) { res_x = (f12->x_max - 0) / pdata->f12_sensor_data->x_mm; res_y = (f12->y_max - 0) / pdata->f12_sensor_data->y_mm; input_abs_set_res(input_dev, ABS_X, res_x); input_abs_set_res(input_dev, ABS_Y, res_y); input_abs_set_res(input_dev, ABS_MT_POSITION_X, res_x); input_abs_set_res(input_dev, ABS_MT_POSITION_Y, res_y); } //input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE, // 0, MT_TOOL_MAX, 0, 0); input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE, 0, MT_TOOL_FINGER, 0, 0); if (f12->sensor_type == rmi_sensor_touchpad) { set_bit(EV_KEY, input_dev->evbit); set_bit(BTN_LEFT, input_dev->keybit); set_bit(BTN_TOOL_FINGER, input_dev->keybit); set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit); set_bit(BTN_TOOL_TRIPLETAP, input_dev->keybit); set_bit(BTN_TOOL_QUADTAP, input_dev->keybit); set_bit(BTN_TOOL_QUINTTAP, input_dev->keybit); } if (!pdata->unified_input_device) { retval = rmi_input_dev_register(f12->rmi_input); if (retval < 0) goto error_free_dev; } return 0; error_free_dev: if (!pdata->unified_input_device) rmi_input_dev_free(f12->rmi_input); error_free_data: devm_kfree(&fn->dev, f12->object_buf); devm_kfree(&fn->dev, f12); return retval; }
static int uinput_setup_device(struct uinput_device *udev, const char __user *buffer, size_t count) { struct uinput_user_dev *user_dev; struct input_dev *dev; int i; int retval; size_t size; size = min_t(size_t, count, sizeof(struct uinput_user_dev)); if (!udev->dev) { retval = uinput_allocate_device(udev); if (retval) return retval; } dev = udev->dev; user_dev = kzalloc(sizeof(struct uinput_user_dev), GFP_KERNEL); if (!user_dev) return -ENOMEM; if (copy_from_user(user_dev, buffer, size)) { retval = -EFAULT; goto exit; } udev->ff_effects_max = user_dev->ff_effects_max; /* Ensure name is filled in */ if (!user_dev->name[0]) { retval = -EINVAL; goto exit; } kfree(dev->name); dev->name = kstrndup(user_dev->name, UINPUT_MAX_NAME_SIZE, GFP_KERNEL); if (!dev->name) { retval = -ENOMEM; goto exit; } dev->id.bustype = user_dev->id.bustype; dev->id.vendor = user_dev->id.vendor; dev->id.product = user_dev->id.product; dev->id.version = user_dev->id.version; for (i = 0; i < ABS_CNT; i++) { input_abs_set_max(dev, i, user_dev->absmax[i]); input_abs_set_min(dev, i, user_dev->absmin[i]); input_abs_set_fuzz(dev, i, user_dev->absfuzz[i]); input_abs_set_flat(dev, i, user_dev->absflat[i]); input_abs_set_res(dev, i, user_dev->absres[i]); } /* check if absmin/absmax/absfuzz/absflat are filled as * told in Documentation/input/input-programming.txt */ if (test_bit(EV_ABS, dev->evbit)) { retval = uinput_validate_absbits(dev); if (retval < 0) goto exit; if (test_bit(ABS_MT_SLOT, dev->absbit)) { int nslot = input_abs_get_max(dev, ABS_MT_SLOT) + 1; #ifdef INPUT_MT_POINTER input_mt_init_slots(dev, nslot, 0); #else /* INPUT_MT_POINTER */ input_mt_init_slots(dev, nslot); #endif /* INPUT_MT_POINTER */ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36) } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) { input_set_events_per_packet(dev, 60); #endif /* LINUX_VERSION_CODE >= 2.6.36 */ } } udev->state = UIST_SETUP_COMPLETE; retval = count; exit: kfree(user_dev); return retval; }
/* touch panel probe */ static int tpd_probe(struct platform_device *pdev) { int touch_type = 1; /* 0:R-touch, 1: Cap-touch */ int i = 0; TPD_DMESG("enter %s, %d\n", __func__, __LINE__); /* Select R-Touch */ /* if(g_tpd_drv == NULL||tpd_load_status == 0) */ #if 0 if (g_tpd_drv == NULL) { g_tpd_drv = &tpd_driver_list[0]; /* touch_type:0: r-touch, 1: C-touch */ touch_type = 0; TPD_DMESG("Generic touch panel driver\n"); } #ifdef CONFIG_HAS_EARLYSUSPEND MTK_TS_early_suspend_handler.suspend = g_tpd_drv->suspend; MTK_TS_early_suspend_handler.resume = g_tpd_drv->resume; register_early_suspend(&MTK_TS_early_suspend_handler); #endif #endif if (misc_register(&tpd_misc_device)) { printk("mtk_tpd: tpd_misc_device register failed\n"); } if ((tpd = (struct tpd_device *)kmalloc(sizeof(struct tpd_device), GFP_KERNEL)) == NULL) return -ENOMEM; memset(tpd, 0, sizeof(struct tpd_device)); /* allocate input device */ if ((tpd->dev = input_allocate_device()) == NULL) { kfree(tpd); return -ENOMEM; } /* TPD_RES_X = simple_strtoul(LCM_WIDTH, NULL, 0); */ /* TPD_RES_Y = simple_strtoul(LCM_HEIGHT, NULL, 0); */ #ifdef CONFIG_MTK_LCM_PHYSICAL_ROTATION if(0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "90", 2) || 0 == strncmp(CONFIG_MTK_LCM_PHYSICAL_ROTATION, "270", 3)) { TPD_RES_Y = DISP_GetScreenWidth(); TPD_RES_X = DISP_GetScreenHeight(); } else #endif { #ifdef CONFIG_CUSTOM_LCM_X #ifndef CONFIG_MTK_FPGA TPD_RES_X = DISP_GetScreenWidth(); TPD_RES_Y = DISP_GetScreenHeight(); #endif #else TPD_RES_X = simple_strtoul(CONFIG_LCM_WIDTH, NULL, 0); TPD_RES_Y = simple_strtoul(CONFIG_LCM_HEIGHT, NULL, 0); #endif } printk("mtk_tpd: TPD_RES_X = %d, TPD_RES_Y = %d\n", TPD_RES_X, TPD_RES_Y); tpd_mode = TPD_MODE_NORMAL; tpd_mode_axis = 0; tpd_mode_min = TPD_RES_Y / 2; tpd_mode_max = TPD_RES_Y; tpd_mode_keypad_tolerance = TPD_RES_X * TPD_RES_X / 1600; /* struct input_dev dev initialization and registration */ tpd->dev->name = TPD_DEVICE; set_bit(EV_ABS, tpd->dev->evbit); set_bit(EV_KEY, tpd->dev->evbit); set_bit(ABS_X, tpd->dev->absbit); set_bit(ABS_Y, tpd->dev->absbit); set_bit(ABS_PRESSURE, tpd->dev->absbit); #if !defined(CONFIG_MTK_S3320) && !defined(CONFIG_MTK_S3320_47) && !defined(CONFIG_MTK_S3320_50) && !defined(CONFIG_MTK_MIT200) && !defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S3528) && !defined(CONFIG_MTK_S7020) set_bit(BTN_TOUCH, tpd->dev->keybit); #endif /* CONFIG_MTK_S3320 */ set_bit(INPUT_PROP_DIRECT, tpd->dev->propbit); /* save dev for regulator_get() before tpd_local_init() */ tpd->tpd_dev = &pdev->dev; #if 1 for (i = 1; i < TP_DRV_MAX_COUNT; i++) { /* add tpd driver into list */ if (tpd_driver_list[i].tpd_device_name != NULL) { tpd_driver_list[i].tpd_local_init(); /* msleep(1); */ if (tpd_load_status == 1) { TPD_DMESG("[mtk-tpd]tpd_probe, tpd_driver_name=%s\n", tpd_driver_list[i].tpd_device_name); g_tpd_drv = &tpd_driver_list[i]; break; } } } if (g_tpd_drv == NULL) { if (tpd_driver_list[0].tpd_device_name != NULL) { g_tpd_drv = &tpd_driver_list[0]; /* touch_type:0: r-touch, 1: C-touch */ touch_type = 0; g_tpd_drv->tpd_local_init(); TPD_DMESG("[mtk-tpd]Generic touch panel driver\n"); } else { TPD_DMESG("[mtk-tpd]cap touch and Generic touch both are not loaded!!\n"); return 0; } } #ifdef CONFIG_HAS_EARLYSUSPEND #ifndef CONFIG_MTK_FPGA MTK_TS_early_suspend_handler.suspend = g_tpd_drv->suspend; MTK_TS_early_suspend_handler.resume = g_tpd_drv->resume; #ifdef CONFIG_EARLYSUSPEND register_early_suspend(&MTK_TS_early_suspend_handler); #endif #endif #endif #endif /* #ifdef TPD_TYPE_CAPACITIVE */ /* TPD_TYPE_CAPACITIVE handle */ if (touch_type == 1) { set_bit(ABS_MT_TRACKING_ID, tpd->dev->absbit); set_bit(ABS_MT_TOUCH_MAJOR, tpd->dev->absbit); set_bit(ABS_MT_TOUCH_MINOR, tpd->dev->absbit); set_bit(ABS_MT_POSITION_X, tpd->dev->absbit); set_bit(ABS_MT_POSITION_Y, tpd->dev->absbit); #if 0 /* linux kernel update from 2.6.35 --> 3.0 */ tpd->dev->absmax[ABS_MT_POSITION_X] = TPD_RES_X; tpd->dev->absmin[ABS_MT_POSITION_X] = 0; tpd->dev->absmax[ABS_MT_POSITION_Y] = TPD_RES_Y; tpd->dev->absmin[ABS_MT_POSITION_Y] = 0; tpd->dev->absmax[ABS_MT_TOUCH_MAJOR] = 100; tpd->dev->absmin[ABS_MT_TOUCH_MINOR] = 0; #else input_set_abs_params(tpd->dev, ABS_MT_POSITION_X, 0, TPD_RES_X, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_POSITION_Y, 0, TPD_RES_Y, 0, 0); #if defined(CONFIG_MTK_S3320) || defined(CONFIG_MTK_S3320_47) || defined(CONFIG_MTK_S3320_50) || defined(CONFIG_MTK_MIT200) || defined(CONFIG_TOUCHSCREEN_SYNAPTICS_S3528) || defined(CONFIG_MTK_S7020) input_set_abs_params(tpd->dev, ABS_MT_PRESSURE, 0, 255, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MAJOR, 0, 15, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_WIDTH_MINOR, 0, 15, 0, 0); input_mt_init_slots(tpd->dev, 10, 0); #else input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MAJOR, 0, 100, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_TOUCH_MINOR, 0, 100, 0, 0); #endif /* CONFIG_MTK_S3320 */ #endif TPD_DMESG("Cap touch panel driver\n"); } /* #endif */ #if 0 /* linux kernel update from 2.6.35 --> 3.0 */ tpd->dev->absmax[ABS_X] = TPD_RES_X; tpd->dev->absmin[ABS_X] = 0; tpd->dev->absmax[ABS_Y] = TPD_RES_Y; tpd->dev->absmin[ABS_Y] = 0; tpd->dev->absmax[ABS_PRESSURE] = 255; tpd->dev->absmin[ABS_PRESSURE] = 0; #else input_set_abs_params(tpd->dev, ABS_X, 0, TPD_RES_X, 0, 0); input_set_abs_params(tpd->dev, ABS_Y, 0, TPD_RES_Y, 0, 0); input_abs_set_res(tpd->dev, ABS_X, TPD_RES_X); input_abs_set_res(tpd->dev, ABS_Y, TPD_RES_Y); input_set_abs_params(tpd->dev, ABS_PRESSURE, 0, 255, 0, 0); input_set_abs_params(tpd->dev, ABS_MT_TRACKING_ID, 0, 10, 0, 0); #endif if (input_register_device(tpd->dev)) TPD_DMESG("input_register_device failed.(tpd)\n"); else tpd_register_flag = 1; /* init R-Touch */ #if 0 if (touch_type == 0) { g_tpd_drv->tpd_local_init(); } #endif if (g_tpd_drv->tpd_have_button) { tpd_button_init(); } if (g_tpd_drv->attrs.num) tpd_create_attributes(&pdev->dev, &g_tpd_drv->attrs); return 0; }