| /* drivers/input/keyboard/synaptics_i2c_rmi.c |
| * |
| * Copyright (C) 2007 Google, Inc. |
| * |
| * This software is licensed under the terms of the GNU General Public |
| * License version 2, as published by the Free Software Foundation, and |
| * may be copied, distributed, and modified under those terms. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/delay.h> |
| #include <linux/earlysuspend.h> |
| #include <linux/hrtimer.h> |
| #include <linux/i2c.h> |
| #include <linux/input.h> |
| #include <linux/interrupt.h> |
| #include <linux/io.h> |
| #include <linux/platform_device.h> |
| #include <linux/slab.h> |
| #include <linux/synaptics_i2c_rmi.h> |
| |
| static struct workqueue_struct *synaptics_wq; |
| |
| struct synaptics_ts_data { |
| uint16_t addr; |
| struct i2c_client *client; |
| struct input_dev *input_dev; |
| int use_irq; |
| bool has_relative_report; |
| struct hrtimer timer; |
| struct work_struct work; |
| uint16_t max[2]; |
| int snap_state[2][2]; |
| int snap_down_on[2]; |
| int snap_down_off[2]; |
| int snap_up_on[2]; |
| int snap_up_off[2]; |
| int snap_down[2]; |
| int snap_up[2]; |
| uint32_t flags; |
| int reported_finger_count; |
| int8_t sensitivity_adjust; |
| int (*power)(int on); |
| struct early_suspend early_suspend; |
| }; |
| |
| #ifdef CONFIG_HAS_EARLYSUSPEND |
| static void synaptics_ts_early_suspend(struct early_suspend *h); |
| static void synaptics_ts_late_resume(struct early_suspend *h); |
| #endif |
| |
| static int synaptics_init_panel(struct synaptics_ts_data *ts) |
| { |
| int ret; |
| |
| ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x10); /* page select = 0x10 */ |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n"); |
| goto err_page_select_failed; |
| } |
| ret = i2c_smbus_write_byte_data(ts->client, 0x41, 0x04); /* Set "No Clip Z" */ |
| if (ret < 0) |
| printk(KERN_ERR "i2c_smbus_write_byte_data failed for No Clip Z\n"); |
| |
| ret = i2c_smbus_write_byte_data(ts->client, 0x44, |
| ts->sensitivity_adjust); |
| if (ret < 0) |
| pr_err("synaptics_ts: failed to set Sensitivity Adjust\n"); |
| |
| err_page_select_failed: |
| ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x04); /* page select = 0x04 */ |
| if (ret < 0) |
| printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n"); |
| ret = i2c_smbus_write_byte_data(ts->client, 0xf0, 0x81); /* normal operation, 80 reports per second */ |
| if (ret < 0) |
| printk(KERN_ERR "synaptics_ts_resume: i2c_smbus_write_byte_data failed\n"); |
| return ret; |
| } |
| |
| static void synaptics_ts_work_func(struct work_struct *work) |
| { |
| int i; |
| int ret; |
| int bad_data = 0; |
| struct i2c_msg msg[2]; |
| uint8_t start_reg; |
| uint8_t buf[15]; |
| struct synaptics_ts_data *ts = container_of(work, struct synaptics_ts_data, work); |
| int buf_len = ts->has_relative_report ? 15 : 13; |
| |
| msg[0].addr = ts->client->addr; |
| msg[0].flags = 0; |
| msg[0].len = 1; |
| msg[0].buf = &start_reg; |
| start_reg = 0x00; |
| msg[1].addr = ts->client->addr; |
| msg[1].flags = I2C_M_RD; |
| msg[1].len = buf_len; |
| msg[1].buf = buf; |
| |
| /* printk("synaptics_ts_work_func\n"); */ |
| for (i = 0; i < ((ts->use_irq && !bad_data) ? 1 : 10); i++) { |
| ret = i2c_transfer(ts->client->adapter, msg, 2); |
| if (ret < 0) { |
| printk(KERN_ERR "synaptics_ts_work_func: i2c_transfer failed\n"); |
| bad_data = 1; |
| } else { |
| /* printk("synaptics_ts_work_func: %x %x %x %x %x %x" */ |
| /* " %x %x %x %x %x %x %x %x %x, ret %d\n", */ |
| /* buf[0], buf[1], buf[2], buf[3], */ |
| /* buf[4], buf[5], buf[6], buf[7], */ |
| /* buf[8], buf[9], buf[10], buf[11], */ |
| /* buf[12], buf[13], buf[14], ret); */ |
| if ((buf[buf_len - 1] & 0xc0) != 0x40) { |
| printk(KERN_WARNING "synaptics_ts_work_func:" |
| " bad read %x %x %x %x %x %x %x %x %x" |
| " %x %x %x %x %x %x, ret %d\n", |
| buf[0], buf[1], buf[2], buf[3], |
| buf[4], buf[5], buf[6], buf[7], |
| buf[8], buf[9], buf[10], buf[11], |
| buf[12], buf[13], buf[14], ret); |
| if (bad_data) |
| synaptics_init_panel(ts); |
| bad_data = 1; |
| continue; |
| } |
| bad_data = 0; |
| if ((buf[buf_len - 1] & 1) == 0) { |
| /* printk("read %d coordinates\n", i); */ |
| break; |
| } else { |
| int pos[2][2]; |
| int f, a; |
| int base; |
| /* int x = buf[3] | (uint16_t)(buf[2] & 0x1f) << 8; */ |
| /* int y = buf[5] | (uint16_t)(buf[4] & 0x1f) << 8; */ |
| int z = buf[1]; |
| int w = buf[0] >> 4; |
| int finger = buf[0] & 7; |
| |
| /* int x2 = buf[3+6] | (uint16_t)(buf[2+6] & 0x1f) << 8; */ |
| /* int y2 = buf[5+6] | (uint16_t)(buf[4+6] & 0x1f) << 8; */ |
| /* int z2 = buf[1+6]; */ |
| /* int w2 = buf[0+6] >> 4; */ |
| /* int finger2 = buf[0+6] & 7; */ |
| |
| /* int dx = (int8_t)buf[12]; */ |
| /* int dy = (int8_t)buf[13]; */ |
| int finger2_pressed; |
| |
| /* printk("x %4d, y %4d, z %3d, w %2d, F %d, 2nd: x %4d, y %4d, z %3d, w %2d, F %d, dx %4d, dy %4d\n", */ |
| /* x, y, z, w, finger, */ |
| /* x2, y2, z2, w2, finger2, */ |
| /* dx, dy); */ |
| |
| base = 2; |
| for (f = 0; f < 2; f++) { |
| uint32_t flip_flag = SYNAPTICS_FLIP_X; |
| for (a = 0; a < 2; a++) { |
| int p = buf[base + 1]; |
| p |= (uint16_t)(buf[base] & 0x1f) << 8; |
| if (ts->flags & flip_flag) |
| p = ts->max[a] - p; |
| if (ts->flags & SYNAPTICS_SNAP_TO_INACTIVE_EDGE) { |
| if (ts->snap_state[f][a]) { |
| if (p <= ts->snap_down_off[a]) |
| p = ts->snap_down[a]; |
| else if (p >= ts->snap_up_off[a]) |
| p = ts->snap_up[a]; |
| else |
| ts->snap_state[f][a] = 0; |
| } else { |
| if (p <= ts->snap_down_on[a]) { |
| p = ts->snap_down[a]; |
| ts->snap_state[f][a] = 1; |
| } else if (p >= ts->snap_up_on[a]) { |
| p = ts->snap_up[a]; |
| ts->snap_state[f][a] = 1; |
| } |
| } |
| } |
| pos[f][a] = p; |
| base += 2; |
| flip_flag <<= 1; |
| } |
| base += 2; |
| if (ts->flags & SYNAPTICS_SWAP_XY) |
| swap(pos[f][0], pos[f][1]); |
| } |
| if (z) { |
| input_report_abs(ts->input_dev, ABS_X, pos[0][0]); |
| input_report_abs(ts->input_dev, ABS_Y, pos[0][1]); |
| } |
| input_report_abs(ts->input_dev, ABS_PRESSURE, z); |
| input_report_abs(ts->input_dev, ABS_TOOL_WIDTH, w); |
| input_report_key(ts->input_dev, BTN_TOUCH, finger); |
| finger2_pressed = finger > 1 && finger != 7; |
| input_report_key(ts->input_dev, BTN_2, finger2_pressed); |
| if (finger2_pressed) { |
| input_report_abs(ts->input_dev, ABS_HAT0X, pos[1][0]); |
| input_report_abs(ts->input_dev, ABS_HAT0Y, pos[1][1]); |
| } |
| |
| if (!finger) |
| z = 0; |
| input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, z); |
| input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, w); |
| input_report_abs(ts->input_dev, ABS_MT_POSITION_X, pos[0][0]); |
| input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, pos[0][1]); |
| input_mt_sync(ts->input_dev); |
| if (finger2_pressed) { |
| input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, z); |
| input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, w); |
| input_report_abs(ts->input_dev, ABS_MT_POSITION_X, pos[1][0]); |
| input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, pos[1][1]); |
| input_mt_sync(ts->input_dev); |
| } else if (ts->reported_finger_count > 1) { |
| input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0); |
| input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0); |
| input_mt_sync(ts->input_dev); |
| } |
| ts->reported_finger_count = finger; |
| input_sync(ts->input_dev); |
| } |
| } |
| } |
| if (ts->use_irq) |
| enable_irq(ts->client->irq); |
| } |
| |
| static enum hrtimer_restart synaptics_ts_timer_func(struct hrtimer *timer) |
| { |
| struct synaptics_ts_data *ts = container_of(timer, struct synaptics_ts_data, timer); |
| /* printk("synaptics_ts_timer_func\n"); */ |
| |
| queue_work(synaptics_wq, &ts->work); |
| |
| hrtimer_start(&ts->timer, ktime_set(0, 12500000), HRTIMER_MODE_REL); |
| return HRTIMER_NORESTART; |
| } |
| |
| static irqreturn_t synaptics_ts_irq_handler(int irq, void *dev_id) |
| { |
| struct synaptics_ts_data *ts = dev_id; |
| |
| /* printk("synaptics_ts_irq_handler\n"); */ |
| disable_irq_nosync(ts->client->irq); |
| queue_work(synaptics_wq, &ts->work); |
| return IRQ_HANDLED; |
| } |
| |
| static int synaptics_ts_probe( |
| struct i2c_client *client, const struct i2c_device_id *id) |
| { |
| struct synaptics_ts_data *ts; |
| uint8_t buf0[4]; |
| uint8_t buf1[8]; |
| struct i2c_msg msg[2]; |
| int ret = 0; |
| uint16_t max_x, max_y; |
| int fuzz_x, fuzz_y, fuzz_p, fuzz_w; |
| struct synaptics_i2c_rmi_platform_data *pdata; |
| int inactive_area_left; |
| int inactive_area_right; |
| int inactive_area_top; |
| int inactive_area_bottom; |
| int snap_left_on; |
| int snap_left_off; |
| int snap_right_on; |
| int snap_right_off; |
| int snap_top_on; |
| int snap_top_off; |
| int snap_bottom_on; |
| int snap_bottom_off; |
| uint32_t panel_version; |
| |
| if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { |
| printk(KERN_ERR "synaptics_ts_probe: need I2C_FUNC_I2C\n"); |
| ret = -ENODEV; |
| goto err_check_functionality_failed; |
| } |
| |
| ts = kzalloc(sizeof(*ts), GFP_KERNEL); |
| if (ts == NULL) { |
| ret = -ENOMEM; |
| goto err_alloc_data_failed; |
| } |
| INIT_WORK(&ts->work, synaptics_ts_work_func); |
| ts->client = client; |
| i2c_set_clientdata(client, ts); |
| pdata = client->dev.platform_data; |
| if (pdata) |
| ts->power = pdata->power; |
| if (ts->power) { |
| ret = ts->power(1); |
| if (ret < 0) { |
| printk(KERN_ERR "synaptics_ts_probe power on failed\n"); |
| goto err_power_failed; |
| } |
| } |
| |
| ret = i2c_smbus_write_byte_data(ts->client, 0xf4, 0x01); /* device command = reset */ |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_write_byte_data failed\n"); |
| /* fail? */ |
| } |
| { |
| int retry = 10; |
| while (retry-- > 0) { |
| ret = i2c_smbus_read_byte_data(ts->client, 0xe4); |
| if (ret >= 0) |
| break; |
| msleep(100); |
| } |
| } |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_read_byte_data failed\n"); |
| goto err_detect_failed; |
| } |
| printk(KERN_INFO "synaptics_ts_probe: Product Major Version %x\n", ret); |
| panel_version = ret << 8; |
| ret = i2c_smbus_read_byte_data(ts->client, 0xe5); |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_read_byte_data failed\n"); |
| goto err_detect_failed; |
| } |
| printk(KERN_INFO "synaptics_ts_probe: Product Minor Version %x\n", ret); |
| panel_version |= ret; |
| |
| ret = i2c_smbus_read_byte_data(ts->client, 0xe3); |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_read_byte_data failed\n"); |
| goto err_detect_failed; |
| } |
| printk(KERN_INFO "synaptics_ts_probe: product property %x\n", ret); |
| |
| if (pdata) { |
| while (pdata->version > panel_version) |
| pdata++; |
| ts->flags = pdata->flags; |
| ts->sensitivity_adjust = pdata->sensitivity_adjust; |
| inactive_area_left = pdata->inactive_left; |
| inactive_area_right = pdata->inactive_right; |
| inactive_area_top = pdata->inactive_top; |
| inactive_area_bottom = pdata->inactive_bottom; |
| snap_left_on = pdata->snap_left_on; |
| snap_left_off = pdata->snap_left_off; |
| snap_right_on = pdata->snap_right_on; |
| snap_right_off = pdata->snap_right_off; |
| snap_top_on = pdata->snap_top_on; |
| snap_top_off = pdata->snap_top_off; |
| snap_bottom_on = pdata->snap_bottom_on; |
| snap_bottom_off = pdata->snap_bottom_off; |
| fuzz_x = pdata->fuzz_x; |
| fuzz_y = pdata->fuzz_y; |
| fuzz_p = pdata->fuzz_p; |
| fuzz_w = pdata->fuzz_w; |
| } else { |
| inactive_area_left = 0; |
| inactive_area_right = 0; |
| inactive_area_top = 0; |
| inactive_area_bottom = 0; |
| snap_left_on = 0; |
| snap_left_off = 0; |
| snap_right_on = 0; |
| snap_right_off = 0; |
| snap_top_on = 0; |
| snap_top_off = 0; |
| snap_bottom_on = 0; |
| snap_bottom_off = 0; |
| fuzz_x = 0; |
| fuzz_y = 0; |
| fuzz_p = 0; |
| fuzz_w = 0; |
| } |
| |
| ret = i2c_smbus_read_byte_data(ts->client, 0xf0); |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_read_byte_data failed\n"); |
| goto err_detect_failed; |
| } |
| printk(KERN_INFO "synaptics_ts_probe: device control %x\n", ret); |
| |
| ret = i2c_smbus_read_byte_data(ts->client, 0xf1); |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_read_byte_data failed\n"); |
| goto err_detect_failed; |
| } |
| printk(KERN_INFO "synaptics_ts_probe: interrupt enable %x\n", ret); |
| |
| ret = i2c_smbus_write_byte_data(ts->client, 0xf1, 0); /* disable interrupt */ |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_write_byte_data failed\n"); |
| goto err_detect_failed; |
| } |
| |
| msg[0].addr = ts->client->addr; |
| msg[0].flags = 0; |
| msg[0].len = 1; |
| msg[0].buf = buf0; |
| buf0[0] = 0xe0; |
| msg[1].addr = ts->client->addr; |
| msg[1].flags = I2C_M_RD; |
| msg[1].len = 8; |
| msg[1].buf = buf1; |
| ret = i2c_transfer(ts->client->adapter, msg, 2); |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_transfer failed\n"); |
| goto err_detect_failed; |
| } |
| printk(KERN_INFO "synaptics_ts_probe: 0xe0: %x %x %x %x %x %x %x %x\n", |
| buf1[0], buf1[1], buf1[2], buf1[3], |
| buf1[4], buf1[5], buf1[6], buf1[7]); |
| |
| ret = i2c_smbus_write_byte_data(ts->client, 0xff, 0x10); /* page select = 0x10 */ |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_write_byte_data failed for page select\n"); |
| goto err_detect_failed; |
| } |
| ret = i2c_smbus_read_word_data(ts->client, 0x02); |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_read_word_data failed\n"); |
| goto err_detect_failed; |
| } |
| ts->has_relative_report = !(ret & 0x100); |
| printk(KERN_INFO "synaptics_ts_probe: Sensor properties %x\n", ret); |
| ret = i2c_smbus_read_word_data(ts->client, 0x04); |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_read_word_data failed\n"); |
| goto err_detect_failed; |
| } |
| ts->max[0] = max_x = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8); |
| ret = i2c_smbus_read_word_data(ts->client, 0x06); |
| if (ret < 0) { |
| printk(KERN_ERR "i2c_smbus_read_word_data failed\n"); |
| goto err_detect_failed; |
| } |
| ts->max[1] = max_y = (ret >> 8 & 0xff) | ((ret & 0x1f) << 8); |
| if (ts->flags & SYNAPTICS_SWAP_XY) |
| swap(max_x, max_y); |
| |
| ret = synaptics_init_panel(ts); /* will also switch back to page 0x04 */ |
| if (ret < 0) { |
| printk(KERN_ERR "synaptics_init_panel failed\n"); |
| goto err_detect_failed; |
| } |
| |
| ts->input_dev = input_allocate_device(); |
| if (ts->input_dev == NULL) { |
| ret = -ENOMEM; |
| printk(KERN_ERR "synaptics_ts_probe: Failed to allocate input device\n"); |
| goto err_input_dev_alloc_failed; |
| } |
| ts->input_dev->name = "synaptics-rmi-touchscreen"; |
| set_bit(EV_SYN, ts->input_dev->evbit); |
| set_bit(EV_KEY, ts->input_dev->evbit); |
| set_bit(BTN_TOUCH, ts->input_dev->keybit); |
| set_bit(BTN_2, ts->input_dev->keybit); |
| set_bit(EV_ABS, ts->input_dev->evbit); |
| inactive_area_left = inactive_area_left * max_x / 0x10000; |
| inactive_area_right = inactive_area_right * max_x / 0x10000; |
| inactive_area_top = inactive_area_top * max_y / 0x10000; |
| inactive_area_bottom = inactive_area_bottom * max_y / 0x10000; |
| snap_left_on = snap_left_on * max_x / 0x10000; |
| snap_left_off = snap_left_off * max_x / 0x10000; |
| snap_right_on = snap_right_on * max_x / 0x10000; |
| snap_right_off = snap_right_off * max_x / 0x10000; |
| snap_top_on = snap_top_on * max_y / 0x10000; |
| snap_top_off = snap_top_off * max_y / 0x10000; |
| snap_bottom_on = snap_bottom_on * max_y / 0x10000; |
| snap_bottom_off = snap_bottom_off * max_y / 0x10000; |
| fuzz_x = fuzz_x * max_x / 0x10000; |
| fuzz_y = fuzz_y * max_y / 0x10000; |
| ts->snap_down[!!(ts->flags & SYNAPTICS_SWAP_XY)] = -inactive_area_left; |
| ts->snap_up[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x + inactive_area_right; |
| ts->snap_down[!(ts->flags & SYNAPTICS_SWAP_XY)] = -inactive_area_top; |
| ts->snap_up[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y + inactive_area_bottom; |
| ts->snap_down_on[!!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_left_on; |
| ts->snap_down_off[!!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_left_off; |
| ts->snap_up_on[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x - snap_right_on; |
| ts->snap_up_off[!!(ts->flags & SYNAPTICS_SWAP_XY)] = max_x - snap_right_off; |
| ts->snap_down_on[!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_top_on; |
| ts->snap_down_off[!(ts->flags & SYNAPTICS_SWAP_XY)] = snap_top_off; |
| ts->snap_up_on[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y - snap_bottom_on; |
| ts->snap_up_off[!(ts->flags & SYNAPTICS_SWAP_XY)] = max_y - snap_bottom_off; |
| printk(KERN_INFO "synaptics_ts_probe: max_x %d, max_y %d\n", max_x, max_y); |
| printk(KERN_INFO "synaptics_ts_probe: inactive_x %d %d, inactive_y %d %d\n", |
| inactive_area_left, inactive_area_right, |
| inactive_area_top, inactive_area_bottom); |
| printk(KERN_INFO "synaptics_ts_probe: snap_x %d-%d %d-%d, snap_y %d-%d %d-%d\n", |
| snap_left_on, snap_left_off, snap_right_on, snap_right_off, |
| snap_top_on, snap_top_off, snap_bottom_on, snap_bottom_off); |
| input_set_abs_params(ts->input_dev, ABS_X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0); |
| input_set_abs_params(ts->input_dev, ABS_Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0); |
| input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, fuzz_p, 0); |
| input_set_abs_params(ts->input_dev, ABS_TOOL_WIDTH, 0, 15, fuzz_w, 0); |
| input_set_abs_params(ts->input_dev, ABS_HAT0X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0); |
| input_set_abs_params(ts->input_dev, ABS_HAT0Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0); |
| input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, -inactive_area_left, max_x + inactive_area_right, fuzz_x, 0); |
| input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, -inactive_area_top, max_y + inactive_area_bottom, fuzz_y, 0); |
| input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, fuzz_p, 0); |
| input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 15, fuzz_w, 0); |
| /* ts->input_dev->name = ts->keypad_info->name; */ |
| ret = input_register_device(ts->input_dev); |
| if (ret) { |
| printk(KERN_ERR "synaptics_ts_probe: Unable to register %s input device\n", ts->input_dev->name); |
| goto err_input_register_device_failed; |
| } |
| if (client->irq) { |
| ret = request_irq(client->irq, synaptics_ts_irq_handler, 0, client->name, ts); |
| if (ret == 0) { |
| ret = i2c_smbus_write_byte_data(ts->client, 0xf1, 0x01); /* enable abs int */ |
| if (ret) |
| free_irq(client->irq, ts); |
| } |
| if (ret == 0) |
| ts->use_irq = 1; |
| else |
| dev_err(&client->dev, "request_irq failed\n"); |
| } |
| if (!ts->use_irq) { |
| hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); |
| ts->timer.function = synaptics_ts_timer_func; |
| hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL); |
| } |
| #ifdef CONFIG_HAS_EARLYSUSPEND |
| ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; |
| ts->early_suspend.suspend = synaptics_ts_early_suspend; |
| ts->early_suspend.resume = synaptics_ts_late_resume; |
| register_early_suspend(&ts->early_suspend); |
| #endif |
| |
| printk(KERN_INFO "synaptics_ts_probe: Start touchscreen %s in %s mode\n", ts->input_dev->name, ts->use_irq ? "interrupt" : "polling"); |
| |
| return 0; |
| |
| err_input_register_device_failed: |
| input_free_device(ts->input_dev); |
| |
| err_input_dev_alloc_failed: |
| err_detect_failed: |
| err_power_failed: |
| kfree(ts); |
| err_alloc_data_failed: |
| err_check_functionality_failed: |
| return ret; |
| } |
| |
| static int synaptics_ts_remove(struct i2c_client *client) |
| { |
| struct synaptics_ts_data *ts = i2c_get_clientdata(client); |
| unregister_early_suspend(&ts->early_suspend); |
| if (ts->use_irq) |
| free_irq(client->irq, ts); |
| else |
| hrtimer_cancel(&ts->timer); |
| input_unregister_device(ts->input_dev); |
| kfree(ts); |
| return 0; |
| } |
| |
| static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg) |
| { |
| int ret; |
| struct synaptics_ts_data *ts = i2c_get_clientdata(client); |
| |
| if (ts->use_irq) |
| disable_irq(client->irq); |
| else |
| hrtimer_cancel(&ts->timer); |
| ret = cancel_work_sync(&ts->work); |
| if (ret && ts->use_irq) /* if work was pending disable-count is now 2 */ |
| enable_irq(client->irq); |
| ret = i2c_smbus_write_byte_data(ts->client, 0xf1, 0); /* disable interrupt */ |
| if (ret < 0) |
| printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed\n"); |
| |
| ret = i2c_smbus_write_byte_data(client, 0xf0, 0x86); /* deep sleep */ |
| if (ret < 0) |
| printk(KERN_ERR "synaptics_ts_suspend: i2c_smbus_write_byte_data failed\n"); |
| if (ts->power) { |
| ret = ts->power(0); |
| if (ret < 0) |
| printk(KERN_ERR "synaptics_ts_resume power off failed\n"); |
| } |
| return 0; |
| } |
| |
| static int synaptics_ts_resume(struct i2c_client *client) |
| { |
| int ret; |
| struct synaptics_ts_data *ts = i2c_get_clientdata(client); |
| |
| if (ts->power) { |
| ret = ts->power(1); |
| if (ret < 0) |
| printk(KERN_ERR "synaptics_ts_resume power on failed\n"); |
| } |
| |
| synaptics_init_panel(ts); |
| |
| if (ts->use_irq) |
| enable_irq(client->irq); |
| |
| if (!ts->use_irq) |
| hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL); |
| else |
| i2c_smbus_write_byte_data(ts->client, 0xf1, 0x01); /* enable abs int */ |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_HAS_EARLYSUSPEND |
| static void synaptics_ts_early_suspend(struct early_suspend *h) |
| { |
| struct synaptics_ts_data *ts; |
| ts = container_of(h, struct synaptics_ts_data, early_suspend); |
| synaptics_ts_suspend(ts->client, PMSG_SUSPEND); |
| } |
| |
| static void synaptics_ts_late_resume(struct early_suspend *h) |
| { |
| struct synaptics_ts_data *ts; |
| ts = container_of(h, struct synaptics_ts_data, early_suspend); |
| synaptics_ts_resume(ts->client); |
| } |
| #endif |
| |
| static const struct i2c_device_id synaptics_ts_id[] = { |
| { SYNAPTICS_I2C_RMI_NAME, 0 }, |
| { } |
| }; |
| |
| static struct i2c_driver synaptics_ts_driver = { |
| .probe = synaptics_ts_probe, |
| .remove = synaptics_ts_remove, |
| #ifndef CONFIG_HAS_EARLYSUSPEND |
| .suspend = synaptics_ts_suspend, |
| .resume = synaptics_ts_resume, |
| #endif |
| .id_table = synaptics_ts_id, |
| .driver = { |
| .name = SYNAPTICS_I2C_RMI_NAME, |
| }, |
| }; |
| |
| static int __devinit synaptics_ts_init(void) |
| { |
| synaptics_wq = create_singlethread_workqueue("synaptics_wq"); |
| if (!synaptics_wq) |
| return -ENOMEM; |
| return i2c_add_driver(&synaptics_ts_driver); |
| } |
| |
| static void __exit synaptics_ts_exit(void) |
| { |
| i2c_del_driver(&synaptics_ts_driver); |
| if (synaptics_wq) |
| destroy_workqueue(synaptics_wq); |
| } |
| |
| module_init(synaptics_ts_init); |
| module_exit(synaptics_ts_exit); |
| |
| MODULE_DESCRIPTION("Synaptics Touchscreen Driver"); |
| MODULE_LICENSE("GPL"); |