2 * Atmel maXTouch Touchscreen Controller Driver
5 * Copyright (C) 2010 Atmel Corporation
6 * Copyright (C) 2010 Ulf Samuelsson (ulf@atmel.com)
7 * Copyright (C) 2009 Raphael Derosso Pereira <raphaelpereira@gmail.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; version 2 of the License
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * Driver for Atmel maXTouch family of touch controllers.
29 #include <linux/i2c.h>
30 #include <linux/interrupt.h>
31 #include <linux/input.h>
32 #include <linux/debugfs.h>
33 #include <linux/cdev.h>
34 #include <linux/mutex.h>
35 #include <linux/slab.h>
36 #include <mach/gpio.h>
37 #include <asm/uaccess.h>
39 #include <linux/atmel_maxtouch.h>
40 #include <linux/delay.h>
43 #define DRIVER_VERSION "0.91a_mod"
47 static int debug = DEBUG_TRACE;
49 module_param(debug, int, 0644);
50 module_param(comms, int, 0644);
52 MODULE_PARM_DESC(debug, "Activate debugging output");
53 MODULE_PARM_DESC(comms, "Select communications mode");
55 /* Device Info descriptor */
56 /* Parsed from maXTouch "Id information" inside device */
57 struct mxt_device_info {
66 char family_name[16]; /* Family name */
67 char variant_name[16]; /* Variant name */
68 u16 num_nodes; /* Number of sensor nodes */
71 /* object descriptor table, parsed from maXTouch "object table" */
81 /* Mapping from report id to object type and instance */
82 struct report_id_map {
86 * This is the first report ID belonging to object. It enables us to
87 * find out easily the touch number: each touch has different report
88 * ID (which are assigned to touches in increasing order). By
89 * subtracting the first report ID from current, we get the touch
96 /* Driver datastructure */
98 struct i2c_client *client;
99 struct input_dev *input;
107 int valid_irq_counter;
108 int invalid_irq_counter;
111 int read_fail_counter;
116 struct delayed_work dwork;
122 struct mxt_device_info device_info;
125 u32 configuration_crc;
127 struct report_id_map *rid_map;
128 struct mxt_object *object_table;
136 int (*init_hw)(struct i2c_client *client);
137 int (*exit_hw)(struct i2c_client *client);
138 u8 (*valid_interrupt)(void);
139 u8 (*read_chg)(void);
141 /* debugfs variables */
142 struct dentry *debug_dir;
143 int current_debug_datap;
145 struct mutex debug_mutex;
148 /* Character device variables */
150 struct cdev cdev_messages; /* 2nd Char dev for messages */
152 struct class *mxt_class;
158 /* Message buffer & pointers */
160 int msg_buffer_startp, msg_buffer_endp;
161 /* Put only non-touch messages to buffer if this is set */
162 char nontouch_msg_only;
163 struct mutex msg_mutex;
172 const struct mxt_key_info key_info[] = {
182 0x83, 0x00, 0x00, 0x12, 0x0b, 0x00, 0x00, 0x1e,
183 0x02, 0x06, 0x00, 0x03, 0x01, 0x0f, 0x0A, 0x0a,
184 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
185 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64,
188 static int mxt_read_block(struct i2c_client *client, u16 addr, u16 length,
190 static int mxt_write_byte(struct i2c_client *client, u16 addr, u8 value);
191 static int mxt_write_block(struct i2c_client *client, u16 addr, u16 length,
193 static u8 mxt_valid_interrupt_dummy(void)
198 #define I2C_RETRY_COUNT 5
199 #define I2C_PAYLOAD_SIZE 254
201 /* Returns the start address of object in mXT memory. */
202 #define MXT_BASE_ADDR(object_type, mxt) \
203 get_object_address(object_type, 0, mxt->object_table, \
204 mxt->device_info.num_objs)
206 /* Maps a report ID to an object type (object type number). */
207 #define REPORT_ID_TO_OBJECT(rid, mxt) \
208 (((rid) == 0xff) ? 0 : mxt->rid_map[rid].object)
210 /* Maps a report ID to an object type (string). */
211 #define REPORT_ID_TO_OBJECT_NAME(rid, mxt) \
212 object_type_name[REPORT_ID_TO_OBJECT(rid, mxt)]
214 /* Returns non-zero if given object is a touch object */
215 #define IS_TOUCH_OBJECT(object) \
216 ((object == MXT_TOUCH_MULTITOUCHSCREEN_T9) || \
217 (object == MXT_TOUCH_KEYARRAY_T15) || \
218 (object == MXT_TOUCH_PROXIMITY_T23) || \
219 (object == MXT_TOUCH_SINGLETOUCHSCREEN_T10) || \
220 (object == MXT_TOUCH_XSLIDER_T11) || \
221 (object == MXT_TOUCH_YSLIDER_T12) || \
222 (object == MXT_TOUCH_XWHEEL_T13) || \
223 (object == MXT_TOUCH_YWHEEL_T14) || \
224 (object == MXT_TOUCH_KEYSET_T31) || \
225 (object == MXT_TOUCH_XSLIDERSET_T32) ? 1 : 0)
227 #define mxt_debug(level, ...) \
229 if (debug >= (level)) \
230 pr_debug(__VA_ARGS__); \
233 #define mxt_debug(level, ...) \
235 printk(__VA_ARGS__); \
240 * Check whether we have multi-touch enabled kernel; if not, report just the
241 * first touch (on mXT224, the maximum is 10 simultaneous touches).
242 * Because just the 1st one is reported, it might seem that the screen is not
243 * responding to touch if the first touch is removed while the screen is being
244 * touched by another finger, so beware.
248 #ifdef ABS_MT_TRACKING_ID
249 static inline void report_mt(int touch_number, int size, int x, int y, struct
251 input_report_abs(mxt->input, ABS_MT_TRACKING_ID, touch_number);
252 input_report_abs(mxt->input, ABS_MT_TOUCH_MAJOR, size);
253 input_report_abs(mxt->input, ABS_MT_POSITION_X, x);
254 input_report_abs(mxt->input, ABS_MT_POSITION_Y, y);
255 input_mt_sync(mxt->input);
258 static inline void report_mt(int touch_number, int size, int x, int y, struct
260 if (touch_number == 0) {
261 input_report_abs(mxt->input, ABS_TOOL_WIDTH, size);
262 input_report_abs(mxt->input, ABS_X, x);
263 input_report_abs(mxt->input, ABS_Y, y);
269 static inline void report_gesture(int data, struct mxt_data *mxt)
271 input_event(mxt->input, EV_MSC, MSC_GESTURE, data);
275 static const u8 *object_type_name[] = {
277 [5] = "GEN_MESSAGEPROCESSOR_T5",
278 [6] = "GEN_COMMANDPROCESSOR_T6",
279 [7] = "GEN_POWERCONFIG_T7",
280 [8] = "GEN_ACQUIRECONFIG_T8",
281 [9] = "TOUCH_MULTITOUCHSCREEN_T9",
282 [15] = "TOUCH_KEYARRAY_T15",
283 [17] = "SPT_COMMSCONFIG_T18",
284 [19] = "SPT_GPIOPWM_T19",
285 [20] = "PROCI_GRIPFACESUPPRESSION_T20",
286 [22] = "PROCG_NOISESUPPRESSION_T22",
287 [23] = "TOUCH_PROXIMITY_T23",
288 [24] = "PROCI_ONETOUCHGESTUREPROCESSOR_T24",
289 [25] = "SPT_SELFTEST_T25",
290 [27] = "PROCI_TWOTOUCHGESTUREPROCESSOR_T27",
291 [28] = "SPT_CTECONFIG_T28",
292 [37] = "DEBUG_DIAGNOSTICS_T37",
293 [38] = "SPT_USER_DATA_T38",
294 [40] = "PROCI_GRIPSUPPRESSION_T40",
295 [41] = "PROCI_PALMSUPPRESSION_T41",
296 [42] = "PROCI_FACESUPPRESSION_T42",
297 [43] = "SPT_DIGITIZER_T43",
298 [44] = "SPT_MESSAGECOUNT_T44",
302 static u16 get_object_address(uint8_t object_type,
304 struct mxt_object *object_table,
307 int mxt_write_ap(struct mxt_data *mxt, u16 ap);
309 static int mxt_read_block_wo_addr(struct i2c_client *client,
313 ssize_t debug_data_read(struct mxt_data *mxt, char *buf, size_t count,
314 loff_t *ppos, u8 debug_command){
326 u8 debug_command_reg;
328 data = mxt->debug_data;
332 /* If first read after open, read all data to buffer. */
333 if (mxt->current_debug_datap == 0){
335 diagnostics_reg = MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6,
337 MXT_ADR_T6_DIAGNOSTIC;
338 if (count > (mxt->device_info.num_nodes * 2))
339 count = mxt->device_info.num_nodes;
341 debug_data_addr = MXT_BASE_ADDR(MXT_DEBUG_DIAGNOSTIC_T37, mxt)+
343 page_address = MXT_BASE_ADDR(MXT_DEBUG_DIAGNOSTIC_T37, mxt) +
345 error = mxt_read_block(mxt->client, page_address, 1, &page);
348 mxt_debug(DEBUG_TRACE, "debug data page = %d\n", page);
350 error = mxt_write_byte(mxt->client,
352 MXT_CMD_T6_PAGE_DOWN);
355 /* Wait for command to be handled; when it has, the
356 register will be cleared. */
357 debug_command_reg = 1;
358 while (debug_command_reg != 0) {
359 error = mxt_read_block(mxt->client,
364 mxt_debug(DEBUG_TRACE,
365 "Waiting for debug diag command "
366 "to propagate...\n");
369 error = mxt_read_block(mxt->client, page_address, 1,
373 mxt_debug(DEBUG_TRACE, "debug data page = %d\n", page);
377 * Lock mutex to prevent writing some unwanted data to debug
378 * command register. User can still write through the char
379 * device interface though. TODO: fix?
382 mutex_lock(&mxt->debug_mutex);
383 /* Configure Debug Diagnostics object to show deltas/refs */
384 error = mxt_write_byte(mxt->client, diagnostics_reg,
387 /* Wait for command to be handled; when it has, the
388 * register will be cleared. */
389 debug_command_reg = 1;
390 while (debug_command_reg != 0) {
391 error = mxt_read_block(mxt->client,
396 mxt_debug(DEBUG_TRACE, "Waiting for debug diag command "
397 "to propagate...\n");
403 "Error writing to maXTouch device!\n");
407 size = mxt->device_info.num_nodes * sizeof(u16);
410 read_size = size > 128 ? 128 : size;
411 mxt_debug(DEBUG_TRACE,
412 "Debug data read loop, reading %d bytes...\n",
414 error = mxt_read_block(mxt->client,
417 (u8 *) &data[offset]);
420 "Error reading debug data\n");
423 offset += read_size/2;
426 /* Select next page */
427 error = mxt_write_byte(mxt->client, diagnostics_reg,
431 "Error writing to maXTouch device!\n");
435 mutex_unlock(&mxt->debug_mutex);
439 i = mxt->current_debug_datap;
441 while (((buf- buf_start) < (count - 6)) &&
442 (i < mxt->device_info.num_nodes)){
444 mxt->current_debug_datap++;
445 if (debug_command == MXT_CMD_T6_REFERENCES_MODE)
446 buf += sprintf(buf, "%d: %5d\n", i,
447 (u16) le16_to_cpu(data[i]));
448 else if (debug_command == MXT_CMD_T6_DELTAS_MODE)
449 buf += sprintf(buf, "%d: %5d\n", i,
450 (s16) le16_to_cpu(data[i]));
454 return (buf - buf_start);
456 mutex_unlock(&mxt->debug_mutex);
460 ssize_t deltas_read(struct file *file, char *buf, size_t count, loff_t *ppos)
462 return debug_data_read(file->private_data, buf, count, ppos,
463 MXT_CMD_T6_DELTAS_MODE);
466 ssize_t refs_read(struct file *file, char *buf, size_t count,
469 return debug_data_read(file->private_data, buf, count, ppos,
470 MXT_CMD_T6_REFERENCES_MODE);
473 int debug_data_open(struct inode *inode, struct file *file)
475 struct mxt_data *mxt;
477 mxt = inode->i_private;
480 mxt->current_debug_datap = 0;
481 mxt->debug_data = kmalloc(mxt->device_info.num_nodes * sizeof(u16),
483 if (mxt->debug_data == NULL)
487 for (i = 0; i < mxt->device_info.num_nodes; i++)
488 mxt->debug_data[i] = 7777;
491 file->private_data = mxt;
495 int debug_data_release(struct inode *inode, struct file *file)
497 struct mxt_data *mxt;
498 mxt = file->private_data;
499 kfree(mxt->debug_data);
503 static struct file_operations delta_fops = {
504 .owner = THIS_MODULE,
505 .open = debug_data_open,
506 .release = debug_data_release,
510 static struct file_operations refs_fops = {
511 .owner = THIS_MODULE,
512 .open = debug_data_open,
513 .release = debug_data_release,
518 int mxt_memory_open(struct inode *inode, struct file *file)
520 struct mxt_data *mxt;
521 mxt = container_of(inode->i_cdev, struct mxt_data, cdev);
524 file->private_data = mxt;
528 int mxt_message_open(struct inode *inode, struct file *file)
530 struct mxt_data *mxt;
531 mxt = container_of(inode->i_cdev, struct mxt_data, cdev_messages);
534 file->private_data = mxt;
539 ssize_t mxt_memory_read(struct file *file, char *buf, size_t count,
543 struct mxt_data *mxt;
545 mxt = file->private_data;
547 mxt_debug(DEBUG_TRACE, "Reading %d bytes from current ap\n",
549 i = mxt_read_block_wo_addr(mxt->client, count, (u8 *) buf);
551 mxt_debug(DEBUG_TRACE, "Address pointer changed since set;"
552 "writing AP (%d) before reading %d bytes",
553 mxt->address_pointer, (int) count);
554 i = mxt_read_block(mxt->client, mxt->address_pointer, count,
561 ssize_t mxt_memory_write(struct file *file, const char *buf, size_t count,
567 struct mxt_data *mxt;
570 mxt = file->private_data;
571 address = mxt->address_pointer;
573 mxt_debug(DEBUG_TRACE, "mxt_memory_write entered\n");
574 whole_blocks = count / I2C_PAYLOAD_SIZE;
575 last_block_size = count % I2C_PAYLOAD_SIZE;
577 for (i = 0; i < whole_blocks; i++) {
578 mxt_debug(DEBUG_TRACE, "About to write to %d...",
580 mxt_write_block(mxt->client, address, I2C_PAYLOAD_SIZE,
582 address += I2C_PAYLOAD_SIZE;
583 buf += I2C_PAYLOAD_SIZE;
586 mxt_write_block(mxt->client, address, last_block_size, (u8 *) buf);
591 static int mxt_ioctl(struct inode *inode, struct file *file,
592 unsigned int cmd, unsigned long arg)
595 struct mxt_data *mxt;
598 mxt = file->private_data;
601 case MXT_SET_ADDRESS_IOCTL:
602 retval = mxt_write_ap(mxt, (u16) arg);
604 mxt->address_pointer = (u16) arg;
608 case MXT_RESET_IOCTL:
609 retval = mxt_write_byte(mxt->client,
610 MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +
614 case MXT_CALIBRATE_IOCTL:
615 retval = mxt_write_byte(mxt->client,
616 MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +
617 MXT_ADR_T6_CALIBRATE,
621 case MXT_BACKUP_IOCTL:
622 retval = mxt_write_byte(mxt->client,
623 MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +
627 case MXT_NONTOUCH_MSG_IOCTL:
628 mxt->nontouch_msg_only = 1;
630 case MXT_ALL_MSG_IOCTL:
631 mxt->nontouch_msg_only = 0;
641 * Copies messages from buffer to user space.
643 * NOTE: if less than (mxt->message_size * 5 + 1) bytes requested,
644 * this will return 0!
647 ssize_t mxt_message_read(struct file *file, char *buf, size_t count,
651 struct mxt_data *mxt;
654 mxt = file->private_data;
659 mutex_lock(&mxt->msg_mutex);
660 /* Copy messages until buffer empty, or 'count' bytes written */
661 while ((mxt->msg_buffer_startp != mxt->msg_buffer_endp) &&
662 ((buf - buf_start) < (count - (5 * mxt->message_size) - 1))){
664 for (i = 0; i < mxt->message_size; i++){
665 buf += sprintf(buf, "[%2X] ",
666 *(mxt->messages + mxt->msg_buffer_endp *
667 mxt->message_size + i));
669 buf += sprintf(buf, "\n");
670 if (mxt->msg_buffer_endp < MXT_MESSAGE_BUFFER_SIZE)
671 mxt->msg_buffer_endp++;
673 mxt->msg_buffer_endp = 0;
675 mutex_unlock(&mxt->msg_mutex);
676 return (buf - buf_start);
679 static struct file_operations mxt_message_fops = {
680 .owner = THIS_MODULE,
681 .open = mxt_message_open,
682 .read = mxt_message_read,
685 static struct file_operations mxt_memory_fops = {
686 .owner = THIS_MODULE,
687 .open = mxt_memory_open,
688 .read = mxt_memory_read,
689 .write = mxt_memory_write,
694 /* Writes the address pointer (to set up following reads). */
696 int mxt_write_ap(struct mxt_data *mxt, u16 ap)
698 struct i2c_client *client;
699 __le16 le_ap = cpu_to_le16(ap);
700 client = mxt->client;
702 mxt->last_read_addr = -1;
703 if (i2c_master_send(client, (u8 *) &le_ap, 2) == 2) {
704 mxt_debug(DEBUG_TRACE, "Address pointer set to %d\n", ap);
707 mxt_debug(DEBUG_INFO, "Error writing address pointer!\n");
714 /* Calculates the 24-bit CRC sum. */
715 static u32 CRC_24(u32 crc, u8 byte1, u8 byte2)
717 static const u32 crcpoly = 0x80001B;
721 data_word = ((((u16) byte2) << 8u) | byte1);
722 result = ((crc << 1u) ^ data_word);
723 if (result & 0x1000000)
728 /* Returns object address in mXT chip, or zero if object is not found */
729 static u16 get_object_address(uint8_t object_type,
731 struct mxt_object *object_table,
734 uint8_t object_table_index = 0;
735 uint8_t address_found = 0;
736 uint16_t address = 0;
737 struct mxt_object *obj;
739 while ((object_table_index < max_objs) && !address_found) {
740 obj = &object_table[object_table_index];
741 if (obj->type == object_type) {
743 /* Are there enough instances defined in the FW? */
744 if (obj->instances >= instance) {
745 address = obj->chip_addr +
746 (obj->size + 1) * instance;
751 object_table_index++;
758 * Reads a block of bytes from given address from mXT chip. If we are
759 * reading from message window, and previous read was from message window,
760 * there's no need to write the address pointer: the mXT chip will
761 * automatically set the address pointer back to message window start.
764 static int mxt_read_block(struct i2c_client *client,
769 struct i2c_adapter *adapter = client->adapter;
770 struct i2c_msg msg[2];
772 struct mxt_data *mxt;
774 mxt = i2c_get_clientdata(client);
777 if ((mxt->last_read_addr == addr) &&
778 (addr == mxt->msg_proc_addr)) {
779 if (i2c_master_recv(client, value, length) == length){
785 mxt->last_read_addr = addr;
789 mxt_debug(DEBUG_TRACE, "Writing address pointer & reading %d bytes "
790 "in on i2c transaction...\n", length);
792 le_addr = cpu_to_le16(addr);
793 msg[0].addr = client->addr;
796 msg[0].buf = (u8 *) &le_addr;
798 msg[1].addr = client->addr;
799 msg[1].flags = I2C_M_RD;
801 msg[1].buf = (u8 *) value;
802 if (i2c_transfer(adapter, msg, 2) == 2)
809 /* Reads a block of bytes from current address from mXT chip. */
811 static int mxt_read_block_wo_addr(struct i2c_client *client,
817 if (i2c_master_recv(client, value, length) == length) {
818 mxt_debug(DEBUG_TRACE, "I2C block read ok\n");
821 mxt_debug(DEBUG_INFO, "I2C block read failed\n");
828 /* Writes one byte to given address in mXT chip. */
830 static int mxt_write_byte(struct i2c_client *client, u16 addr, u8 value)
838 struct mxt_data *mxt;
840 mxt = i2c_get_clientdata(client);
842 mxt->last_read_addr = -1;
843 i2c_byte_transfer.le_addr = cpu_to_le16(addr);
844 i2c_byte_transfer.data = value;
845 if (i2c_master_send(client, (u8 *) &i2c_byte_transfer, 3) == 3)
852 /* Writes a block of bytes (max 256) to given address in mXT chip. */
853 static int mxt_write_block(struct i2c_client *client,
863 } i2c_block_transfer;
865 struct mxt_data *mxt;
867 mxt_debug(DEBUG_TRACE, "Writing %d bytes to %d...", length, addr);
870 mxt = i2c_get_clientdata(client);
872 mxt->last_read_addr = -1;
873 for (i = 0; i < length; i++)
874 i2c_block_transfer.data[i] = *value++;
875 i2c_block_transfer.le_addr = cpu_to_le16(addr);
876 i = i2c_master_send(client, (u8 *) &i2c_block_transfer, length + 2);
877 if (i == (length + 2))
883 /* Calculates the CRC value for mXT infoblock. */
884 int calculate_infoblock_crc(u32 *crc_result, u8 *data, int crc_area_size)
889 for (i = 0; i < (crc_area_size - 1); i = i + 2)
890 crc = CRC_24(crc, *(data + i), *(data + i + 1));
891 /* If uneven size, pad with zero */
892 if (crc_area_size & 0x0001)
893 crc = CRC_24(crc, *(data + i), 0);
894 /* Return only 24 bits of CRC. */
895 *crc_result = (crc & 0x00FFFFFF);
900 /* Processes a touchscreen message. */
901 void process_T9_message(u8 *message, struct mxt_data *mxt, int last_touch)
904 struct input_dev *input;
913 static int stored_size[10];
914 static int stored_x[10];
915 static int stored_y[10];
917 int active_touches = 0;
919 * If the 'last_touch' flag is set, we have received all the touch
921 * there are available in this cycle, so send the events for touches
926 /* TODO: For compatibility with single-touch systems, send ABS_X &
930 input_report_abs(mxt->input, ABS_X, stored_x[0]);
931 input_report_abs(mxt->input, ABS_Y, stored_y[0]);
935 for (i = 0; i < 10; i++){
938 input_report_abs(mxt->input,
941 input_report_abs(mxt->input,
944 input_report_abs(mxt->input,
947 input_report_abs(mxt->input,
950 input_mt_sync(mxt->input);
953 if (active_touches == 0) {
954 input_mt_sync(mxt->input);
956 input_sync(mxt->input);
961 status = message[MXT_MSG_T9_STATUS];
962 report_id = message[0];
964 if (status & MXT_MSGB_T9_SUPPRESS) {
965 /* Touch has been suppressed by grip/face */
967 mxt_debug(DEBUG_TRACE, "SUPRESS");
969 /* Put together the 10-/12-bit coordinate values. */
970 xpos = message[MXT_MSG_T9_XPOSMSB] * 16 +
971 ((message[MXT_MSG_T9_XYPOSLSB] >> 4) & 0xF);
972 ypos = message[MXT_MSG_T9_YPOSMSB] * 16 +
973 ((message[MXT_MSG_T9_XYPOSLSB] >> 0) & 0xF);
975 if (mxt->max_x_val < 1024)
977 if (mxt->max_y_val < 1024)
980 touch_number = message[MXT_MSG_REPORTID] -
981 mxt->rid_map[report_id].first_rid;
983 stored_x[touch_number] = xpos;
984 stored_y[touch_number] = ypos;
986 if (status & MXT_MSGB_T9_DETECT) {
988 * mXT224 reports the number of touched nodes,
989 * so the exact value for touch ellipse major
990 * axis length in nodes would be 2*sqrt(touch_size/pi)
991 * (assuming round touch shape), which would then need
992 * to be scaled using information about how many sensor
993 * lines we do have. So this is very much simplified,
994 * but sufficient for most if not all apps?
996 touch_size = message[MXT_MSG_T9_TCHAREA];
997 touch_size = touch_size >> 2;
1001 * report_mt(touch_number, touch_size, xpos, ypos, mxt);
1004 stored_size[touch_number] = touch_size;
1006 if (status & MXT_MSGB_T9_AMP)
1007 /* Amplitude of touch has changed */
1008 amplitude = message[MXT_MSG_T9_TCHAMPLITUDE];
1011 if (status & MXT_MSGB_T9_RELEASE) {
1012 /* The previously reported touch has been removed.*/
1013 /* report_mt(touch_number, 0, xpos, ypos, mxt); */
1014 stored_size[touch_number] = 0;
1017 /* input_sync(input); */
1020 if (status & MXT_MSGB_T9_SUPPRESS) {
1021 mxt_debug(DEBUG_TRACE, "SUPRESS");
1023 if (status & MXT_MSGB_T9_DETECT) {
1024 mxt_debug(DEBUG_TRACE, "DETECT:%s%s%s%s\n",
1025 ((status & MXT_MSGB_T9_PRESS) ? " PRESS" : ""),
1026 ((status & MXT_MSGB_T9_MOVE) ? " MOVE" : ""),
1027 ((status & MXT_MSGB_T9_AMP) ? " AMP" : ""),
1028 ((status & MXT_MSGB_T9_VECTOR) ? " VECT" : ""));
1030 } else if (status & MXT_MSGB_T9_RELEASE) {
1031 mxt_debug(DEBUG_TRACE, "RELEASE\n");
1034 mxt_debug(DEBUG_TRACE,"X=%d, Y=%d, TOUCHSIZE=%d\n",
1035 xpos, ypos, touch_size);
1041 int process_message(u8 *message, u8 object, struct mxt_data *mxt)
1043 struct i2c_client *client;
1052 static u8 error_cond = 0;
1055 client = mxt->client;
1056 length = mxt->message_size;
1057 report_id = message[0];
1059 if ((mxt->nontouch_msg_only == 0) ||
1060 (!IS_TOUCH_OBJECT(object))){
1061 mutex_lock(&mxt->msg_mutex);
1062 /* Copy the message to buffer */
1063 if (mxt->msg_buffer_startp < MXT_MESSAGE_BUFFER_SIZE) {
1064 mxt->msg_buffer_startp++;
1066 mxt->msg_buffer_startp = 0;
1069 if (mxt->msg_buffer_startp == mxt->msg_buffer_endp) {
1070 mxt_debug(DEBUG_TRACE,
1071 "Message buf full, discarding last entry.\n");
1072 if (mxt->msg_buffer_endp < MXT_MESSAGE_BUFFER_SIZE) {
1073 mxt->msg_buffer_endp++;
1075 mxt->msg_buffer_endp = 0;
1078 memcpy((mxt->messages + mxt->msg_buffer_startp * length),
1081 mutex_unlock(&mxt->msg_mutex);
1085 case MXT_GEN_COMMANDPROCESSOR_T6:
1086 status = message[1];
1088 if (status & MXT_MSGB_T6_COMSERR) {
1089 if ((!error_cond) & MXT_MSGB_T6_COMSERR){
1090 dev_err(&client->dev,
1091 "maXTouch checksum error\n");
1092 error_cond |= MXT_MSGB_T6_COMSERR;
1095 if (status & MXT_MSGB_T6_CFGERR) {
1097 * Configuration error. A proper configuration
1098 * needs to be written to chip and backed up.
1100 if ((!error_cond) & MXT_MSGB_T6_CFGERR){
1101 dev_err(&client->dev,
1102 "maXTouch configuration error\n");
1103 error_cond |= MXT_MSGB_T6_CFGERR;
1106 if (status & MXT_MSGB_T6_CAL) {
1107 /* Calibration in action, no need to react */
1108 dev_info(&client->dev,
1109 "maXTouch calibration in progress\n");
1111 if (status & MXT_MSGB_T6_SIGERR) {
1113 * Signal acquisition error, something is seriously
1114 * wrong, not much we can in the driver to correct
1117 if ((!error_cond) & MXT_MSGB_T6_SIGERR){
1118 dev_err(&client->dev,
1119 "maXTouch acquisition error\n");
1120 error_cond |= MXT_MSGB_T6_SIGERR;
1123 if (status & MXT_MSGB_T6_OFL) {
1125 * Cycle overflow, the acquisition interval is too
1128 dev_err(&client->dev,
1129 "maXTouch cycle overflow\n");
1131 if (status & MXT_MSGB_T6_RESET) {
1132 /* Chip has reseted, no need to react. */
1133 dev_info(&client->dev,
1134 "maXTouch chip reset\n");
1137 /* Chip status back to normal. */
1138 dev_info(&client->dev,
1139 "maXTouch status normal\n");
1144 case MXT_TOUCH_MULTITOUCHSCREEN_T9:
1145 process_T9_message(message, mxt, 0);
1148 case MXT_SPT_GPIOPWM_T19:
1149 if (debug >= DEBUG_TRACE)
1150 dev_info(&client->dev,
1151 "Receiving GPIO message\n");
1154 case MXT_PROCI_GRIPFACESUPPRESSION_T20:
1155 if (debug >= DEBUG_TRACE)
1156 dev_info(&client->dev,
1157 "Receiving face suppression msg\n");
1160 case MXT_PROCG_NOISESUPPRESSION_T22:
1161 if (debug >= DEBUG_TRACE)
1162 dev_info(&client->dev,
1163 "Receiving noise suppression msg\n");
1164 status = message[MXT_MSG_T22_STATUS];
1165 if (status & MXT_MSGB_T22_FHCHG) {
1166 if (debug >= DEBUG_TRACE)
1167 dev_info(&client->dev,
1168 "maXTouch: Freq changed\n");
1170 if (status & MXT_MSGB_T22_GCAFERR) {
1171 if (debug >= DEBUG_TRACE)
1172 dev_info(&client->dev,
1173 "maXTouch: High noise "
1176 if (status & MXT_MSGB_T22_FHERR) {
1177 if (debug >= DEBUG_TRACE)
1178 dev_info(&client->dev,
1179 "maXTouch: Freq changed - "
1180 "Noise level too high\n");
1184 case MXT_PROCI_ONETOUCHGESTUREPROCESSOR_T24:
1185 if (debug >= DEBUG_TRACE)
1186 dev_info(&client->dev,
1187 "Receiving one-touch gesture msg\n");
1189 event = message[MXT_MSG_T24_STATUS] & 0x0F;
1190 xpos = message[MXT_MSG_T24_XPOSMSB] * 16 +
1191 ((message[MXT_MSG_T24_XYPOSLSB] >> 4) & 0x0F);
1192 ypos = message[MXT_MSG_T24_YPOSMSB] * 16 +
1193 ((message[MXT_MSG_T24_XYPOSLSB] >> 0) & 0x0F);
1194 if (mxt->max_x_val < 1024)
1196 if (mxt->max_y_val < 1024)
1198 direction = message[MXT_MSG_T24_DIR];
1199 distance = message[MXT_MSG_T24_DIST] +
1200 (message[MXT_MSG_T24_DIST + 1] << 16);
1202 report_gesture((event << 24) | (direction << 16) | distance,
1204 report_gesture((xpos << 16) | ypos, mxt);
1208 case MXT_SPT_SELFTEST_T25:
1209 if (debug >= DEBUG_TRACE)
1210 dev_info(&client->dev,
1211 "Receiving Self-Test msg\n");
1213 if (message[MXT_MSG_T25_STATUS] == MXT_MSGR_T25_OK) {
1214 if (debug >= DEBUG_TRACE)
1215 dev_info(&client->dev,
1216 "maXTouch: Self-Test OK\n");
1219 dev_err(&client->dev,
1220 "maXTouch: Self-Test Failed [%02x]:"
1221 "{%02x,%02x,%02x,%02x,%02x}\n",
1222 message[MXT_MSG_T25_STATUS],
1223 message[MXT_MSG_T25_STATUS + 0],
1224 message[MXT_MSG_T25_STATUS + 1],
1225 message[MXT_MSG_T25_STATUS + 2],
1226 message[MXT_MSG_T25_STATUS + 3],
1227 message[MXT_MSG_T25_STATUS + 4]
1232 case MXT_PROCI_TWOTOUCHGESTUREPROCESSOR_T27:
1233 if (debug >= DEBUG_TRACE)
1234 dev_info(&client->dev,
1235 "Receiving 2-touch gesture message\n");
1237 event = message[MXT_MSG_T27_STATUS] & 0xF0;
1238 xpos = message[MXT_MSG_T27_XPOSMSB] * 16 +
1239 ((message[MXT_MSG_T27_XYPOSLSB] >> 4) & 0x0F);
1240 ypos = message[MXT_MSG_T27_YPOSMSB] * 16 +
1241 ((message[MXT_MSG_T27_XYPOSLSB] >> 0) & 0x0F);
1242 if (mxt->max_x_val < 1024)
1244 if (mxt->max_y_val < 1024)
1247 direction = message[MXT_MSG_T27_ANGLE];
1248 distance = message[MXT_MSG_T27_SEPARATION] +
1249 (message[MXT_MSG_T27_SEPARATION + 1] << 16);
1251 report_gesture((event << 24) | (direction << 16) | distance,
1253 report_gesture((xpos << 16) | ypos, mxt);
1258 case MXT_SPT_CTECONFIG_T28:
1259 if (debug >= DEBUG_TRACE)
1260 dev_info(&client->dev,
1261 "Receiving CTE message...\n");
1262 status = message[MXT_MSG_T28_STATUS];
1263 if (status & MXT_MSGB_T28_CHKERR)
1264 dev_err(&client->dev,
1265 "maXTouch: Power-Up CRC failure\n");
1268 case MXT_TOUCH_KEYARRAY_T15:
1270 status = message[1] >> 7;
1272 last_key = message[2];
1296 printk("%s: Default keyIndex [0x%x]\n", __func__, keyIndex);
1300 input_report_key(mxt->input, key_info[keyIndex].code, status);
1303 if (debug >= DEBUG_TRACE)
1304 dev_info(&client->dev,
1305 "maXTouch: Unknown message!\n");
1315 * Processes messages when the interrupt line (CHG) is asserted. Keeps
1316 * reading messages until a message with report ID 0xFF is received,
1317 * which indicates that there is no more new messages.
1321 static void mxt_worker(struct work_struct *work)
1323 struct mxt_data *mxt;
1324 struct i2c_client *client;
1333 char *message_string;
1334 char *message_start;
1337 mxt = container_of(work, struct mxt_data, dwork.work);
1338 disable_irq(mxt->irq);
1339 client = mxt->client;
1340 message_addr = mxt->msg_proc_addr;
1341 message_length = mxt->message_size;
1343 if (message_length < 256) {
1344 message = kmalloc(message_length, GFP_KERNEL);
1345 if (message == NULL) {
1346 dev_err(&client->dev, "Error allocating memory\n");
1350 dev_err(&client->dev,
1351 "Message length larger than 256 bytes not supported\n");
1355 mxt_debug(DEBUG_TRACE, "maXTouch worker active: \n");
1358 /* Read next message, reread on failure. */
1359 /* TODO: message length, CRC included? */
1360 mxt->message_counter++;
1361 for (i = 1; i < I2C_RETRY_COUNT; i++) {
1362 error = mxt_read_block(client,
1368 mxt->read_fail_counter++;
1369 dev_err(&client->dev,
1370 "Failure reading maxTouch device\n");
1377 if (mxt->address_pointer != message_addr)
1379 report_id = message[0];
1381 if (debug >= DEBUG_RAW) {
1382 mxt_debug(DEBUG_RAW, "%s message [msg count: %08x]:",
1383 REPORT_ID_TO_OBJECT_NAME(report_id, mxt),
1384 mxt->message_counter
1386 /* 5 characters per one byte */
1387 message_string = kmalloc(message_length * 5,
1389 if (message_string == NULL) {
1390 dev_err(&client->dev,
1391 "Error allocating memory\n");
1395 message_start = message_string;
1396 for (i = 0; i < message_length; i++) {
1398 sprintf(message_string,
1399 "0x%02X ", message[i]);
1401 mxt_debug(DEBUG_RAW, "%s", message_start);
1402 kfree(message_start);
1405 if ((report_id != MXT_END_OF_MESSAGES) && (report_id != 0)) {
1406 memcpy(mxt->last_message, message, message_length);
1409 /* Get type of object and process the message */
1410 object = mxt->rid_map[report_id].object;
1411 process_message(message, object, mxt);
1414 mxt_debug(DEBUG_TRACE, "chgline: %d\n", mxt->read_chg());
1415 } while (comms ? (mxt->read_chg() == 0) :
1416 ((report_id != MXT_END_OF_MESSAGES) && (report_id != 0)));
1418 /* All messages processed, send the events) */
1419 process_T9_message(NULL, mxt, 1);
1423 enable_irq(mxt->irq);
1424 /* Make sure we just didn't miss a interrupt. */
1425 if (mxt->read_chg() == 0){
1426 schedule_delayed_work(&mxt->dwork, 0);
1432 * The maXTouch device will signal the host about a new message by asserting
1433 * the CHG line. This ISR schedules a worker routine to read the message when
1437 static irqreturn_t mxt_irq_handler(int irq, void *_mxt)
1439 struct mxt_data *mxt = _mxt;
1442 if (mxt->valid_interrupt()) {
1443 /* Send the signal only if falling edge generated the irq. */
1444 cancel_delayed_work(&mxt->dwork);
1445 schedule_delayed_work(&mxt->dwork, 0);
1446 mxt->valid_irq_counter++;
1448 mxt->invalid_irq_counter++;
1457 /******************************************************************************/
1458 /* Initialization of driver */
1459 /******************************************************************************/
1461 static int __devinit mxt_identify(struct i2c_client *client,
1462 struct mxt_data *mxt,
1465 u8 buf[MXT_ID_BLOCK_SIZE];
1471 /* Read Device info to check if chip is valid */
1472 error = mxt_read_block(client, MXT_ADDR_INFO_BLOCK, MXT_ID_BLOCK_SIZE,
1476 mxt->read_fail_counter++;
1477 dev_err(&client->dev, "Failure accessing maXTouch device\n");
1481 memcpy(id_block_data, buf, MXT_ID_BLOCK_SIZE);
1483 mxt->device_info.family_id = buf[0];
1484 mxt->device_info.variant_id = buf[1];
1485 mxt->device_info.major = ((buf[2] >> 4) & 0x0F);
1486 mxt->device_info.minor = (buf[2] & 0x0F);
1487 mxt->device_info.build = buf[3];
1488 mxt->device_info.x_size = buf[4];
1489 mxt->device_info.y_size = buf[5];
1490 mxt->device_info.num_objs = buf[6];
1491 mxt->device_info.num_nodes = mxt->device_info.x_size *
1492 mxt->device_info.y_size;
1495 * Check Family & Variant Info; warn if not recognized but
1500 if (mxt->device_info.family_id == MXT224_FAMILYID) {
1501 strcpy(mxt->device_info.family_name, "mXT224");
1503 if (mxt->device_info.variant_id == MXT224_CAL_VARIANTID) {
1504 strcpy(mxt->device_info.variant_name, "Calibrated");
1505 } else if (mxt->device_info.variant_id ==
1506 MXT224_UNCAL_VARIANTID) {
1507 strcpy(mxt->device_info.variant_name, "Uncalibrated");
1509 dev_err(&client->dev,
1510 "Warning: maXTouch Variant ID [%d] not "
1512 mxt->device_info.variant_id);
1513 strcpy(mxt->device_info.variant_name, "UNKNOWN");
1514 /* identified = -ENXIO; */
1518 } else if (mxt->device_info.family_id == MXT1386_FAMILYID) {
1519 strcpy(mxt->device_info.family_name, "mXT1386");
1521 if (mxt->device_info.variant_id == MXT1386_CAL_VARIANTID) {
1522 strcpy(mxt->device_info.variant_name, "Calibrated");
1524 dev_err(&client->dev,
1525 "Warning: maXTouch Variant ID [%d] not "
1527 mxt->device_info.variant_id);
1528 strcpy(mxt->device_info.variant_name, "UNKNOWN");
1529 /* identified = -ENXIO; */
1531 /* Unknown family ID! */
1533 dev_err(&client->dev,
1534 "Warning: maXTouch Family ID [%d] not supported\n",
1535 mxt->device_info.family_id);
1536 strcpy(mxt->device_info.family_name, "UNKNOWN");
1537 strcpy(mxt->device_info.variant_name, "UNKNOWN");
1538 /* identified = -ENXIO; */
1543 "Atmel maXTouch (Family %s (%X), Variant %s (%X)) Firmware "
1544 "version [%d.%d] Build %d\n",
1545 mxt->device_info.family_name,
1546 mxt->device_info.family_id,
1547 mxt->device_info.variant_name,
1548 mxt->device_info.variant_id,
1549 mxt->device_info.major,
1550 mxt->device_info.minor,
1551 mxt->device_info.build
1555 "Atmel maXTouch Configuration "
1556 "[X: %d] x [Y: %d]\n",
1557 mxt->device_info.x_size,
1558 mxt->device_info.y_size
1564 * Reads the object table from maXTouch chip to get object data like
1565 * address, size, report id. For Info Block CRC calculation, already read
1566 * id data is passed to this function too (Info Block consists of the ID
1567 * block and object table).
1570 static int __devinit mxt_read_object_table(struct i2c_client *client,
1571 struct mxt_data *mxt,
1574 u16 report_id_count;
1575 u8 buf[MXT_OBJECT_TABLE_ELEMENT_SIZE];
1580 u8 object_instances;
1581 u8 object_report_ids;
1582 u16 object_info_address;
1589 u8 object_report_id;
1591 int first_report_id;
1593 struct mxt_object *object_table;
1595 mxt_debug(DEBUG_TRACE, "maXTouch driver reading configuration\n");
1597 object_table = kzalloc(sizeof(struct mxt_object) *
1598 mxt->device_info.num_objs,
1600 if (object_table == NULL) {
1601 printk(KERN_WARNING "maXTouch: Memory allocation failed!\n");
1603 goto err_object_table_alloc;
1606 raw_ib_data = kmalloc(MXT_OBJECT_TABLE_ELEMENT_SIZE *
1607 mxt->device_info.num_objs + MXT_ID_BLOCK_SIZE,
1609 if (raw_ib_data == NULL) {
1610 printk(KERN_WARNING "maXTouch: Memory allocation failed!\n");
1615 /* Copy the ID data for CRC calculation. */
1616 memcpy(raw_ib_data, raw_id_data, MXT_ID_BLOCK_SIZE);
1617 ib_pointer = MXT_ID_BLOCK_SIZE;
1619 mxt->object_table = object_table;
1621 mxt_debug(DEBUG_TRACE, "maXTouch driver Memory allocated\n");
1623 object_info_address = MXT_ADDR_OBJECT_TABLE;
1625 report_id_count = 0;
1626 for (i = 0; i < mxt->device_info.num_objs; i++) {
1627 mxt_debug(DEBUG_TRACE, "Reading maXTouch at [0x%04x]: ",
1628 object_info_address);
1630 error = mxt_read_block(client, object_info_address,
1631 MXT_OBJECT_TABLE_ELEMENT_SIZE, buf);
1634 mxt->read_fail_counter++;
1635 dev_err(&client->dev,
1636 "maXTouch Object %d could not be read\n", i);
1638 goto err_object_read;
1641 memcpy(raw_ib_data + ib_pointer, buf,
1642 MXT_OBJECT_TABLE_ELEMENT_SIZE);
1643 ib_pointer += MXT_OBJECT_TABLE_ELEMENT_SIZE;
1645 object_type = buf[0];
1646 object_address = (buf[2] << 8) + buf[1];
1647 object_size = buf[3] + 1;
1648 object_instances = buf[4] + 1;
1649 object_report_ids = buf[5];
1650 mxt_debug(DEBUG_TRACE, "Type=%03d, Address=0x%04x, "
1651 "Size=0x%02x, %d instances, %d report id's\n",
1659 /* TODO: check whether object is known and supported? */
1661 /* Save frequently needed info. */
1662 if (object_type == MXT_GEN_MESSAGEPROCESSOR_T5) {
1663 mxt->msg_proc_addr = object_address;
1664 mxt->message_size = object_size;
1667 object_table[i].type = object_type;
1668 object_table[i].chip_addr = object_address;
1669 object_table[i].size = object_size;
1670 object_table[i].instances = object_instances;
1671 object_table[i].num_report_ids = object_report_ids;
1672 report_id_count += object_instances * object_report_ids;
1674 object_info_address += MXT_OBJECT_TABLE_ELEMENT_SIZE;
1678 kzalloc(sizeof(struct report_id_map) * (report_id_count + 1),
1679 /* allocate for report_id 0, even if not used */
1681 if (mxt->rid_map == NULL) {
1682 printk(KERN_WARNING "maXTouch: Can't allocate memory!\n");
1684 goto err_rid_map_alloc;
1687 mxt->messages = kzalloc(mxt->message_size * MXT_MESSAGE_BUFFER_SIZE,
1689 if (mxt->messages == NULL) {
1690 printk(KERN_WARNING "maXTouch: Can't allocate memory!\n");
1695 mxt->last_message = kzalloc(mxt->message_size, GFP_KERNEL);
1696 if (mxt->last_message == NULL) {
1697 printk(KERN_WARNING "maXTouch: Can't allocate memory!\n");
1702 mxt->report_id_count = report_id_count;
1703 if (report_id_count > 254) { /* 0 & 255 are reserved */
1704 dev_err(&client->dev,
1705 "Too many maXTouch report id's [%d]\n",
1711 /* Create a mapping from report id to object type */
1712 report_id = 1; /* Start from 1, 0 is reserved. */
1714 /* Create table associating report id's with objects & instances */
1715 for (i = 0; i < mxt->device_info.num_objs; i++) {
1716 for (object_instance = 0;
1717 object_instance < object_table[i].instances;
1719 first_report_id = report_id;
1720 for (object_report_id = 0;
1721 object_report_id < object_table[i].num_report_ids;
1722 object_report_id++) {
1723 mxt->rid_map[report_id].object =
1724 object_table[i].type;
1725 mxt->rid_map[report_id].instance =
1727 mxt->rid_map[report_id].first_rid =
1734 /* Read 3 byte CRC */
1735 error = mxt_read_block(client, object_info_address, 3, buf);
1737 mxt->read_fail_counter++;
1738 dev_err(&client->dev, "Error reading CRC\n");
1741 crc = (buf[2] << 16) | (buf[1] << 8) | buf[0];
1743 if (calculate_infoblock_crc(&calculated_crc, raw_ib_data,
1745 printk(KERN_WARNING "Error while calculating CRC!\n");
1750 mxt_debug(DEBUG_TRACE, "\nReported info block CRC = 0x%6X\n", crc);
1751 mxt_debug(DEBUG_TRACE, "Calculated info block CRC = 0x%6X\n\n",
1754 if (crc == calculated_crc) {
1755 mxt->info_block_crc = crc;
1757 mxt->info_block_crc = 0;
1758 printk(KERN_ALERT "maXTouch: Info block CRC invalid!\n");
1761 if (debug >= DEBUG_VERBOSE) {
1763 dev_info(&client->dev, "maXTouch: %d Objects\n",
1764 mxt->device_info.num_objs);
1766 for (i = 0; i < mxt->device_info.num_objs; i++) {
1767 dev_info(&client->dev, "Type:\t\t\t[%d]: %s\n",
1768 object_table[i].type,
1769 object_type_name[object_table[i].type]);
1770 dev_info(&client->dev, "\tAddress:\t0x%04X\n",
1771 object_table[i].chip_addr);
1772 dev_info(&client->dev, "\tSize:\t\t%d Bytes\n",
1773 object_table[i].size);
1774 dev_info(&client->dev, "\tInstances:\t%d\n",
1775 object_table[i].instances);
1776 dev_info(&client->dev, "\tReport Id's:\t%d\n",
1777 object_table[i].num_report_ids);
1785 kfree(mxt->last_message);
1787 kfree(mxt->rid_map);
1792 kfree(object_table);
1793 err_object_table_alloc:
1797 static int __devinit mxt_probe(struct i2c_client *client,
1798 const struct i2c_device_id *id)
1800 struct mxt_data *mxt;
1801 struct mxt_platform_data *pdata;
1802 struct input_dev *input;
1806 u8 buf[MXT_ACK_BUFFER_SIZE] = {0};
1807 u8 buf_size = MXT_MAKE_HIGH_CHG_SIZE_MIN;
1808 char t7_buf[2] = {64, 32};
1810 mxt_debug(DEBUG_INFO, "mXT224: mxt_probe\n");
1812 if (client == NULL) {
1813 pr_debug("maXTouch: client == NULL\n");
1815 } else if (client->adapter == NULL) {
1816 pr_debug("maXTouch: client->adapter == NULL\n");
1818 } else if (&client->dev == NULL) {
1819 pr_debug("maXTouch: client->dev == NULL\n");
1821 } else if (&client->adapter->dev == NULL) {
1822 pr_debug("maXTouch: client->adapter->dev == NULL\n");
1824 } else if (id == NULL) {
1825 pr_debug("maXTouch: id == NULL\n");
1829 mxt_debug(DEBUG_INFO, "maXTouch driver v. %s\n", DRIVER_VERSION);
1830 mxt_debug(DEBUG_INFO, "\t \"%s\"\n", client->name);
1831 mxt_debug(DEBUG_INFO, "\taddr:\t0x%04x\n", client->addr);
1832 mxt_debug(DEBUG_INFO, "\tirq:\t%d\n", client->irq);
1833 mxt_debug(DEBUG_INFO, "\tflags:\t0x%04x\n", client->flags);
1834 mxt_debug(DEBUG_INFO, "\tadapter:\"%s\"\n", client->adapter->name);
1835 mxt_debug(DEBUG_INFO, "\tdevice:\t\"%s\"\n", client->dev.init_name);
1837 mxt_debug(DEBUG_TRACE, "maXTouch driver functionality OK\n");
1839 /* Allocate structure - we need it to identify device */
1840 mxt = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
1842 dev_err(&client->dev, "insufficient memory\n");
1847 id_data = kmalloc(MXT_ID_BLOCK_SIZE, GFP_KERNEL);
1848 if (id_data == NULL) {
1849 dev_err(&client->dev, "insufficient memory\n");
1854 input = input_allocate_device();
1856 dev_err(&client->dev, "error allocating input device\n");
1858 goto err_input_dev_alloc;
1861 /* Initialize Platform data */
1863 pdata = client->dev.platform_data;
1864 if (pdata == NULL) {
1865 dev_err(&client->dev, "platform data is required!\n");
1869 if (debug >= DEBUG_TRACE)
1870 printk(KERN_INFO "Platform OK: pdata = 0x%08x\n",
1871 (unsigned int) pdata);
1873 mxt->read_fail_counter = 0;
1874 mxt->message_counter = 0;
1875 mxt->max_x_val = pdata->max_x;
1876 mxt->max_y_val = pdata->max_y;
1878 /* Get data that is defined in board specific code. */
1879 mxt->init_hw = pdata->init_platform_hw;
1880 mxt->exit_hw = pdata->exit_platform_hw;
1881 mxt->read_chg = pdata->read_chg;
1883 if (pdata->valid_interrupt != NULL)
1884 mxt->valid_interrupt = pdata->valid_interrupt;
1886 mxt->valid_interrupt = mxt_valid_interrupt_dummy;
1888 if (mxt->init_hw != NULL)
1889 mxt->init_hw(client);
1891 if (debug >= DEBUG_TRACE)
1892 printk(KERN_INFO "maXTouch driver identifying chip\n");
1894 if (mxt_identify(client, mxt, id_data) < 0) {
1895 dev_err(&client->dev, "Chip could not be identified\n");
1899 /* Chip is valid and active. */
1900 if (debug >= DEBUG_TRACE)
1901 printk(KERN_INFO "maXTouch driver allocating input device\n");
1903 mxt->client = client;
1906 INIT_DELAYED_WORK(&mxt->dwork, mxt_worker);
1907 mutex_init(&mxt->debug_mutex);
1908 mutex_init(&mxt->msg_mutex);
1909 mxt_debug(DEBUG_TRACE, "maXTouch driver creating device name\n");
1913 sizeof(mxt->phys_name),
1915 dev_name(&client->dev)
1917 input->name = "Atmel maXTouch Touchscreen controller";
1918 input->phys = mxt->phys_name;
1919 input->id.bustype = BUS_I2C;
1920 input->dev.parent = &client->dev;
1922 mxt_debug(DEBUG_INFO, "maXTouch name: \"%s\"\n", input->name);
1923 mxt_debug(DEBUG_INFO, "maXTouch phys: \"%s\"\n", input->phys);
1924 mxt_debug(DEBUG_INFO, "maXTouch driver setting abs parameters\n");
1926 set_bit(BTN_TOUCH, input->keybit);
1929 input_set_abs_params(input, ABS_X, 0, mxt->max_x_val, 0, 0);
1930 input_set_abs_params(input, ABS_Y, 0, mxt->max_y_val, 0, 0);
1931 input_set_abs_params(input, ABS_PRESSURE, 0, MXT_MAX_REPORTED_PRESSURE,
1933 input_set_abs_params(input, ABS_TOOL_WIDTH, 0, MXT_MAX_REPORTED_WIDTH,
1937 input_set_abs_params(input, ABS_MT_POSITION_X, 0, mxt->max_x_val, 0, 0);
1938 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, mxt->max_y_val, 0, 0);
1939 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, MXT_MAX_TOUCH_SIZE,
1941 input_set_abs_params(input, ABS_MT_TRACKING_ID, 0, MXT_MAX_NUM_TOUCHES,
1944 __set_bit(EV_ABS, input->evbit);
1945 __set_bit(EV_SYN, input->evbit);
1946 __set_bit(EV_KEY, input->evbit);
1947 __set_bit(EV_MSC, input->evbit);
1948 input->mscbit[0] = BIT_MASK(MSC_GESTURE);
1950 for(index=0; index<(sizeof(key_info)/sizeof(key_info[0])); index++)
1952 input_set_capability(input, EV_KEY, key_info[index].code);
1955 mxt_debug(DEBUG_TRACE, "maXTouch driver setting client data\n");
1956 i2c_set_clientdata(client, mxt);
1957 mxt_debug(DEBUG_TRACE, "maXTouch driver setting drv data\n");
1958 input_set_drvdata(input, mxt);
1959 mxt_debug(DEBUG_TRACE, "maXTouch driver input register device\n");
1960 error = input_register_device(mxt->input);
1962 dev_err(&client->dev,
1963 "Failed to register input device\n");
1964 goto err_register_device;
1967 error = mxt_read_object_table(client, mxt, id_data);
1972 /* Create debugfs entries. */
1973 mxt->debug_dir = debugfs_create_dir("maXTouch", NULL);
1974 if (mxt->debug_dir == ERR_PTR(-ENODEV)) {
1975 /* debugfs is not enabled. */
1976 printk(KERN_WARNING "debugfs not enabled in kernel\n");
1977 } else if (mxt->debug_dir == NULL) {
1978 printk(KERN_WARNING "error creating debugfs dir\n");
1980 mxt_debug(DEBUG_TRACE, "created \"maXTouch\" debugfs dir\n");
1982 debugfs_create_file("deltas", S_IRUSR, mxt->debug_dir, mxt,
1984 debugfs_create_file("refs", S_IRUSR, mxt->debug_dir, mxt,
1988 /* Create character device nodes for reading & writing registers */
1989 mxt->mxt_class = class_create(THIS_MODULE, "maXTouch_memory");
1990 if (IS_ERR(mxt->mxt_class)){
1991 printk(KERN_WARNING "class create failed! exiting...");
1995 /* 2 numbers; one for memory and one for messages */
1996 error = alloc_chrdev_region(&mxt->dev_num, 0, 2,
1998 mxt_debug(DEBUG_VERBOSE,
1999 "device number %d allocated!\n", MAJOR(mxt->dev_num));
2001 printk(KERN_WARNING "Error registering device\n");
2003 cdev_init(&mxt->cdev, &mxt_memory_fops);
2004 cdev_init(&mxt->cdev_messages, &mxt_message_fops);
2006 mxt_debug(DEBUG_VERBOSE, "cdev initialized\n");
2007 mxt->cdev.owner = THIS_MODULE;
2008 mxt->cdev_messages.owner = THIS_MODULE;
2010 error = cdev_add(&mxt->cdev, mxt->dev_num, 1);
2012 printk(KERN_WARNING "Bad cdev\n");
2015 error = cdev_add(&mxt->cdev_messages, mxt->dev_num + 1, 1);
2017 printk(KERN_WARNING "Bad cdev\n");
2020 mxt_debug(DEBUG_VERBOSE, "cdev added\n");
2022 device_create(mxt->mxt_class, NULL, MKDEV(MAJOR(mxt->dev_num), 0), NULL,
2025 device_create(mxt->mxt_class, NULL, MKDEV(MAJOR(mxt->dev_num), 1), NULL,
2026 "maXTouch_messages");
2028 mxt->msg_buffer_startp = 0;
2029 mxt->msg_buffer_endp = 0;
2031 /* Allocate the interrupt */
2032 mxt_debug(DEBUG_TRACE, "maXTouch driver allocating interrupt...\n");
2033 mxt->irq = gpio_to_irq(client->irq);
2034 mxt->valid_irq_counter = 0;
2035 mxt->invalid_irq_counter = 0;
2036 mxt->irq_counter = 0;
2038 //mxt_write_byte(mxt->client, MXT_BASE_ADDR(MXT_TOUCH_MULTITOUCHSCREEN_T9, mxt)+9, 0);
2044 mxt_read_block(mxt->client, MXT_BASE_ADDR(MXT_TOUCH_MULTITOUCHSCREEN_T9, mxt), 31, t9_buf);
2045 printk("Enter:%s, %d mxt 224 T9 Value!==============\n");
2046 for(ii=1; ii<32;ii++) {
2048 printk("%02X ", t9_buf[ii-1]);
2055 for(ii=0; ii<sizeof(T9_cfg); ii++)
2056 mxt_write_byte(mxt->client, MXT_BASE_ADDR(MXT_TOUCH_MULTITOUCHSCREEN_T9, mxt)+ii, T9_cfg[ii]);
2058 mxt_write_block(client, MXT_BASE_ADDR(MXT_GEN_POWERCONFIG_T7, mxt), 2, t7_buf);
2062 /* Try to request IRQ with falling edge first. This is
2063 * not always supported. If it fails, try with any edge. */
2065 error = request_irq(mxt->irq,
2067 IRQF_TRIGGER_FALLING,
2068 client->dev.driver->name,
2071 /* TODO: why only 0 works on STK1000? */
2072 error = request_irq(mxt->irq,
2075 client->dev.driver->name,
2080 dev_err(&client->dev,
2081 "failed to allocate irq %d\n", mxt->irq);
2086 if (debug > DEBUG_INFO)
2087 dev_info(&client->dev, "touchscreen, irq %d\n", mxt->irq);
2090 /* Schedule a worker routine to read any messages that might have
2091 * been sent before interrupts were enabled. */
2092 cancel_delayed_work(&mxt->dwork);
2093 schedule_delayed_work(&mxt->dwork, 0);
2100 kfree(mxt->rid_map);
2101 kfree(mxt->object_table);
2102 kfree(mxt->last_message);
2104 err_register_device:
2107 input_free_device(input);
2108 err_input_dev_alloc:
2111 if (mxt->exit_hw != NULL)
2112 mxt->exit_hw(client);
2118 static int __devexit mxt_remove(struct i2c_client *client)
2120 struct mxt_data *mxt;
2122 mxt = i2c_get_clientdata(client);
2124 /* Remove debug dir entries */
2125 debugfs_remove_recursive(mxt->debug_dir);
2129 if (mxt->exit_hw != NULL)
2130 mxt->exit_hw(client);
2133 free_irq(mxt->irq, mxt);
2136 unregister_chrdev_region(mxt->dev_num, 2);
2137 device_destroy(mxt->mxt_class, MKDEV(MAJOR(mxt->dev_num), 0));
2138 device_destroy(mxt->mxt_class, MKDEV(MAJOR(mxt->dev_num), 1));
2139 cdev_del(&mxt->cdev);
2140 cdev_del(&mxt->cdev_messages);
2141 cancel_delayed_work_sync(&mxt->dwork);
2142 input_unregister_device(mxt->input);
2143 class_destroy(mxt->mxt_class);
2144 debugfs_remove(mxt->debug_dir);
2146 kfree(mxt->rid_map);
2147 kfree(mxt->object_table);
2148 kfree(mxt->last_message);
2152 i2c_set_clientdata(client, NULL);
2153 if (debug >= DEBUG_TRACE)
2154 dev_info(&client->dev, "Touchscreen unregistered\n");
2159 #if defined(CONFIG_PM)
2160 static int mxt_suspend(struct i2c_client *client, pm_message_t mesg)
2162 struct mxt_data *mxt = i2c_get_clientdata(client);
2163 char t7_buf[2] = {0, 0};
2165 printk("Enter:%s, %d\n", __FUNCTION__, __LINE__);
2167 mxt_write_block(client, MXT_BASE_ADDR(MXT_GEN_POWERCONFIG_T7, mxt), 2, t7_buf);
2168 if (device_may_wakeup(&client->dev))
2169 enable_irq_wake(mxt->irq);
2174 static int mxt_resume(struct i2c_client *client)
2176 struct mxt_data *mxt = i2c_get_clientdata(client);
2178 char t7_buf[2] = {64, 32};
2180 printk("Enter:%s, %d\n", __FUNCTION__, __LINE__);
2182 mxt_write_block(client, MXT_BASE_ADDR(MXT_GEN_POWERCONFIG_T7, mxt), 2, t7_buf);
2183 mxt_read_block(client, MXT_BASE_ADDR(MXT_GEN_MESSAGEPROCESSOR_T5, mxt), 10, t5_buf);
2185 if (device_may_wakeup(&client->dev))
2186 disable_irq_wake(mxt->irq);
2191 #define mxt_suspend NULL
2192 #define mxt_resume NULL
2195 static const struct i2c_device_id mxt_idtable[] = {
2200 MODULE_DEVICE_TABLE(i2c, mxt_idtable);
2202 static struct i2c_driver mxt_driver = {
2205 .owner = THIS_MODULE,
2208 .id_table = mxt_idtable,
2210 .remove = __devexit_p(mxt_remove),
2211 .suspend = mxt_suspend,
2212 .resume = mxt_resume,
2216 static int __init mxt_init(void)
2219 err = i2c_add_driver(&mxt_driver);
2221 printk(KERN_WARNING "Adding maXTouch driver failed "
2222 "(errno = %d)\n", err);
2224 mxt_debug(DEBUG_TRACE, "Successfully added driver %s\n",
2225 mxt_driver.driver.name);
2230 static void __exit mxt_cleanup(void)
2232 i2c_del_driver(&mxt_driver);
2236 module_init(mxt_init);
2237 module_exit(mxt_cleanup);
2239 MODULE_AUTHOR("Iiro Valkonen");
2240 MODULE_DESCRIPTION("Driver for Atmel maXTouch Touchscreen Controller");
2241 MODULE_LICENSE("GPL");