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