1 /**
2 *
3 * Synaptics Register Mapped Interface (RMI4) I2C Physical Layer Driver.
4 * Copyright (c) 2007-2010, Synaptics Incorporated
5 *
6 * Author: Js HA <js.ha@stericsson.com> for ST-Ericsson
7 * Author: Naveen Kumar G <naveen.gaddipati@stericsson.com> for ST-Ericsson
8 * Copyright 2010 (c) ST-Ericsson AB
9 */
10 /*
11 * This file is licensed under the GPL2 license.
12 *
13 *#############################################################################
14 * GPL
15 *
16 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License version 2 as published
18 * by the Free Software Foundation.
19 *
20 * This program is distributed in the hope that it will be useful, but
21 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
22 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
23 * for more details.
24 *
25 *#############################################################################
26 */
27
28 #include <linux/input.h>
29 #include <linux/slab.h>
30 #include <linux/i2c.h>
31 #include <linux/interrupt.h>
32 #include <linux/regulator/consumer.h>
33 #include <linux/module.h>
34 #include <linux/input/mt.h>
35 #include "synaptics_i2c_rmi4.h"
36
37 /* TODO: for multiple device support will need a per-device mutex */
38 #define DRIVER_NAME "synaptics_rmi4_i2c"
39
40 #define MAX_ERROR_REPORT 6
41 #define MAX_TOUCH_MAJOR 15
42 #define MAX_RETRY_COUNT 5
43 #define STD_QUERY_LEN 21
44 #define PAGE_LEN 2
45 #define DATA_BUF_LEN 32
46 #define BUF_LEN 37
47 #define QUERY_LEN 9
48 #define DATA_LEN 12
49 #define HAS_TAP 0x01
50 #define HAS_PALMDETECT 0x01
51 #define HAS_ROTATE 0x02
52 #define HAS_TAPANDHOLD 0x02
53 #define HAS_DOUBLETAP 0x04
54 #define HAS_EARLYTAP 0x08
55 #define HAS_RELEASE 0x08
56 #define HAS_FLICK 0x10
57 #define HAS_PRESS 0x20
58 #define HAS_PINCH 0x40
59
60 #define MASK_16BIT 0xFFFF
61 #define MASK_8BIT 0xFF
62 #define MASK_7BIT 0x7F
63 #define MASK_5BIT 0x1F
64 #define MASK_4BIT 0x0F
65 #define MASK_3BIT 0x07
66 #define MASK_2BIT 0x03
67 #define TOUCHPAD_CTRL_INTR 0x8
68 #define PDT_START_SCAN_LOCATION (0x00E9)
69 #define PDT_END_SCAN_LOCATION (0x000A)
70 #define PDT_ENTRY_SIZE (0x0006)
71 #define SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM (0x11)
72 #define SYNAPTICS_RMI4_DEVICE_CONTROL_FUNC_NUM (0x01)
73
74 /**
75 * struct synaptics_rmi4_fn_desc - contains the function descriptor information
76 * @query_base_addr: base address for query
77 * @cmd_base_addr: base address for command
78 * @ctrl_base_addr: base address for control
79 * @data_base_addr: base address for data
80 * @intr_src_count: count for the interrupt source
81 * @fn_number: function number
82 *
83 * This structure is used to gives the function descriptor information
84 * of the particular functionality.
85 */
86 struct synaptics_rmi4_fn_desc {
87 unsigned char query_base_addr;
88 unsigned char cmd_base_addr;
89 unsigned char ctrl_base_addr;
90 unsigned char data_base_addr;
91 unsigned char intr_src_count;
92 unsigned char fn_number;
93 };
94
95 /**
96 * struct synaptics_rmi4_fn - contains the function information
97 * @fn_number: function number
98 * @num_of_data_sources: number of data sources
99 * @num_of_data_points: number of fingers touched
100 * @size_of_data_register_block: data register block size
101 * @index_to_intr_reg: index for interrupt register
102 * @intr_mask: interrupt mask value
103 * @fn_desc: variable for function descriptor structure
104 * @link: linked list for function descriptors
105 *
106 * This structure gives information about the number of data sources and
107 * the number of data registers associated with the function.
108 */
109 struct synaptics_rmi4_fn {
110 unsigned char fn_number;
111 unsigned char num_of_data_sources;
112 unsigned char num_of_data_points;
113 unsigned char size_of_data_register_block;
114 unsigned char index_to_intr_reg;
115 unsigned char intr_mask;
116 struct synaptics_rmi4_fn_desc fn_desc;
117 struct list_head link;
118 };
119
120 /**
121 * struct synaptics_rmi4_device_info - contains the rmi4 device information
122 * @version_major: protocol major version number
123 * @version_minor: protocol minor version number
124 * @manufacturer_id: manufacturer identification byte
125 * @product_props: product properties information
126 * @product_info: product info array
127 * @date_code: device manufacture date
128 * @tester_id: tester id array
129 * @serial_number: serial number for that device
130 * @product_id_string: product id for the device
131 * @support_fn_list: linked list for device information
132 *
133 * This structure gives information about the number of data sources and
134 * the number of data registers associated with the function.
135 */
136 struct synaptics_rmi4_device_info {
137 unsigned int version_major;
138 unsigned int version_minor;
139 unsigned char manufacturer_id;
140 unsigned char product_props;
141 unsigned char product_info[2];
142 unsigned char date_code[3];
143 unsigned short tester_id;
144 unsigned short serial_number;
145 unsigned char product_id_string[11];
146 struct list_head support_fn_list;
147 };
148
149 /**
150 * struct synaptics_rmi4_data - contains the rmi4 device data
151 * @rmi4_mod_info: structure variable for rmi4 device info
152 * @input_dev: pointer for input device
153 * @i2c_client: pointer for i2c client
154 * @board: constant pointer for touch platform data
155 * @fn_list_mutex: mutex for function list
156 * @rmi4_page_mutex: mutex for rmi4 page
157 * @current_page: variable for integer
158 * @number_of_interrupt_register: interrupt registers count
159 * @fn01_ctrl_base_addr: control base address for fn01
160 * @fn01_query_base_addr: query base address for fn01
161 * @fn01_data_base_addr: data base address for fn01
162 * @sensor_max_x: sensor maximum x value
163 * @sensor_max_y: sensor maximum y value
164 * @regulator: pointer to the regulator structure
165 * @wait: wait queue structure variable
166 * @touch_stopped: flag to stop the thread function
167 * @fingers_supported: maximum supported fingers
168 *
169 * This structure gives the device data information.
170 */
171 struct synaptics_rmi4_data {
172 struct synaptics_rmi4_device_info rmi4_mod_info;
173 struct input_dev *input_dev;
174 struct i2c_client *i2c_client;
175 const struct synaptics_rmi4_platform_data *board;
176 struct mutex fn_list_mutex;
177 struct mutex rmi4_page_mutex;
178 int current_page;
179 unsigned int number_of_interrupt_register;
180 unsigned short fn01_ctrl_base_addr;
181 unsigned short fn01_query_base_addr;
182 unsigned short fn01_data_base_addr;
183 int sensor_max_x;
184 int sensor_max_y;
185 struct regulator *regulator;
186 wait_queue_head_t wait;
187 bool touch_stopped;
188 unsigned char fingers_supported;
189 };
190
191 /**
192 * synaptics_rmi4_set_page() - sets the page
193 * @pdata: pointer to synaptics_rmi4_data structure
194 * @address: set the address of the page
195 *
196 * This function is used to set the page and returns integer.
197 */
synaptics_rmi4_set_page(struct synaptics_rmi4_data * pdata,unsigned int address)198 static int synaptics_rmi4_set_page(struct synaptics_rmi4_data *pdata,
199 unsigned int address)
200 {
201 unsigned char txbuf[PAGE_LEN];
202 int retval;
203 unsigned int page;
204 struct i2c_client *i2c = pdata->i2c_client;
205
206 page = ((address >> 8) & MASK_8BIT);
207 if (page != pdata->current_page) {
208 txbuf[0] = MASK_8BIT;
209 txbuf[1] = page;
210 retval = i2c_master_send(i2c, txbuf, PAGE_LEN);
211 if (retval != PAGE_LEN)
212 dev_err(&i2c->dev, "failed:%d\n", retval);
213 else
214 pdata->current_page = page;
215 } else
216 retval = PAGE_LEN;
217 return retval;
218 }
219 /**
220 * synaptics_rmi4_i2c_block_read() - read the block of data
221 * @pdata: pointer to synaptics_rmi4_data structure
222 * @address: read the block of data from this offset
223 * @valp: pointer to a buffer containing the data to be read
224 * @size: number of bytes to read
225 *
226 * This function is to read the block of data and returns integer.
227 */
synaptics_rmi4_i2c_block_read(struct synaptics_rmi4_data * pdata,unsigned short address,unsigned char * valp,int size)228 static int synaptics_rmi4_i2c_block_read(struct synaptics_rmi4_data *pdata,
229 unsigned short address,
230 unsigned char *valp, int size)
231 {
232 int retval = 0;
233 int retry_count = 0;
234 int index;
235 struct i2c_client *i2c = pdata->i2c_client;
236
237 mutex_lock(&(pdata->rmi4_page_mutex));
238 retval = synaptics_rmi4_set_page(pdata, address);
239 if (retval != PAGE_LEN)
240 goto exit;
241 index = address & MASK_8BIT;
242 retry:
243 retval = i2c_smbus_read_i2c_block_data(i2c, index, size, valp);
244 if (retval != size) {
245 if (++retry_count == MAX_RETRY_COUNT)
246 dev_err(&i2c->dev,
247 "%s:address 0x%04x size %d failed:%d\n",
248 __func__, address, size, retval);
249 else {
250 synaptics_rmi4_set_page(pdata, address);
251 goto retry;
252 }
253 }
254 exit:
255 mutex_unlock(&(pdata->rmi4_page_mutex));
256 return retval;
257 }
258
259 /**
260 * synaptics_rmi4_i2c_byte_write() - write the single byte data
261 * @pdata: pointer to synaptics_rmi4_data structure
262 * @address: write the block of data from this offset
263 * @data: data to be write
264 *
265 * This function is to write the single byte data and returns integer.
266 */
synaptics_rmi4_i2c_byte_write(struct synaptics_rmi4_data * pdata,unsigned short address,unsigned char data)267 static int synaptics_rmi4_i2c_byte_write(struct synaptics_rmi4_data *pdata,
268 unsigned short address,
269 unsigned char data)
270 {
271 unsigned char txbuf[2];
272 int retval = 0;
273 struct i2c_client *i2c = pdata->i2c_client;
274
275 /* Can't have anyone else changing the page behind our backs */
276 mutex_lock(&(pdata->rmi4_page_mutex));
277
278 retval = synaptics_rmi4_set_page(pdata, address);
279 if (retval != PAGE_LEN)
280 goto exit;
281 txbuf[0] = address & MASK_8BIT;
282 txbuf[1] = data;
283 retval = i2c_master_send(pdata->i2c_client, txbuf, 2);
284 /* Add in retry on writes only in certain error return values */
285 if (retval != 2) {
286 dev_err(&i2c->dev, "failed:%d\n", retval);
287 retval = -EIO;
288 } else
289 retval = 1;
290 exit:
291 mutex_unlock(&(pdata->rmi4_page_mutex));
292 return retval;
293 }
294
295 /**
296 * synpatics_rmi4_touchpad_report() - reports for the rmi4 touchpad device
297 * @pdata: pointer to synaptics_rmi4_data structure
298 * @rfi: pointer to synaptics_rmi4_fn structure
299 *
300 * This function calls to reports for the rmi4 touchpad device
301 */
synpatics_rmi4_touchpad_report(struct synaptics_rmi4_data * pdata,struct synaptics_rmi4_fn * rfi)302 static int synpatics_rmi4_touchpad_report(struct synaptics_rmi4_data *pdata,
303 struct synaptics_rmi4_fn *rfi)
304 {
305 /* number of touch points - fingers down in this case */
306 int touch_count = 0;
307 int finger;
308 int finger_registers;
309 int reg;
310 int finger_shift;
311 int finger_status;
312 int retval;
313 int x, y;
314 int wx, wy;
315 unsigned short data_base_addr;
316 unsigned short data_offset;
317 unsigned char data_reg_blk_size;
318 unsigned char values[2];
319 unsigned char data[DATA_LEN];
320 unsigned char fingers_supported = pdata->fingers_supported;
321 struct i2c_client *client = pdata->i2c_client;
322 struct input_dev *input_dev = pdata->input_dev;
323
324 /* get 2D sensor finger data */
325 /*
326 * First get the finger status field - the size of the finger status
327 * field is determined by the number of finger supporte - 2 bits per
328 * finger, so the number of registers to read is:
329 * registerCount = ceil(numberOfFingers/4).
330 * Read the required number of registers and check each 2 bit field to
331 * determine if a finger is down:
332 * 00 = finger not present,
333 * 01 = finger present and data accurate,
334 * 10 = finger present but data may not be accurate,
335 * 11 = reserved for product use.
336 */
337 finger_registers = (fingers_supported + 3)/4;
338 data_base_addr = rfi->fn_desc.data_base_addr;
339 retval = synaptics_rmi4_i2c_block_read(pdata, data_base_addr, values,
340 finger_registers);
341 if (retval != finger_registers) {
342 dev_err(&client->dev, "%s:read status registers failed\n",
343 __func__);
344 return 0;
345 }
346 /*
347 * For each finger present, read the proper number of registers
348 * to get absolute data.
349 */
350 data_reg_blk_size = rfi->size_of_data_register_block;
351 for (finger = 0; finger < fingers_supported; finger++) {
352 /* determine which data byte the finger status is in */
353 reg = finger/4;
354 /* bit shift to get finger's status */
355 finger_shift = (finger % 4) * 2;
356 finger_status = (values[reg] >> finger_shift) & 3;
357 /*
358 * if finger status indicates a finger is present then
359 * read the finger data and report it
360 */
361 input_mt_slot(input_dev, finger);
362 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER,
363 finger_status != 0);
364
365 if (finger_status) {
366 /* Read the finger data */
367 data_offset = data_base_addr +
368 ((finger * data_reg_blk_size) +
369 finger_registers);
370 retval = synaptics_rmi4_i2c_block_read(pdata,
371 data_offset, data,
372 data_reg_blk_size);
373 if (retval != data_reg_blk_size) {
374 dev_err(&client->dev, "%s:read data failed\n",
375 __func__);
376 return 0;
377 }
378 x = (data[0] << 4) | (data[2] & MASK_4BIT);
379 y = (data[1] << 4) | ((data[2] >> 4) & MASK_4BIT);
380 wy = (data[3] >> 4) & MASK_4BIT;
381 wx = (data[3] & MASK_4BIT);
382
383 if (pdata->board->x_flip)
384 x = pdata->sensor_max_x - x;
385 if (pdata->board->y_flip)
386 y = pdata->sensor_max_y - y;
387
388 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR,
389 max(wx, wy));
390 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
391 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
392
393 /* number of active touch points */
394 touch_count++;
395 }
396 }
397
398 /* sync after groups of events */
399 input_mt_sync_frame(input_dev);
400 input_sync(input_dev);
401 /* return the number of touch points */
402 return touch_count;
403 }
404
405 /**
406 * synaptics_rmi4_report_device() - reports the rmi4 device
407 * @pdata: pointer to synaptics_rmi4_data structure
408 * @rfi: pointer to synaptics_rmi4_fn
409 *
410 * This function is used to call the report function of the rmi4 device.
411 */
synaptics_rmi4_report_device(struct synaptics_rmi4_data * pdata,struct synaptics_rmi4_fn * rfi)412 static int synaptics_rmi4_report_device(struct synaptics_rmi4_data *pdata,
413 struct synaptics_rmi4_fn *rfi)
414 {
415 int touch = 0;
416 struct i2c_client *client = pdata->i2c_client;
417 static int num_error_reports;
418
419 if (rfi->fn_number != SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM) {
420 num_error_reports++;
421 if (num_error_reports < MAX_ERROR_REPORT)
422 dev_err(&client->dev, "%s:report not supported\n",
423 __func__);
424 } else
425 touch = synpatics_rmi4_touchpad_report(pdata, rfi);
426 return touch;
427 }
428 /**
429 * synaptics_rmi4_sensor_report() - reports to input subsystem
430 * @pdata: pointer to synaptics_rmi4_data structure
431 *
432 * This function is used to reads in all data sources and reports
433 * them to the input subsystem.
434 */
synaptics_rmi4_sensor_report(struct synaptics_rmi4_data * pdata)435 static int synaptics_rmi4_sensor_report(struct synaptics_rmi4_data *pdata)
436 {
437 unsigned char intr_status[4];
438 /* number of touch points - fingers or buttons */
439 int touch = 0;
440 unsigned int retval;
441 struct synaptics_rmi4_fn *rfi;
442 struct synaptics_rmi4_device_info *rmi;
443 struct i2c_client *client = pdata->i2c_client;
444
445 /*
446 * Get the interrupt status from the function $01
447 * control register+1 to find which source(s) were interrupting
448 * so we can read the data from the source(s) (2D sensor, buttons..)
449 */
450 retval = synaptics_rmi4_i2c_block_read(pdata,
451 pdata->fn01_data_base_addr + 1,
452 intr_status,
453 pdata->number_of_interrupt_register);
454 if (retval != pdata->number_of_interrupt_register) {
455 dev_err(&client->dev,
456 "could not read interrupt status registers\n");
457 return 0;
458 }
459 /*
460 * check each function that has data sources and if the interrupt for
461 * that triggered then call that RMI4 functions report() function to
462 * gather data and report it to the input subsystem
463 */
464 rmi = &(pdata->rmi4_mod_info);
465 list_for_each_entry(rfi, &rmi->support_fn_list, link) {
466 if (rfi->num_of_data_sources) {
467 if (intr_status[rfi->index_to_intr_reg] &
468 rfi->intr_mask)
469 touch = synaptics_rmi4_report_device(pdata,
470 rfi);
471 }
472 }
473 /* return the number of touch points */
474 return touch;
475 }
476
477 /**
478 * synaptics_rmi4_irq() - thread function for rmi4 attention line
479 * @irq: irq value
480 * @data: void pointer
481 *
482 * This function is interrupt thread function. It just notifies the
483 * application layer that attention is required.
484 */
synaptics_rmi4_irq(int irq,void * data)485 static irqreturn_t synaptics_rmi4_irq(int irq, void *data)
486 {
487 struct synaptics_rmi4_data *pdata = data;
488 int touch_count;
489
490 do {
491 touch_count = synaptics_rmi4_sensor_report(pdata);
492 if (touch_count)
493 wait_event_timeout(pdata->wait, pdata->touch_stopped,
494 msecs_to_jiffies(1));
495 else
496 break;
497 } while (!pdata->touch_stopped);
498 return IRQ_HANDLED;
499 }
500
501 /**
502 * synpatics_rmi4_touchpad_detect() - detects the rmi4 touchpad device
503 * @pdata: pointer to synaptics_rmi4_data structure
504 * @rfi: pointer to synaptics_rmi4_fn structure
505 * @fd: pointer to synaptics_rmi4_fn_desc structure
506 * @interruptcount: count the number of interrupts
507 *
508 * This function calls to detects the rmi4 touchpad device
509 */
synpatics_rmi4_touchpad_detect(struct synaptics_rmi4_data * pdata,struct synaptics_rmi4_fn * rfi,struct synaptics_rmi4_fn_desc * fd,unsigned int interruptcount)510 static int synpatics_rmi4_touchpad_detect(struct synaptics_rmi4_data *pdata,
511 struct synaptics_rmi4_fn *rfi,
512 struct synaptics_rmi4_fn_desc *fd,
513 unsigned int interruptcount)
514 {
515 unsigned char queries[QUERY_LEN];
516 unsigned short intr_offset;
517 unsigned char abs_data_size;
518 unsigned char abs_data_blk_size;
519 unsigned char egr_0, egr_1;
520 unsigned int all_data_blk_size;
521 int has_pinch, has_flick, has_tap;
522 int has_tapandhold, has_doubletap;
523 int has_earlytap, has_press;
524 int has_palmdetect, has_rotate;
525 int has_rel;
526 int i;
527 int retval;
528 struct i2c_client *client = pdata->i2c_client;
529
530 rfi->fn_desc.query_base_addr = fd->query_base_addr;
531 rfi->fn_desc.data_base_addr = fd->data_base_addr;
532 rfi->fn_desc.intr_src_count = fd->intr_src_count;
533 rfi->fn_desc.fn_number = fd->fn_number;
534 rfi->fn_number = fd->fn_number;
535 rfi->num_of_data_sources = fd->intr_src_count;
536 rfi->fn_desc.ctrl_base_addr = fd->ctrl_base_addr;
537 rfi->fn_desc.cmd_base_addr = fd->cmd_base_addr;
538
539 /*
540 * need to get number of fingers supported, data size, etc.
541 * to be used when getting data since the number of registers to
542 * read depends on the number of fingers supported and data size.
543 */
544 retval = synaptics_rmi4_i2c_block_read(pdata, fd->query_base_addr,
545 queries,
546 sizeof(queries));
547 if (retval != sizeof(queries)) {
548 dev_err(&client->dev, "%s:read function query registers\n",
549 __func__);
550 return retval;
551 }
552 /*
553 * 2D data sources have only 3 bits for the number of fingers
554 * supported - so the encoding is a bit weird.
555 */
556 if ((queries[1] & MASK_3BIT) <= 4)
557 /* add 1 since zero based */
558 rfi->num_of_data_points = (queries[1] & MASK_3BIT) + 1;
559 else {
560 /*
561 * a value of 5 is up to 10 fingers - 6 and 7 are reserved
562 * (shouldn't get these i int retval;n a normal 2D source).
563 */
564 if ((queries[1] & MASK_3BIT) == 5)
565 rfi->num_of_data_points = 10;
566 }
567 pdata->fingers_supported = rfi->num_of_data_points;
568 /* Need to get interrupt info for handling interrupts */
569 rfi->index_to_intr_reg = (interruptcount + 7)/8;
570 if (rfi->index_to_intr_reg != 0)
571 rfi->index_to_intr_reg -= 1;
572 /*
573 * loop through interrupts for each source in fn $11
574 * and or in a bit to the interrupt mask for each.
575 */
576 intr_offset = interruptcount % 8;
577 rfi->intr_mask = 0;
578 for (i = intr_offset;
579 i < ((fd->intr_src_count & MASK_3BIT) + intr_offset); i++)
580 rfi->intr_mask |= 1 << i;
581
582 /* Size of just the absolute data for one finger */
583 abs_data_size = queries[5] & MASK_2BIT;
584 /* One each for X and Y, one for LSB for X & Y, one for W, one for Z */
585 abs_data_blk_size = 3 + (2 * (abs_data_size == 0 ? 1 : 0));
586 rfi->size_of_data_register_block = abs_data_blk_size;
587
588 /*
589 * need to determine the size of data to read - this depends on
590 * conditions such as whether Relative data is reported and if Gesture
591 * data is reported.
592 */
593 egr_0 = queries[7];
594 egr_1 = queries[8];
595
596 /*
597 * Get info about what EGR data is supported, whether it has
598 * Relative data supported, etc.
599 */
600 has_pinch = egr_0 & HAS_PINCH;
601 has_flick = egr_0 & HAS_FLICK;
602 has_tap = egr_0 & HAS_TAP;
603 has_earlytap = egr_0 & HAS_EARLYTAP;
604 has_press = egr_0 & HAS_PRESS;
605 has_rotate = egr_1 & HAS_ROTATE;
606 has_rel = queries[1] & HAS_RELEASE;
607 has_tapandhold = egr_0 & HAS_TAPANDHOLD;
608 has_doubletap = egr_0 & HAS_DOUBLETAP;
609 has_palmdetect = egr_1 & HAS_PALMDETECT;
610
611 /*
612 * Size of all data including finger status, absolute data for each
613 * finger, relative data and EGR data
614 */
615 all_data_blk_size =
616 /* finger status, four fingers per register */
617 ((rfi->num_of_data_points + 3) / 4) +
618 /* absolute data, per finger times number of fingers */
619 (abs_data_blk_size * rfi->num_of_data_points) +
620 /*
621 * two relative registers (if relative is being reported)
622 */
623 2 * has_rel +
624 /*
625 * F11_2D_data8 is only present if the egr_0
626 * register is non-zero.
627 */
628 !!(egr_0) +
629 /*
630 * F11_2D_data9 is only present if either egr_0 or
631 * egr_1 registers are non-zero.
632 */
633 (egr_0 || egr_1) +
634 /*
635 * F11_2D_data10 is only present if EGR_PINCH or EGR_FLICK of
636 * egr_0 reports as 1.
637 */
638 !!(has_pinch | has_flick) +
639 /*
640 * F11_2D_data11 and F11_2D_data12 are only present if
641 * EGR_FLICK of egr_0 reports as 1.
642 */
643 2 * !!(has_flick);
644 return retval;
645 }
646
647 /**
648 * synaptics_rmi4_touchpad_config() - configures the rmi4 touchpad device
649 * @pdata: pointer to synaptics_rmi4_data structure
650 * @rfi: pointer to synaptics_rmi4_fn structure
651 *
652 * This function calls to configures the rmi4 touchpad device
653 */
synaptics_rmi4_touchpad_config(struct synaptics_rmi4_data * pdata,struct synaptics_rmi4_fn * rfi)654 static int synaptics_rmi4_touchpad_config(struct synaptics_rmi4_data *pdata,
655 struct synaptics_rmi4_fn *rfi)
656 {
657 /*
658 * For the data source - print info and do any
659 * source specific configuration.
660 */
661 unsigned char data[BUF_LEN];
662 int retval = 0;
663 struct i2c_client *client = pdata->i2c_client;
664
665 /* Get and print some info about the data source... */
666 /* To Query 2D devices we need to read from the address obtained
667 * from the function descriptor stored in the RMI function info.
668 */
669 retval = synaptics_rmi4_i2c_block_read(pdata,
670 rfi->fn_desc.query_base_addr,
671 data, QUERY_LEN);
672 if (retval != QUERY_LEN)
673 dev_err(&client->dev, "%s:read query registers failed\n",
674 __func__);
675 else {
676 retval = synaptics_rmi4_i2c_block_read(pdata,
677 rfi->fn_desc.ctrl_base_addr,
678 data, DATA_BUF_LEN);
679 if (retval != DATA_BUF_LEN) {
680 dev_err(&client->dev,
681 "%s:read control registers failed\n",
682 __func__);
683 return retval;
684 }
685 /* Store these for use later*/
686 pdata->sensor_max_x = ((data[6] & MASK_8BIT) << 0) |
687 ((data[7] & MASK_4BIT) << 8);
688 pdata->sensor_max_y = ((data[8] & MASK_5BIT) << 0) |
689 ((data[9] & MASK_4BIT) << 8);
690 }
691 return retval;
692 }
693
694 /**
695 * synaptics_rmi4_i2c_query_device() - query the rmi4 device
696 * @pdata: pointer to synaptics_rmi4_data structure
697 *
698 * This function is used to query the rmi4 device.
699 */
synaptics_rmi4_i2c_query_device(struct synaptics_rmi4_data * pdata)700 static int synaptics_rmi4_i2c_query_device(struct synaptics_rmi4_data *pdata)
701 {
702 int i;
703 int retval;
704 unsigned char std_queries[STD_QUERY_LEN];
705 unsigned char intr_count = 0;
706 int data_sources = 0;
707 unsigned int ctrl_offset;
708 struct synaptics_rmi4_fn *rfi;
709 struct synaptics_rmi4_fn_desc rmi_fd;
710 struct synaptics_rmi4_device_info *rmi;
711 struct i2c_client *client = pdata->i2c_client;
712
713 /*
714 * init the physical drivers RMI module
715 * info list of functions
716 */
717 INIT_LIST_HEAD(&pdata->rmi4_mod_info.support_fn_list);
718
719 /*
720 * Read the Page Descriptor Table to determine what functions
721 * are present
722 */
723 for (i = PDT_START_SCAN_LOCATION; i > PDT_END_SCAN_LOCATION;
724 i -= PDT_ENTRY_SIZE) {
725 retval = synaptics_rmi4_i2c_block_read(pdata, i,
726 (unsigned char *)&rmi_fd,
727 sizeof(rmi_fd));
728 if (retval != sizeof(rmi_fd)) {
729 /* failed to read next PDT entry */
730 dev_err(&client->dev, "%s: read error\n", __func__);
731 return -EIO;
732 }
733 rfi = NULL;
734 if (rmi_fd.fn_number) {
735 switch (rmi_fd.fn_number & MASK_8BIT) {
736 case SYNAPTICS_RMI4_DEVICE_CONTROL_FUNC_NUM:
737 pdata->fn01_query_base_addr =
738 rmi_fd.query_base_addr;
739 pdata->fn01_ctrl_base_addr =
740 rmi_fd.ctrl_base_addr;
741 pdata->fn01_data_base_addr =
742 rmi_fd.data_base_addr;
743 break;
744 case SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM:
745 if (rmi_fd.intr_src_count) {
746 rfi = kmalloc(sizeof(*rfi),
747 GFP_KERNEL);
748 if (!rfi)
749 return -ENOMEM;
750 retval = synpatics_rmi4_touchpad_detect
751 (pdata, rfi,
752 &rmi_fd,
753 intr_count);
754 if (retval < 0) {
755 kfree(rfi);
756 return retval;
757 }
758 }
759 break;
760 }
761 /* interrupt count for next iteration */
762 intr_count += (rmi_fd.intr_src_count & MASK_3BIT);
763 /*
764 * We only want to add functions to the list
765 * that have data associated with them.
766 */
767 if (rfi && rmi_fd.intr_src_count) {
768 /* link this function info to the RMI module */
769 mutex_lock(&(pdata->fn_list_mutex));
770 list_add_tail(&rfi->link,
771 &pdata->rmi4_mod_info.support_fn_list);
772 mutex_unlock(&(pdata->fn_list_mutex));
773 }
774 } else {
775 /*
776 * A zero in the function number
777 * signals the end of the PDT
778 */
779 dev_dbg(&client->dev,
780 "%s:end of PDT\n", __func__);
781 break;
782 }
783 }
784 /*
785 * calculate the interrupt register count - used in the
786 * ISR to read the correct number of interrupt registers
787 */
788 pdata->number_of_interrupt_register = (intr_count + 7) / 8;
789 /*
790 * Function $01 will be used to query the product properties,
791 * and product ID so we had to read the PDT above first to get
792 * the Fn $01 query address and prior to filling in the product
793 * info. NOTE: Even an unflashed device will still have FN $01.
794 */
795
796 /* Load up the standard queries and get the RMI4 module info */
797 retval = synaptics_rmi4_i2c_block_read(pdata,
798 pdata->fn01_query_base_addr,
799 std_queries,
800 sizeof(std_queries));
801 if (retval != sizeof(std_queries)) {
802 dev_err(&client->dev, "%s:Failed reading queries\n",
803 __func__);
804 return -EIO;
805 }
806
807 /* Currently supported RMI version is 4.0 */
808 pdata->rmi4_mod_info.version_major = 4;
809 pdata->rmi4_mod_info.version_minor = 0;
810 /*
811 * get manufacturer id, product_props, product info,
812 * date code, tester id, serial num and product id (name)
813 */
814 pdata->rmi4_mod_info.manufacturer_id = std_queries[0];
815 pdata->rmi4_mod_info.product_props = std_queries[1];
816 pdata->rmi4_mod_info.product_info[0] = std_queries[2];
817 pdata->rmi4_mod_info.product_info[1] = std_queries[3];
818 /* year - 2001-2032 */
819 pdata->rmi4_mod_info.date_code[0] = std_queries[4] & MASK_5BIT;
820 /* month - 1-12 */
821 pdata->rmi4_mod_info.date_code[1] = std_queries[5] & MASK_4BIT;
822 /* day - 1-31 */
823 pdata->rmi4_mod_info.date_code[2] = std_queries[6] & MASK_5BIT;
824 pdata->rmi4_mod_info.tester_id = ((std_queries[7] & MASK_7BIT) << 8) |
825 (std_queries[8] & MASK_7BIT);
826 pdata->rmi4_mod_info.serial_number =
827 ((std_queries[9] & MASK_7BIT) << 8) |
828 (std_queries[10] & MASK_7BIT);
829 memcpy(pdata->rmi4_mod_info.product_id_string, &std_queries[11], 10);
830
831 /* Check if this is a Synaptics device - report if not. */
832 if (pdata->rmi4_mod_info.manufacturer_id != 1)
833 dev_err(&client->dev, "non-Synaptics mfg id:%d\n",
834 pdata->rmi4_mod_info.manufacturer_id);
835
836 list_for_each_entry(rfi, &pdata->rmi4_mod_info.support_fn_list, link)
837 data_sources += rfi->num_of_data_sources;
838 if (data_sources) {
839 rmi = &(pdata->rmi4_mod_info);
840 list_for_each_entry(rfi, &rmi->support_fn_list, link) {
841 if (rfi->num_of_data_sources) {
842 if (rfi->fn_number ==
843 SYNAPTICS_RMI4_TOUCHPAD_FUNC_NUM) {
844 retval = synaptics_rmi4_touchpad_config
845 (pdata, rfi);
846 if (retval < 0)
847 return retval;
848 } else
849 dev_err(&client->dev,
850 "%s:fn_number not supported\n",
851 __func__);
852 /*
853 * Turn on interrupts for this
854 * function's data sources.
855 */
856 ctrl_offset = pdata->fn01_ctrl_base_addr + 1 +
857 rfi->index_to_intr_reg;
858 retval = synaptics_rmi4_i2c_byte_write(pdata,
859 ctrl_offset,
860 rfi->intr_mask);
861 if (retval < 0)
862 return retval;
863 }
864 }
865 }
866 return 0;
867 }
868
869 /*
870 * Descriptor structure.
871 * Describes the number of i2c devices on the bus that speak RMI.
872 */
873 static struct synaptics_rmi4_platform_data synaptics_rmi4_platformdata = {
874 .irq_type = (IRQF_TRIGGER_FALLING | IRQF_SHARED),
875 .x_flip = false,
876 .y_flip = true,
877 };
878
879 /**
880 * synaptics_rmi4_probe() - Initialze the i2c-client touchscreen driver
881 * @i2c: i2c client structure pointer
882 * @id:i2c device id pointer
883 *
884 * This function will allocate and initialize the instance
885 * data and request the irq and set the instance data as the clients
886 * platform data then register the physical driver which will do a scan of
887 * the rmi4 Physical Device Table and enumerate any rmi4 functions that
888 * have data sources associated with them.
889 */
synaptics_rmi4_probe(struct i2c_client * client,const struct i2c_device_id * dev_id)890 static int synaptics_rmi4_probe
891 (struct i2c_client *client, const struct i2c_device_id *dev_id)
892 {
893 int retval;
894 unsigned char intr_status[4];
895 struct synaptics_rmi4_data *rmi4_data;
896 const struct synaptics_rmi4_platform_data *platformdata =
897 client->dev.platform_data;
898
899 if (!i2c_check_functionality(client->adapter,
900 I2C_FUNC_SMBUS_BYTE_DATA)) {
901 dev_err(&client->dev, "i2c smbus byte data not supported\n");
902 return -EIO;
903 }
904
905 if (!platformdata)
906 platformdata = &synaptics_rmi4_platformdata;
907
908 /* Allocate and initialize the instance data for this client */
909 rmi4_data = kcalloc(2, sizeof(struct synaptics_rmi4_data),
910 GFP_KERNEL);
911 if (!rmi4_data)
912 return -ENOMEM;
913
914 rmi4_data->input_dev = input_allocate_device();
915 if (rmi4_data->input_dev == NULL) {
916 retval = -ENOMEM;
917 goto err_input;
918 }
919
920 rmi4_data->regulator = regulator_get(&client->dev, "vdd");
921 if (IS_ERR(rmi4_data->regulator)) {
922 dev_err(&client->dev, "%s:get regulator failed\n",
923 __func__);
924 retval = PTR_ERR(rmi4_data->regulator);
925 goto err_get_regulator;
926 }
927 retval = regulator_enable(rmi4_data->regulator);
928 if (retval < 0) {
929 dev_err(&client->dev, "%s:regulator enable failed\n",
930 __func__);
931 goto err_regulator_enable;
932 }
933 init_waitqueue_head(&rmi4_data->wait);
934 /*
935 * Copy i2c_client pointer into RTID's i2c_client pointer for
936 * later use in rmi4_read, rmi4_write, etc.
937 */
938 rmi4_data->i2c_client = client;
939 /* So we set the page correctly the first time */
940 rmi4_data->current_page = MASK_16BIT;
941 rmi4_data->board = platformdata;
942 rmi4_data->touch_stopped = false;
943
944 /* init the mutexes for maintain the lists */
945 mutex_init(&(rmi4_data->fn_list_mutex));
946 mutex_init(&(rmi4_data->rmi4_page_mutex));
947
948 /*
949 * Register physical driver - this will call the detect function that
950 * will then scan the device and determine the supported
951 * rmi4 functions.
952 */
953 retval = synaptics_rmi4_i2c_query_device(rmi4_data);
954 if (retval) {
955 dev_err(&client->dev, "%s: rmi4 query device failed\n",
956 __func__);
957 goto err_query_dev;
958 }
959
960 /* Store the instance data in the i2c_client */
961 i2c_set_clientdata(client, rmi4_data);
962
963 /*initialize the input device parameters */
964 rmi4_data->input_dev->name = DRIVER_NAME;
965 rmi4_data->input_dev->phys = "Synaptics_Clearpad";
966 rmi4_data->input_dev->id.bustype = BUS_I2C;
967 rmi4_data->input_dev->dev.parent = &client->dev;
968 input_set_drvdata(rmi4_data->input_dev, rmi4_data);
969
970 /* Initialize the function handlers for rmi4 */
971 set_bit(EV_SYN, rmi4_data->input_dev->evbit);
972 set_bit(EV_KEY, rmi4_data->input_dev->evbit);
973 set_bit(EV_ABS, rmi4_data->input_dev->evbit);
974
975 input_set_abs_params(rmi4_data->input_dev, ABS_MT_POSITION_X, 0,
976 rmi4_data->sensor_max_x, 0, 0);
977 input_set_abs_params(rmi4_data->input_dev, ABS_MT_POSITION_Y, 0,
978 rmi4_data->sensor_max_y, 0, 0);
979 input_set_abs_params(rmi4_data->input_dev, ABS_MT_TOUCH_MAJOR, 0,
980 MAX_TOUCH_MAJOR, 0, 0);
981 input_mt_init_slots(rmi4_data->input_dev,
982 rmi4_data->fingers_supported, 0);
983
984 /* Clear interrupts */
985 synaptics_rmi4_i2c_block_read(rmi4_data,
986 rmi4_data->fn01_data_base_addr + 1, intr_status,
987 rmi4_data->number_of_interrupt_register);
988 retval = request_threaded_irq(client->irq, NULL,
989 synaptics_rmi4_irq,
990 platformdata->irq_type,
991 DRIVER_NAME, rmi4_data);
992 if (retval) {
993 dev_err(&client->dev, "Unable to get attn irq %d\n",
994 client->irq);
995 goto err_query_dev;
996 }
997
998 retval = input_register_device(rmi4_data->input_dev);
999 if (retval) {
1000 dev_err(&client->dev, "%s:input register failed\n", __func__);
1001 goto err_free_irq;
1002 }
1003
1004 return retval;
1005
1006 err_free_irq:
1007 free_irq(client->irq, rmi4_data);
1008 err_query_dev:
1009 regulator_disable(rmi4_data->regulator);
1010 err_regulator_enable:
1011 regulator_put(rmi4_data->regulator);
1012 err_get_regulator:
1013 input_free_device(rmi4_data->input_dev);
1014 rmi4_data->input_dev = NULL;
1015 err_input:
1016 kfree(rmi4_data);
1017
1018 return retval;
1019 }
1020 /**
1021 * synaptics_rmi4_remove() - Removes the i2c-client touchscreen driver
1022 * @client: i2c client structure pointer
1023 *
1024 * This function uses to remove the i2c-client
1025 * touchscreen driver and returns integer.
1026 */
synaptics_rmi4_remove(struct i2c_client * client)1027 static int synaptics_rmi4_remove(struct i2c_client *client)
1028 {
1029 struct synaptics_rmi4_data *rmi4_data = i2c_get_clientdata(client);
1030
1031 rmi4_data->touch_stopped = true;
1032 wake_up(&rmi4_data->wait);
1033 free_irq(client->irq, rmi4_data);
1034 input_unregister_device(rmi4_data->input_dev);
1035 regulator_disable(rmi4_data->regulator);
1036 regulator_put(rmi4_data->regulator);
1037 kfree(rmi4_data);
1038
1039 return 0;
1040 }
1041
1042 #ifdef CONFIG_PM
1043 /**
1044 * synaptics_rmi4_suspend() - suspend the touch screen controller
1045 * @dev: pointer to device structure
1046 *
1047 * This function is used to suspend the
1048 * touch panel controller and returns integer
1049 */
synaptics_rmi4_suspend(struct device * dev)1050 static int synaptics_rmi4_suspend(struct device *dev)
1051 {
1052 /* Touch sleep mode */
1053 int retval;
1054 unsigned char intr_status;
1055 struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
1056
1057 rmi4_data->touch_stopped = true;
1058 disable_irq(rmi4_data->i2c_client->irq);
1059
1060 retval = synaptics_rmi4_i2c_block_read(rmi4_data,
1061 rmi4_data->fn01_data_base_addr + 1,
1062 &intr_status,
1063 rmi4_data->number_of_interrupt_register);
1064 if (retval < 0)
1065 return retval;
1066
1067 retval = synaptics_rmi4_i2c_byte_write(rmi4_data,
1068 rmi4_data->fn01_ctrl_base_addr + 1,
1069 (intr_status & ~TOUCHPAD_CTRL_INTR));
1070 if (retval < 0)
1071 return retval;
1072
1073 regulator_disable(rmi4_data->regulator);
1074
1075 return 0;
1076 }
1077 /**
1078 * synaptics_rmi4_resume() - resume the touch screen controller
1079 * @dev: pointer to device structure
1080 *
1081 * This function is used to resume the touch panel
1082 * controller and returns integer.
1083 */
synaptics_rmi4_resume(struct device * dev)1084 static int synaptics_rmi4_resume(struct device *dev)
1085 {
1086 int retval;
1087 unsigned char intr_status;
1088 struct synaptics_rmi4_data *rmi4_data = dev_get_drvdata(dev);
1089
1090 retval = regulator_enable(rmi4_data->regulator);
1091 if (retval) {
1092 dev_err(dev, "Regulator enable failed (%d)\n", retval);
1093 return retval;
1094 }
1095
1096 enable_irq(rmi4_data->i2c_client->irq);
1097 rmi4_data->touch_stopped = false;
1098
1099 retval = synaptics_rmi4_i2c_block_read(rmi4_data,
1100 rmi4_data->fn01_data_base_addr + 1,
1101 &intr_status,
1102 rmi4_data->number_of_interrupt_register);
1103 if (retval < 0)
1104 return retval;
1105
1106 retval = synaptics_rmi4_i2c_byte_write(rmi4_data,
1107 rmi4_data->fn01_ctrl_base_addr + 1,
1108 (intr_status | TOUCHPAD_CTRL_INTR));
1109 if (retval < 0)
1110 return retval;
1111
1112 return 0;
1113 }
1114
1115 #endif
1116
1117 static SIMPLE_DEV_PM_OPS(synaptics_rmi4_dev_pm_ops, synaptics_rmi4_suspend,
1118 synaptics_rmi4_resume);
1119
1120 static const struct i2c_device_id synaptics_rmi4_id_table[] = {
1121 { DRIVER_NAME, 0 },
1122 { },
1123 };
1124 MODULE_DEVICE_TABLE(i2c, synaptics_rmi4_id_table);
1125
1126 static struct i2c_driver synaptics_rmi4_driver = {
1127 .driver = {
1128 .name = DRIVER_NAME,
1129 .owner = THIS_MODULE,
1130 .pm = &synaptics_rmi4_dev_pm_ops,
1131 },
1132 .probe = synaptics_rmi4_probe,
1133 .remove = synaptics_rmi4_remove,
1134 .id_table = synaptics_rmi4_id_table,
1135 };
1136
1137 module_i2c_driver(synaptics_rmi4_driver);
1138
1139 MODULE_LICENSE("GPL v2");
1140 MODULE_AUTHOR("naveen.gaddipati@stericsson.com, js.ha@stericsson.com");
1141 MODULE_DESCRIPTION("synaptics rmi4 i2c touch Driver");
1142 MODULE_ALIAS("i2c:synaptics_rmi4_ts");
1143