Commit | Line | Data |
---|---|---|
eef3e4ca MR |
1 | /* |
2 | * Synaptics touchpad with I2C interface | |
3 | * | |
4 | * Copyright (C) 2009 Compulab, Ltd. | |
5 | * Mike Rapoport <mike@compulab.co.il> | |
6 | * Igor Grinberg <grinberg@compulab.co.il> | |
7 | * | |
8 | * This file is subject to the terms and conditions of the GNU General Public | |
9 | * License. See the file COPYING in the main directory of this archive for | |
10 | * more details. | |
11 | */ | |
12 | ||
13 | #include <linux/module.h> | |
14 | #include <linux/i2c.h> | |
15 | #include <linux/irq.h> | |
16 | #include <linux/interrupt.h> | |
17 | #include <linux/input.h> | |
18 | #include <linux/delay.h> | |
19 | #include <linux/workqueue.h> | |
5a0e3ad6 | 20 | #include <linux/slab.h> |
87b2c7df | 21 | #include <linux/pm.h> |
eef3e4ca MR |
22 | |
23 | #define DRIVER_NAME "synaptics_i2c" | |
24 | /* maximum product id is 15 characters */ | |
25 | #define PRODUCT_ID_LENGTH 15 | |
26 | #define REGISTER_LENGTH 8 | |
27 | ||
28 | /* | |
29 | * after soft reset, we should wait for 1 ms | |
30 | * before the device becomes operational | |
31 | */ | |
32 | #define SOFT_RESET_DELAY_MS 3 | |
33 | /* and after hard reset, we should wait for max 500ms */ | |
34 | #define HARD_RESET_DELAY_MS 500 | |
35 | ||
36 | /* Registers by SMBus address */ | |
37 | #define PAGE_SEL_REG 0xff | |
38 | #define DEVICE_STATUS_REG 0x09 | |
39 | ||
40 | /* Registers by RMI address */ | |
41 | #define DEV_CONTROL_REG 0x0000 | |
42 | #define INTERRUPT_EN_REG 0x0001 | |
43 | #define ERR_STAT_REG 0x0002 | |
44 | #define INT_REQ_STAT_REG 0x0003 | |
45 | #define DEV_COMMAND_REG 0x0004 | |
46 | ||
47 | #define RMI_PROT_VER_REG 0x0200 | |
48 | #define MANUFACT_ID_REG 0x0201 | |
49 | #define PHYS_INT_VER_REG 0x0202 | |
50 | #define PROD_PROPERTY_REG 0x0203 | |
51 | #define INFO_QUERY_REG0 0x0204 | |
52 | #define INFO_QUERY_REG1 (INFO_QUERY_REG0 + 1) | |
53 | #define INFO_QUERY_REG2 (INFO_QUERY_REG0 + 2) | |
54 | #define INFO_QUERY_REG3 (INFO_QUERY_REG0 + 3) | |
55 | ||
56 | #define PRODUCT_ID_REG0 0x0210 | |
57 | #define PRODUCT_ID_REG1 (PRODUCT_ID_REG0 + 1) | |
58 | #define PRODUCT_ID_REG2 (PRODUCT_ID_REG0 + 2) | |
59 | #define PRODUCT_ID_REG3 (PRODUCT_ID_REG0 + 3) | |
60 | #define PRODUCT_ID_REG4 (PRODUCT_ID_REG0 + 4) | |
61 | #define PRODUCT_ID_REG5 (PRODUCT_ID_REG0 + 5) | |
62 | #define PRODUCT_ID_REG6 (PRODUCT_ID_REG0 + 6) | |
63 | #define PRODUCT_ID_REG7 (PRODUCT_ID_REG0 + 7) | |
64 | #define PRODUCT_ID_REG8 (PRODUCT_ID_REG0 + 8) | |
65 | #define PRODUCT_ID_REG9 (PRODUCT_ID_REG0 + 9) | |
66 | #define PRODUCT_ID_REG10 (PRODUCT_ID_REG0 + 10) | |
67 | #define PRODUCT_ID_REG11 (PRODUCT_ID_REG0 + 11) | |
68 | #define PRODUCT_ID_REG12 (PRODUCT_ID_REG0 + 12) | |
69 | #define PRODUCT_ID_REG13 (PRODUCT_ID_REG0 + 13) | |
70 | #define PRODUCT_ID_REG14 (PRODUCT_ID_REG0 + 14) | |
71 | #define PRODUCT_ID_REG15 (PRODUCT_ID_REG0 + 15) | |
72 | ||
73 | #define DATA_REG0 0x0400 | |
74 | #define ABS_PRESSURE_REG 0x0401 | |
75 | #define ABS_MSB_X_REG 0x0402 | |
76 | #define ABS_LSB_X_REG (ABS_MSB_X_REG + 1) | |
77 | #define ABS_MSB_Y_REG 0x0404 | |
78 | #define ABS_LSB_Y_REG (ABS_MSB_Y_REG + 1) | |
79 | #define REL_X_REG 0x0406 | |
80 | #define REL_Y_REG 0x0407 | |
81 | ||
82 | #define DEV_QUERY_REG0 0x1000 | |
83 | #define DEV_QUERY_REG1 (DEV_QUERY_REG0 + 1) | |
84 | #define DEV_QUERY_REG2 (DEV_QUERY_REG0 + 2) | |
85 | #define DEV_QUERY_REG3 (DEV_QUERY_REG0 + 3) | |
86 | #define DEV_QUERY_REG4 (DEV_QUERY_REG0 + 4) | |
87 | #define DEV_QUERY_REG5 (DEV_QUERY_REG0 + 5) | |
88 | #define DEV_QUERY_REG6 (DEV_QUERY_REG0 + 6) | |
89 | #define DEV_QUERY_REG7 (DEV_QUERY_REG0 + 7) | |
90 | #define DEV_QUERY_REG8 (DEV_QUERY_REG0 + 8) | |
91 | ||
92 | #define GENERAL_2D_CONTROL_REG 0x1041 | |
93 | #define SENSOR_SENSITIVITY_REG 0x1044 | |
94 | #define SENS_MAX_POS_MSB_REG 0x1046 | |
95 | #define SENS_MAX_POS_LSB_REG (SENS_MAX_POS_UPPER_REG + 1) | |
96 | ||
97 | /* Register bits */ | |
98 | /* Device Control Register Bits */ | |
99 | #define REPORT_RATE_1ST_BIT 6 | |
100 | ||
101 | /* Interrupt Enable Register Bits (INTERRUPT_EN_REG) */ | |
102 | #define F10_ABS_INT_ENA 0 | |
103 | #define F10_REL_INT_ENA 1 | |
104 | #define F20_INT_ENA 2 | |
105 | ||
106 | /* Interrupt Request Register Bits (INT_REQ_STAT_REG | DEVICE_STATUS_REG) */ | |
107 | #define F10_ABS_INT_REQ 0 | |
108 | #define F10_REL_INT_REQ 1 | |
109 | #define F20_INT_REQ 2 | |
110 | /* Device Status Register Bits (DEVICE_STATUS_REG) */ | |
111 | #define STAT_CONFIGURED 6 | |
112 | #define STAT_ERROR 7 | |
113 | ||
114 | /* Device Command Register Bits (DEV_COMMAND_REG) */ | |
115 | #define RESET_COMMAND 0x01 | |
116 | #define REZERO_COMMAND 0x02 | |
117 | ||
118 | /* Data Register 0 Bits (DATA_REG0) */ | |
119 | #define GESTURE 3 | |
120 | ||
121 | /* Device Query Registers Bits */ | |
122 | /* DEV_QUERY_REG3 */ | |
123 | #define HAS_PALM_DETECT 1 | |
124 | #define HAS_MULTI_FING 2 | |
125 | #define HAS_SCROLLER 4 | |
126 | #define HAS_2D_SCROLL 5 | |
127 | ||
128 | /* General 2D Control Register Bits (GENERAL_2D_CONTROL_REG) */ | |
129 | #define NO_DECELERATION 1 | |
130 | #define REDUCE_REPORTING 3 | |
131 | #define NO_FILTER 5 | |
132 | ||
133 | /* Function Masks */ | |
134 | /* Device Control Register Masks (DEV_CONTROL_REG) */ | |
135 | #define REPORT_RATE_MSK 0xc0 | |
136 | #define SLEEP_MODE_MSK 0x07 | |
137 | ||
138 | /* Device Sleep Modes */ | |
139 | #define FULL_AWAKE 0x0 | |
140 | #define NORMAL_OP 0x1 | |
141 | #define LOW_PWR_OP 0x2 | |
142 | #define VERY_LOW_PWR_OP 0x3 | |
143 | #define SENS_SLEEP 0x4 | |
144 | #define SLEEP_MOD 0x5 | |
145 | #define DEEP_SLEEP 0x6 | |
146 | #define HIBERNATE 0x7 | |
147 | ||
148 | /* Interrupt Register Mask */ | |
149 | /* (INT_REQ_STAT_REG | DEVICE_STATUS_REG | INTERRUPT_EN_REG) */ | |
150 | #define INT_ENA_REQ_MSK 0x07 | |
151 | #define INT_ENA_ABS_MSK 0x01 | |
152 | #define INT_ENA_REL_MSK 0x02 | |
153 | #define INT_ENA_F20_MSK 0x04 | |
154 | ||
155 | /* Device Status Register Masks (DEVICE_STATUS_REG) */ | |
156 | #define CONFIGURED_MSK 0x40 | |
157 | #define ERROR_MSK 0x80 | |
158 | ||
159 | /* Data Register 0 Masks */ | |
160 | #define FINGER_WIDTH_MSK 0xf0 | |
161 | #define GESTURE_MSK 0x08 | |
162 | #define SENSOR_STATUS_MSK 0x07 | |
163 | ||
164 | /* | |
165 | * MSB Position Register Masks | |
166 | * ABS_MSB_X_REG | ABS_MSB_Y_REG | SENS_MAX_POS_MSB_REG | | |
167 | * DEV_QUERY_REG3 | DEV_QUERY_REG5 | |
168 | */ | |
169 | #define MSB_POSITION_MSK 0x1f | |
170 | ||
171 | /* Device Query Registers Masks */ | |
172 | ||
173 | /* DEV_QUERY_REG2 */ | |
174 | #define NUM_EXTRA_POS_MSK 0x07 | |
175 | ||
176 | /* When in IRQ mode read the device every THREAD_IRQ_SLEEP_SECS */ | |
177 | #define THREAD_IRQ_SLEEP_SECS 2 | |
178 | #define THREAD_IRQ_SLEEP_MSECS (THREAD_IRQ_SLEEP_SECS * MSEC_PER_SEC) | |
179 | ||
180 | /* | |
181 | * When in Polling mode and no data received for NO_DATA_THRES msecs | |
182 | * reduce the polling rate to NO_DATA_SLEEP_MSECS | |
183 | */ | |
184 | #define NO_DATA_THRES (MSEC_PER_SEC) | |
185 | #define NO_DATA_SLEEP_MSECS (MSEC_PER_SEC / 4) | |
186 | ||
187 | /* Control touchpad's No Deceleration option */ | |
90ab5ee9 | 188 | static bool no_decel = 1; |
eef3e4ca MR |
189 | module_param(no_decel, bool, 0644); |
190 | MODULE_PARM_DESC(no_decel, "No Deceleration. Default = 1 (on)"); | |
191 | ||
192 | /* Control touchpad's Reduced Reporting option */ | |
90ab5ee9 | 193 | static bool reduce_report; |
eef3e4ca MR |
194 | module_param(reduce_report, bool, 0644); |
195 | MODULE_PARM_DESC(reduce_report, "Reduced Reporting. Default = 0 (off)"); | |
196 | ||
197 | /* Control touchpad's No Filter option */ | |
90ab5ee9 | 198 | static bool no_filter; |
eef3e4ca MR |
199 | module_param(no_filter, bool, 0644); |
200 | MODULE_PARM_DESC(no_filter, "No Filter. Default = 0 (off)"); | |
201 | ||
202 | /* | |
203 | * touchpad Attention line is Active Low and Open Drain, | |
204 | * therefore should be connected to pulled up line | |
205 | * and the irq configuration should be set to Falling Edge Trigger | |
206 | */ | |
207 | /* Control IRQ / Polling option */ | |
30b37131 | 208 | static bool polling_req; |
eef3e4ca MR |
209 | module_param(polling_req, bool, 0444); |
210 | MODULE_PARM_DESC(polling_req, "Request Polling. Default = 0 (use irq)"); | |
211 | ||
212 | /* Control Polling Rate */ | |
213 | static int scan_rate = 80; | |
214 | module_param(scan_rate, int, 0644); | |
215 | MODULE_PARM_DESC(scan_rate, "Polling rate in times/sec. Default = 80"); | |
216 | ||
217 | /* The main device structure */ | |
218 | struct synaptics_i2c { | |
219 | struct i2c_client *client; | |
220 | struct input_dev *input; | |
221 | struct delayed_work dwork; | |
30b37131 | 222 | spinlock_t lock; |
eef3e4ca MR |
223 | int no_data_count; |
224 | int no_decel_param; | |
225 | int reduce_report_param; | |
226 | int no_filter_param; | |
227 | int scan_rate_param; | |
228 | int scan_ms; | |
229 | }; | |
230 | ||
231 | static inline void set_scan_rate(struct synaptics_i2c *touch, int scan_rate) | |
232 | { | |
233 | touch->scan_ms = MSEC_PER_SEC / scan_rate; | |
234 | touch->scan_rate_param = scan_rate; | |
235 | } | |
236 | ||
237 | /* | |
238 | * Driver's initial design makes no race condition possible on i2c bus, | |
239 | * so there is no need in any locking. | |
240 | * Keep it in mind, while playing with the code. | |
241 | */ | |
242 | static s32 synaptics_i2c_reg_get(struct i2c_client *client, u16 reg) | |
243 | { | |
244 | int ret; | |
245 | ||
246 | ret = i2c_smbus_write_byte_data(client, PAGE_SEL_REG, reg >> 8); | |
247 | if (ret == 0) | |
248 | ret = i2c_smbus_read_byte_data(client, reg & 0xff); | |
249 | ||
250 | return ret; | |
251 | } | |
252 | ||
253 | static s32 synaptics_i2c_reg_set(struct i2c_client *client, u16 reg, u8 val) | |
254 | { | |
255 | int ret; | |
256 | ||
257 | ret = i2c_smbus_write_byte_data(client, PAGE_SEL_REG, reg >> 8); | |
258 | if (ret == 0) | |
259 | ret = i2c_smbus_write_byte_data(client, reg & 0xff, val); | |
260 | ||
261 | return ret; | |
262 | } | |
263 | ||
264 | static s32 synaptics_i2c_word_get(struct i2c_client *client, u16 reg) | |
265 | { | |
266 | int ret; | |
267 | ||
268 | ret = i2c_smbus_write_byte_data(client, PAGE_SEL_REG, reg >> 8); | |
269 | if (ret == 0) | |
270 | ret = i2c_smbus_read_word_data(client, reg & 0xff); | |
271 | ||
272 | return ret; | |
273 | } | |
274 | ||
275 | static int synaptics_i2c_config(struct i2c_client *client) | |
276 | { | |
277 | int ret, control; | |
278 | u8 int_en; | |
279 | ||
280 | /* set Report Rate to Device Highest (>=80) and Sleep to normal */ | |
281 | ret = synaptics_i2c_reg_set(client, DEV_CONTROL_REG, 0xc1); | |
282 | if (ret) | |
283 | return ret; | |
284 | ||
285 | /* set Interrupt Disable to Func20 / Enable to Func10) */ | |
286 | int_en = (polling_req) ? 0 : INT_ENA_ABS_MSK | INT_ENA_REL_MSK; | |
287 | ret = synaptics_i2c_reg_set(client, INTERRUPT_EN_REG, int_en); | |
288 | if (ret) | |
289 | return ret; | |
290 | ||
291 | control = synaptics_i2c_reg_get(client, GENERAL_2D_CONTROL_REG); | |
292 | /* No Deceleration */ | |
293 | control |= no_decel ? 1 << NO_DECELERATION : 0; | |
294 | /* Reduced Reporting */ | |
295 | control |= reduce_report ? 1 << REDUCE_REPORTING : 0; | |
296 | /* No Filter */ | |
297 | control |= no_filter ? 1 << NO_FILTER : 0; | |
298 | ret = synaptics_i2c_reg_set(client, GENERAL_2D_CONTROL_REG, control); | |
299 | if (ret) | |
300 | return ret; | |
301 | ||
302 | return 0; | |
303 | } | |
304 | ||
305 | static int synaptics_i2c_reset_config(struct i2c_client *client) | |
306 | { | |
307 | int ret; | |
308 | ||
309 | /* Reset the Touchpad */ | |
310 | ret = synaptics_i2c_reg_set(client, DEV_COMMAND_REG, RESET_COMMAND); | |
311 | if (ret) { | |
312 | dev_err(&client->dev, "Unable to reset device\n"); | |
313 | } else { | |
314 | msleep(SOFT_RESET_DELAY_MS); | |
315 | ret = synaptics_i2c_config(client); | |
316 | if (ret) | |
317 | dev_err(&client->dev, "Unable to config device\n"); | |
318 | } | |
319 | ||
320 | return ret; | |
321 | } | |
322 | ||
323 | static int synaptics_i2c_check_error(struct i2c_client *client) | |
324 | { | |
325 | int status, ret = 0; | |
326 | ||
327 | status = i2c_smbus_read_byte_data(client, DEVICE_STATUS_REG) & | |
328 | (CONFIGURED_MSK | ERROR_MSK); | |
329 | ||
330 | if (status != CONFIGURED_MSK) | |
331 | ret = synaptics_i2c_reset_config(client); | |
332 | ||
333 | return ret; | |
334 | } | |
335 | ||
336 | static bool synaptics_i2c_get_input(struct synaptics_i2c *touch) | |
337 | { | |
338 | struct input_dev *input = touch->input; | |
339 | int xy_delta, gesture; | |
340 | s32 data; | |
341 | s8 x_delta, y_delta; | |
342 | ||
343 | /* Deal with spontanious resets and errors */ | |
344 | if (synaptics_i2c_check_error(touch->client)) | |
345 | return 0; | |
346 | ||
347 | /* Get Gesture Bit */ | |
348 | data = synaptics_i2c_reg_get(touch->client, DATA_REG0); | |
349 | gesture = (data >> GESTURE) & 0x1; | |
350 | ||
351 | /* | |
352 | * Get Relative axes. we have to get them in one shot, | |
353 | * so we get 2 bytes starting from REL_X_REG. | |
354 | */ | |
355 | xy_delta = synaptics_i2c_word_get(touch->client, REL_X_REG) & 0xffff; | |
356 | ||
357 | /* Separate X from Y */ | |
358 | x_delta = xy_delta & 0xff; | |
359 | y_delta = (xy_delta >> REGISTER_LENGTH) & 0xff; | |
360 | ||
361 | /* Report the button event */ | |
362 | input_report_key(input, BTN_LEFT, gesture); | |
363 | ||
364 | /* Report the deltas */ | |
365 | input_report_rel(input, REL_X, x_delta); | |
366 | input_report_rel(input, REL_Y, -y_delta); | |
367 | input_sync(input); | |
368 | ||
369 | return xy_delta || gesture; | |
370 | } | |
371 | ||
30b37131 DT |
372 | static void synaptics_i2c_reschedule_work(struct synaptics_i2c *touch, |
373 | unsigned long delay) | |
eef3e4ca | 374 | { |
30b37131 DT |
375 | unsigned long flags; |
376 | ||
377 | spin_lock_irqsave(&touch->lock, flags); | |
eef3e4ca | 378 | |
e7c2f967 | 379 | mod_delayed_work(system_wq, &touch->dwork, delay); |
30b37131 DT |
380 | |
381 | spin_unlock_irqrestore(&touch->lock, flags); | |
382 | } | |
383 | ||
384 | static irqreturn_t synaptics_i2c_irq(int irq, void *dev_id) | |
385 | { | |
386 | struct synaptics_i2c *touch = dev_id; | |
387 | ||
388 | synaptics_i2c_reschedule_work(touch, 0); | |
eef3e4ca MR |
389 | |
390 | return IRQ_HANDLED; | |
391 | } | |
392 | ||
393 | static void synaptics_i2c_check_params(struct synaptics_i2c *touch) | |
394 | { | |
395 | bool reset = false; | |
396 | ||
397 | if (scan_rate != touch->scan_rate_param) | |
398 | set_scan_rate(touch, scan_rate); | |
399 | ||
400 | if (no_decel != touch->no_decel_param) { | |
401 | touch->no_decel_param = no_decel; | |
402 | reset = true; | |
403 | } | |
404 | ||
405 | if (no_filter != touch->no_filter_param) { | |
406 | touch->no_filter_param = no_filter; | |
407 | reset = true; | |
408 | } | |
409 | ||
410 | if (reduce_report != touch->reduce_report_param) { | |
411 | touch->reduce_report_param = reduce_report; | |
412 | reset = true; | |
413 | } | |
414 | ||
415 | if (reset) | |
416 | synaptics_i2c_reset_config(touch->client); | |
417 | } | |
418 | ||
419 | /* Control the Device polling rate / Work Handler sleep time */ | |
f5ba3502 DT |
420 | static unsigned long synaptics_i2c_adjust_delay(struct synaptics_i2c *touch, |
421 | bool have_data) | |
eef3e4ca MR |
422 | { |
423 | unsigned long delay, nodata_count_thres; | |
424 | ||
425 | if (polling_req) { | |
426 | delay = touch->scan_ms; | |
427 | if (have_data) { | |
428 | touch->no_data_count = 0; | |
429 | } else { | |
430 | nodata_count_thres = NO_DATA_THRES / touch->scan_ms; | |
431 | if (touch->no_data_count < nodata_count_thres) | |
432 | touch->no_data_count++; | |
433 | else | |
434 | delay = NO_DATA_SLEEP_MSECS; | |
435 | } | |
436 | return msecs_to_jiffies(delay); | |
437 | } else { | |
438 | delay = msecs_to_jiffies(THREAD_IRQ_SLEEP_MSECS); | |
439 | return round_jiffies_relative(delay); | |
440 | } | |
441 | } | |
442 | ||
443 | /* Work Handler */ | |
444 | static void synaptics_i2c_work_handler(struct work_struct *work) | |
445 | { | |
446 | bool have_data; | |
447 | struct synaptics_i2c *touch = | |
448 | container_of(work, struct synaptics_i2c, dwork.work); | |
449 | unsigned long delay; | |
450 | ||
451 | synaptics_i2c_check_params(touch); | |
452 | ||
453 | have_data = synaptics_i2c_get_input(touch); | |
454 | delay = synaptics_i2c_adjust_delay(touch, have_data); | |
455 | ||
456 | /* | |
457 | * While interrupt driven, there is no real need to poll the device. | |
458 | * But touchpads are very sensitive, so there could be errors | |
459 | * related to physical environment and the attention line isn't | |
25985edc | 460 | * necessarily asserted. In such case we can lose the touchpad. |
eef3e4ca MR |
461 | * We poll the device once in THREAD_IRQ_SLEEP_SECS and |
462 | * if error is detected, we try to reset and reconfigure the touchpad. | |
463 | */ | |
30b37131 | 464 | synaptics_i2c_reschedule_work(touch, delay); |
eef3e4ca MR |
465 | } |
466 | ||
467 | static int synaptics_i2c_open(struct input_dev *input) | |
468 | { | |
469 | struct synaptics_i2c *touch = input_get_drvdata(input); | |
470 | int ret; | |
471 | ||
472 | ret = synaptics_i2c_reset_config(touch->client); | |
473 | if (ret) | |
474 | return ret; | |
475 | ||
476 | if (polling_req) | |
30b37131 DT |
477 | synaptics_i2c_reschedule_work(touch, |
478 | msecs_to_jiffies(NO_DATA_SLEEP_MSECS)); | |
eef3e4ca MR |
479 | |
480 | return 0; | |
481 | } | |
482 | ||
483 | static void synaptics_i2c_close(struct input_dev *input) | |
484 | { | |
485 | struct synaptics_i2c *touch = input_get_drvdata(input); | |
486 | ||
487 | if (!polling_req) | |
488 | synaptics_i2c_reg_set(touch->client, INTERRUPT_EN_REG, 0); | |
489 | ||
490 | cancel_delayed_work_sync(&touch->dwork); | |
491 | ||
492 | /* Save some power */ | |
493 | synaptics_i2c_reg_set(touch->client, DEV_CONTROL_REG, DEEP_SLEEP); | |
494 | } | |
495 | ||
496 | static void synaptics_i2c_set_input_params(struct synaptics_i2c *touch) | |
497 | { | |
498 | struct input_dev *input = touch->input; | |
499 | ||
500 | input->name = touch->client->name; | |
501 | input->phys = touch->client->adapter->name; | |
502 | input->id.bustype = BUS_I2C; | |
503 | input->id.version = synaptics_i2c_word_get(touch->client, | |
504 | INFO_QUERY_REG0); | |
505 | input->dev.parent = &touch->client->dev; | |
506 | input->open = synaptics_i2c_open; | |
507 | input->close = synaptics_i2c_close; | |
508 | input_set_drvdata(input, touch); | |
509 | ||
510 | /* Register the device as mouse */ | |
511 | __set_bit(EV_REL, input->evbit); | |
512 | __set_bit(REL_X, input->relbit); | |
513 | __set_bit(REL_Y, input->relbit); | |
514 | ||
515 | /* Register device's buttons and keys */ | |
516 | __set_bit(EV_KEY, input->evbit); | |
517 | __set_bit(BTN_LEFT, input->keybit); | |
518 | } | |
519 | ||
f5ba3502 | 520 | static struct synaptics_i2c *synaptics_i2c_touch_create(struct i2c_client *client) |
eef3e4ca MR |
521 | { |
522 | struct synaptics_i2c *touch; | |
523 | ||
524 | touch = kzalloc(sizeof(struct synaptics_i2c), GFP_KERNEL); | |
525 | if (!touch) | |
526 | return NULL; | |
527 | ||
528 | touch->client = client; | |
529 | touch->no_decel_param = no_decel; | |
530 | touch->scan_rate_param = scan_rate; | |
531 | set_scan_rate(touch, scan_rate); | |
532 | INIT_DELAYED_WORK(&touch->dwork, synaptics_i2c_work_handler); | |
30b37131 | 533 | spin_lock_init(&touch->lock); |
eef3e4ca MR |
534 | |
535 | return touch; | |
536 | } | |
537 | ||
5298cc4c | 538 | static int synaptics_i2c_probe(struct i2c_client *client, |
eef3e4ca MR |
539 | const struct i2c_device_id *dev_id) |
540 | { | |
541 | int ret; | |
542 | struct synaptics_i2c *touch; | |
543 | ||
544 | touch = synaptics_i2c_touch_create(client); | |
545 | if (!touch) | |
546 | return -ENOMEM; | |
547 | ||
eef3e4ca MR |
548 | ret = synaptics_i2c_reset_config(client); |
549 | if (ret) | |
550 | goto err_mem_free; | |
551 | ||
552 | if (client->irq < 1) | |
30b37131 | 553 | polling_req = true; |
eef3e4ca MR |
554 | |
555 | touch->input = input_allocate_device(); | |
556 | if (!touch->input) { | |
557 | ret = -ENOMEM; | |
558 | goto err_mem_free; | |
559 | } | |
560 | ||
561 | synaptics_i2c_set_input_params(touch); | |
562 | ||
563 | if (!polling_req) { | |
564 | dev_dbg(&touch->client->dev, | |
565 | "Requesting IRQ: %d\n", touch->client->irq); | |
566 | ||
567 | ret = request_irq(touch->client->irq, synaptics_i2c_irq, | |
ec4665c4 | 568 | IRQ_TYPE_EDGE_FALLING, |
eef3e4ca MR |
569 | DRIVER_NAME, touch); |
570 | if (ret) { | |
571 | dev_warn(&touch->client->dev, | |
572 | "IRQ request failed: %d, " | |
573 | "falling back to polling\n", ret); | |
30b37131 | 574 | polling_req = true; |
eef3e4ca MR |
575 | synaptics_i2c_reg_set(touch->client, |
576 | INTERRUPT_EN_REG, 0); | |
577 | } | |
578 | } | |
579 | ||
580 | if (polling_req) | |
581 | dev_dbg(&touch->client->dev, | |
582 | "Using polling at rate: %d times/sec\n", scan_rate); | |
583 | ||
584 | /* Register the device in input subsystem */ | |
585 | ret = input_register_device(touch->input); | |
586 | if (ret) { | |
587 | dev_err(&client->dev, | |
588 | "Input device register failed: %d\n", ret); | |
589 | goto err_input_free; | |
590 | } | |
30b37131 DT |
591 | |
592 | i2c_set_clientdata(client, touch); | |
593 | ||
eef3e4ca MR |
594 | return 0; |
595 | ||
596 | err_input_free: | |
597 | input_free_device(touch->input); | |
598 | err_mem_free: | |
eef3e4ca MR |
599 | kfree(touch); |
600 | ||
601 | return ret; | |
602 | } | |
603 | ||
e2619cf7 | 604 | static int synaptics_i2c_remove(struct i2c_client *client) |
eef3e4ca MR |
605 | { |
606 | struct synaptics_i2c *touch = i2c_get_clientdata(client); | |
607 | ||
608 | if (!polling_req) | |
30b37131 | 609 | free_irq(client->irq, touch); |
eef3e4ca MR |
610 | |
611 | input_unregister_device(touch->input); | |
eef3e4ca MR |
612 | kfree(touch); |
613 | ||
614 | return 0; | |
615 | } | |
616 | ||
26e56eb2 | 617 | #ifdef CONFIG_PM_SLEEP |
87b2c7df | 618 | static int synaptics_i2c_suspend(struct device *dev) |
eef3e4ca | 619 | { |
87b2c7df | 620 | struct i2c_client *client = to_i2c_client(dev); |
eef3e4ca MR |
621 | struct synaptics_i2c *touch = i2c_get_clientdata(client); |
622 | ||
623 | cancel_delayed_work_sync(&touch->dwork); | |
624 | ||
625 | /* Save some power */ | |
626 | synaptics_i2c_reg_set(touch->client, DEV_CONTROL_REG, DEEP_SLEEP); | |
627 | ||
628 | return 0; | |
629 | } | |
630 | ||
87b2c7df | 631 | static int synaptics_i2c_resume(struct device *dev) |
eef3e4ca MR |
632 | { |
633 | int ret; | |
87b2c7df | 634 | struct i2c_client *client = to_i2c_client(dev); |
eef3e4ca MR |
635 | struct synaptics_i2c *touch = i2c_get_clientdata(client); |
636 | ||
637 | ret = synaptics_i2c_reset_config(client); | |
638 | if (ret) | |
639 | return ret; | |
640 | ||
30b37131 DT |
641 | synaptics_i2c_reschedule_work(touch, |
642 | msecs_to_jiffies(NO_DATA_SLEEP_MSECS)); | |
eef3e4ca MR |
643 | |
644 | return 0; | |
645 | } | |
eef3e4ca MR |
646 | #endif |
647 | ||
87b2c7df MB |
648 | static SIMPLE_DEV_PM_OPS(synaptics_i2c_pm, synaptics_i2c_suspend, |
649 | synaptics_i2c_resume); | |
650 | ||
eef3e4ca MR |
651 | static const struct i2c_device_id synaptics_i2c_id_table[] = { |
652 | { "synaptics_i2c", 0 }, | |
653 | { }, | |
654 | }; | |
655 | MODULE_DEVICE_TABLE(i2c, synaptics_i2c_id_table); | |
656 | ||
657 | static struct i2c_driver synaptics_i2c_driver = { | |
658 | .driver = { | |
659 | .name = DRIVER_NAME, | |
660 | .owner = THIS_MODULE, | |
87b2c7df | 661 | .pm = &synaptics_i2c_pm, |
eef3e4ca MR |
662 | }, |
663 | ||
664 | .probe = synaptics_i2c_probe, | |
1cb0aa88 | 665 | .remove = synaptics_i2c_remove, |
eef3e4ca | 666 | |
eef3e4ca MR |
667 | .id_table = synaptics_i2c_id_table, |
668 | }; | |
669 | ||
1b92c1cf | 670 | module_i2c_driver(synaptics_i2c_driver); |
eef3e4ca MR |
671 | |
672 | MODULE_DESCRIPTION("Synaptics I2C touchpad driver"); | |
673 | MODULE_AUTHOR("Mike Rapoport, Igor Grinberg, Compulab"); | |
674 | MODULE_LICENSE("GPL"); | |
675 |