2 * Atmel maXTouch Touchscreen Controller Driver
\r
5 * Copyright (C) 2010 Atmel Corporation
\r
6 * Copyright (C) 2009 Raphael Derosso Pereira <raphaelpereira@gmail.com>
\r
8 * This program is free software; you can redistribute it and/or modify
\r
9 * it under the terms of the GNU General Public License as published by
\r
10 * the Free Software Foundation; either version 2 of the License, or
\r
11 * (at your option) any later version.
\r
13 * This program is distributed in the hope that it will be useful,
\r
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
16 * GNU General Public License for more details.
\r
18 * You should have received a copy of the GNU General Public License
\r
19 * along with this program; if not, write to the Free Software
\r
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
\r
25 * Driver for Atmel maXTouch family of touch controllers.
\r
29 #include <linux/i2c.h>
\r
30 #include <linux/interrupt.h>
\r
31 #include <linux/input.h>
\r
32 #include <linux/debugfs.h>
\r
33 #include <linux/cdev.h>
\r
34 #include <linux/mutex.h>
\r
36 #include <asm/uaccess.h>
\r
38 #include <linux/workqueue.h>
\r
39 #include <linux/kernel.h>
\r
40 #include <linux/module.h>
\r
41 #include <linux/gpio.h>
\r
42 #include <linux/slab.h>
\r
43 #include <linux/sched.h>
\r
44 #include <linux/init.h>
\r
45 #include <linux/platform_device.h>
\r
46 #include <linux/irq.h>
\r
48 #include <linux/kthread.h>
\r
49 #include <linux/delay.h>
\r
50 #include <mach/board.h>
\r
51 #include "atmel_mxt1386.h"
\r
53 //#define YANSEN_DEBUG //yansen 20101230 regulator is under control in kernel (sbl too)
\r
55 #include <linux/regulator/consumer.h>
\r
58 #define DRIVER_VERSION "0.9a"
\r
59 #define CONFIG_ABS_MT_TRACKING_ID
\r
61 static int debug = 0;
\r
62 static int comms = 1;
\r
63 static int ts_irq = 0;
\r
64 static u32 last_key=0;
\r
66 module_param(debug, int, 0644);
\r
67 module_param(comms, int, 0644);
\r
69 MODULE_PARM_DESC(debug, "Activate debugging output");
\r
70 MODULE_PARM_DESC(comms, "Select communications mode");
\r
72 static int mxt_read_block(struct i2c_client *client, u16 addr, u16 length,
\r
74 static int mxt_write_byte(struct i2c_client *client, u16 addr, u8 value);
\r
75 static int mxt_write_block(struct i2c_client *client, u16 addr, u16 length,
\r
78 /* Device Info descriptor */
\r
79 /* Parsed from maXTouch "Id information" inside device */
\r
80 struct mxt_device_info {
\r
89 char family_name[16]; /* Family name */
\r
90 char variant_name[16]; /* Variant name */
\r
91 u16 num_nodes; /* Number of sensor nodes */
\r
94 /* object descriptor table, parsed from maXTouch "object table" */
\r
104 /* Mapping from report id to object type and instance */
\r
105 struct report_id_map {
\r
109 * This is the first report ID belonging to object. It enables us to
\r
110 * find out easily the touch number: each touch has different report
\r
111 * ID (which are assigned to touches in increasing order). By
\r
112 * subtracting the first report ID from current, we get the touch
\r
118 /* Driver datastructure */
\r
120 struct i2c_client *client;
\r
121 struct input_dev *input;
\r
122 char phys_name[32];
\r
125 u16 last_read_addr;
\r
129 int valid_irq_counter;
\r
130 int invalid_irq_counter;
\r
132 int message_counter;
\r
133 int read_fail_counter;
\r
137 struct delayed_work dwork;
\r
138 struct work_struct work;
\r
139 struct workqueue_struct *queue;
\r
146 struct mxt_device_info device_info;
\r
148 u32 info_block_crc;
\r
149 u32 configuration_crc;
\r
150 u16 report_id_count;
\r
151 struct report_id_map *rid_map;
\r
152 struct mxt_object *object_table;
\r
160 int (*init_hw)(struct device *dev);
\r
161 void (*exit_hw)(struct device *dev);
\r
162 u8 (*valid_interrupt)(void);
\r
163 u8 (*read_chg)(void);
\r
165 /* debugfs variables */
\r
166 struct dentry *debug_dir;
\r
167 int current_debug_datap;
\r
169 struct mutex debug_mutex;
\r
172 /* Character device variables */
\r
174 struct cdev cdev_messages; /* 2nd Char dev for messages */
\r
176 struct class *mxt_class;
\r
178 u16 address_pointer;
\r
181 /* Message buffer & pointers */
\r
183 int msg_buffer_startp, msg_buffer_endp;
\r
184 /* Put only non-touch messages to buffer if this is set */
\r
185 char nontouch_msg_only;
\r
186 struct mutex msg_mutex;
\r
189 static struct mxt_data *atmel_mxt;
\r
192 #define I2C_RETRY_COUNT 5
\r
193 #define I2C_PAYLOAD_SIZE 254
\r
195 /* Returns the start address of object in mXT memory. */
\r
196 #define MXT_BASE_ADDR(object_type, mxt) \
\r
197 get_object_address(object_type, 0, mxt->object_table, \
\r
198 mxt->device_info.num_objs)
\r
200 /* Maps a report ID to an object type (object type number). */
\r
201 #define REPORT_ID_TO_OBJECT(rid, mxt) \
\r
202 (((rid) == 0xff) ? 0 : mxt->rid_map[rid].object)
\r
204 /* Maps a report ID to an object type (string). */
\r
205 #define REPORT_ID_TO_OBJECT_NAME(rid, mxt) \
\r
206 object_type_name[REPORT_ID_TO_OBJECT(rid, mxt)]
\r
208 /* Returns non-zero if given object is a touch object */
\r
209 #define IS_TOUCH_OBJECT(object) \
\r
210 ((object == MXT_TOUCH_MULTITOUCHSCREEN_T9) || \
\r
211 (object == MXT_TOUCH_KEYARRAY_T15) || \
\r
212 (object == MXT_TOUCH_PROXIMITY_T23) || \
\r
213 (object == MXT_TOUCH_SINGLETOUCHSCREEN_T10) || \
\r
214 (object == MXT_TOUCH_XSLIDER_T11) || \
\r
215 (object == MXT_TOUCH_YSLIDER_T12) || \
\r
216 (object == MXT_TOUCH_XWHEEL_T13) || \
\r
217 (object == MXT_TOUCH_YWHEEL_T14) || \
\r
218 (object == MXT_TOUCH_KEYSET_T31) || \
\r
219 (object == MXT_TOUCH_XSLIDERSET_T32) ? 1 : 0)
\r
221 #define print_ts(level, ...) \
\r
223 if (debug >= (level)) \
\r
224 printk(__VA_ARGS__); \
\r
227 /* following are debug infomation switch, add by acgzx */
\r
228 #define TOUCH_RESET_PIN RK29_PIN6_PC3
\r
229 #define TOUCH_INT_PIN RK29_PIN0_PA2
\r
230 #define LCDC_STANDBY_PIN RK29_PIN6_PD1
\r
231 //#define TS_PEN_IRQ_GPIO RK29_PIN0_PA2//61
\r
233 #define WORKQ_RIGHTNOW 1
\r
234 #define TOUCH_KEY_EN 1
\r
236 /* macro switch for debug log */
\r
237 #define MXT1386_DEBUG_LOG_EN 0// 1
\r
238 #if MXT1386_DEBUG_LOG_EN
\r
239 #define MXT1386_LOG printk
\r
241 #define MXT1386_LOG
\r
244 #define WRITE_MT_CONFIG 1//0
\r
246 struct mxt_key_info{
\r
254 const struct mxt_key_info key_info[] = {
\r
255 {980, 1280, 3100, 4200, KEY_SEARCH},
\r
256 {1600, 1900, 3000, 4200, KEY_HOME},
\r
257 {2200, 2500, 1100, 4200, KEY_MENU},
\r
258 {2750, 3100, 1000, 4200, KEY_BACK},
\r
262 * Check whether we have multi-touch enabled kernel; if not, report just the
\r
263 * first touch (on mXT224, the maximum is 10 simultaneous touches).
\r
264 * Because just the 1st one is reported, it might seem that the screen is not
\r
265 * responding to touch if the first touch is removed while the screen is being
\r
266 * touched by another finger, so beware.
\r
268 * TODO: investigate if there is any standard set of input events that uppper
\r
269 * layers are expecting from a touchscreen? These can however be different for
\r
270 * different platforms, and customers may have different opinions too about
\r
271 * what should be interpreted as right-click, for example.
\r
274 #ifdef EFFICIENT_REPORT
\r
275 static void report_sync(struct mxt_data *mxt)
\r
277 input_sync(mxt->input);
\r
280 static inline void report_mt(int touch_number, int size, int x, int y, struct
\r
282 input_report_abs(mxt->input, ABS_MT_TRACKING_ID, touch_number);
\r
286 input_report_abs(mxt->input, ABS_MT_POSITION_X, x);
\r
287 input_report_abs(mxt->input, ABS_MT_POSITION_Y, y);
\r
288 input_report_abs(mxt->input, ABS_MT_TOUCH_MAJOR, 10);
\r
289 input_report_abs(mxt->input, ABS_MT_WIDTH_MAJOR, 20);
\r
293 input_report_abs(mxt->input, ABS_MT_TOUCH_MAJOR, 0);
\r
294 input_report_abs(mxt->input, ABS_MT_WIDTH_MAJOR, 0);
\r
296 input_mt_sync(mxt->input);
\r
299 #define MAX_FINGERS 5
\r
306 static struct finger fingers[MAX_FINGERS] = {};
\r
308 static void report_mt(int touch_number, int size, int x, int y, struct
\r
311 MXT1386_LOG(KERN_INFO "report_mt touch_number=%d, size=%d, x=%d, t=%d\n", __func__,
\r
312 touch_number, size, x, y);
\r
313 if (touch_number > MAX_FINGERS || touch_number < 0) {
\r
316 fingers[touch_number].x = x;
\r
317 fingers[touch_number].y = y;
\r
318 fingers[touch_number].size = size;
\r
319 MXT1386_LOG(KERN_INFO "report_mt() OUT\n", __func__);
\r
322 static void report_sync(struct mxt_data *mxt)
\r
327 MXT1386_LOG(KERN_INFO "report_sync() IN\n", __func__);
\r
329 for (i = 0; i < MAX_FINGERS; i++) {
\r
330 if (fingers[i].size != 0) {
\r
332 MXT1386_LOG(KERN_INFO "report_sync touch_number=%d, x=%d, y=%d, width=%d\n",
\r
333 i, fingers[i].x, fingers[i].y, fingers[i].size);
\r
334 input_report_abs(mxt->input, ABS_MT_POSITION_X, fingers[i].x);
\r
335 input_report_abs(mxt->input, ABS_MT_POSITION_Y, fingers[i].y);
\r
336 input_report_abs(mxt->input, ABS_MT_TOUCH_MAJOR, 10);
\r
337 input_report_abs(mxt->input, ABS_MT_WIDTH_MAJOR, 20);
\r
338 input_mt_sync(mxt->input);
\r
343 MXT1386_LOG(KERN_INFO "report_sync no fingler\n", __func__);
\r
344 input_report_abs(mxt->input, ABS_MT_TOUCH_MAJOR, 0);
\r
345 input_report_abs(mxt->input, ABS_MT_WIDTH_MAJOR, 0);
\r
346 input_mt_sync(mxt->input);
\r
349 input_sync(mxt->input);
\r
350 MXT1386_LOG(KERN_INFO "report_sync() OUT\n", __func__);
\r
354 static inline void report_gesture(int data, struct mxt_data *mxt)
\r
356 //input_event(mxt->input, EV_MSC, MSC_GESTURE, data);
\r
359 static const u8 *object_type_name[] = {
\r
361 [5] = "GEN_MESSAGEPROCESSOR_T5",
\r
362 [6] = "GEN_COMMANDPROCESSOR_T6",
\r
363 [7] = "GEN_POWERCONFIG_T7",
\r
364 [8] = "GEN_ACQUIRECONFIG_T8",
\r
365 [9] = "TOUCH_MULTITOUCHSCREEN_T9",
\r
366 [15] = "TOUCH_KEYARRAY_T15",
\r
367 [17] = "SPT_COMMSCONFIG_T18",
\r
368 [19] = "SPT_GPIOPWM_T19",
\r
369 [20] = "PROCI_GRIPFACESUPPRESSION_T20",
\r
370 [22] = "PROCG_NOISESUPPRESSION_T22",
\r
371 [23] = "TOUCH_PROXIMITY_T23",
\r
372 [24] = "PROCI_ONETOUCHGESTUREPROCESSOR_T24",
\r
373 [25] = "SPT_SELFTEST_T25",
\r
374 [27] = "PROCI_TWOTOUCHGESTUREPROCESSOR_T27",
\r
375 [28] = "SPT_CTECONFIG_T28",
\r
376 [37] = "DEBUG_DIAGNOSTICS_T37",
\r
377 [38] = "SPT_USER_DATA_T38",
\r
378 [40] = "PROCI_GRIPSUPPRESSION_T40",
\r
379 [41] = "PROCI_PALMSUPPRESSION_T41",
\r
380 [42] = "PROCI_FACESUPPRESSION_T42",
\r
381 [43] = "SPT_DIGITIZER_T43",
\r
382 [44] = "SPT_MESSAGECOUNT_T44",
\r
385 static u16 get_object_address(uint8_t object_type,
\r
387 struct mxt_object *object_table,
\r
390 int mxt_write_ap(struct mxt_data *mxt, u16 ap);
\r
392 static int mxt_read_block_wo_addr(struct i2c_client *client,
\r
396 #if WRITE_MT_CONFIG
\r
397 static const u8 atmel_1386_T7_config[] = {
\r
403 static const u8 atmel_1386_T9_config[] = {
\r
413 7, //1,//7, //ORIENT//xhh
\r
423 0x0f, //XRANGE high
\r
425 0x0f, //YRANGE high
\r
440 static int atmel_1386_write_T7(struct mxt_data *mxt)
\r
443 int size = sizeof(atmel_1386_T7_config);
\r
444 for(i = 0; i<size; i++)
\r
446 ret = mxt_write_byte(mxt->client,
\r
447 MXT_BASE_ADDR(MXT_GEN_POWERCONFIG_T7, mxt) +
\r
449 atmel_1386_T7_config[i]);
\r
452 MXT1386_LOG(KERN_INFO "%s, Error writing to atmel T7!\n", __func__);
\r
458 static int atmel_1386_write_T9(struct mxt_data *mxt)
\r
461 int size = sizeof(atmel_1386_T9_config);
\r
463 for(i = 0; i<size; i++)
\r
465 ret = mxt_write_byte(mxt->client,
\r
466 MXT_BASE_ADDR(MXT_TOUCH_MULTITOUCHSCREEN_T9, mxt) +
\r
468 atmel_1386_T9_config[i]);
\r
471 MXT1386_LOG(KERN_INFO "%s, Error writing to atmel T9!\n", __func__);
\r
477 static int atmel_1386_write_config(struct mxt_data *mxt)
\r
479 atmel_1386_write_T7(mxt);
\r
480 //atmel_1386_write_T9(mxt);
\r
482 mxt_write_byte(mxt->client,
\r
483 MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +
\r
484 MXT_ADR_T6_BACKUPNV,
\r
485 MXT_CMD_T6_BACKUP);
\r
487 mxt_write_byte(mxt->client,
\r
488 MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +
\r
496 static u8 mxt_valid_interrupt_dummy(void)
\r
501 static int mxt_buf_test(const u8 *src, u8 length)
\r
504 u8 *pbuf = (u8*)src;
\r
506 MXT1386_LOG(KERN_INFO "%s, buf test start..., length = %d\n", __func__, length);
\r
507 for(i=0; i<length; i++) {
\r
508 MXT1386_LOG("0x%02x ", pbuf[i]);
\r
512 MXT1386_LOG(KERN_INFO "%s, buf test end...\n", __func__);
\r
517 ssize_t debug_data_read(struct mxt_data *mxt, char *buf, size_t count,
\r
518 loff_t *ppos, u8 debug_command){
\r
521 u16 diagnostics_reg;
\r
527 u16 debug_data_addr;
\r
530 u8 debug_command_reg;
\r
532 data = mxt->debug_data;
\r
536 /* If first read after open, read all data to buffer. */
\r
537 if (mxt->current_debug_datap == 0){
\r
539 diagnostics_reg = MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6,
\r
541 MXT_ADR_T6_DIAGNOSTIC;
\r
542 if (count > (mxt->device_info.num_nodes * 2))
\r
543 count = mxt->device_info.num_nodes;
\r
545 debug_data_addr = MXT_BASE_ADDR(MXT_DEBUG_DIAGNOSTIC_T37, mxt)+
\r
547 page_address = MXT_BASE_ADDR(MXT_DEBUG_DIAGNOSTIC_T37, mxt) +
\r
549 error = mxt_read_block(mxt->client, page_address, 1, &page);
\r
552 MXT1386_LOG(KERN_INFO "debug data page = %d\n", __func__, page);
\r
553 while (page != 0) {
\r
554 error = mxt_write_byte(mxt->client,
\r
556 MXT_CMD_T6_PAGE_DOWN);
\r
559 /* Wait for command to be handled; when it has, the
\r
560 register will be cleared. */
\r
561 debug_command_reg = 1;
\r
562 while (debug_command_reg != 0) {
\r
563 error = mxt_read_block(mxt->client,
\r
564 diagnostics_reg, 1,
\r
565 &debug_command_reg);
\r
568 MXT1386_LOG(KERN_INFO "Waiting for debug diag command "
\r
569 "to propagate...\n", __func__);
\r
572 error = mxt_read_block(mxt->client, page_address, 1,
\r
576 MXT1386_LOG(KERN_INFO "debug data page = %d\n", __func__, page);
\r
580 * Lock mutex to prevent writing some unwanted data to debug
\r
581 * command register. User can still write through the char
\r
582 * device interface though. TODO: fix?
\r
585 mutex_lock(&mxt->debug_mutex);
\r
586 /* Configure Debug Diagnostics object to show deltas/refs */
\r
587 error = mxt_write_byte(mxt->client, diagnostics_reg,
\r
590 /* Wait for command to be handled; when it has, the
\r
591 * register will be cleared. */
\r
592 debug_command_reg = 1;
\r
593 while (debug_command_reg != 0) {
\r
594 error = mxt_read_block(mxt->client,
\r
595 diagnostics_reg, 1,
\r
596 &debug_command_reg);
\r
599 MXT1386_LOG(KERN_INFO "Waiting for debug diag command "
\r
600 "to propagate...\n", __func__);
\r
605 MXT1386_LOG(KERN_INFO "Error writing to maXTouch device!\n", __func__);
\r
609 size = mxt->device_info.num_nodes * sizeof(u16);
\r
612 read_size = size > 128 ? 128 : size;
\r
613 MXT1386_LOG(KERN_INFO "Debug data read loop, reading %d bytes...\n", __func__,
\r
615 error = mxt_read_block(mxt->client,
\r
618 (u8 *) &data[offset]);
\r
620 MXT1386_LOG(KERN_INFO "Error reading debug data\n", __func__);
\r
623 offset += read_size/2;
\r
626 /* Select next page */
\r
627 error = mxt_write_byte(mxt->client, diagnostics_reg,
\r
628 MXT_CMD_T6_PAGE_UP);
\r
630 MXT1386_LOG(KERN_INFO "Error writing to maXTouch device!\n", __func__);
\r
634 mutex_unlock(&mxt->debug_mutex);
\r
638 i = mxt->current_debug_datap;
\r
640 while (((buf- buf_start) < (count - 6)) &&
\r
641 (i < mxt->device_info.num_nodes)){
\r
643 mxt->current_debug_datap++;
\r
644 if (debug_command == MXT_CMD_T6_REFERENCES_MODE)
\r
645 buf += sprintf(buf, "%d: %5d\n", i,
\r
646 (u16) le16_to_cpu(data[i]));
\r
647 else if (debug_command == MXT_CMD_T6_DELTAS_MODE)
\r
648 buf += sprintf(buf, "%d: %5d\n", i,
\r
649 (s16) le16_to_cpu(data[i]));
\r
653 return (buf - buf_start);
\r
655 mutex_unlock(&mxt->debug_mutex);
\r
659 ssize_t deltas_read(struct file *file, char *buf, size_t count, loff_t *ppos)
\r
661 return debug_data_read(file->private_data, buf, count, ppos,
\r
662 MXT_CMD_T6_DELTAS_MODE);
\r
665 ssize_t refs_read(struct file *file, char *buf, size_t count,
\r
668 return debug_data_read(file->private_data, buf, count, ppos,
\r
669 MXT_CMD_T6_REFERENCES_MODE);
\r
672 int debug_data_open(struct inode *inode, struct file *file)
\r
674 struct mxt_data *mxt;
\r
676 mxt = inode->i_private;
\r
679 mxt->current_debug_datap = 0;
\r
680 mxt->debug_data = kmalloc(mxt->device_info.num_nodes * sizeof(u16),
\r
682 if (mxt->debug_data == NULL)
\r
686 for (i = 0; i < mxt->device_info.num_nodes; i++)
\r
687 mxt->debug_data[i] = 7777;
\r
690 file->private_data = mxt;
\r
694 int debug_data_release(struct inode *inode, struct file *file)
\r
696 struct mxt_data *mxt;
\r
697 mxt = file->private_data;
\r
698 kfree(mxt->debug_data);
\r
702 static struct file_operations delta_fops = {
\r
703 .owner = THIS_MODULE,
\r
704 .open = debug_data_open,
\r
705 .release = debug_data_release,
\r
706 .read = deltas_read,
\r
709 static struct file_operations refs_fops = {
\r
710 .owner = THIS_MODULE,
\r
711 .open = debug_data_open,
\r
712 .release = debug_data_release,
\r
717 int mxt_memory_open(struct inode *inode, struct file *file)
\r
719 struct mxt_data *mxt;
\r
720 mxt = container_of(inode->i_cdev, struct mxt_data, cdev);
\r
723 file->private_data = mxt;
\r
727 int mxt_message_open(struct inode *inode, struct file *file)
\r
729 struct mxt_data *mxt;
\r
730 mxt = container_of(inode->i_cdev, struct mxt_data, cdev_messages);
\r
733 file->private_data = mxt;
\r
738 ssize_t mxt_memory_read(struct file *file, char *buf, size_t count,
\r
742 struct mxt_data *mxt;
\r
744 mxt = file->private_data;
\r
745 if (mxt->valid_ap){
\r
746 MXT1386_LOG(KERN_INFO "Reading %d bytes from current ap\n", __func__,
\r
748 i = mxt_read_block_wo_addr(mxt->client, count, (u8 *) buf);
\r
750 MXT1386_LOG(KERN_INFO "Address pointer changed since set;"
\r
751 "writing AP (%d) before reading %d bytes", __func__,
\r
752 mxt->address_pointer, (int) count);
\r
753 i = mxt_read_block(mxt->client, mxt->address_pointer, count,
\r
760 ssize_t mxt_memory_write(struct file *file, const char *buf, size_t count,
\r
765 int last_block_size;
\r
766 struct mxt_data *mxt;
\r
769 mxt = file->private_data;
\r
770 address = mxt->address_pointer;
\r
772 MXT1386_LOG(KERN_INFO "mxt_memory_write entered\n", __func__);
\r
773 whole_blocks = count / I2C_PAYLOAD_SIZE;
\r
774 last_block_size = count % I2C_PAYLOAD_SIZE;
\r
776 for (i = 0; i < whole_blocks; i++) {
\r
777 MXT1386_LOG(KERN_INFO "About to write to %d...\n", __func__,
\r
779 mxt_write_block(mxt->client, address, I2C_PAYLOAD_SIZE,
\r
781 address += I2C_PAYLOAD_SIZE;
\r
782 buf += I2C_PAYLOAD_SIZE;
\r
785 mxt_write_block(mxt->client, address, last_block_size, (u8 *) buf);
\r
791 #define MXT_SET_ADDRESS 0
\r
792 #define MXT_RESET 1
\r
793 #define MXT_CALIBRATE 2
\r
794 #define MXT_BACKUP 3
\r
795 #define MXT_NONTOUCH_MSG 4
\r
796 #define MXT_ALL_MSG 5
\r
798 static int mxt_ioctl(struct inode *inode, struct file *file,
\r
799 unsigned int cmd, unsigned long arg)
\r
802 struct mxt_data *mxt;
\r
805 mxt = file->private_data;
\r
808 case MXT_SET_ADDRESS:
\r
809 retval = mxt_write_ap(mxt, (u16) arg);
\r
811 mxt->address_pointer = (u16) arg;
\r
816 retval = mxt_write_byte(mxt->client,
\r
817 MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +
\r
821 case MXT_CALIBRATE:
\r
822 retval = mxt_write_byte(mxt->client,
\r
823 MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +
\r
824 MXT_ADR_T6_CALIBRATE,
\r
829 retval = mxt_write_byte(mxt->client,
\r
830 MXT_BASE_ADDR(MXT_GEN_COMMANDPROCESSOR_T6, mxt) +
\r
831 MXT_ADR_T6_BACKUPNV,
\r
832 MXT_CMD_T6_BACKUP);
\r
834 case MXT_NONTOUCH_MSG:
\r
835 mxt->nontouch_msg_only = 1;
\r
838 mxt->nontouch_msg_only = 0;
\r
848 * Copies messages from buffer to user space.
\r
850 * NOTE: if less than (mxt->message_size * 5 + 1) bytes requested,
\r
851 * this will return 0!
\r
854 ssize_t mxt_message_read(struct file *file, char *buf, size_t count,
\r
858 struct mxt_data *mxt;
\r
861 mxt = file->private_data;
\r
866 mutex_lock(&mxt->msg_mutex);
\r
867 /* Copy messages until buffer empty, or 'count' bytes written */
\r
868 while ((mxt->msg_buffer_startp != mxt->msg_buffer_endp) &&
\r
869 ((buf - buf_start) < (count - 5 * mxt->message_size - 1))){
\r
871 for (i = 0; i < mxt->message_size; i++){
\r
872 buf += sprintf(buf, "[%2X] ",
\r
873 *(mxt->messages + mxt->msg_buffer_endp *
\r
874 mxt->message_size + i));
\r
876 buf += sprintf(buf, "\n");
\r
877 if (mxt->msg_buffer_endp < MXT_MESSAGE_BUFFER_SIZE)
\r
878 mxt->msg_buffer_endp++;
\r
880 mxt->msg_buffer_endp = 0;
\r
882 mutex_unlock(&mxt->msg_mutex);
\r
883 return (buf - buf_start);
\r
886 static struct file_operations mxt_message_fops = {
\r
887 .owner = THIS_MODULE,
\r
888 .open = mxt_message_open,
\r
889 .read = mxt_message_read,
\r
892 static struct file_operations mxt_memory_fops = {
\r
893 .owner = THIS_MODULE,
\r
894 .open = mxt_memory_open,
\r
895 .read = mxt_memory_read,
\r
896 .write = mxt_memory_write,
\r
897 .ioctl = mxt_ioctl,
\r
901 /* Writes the address pointer (to set up following reads). */
\r
903 int mxt_write_ap(struct mxt_data *mxt, u16 ap)
\r
905 struct i2c_client *client;
\r
906 __le16 le_ap = cpu_to_le16(ap);
\r
907 client = mxt->client;
\r
909 mxt->last_read_addr = -1;
\r
910 if (i2c_master_send(client, (u8 *) &le_ap, 2) == 2) {
\r
911 MXT1386_LOG(KERN_INFO "Address pointer set to %d\n", __func__, ap);
\r
914 MXT1386_LOG(KERN_INFO "Error writing address pointer!\n", __func__);
\r
919 /* Calculates the 24-bit CRC sum. */
\r
920 static u32 CRC_24(u32 crc, u8 byte1, u8 byte2)
\r
922 static const u32 crcpoly = 0x80001B;
\r
926 data_word = ((((u16) byte2) << 8u) | byte1);
\r
927 result = ((crc << 1u) ^ data_word);
\r
928 if (result & 0x1000000)
\r
933 /* Returns object address in mXT chip, or zero if object is not found */
\r
934 static u16 get_object_address(uint8_t object_type,
\r
936 struct mxt_object *object_table,
\r
939 uint8_t object_table_index = 0;
\r
940 uint8_t address_found = 0;
\r
941 uint16_t address = 0;
\r
942 struct mxt_object *obj;
\r
944 while ((object_table_index < max_objs) && !address_found) {
\r
945 obj = &object_table[object_table_index];
\r
946 if (obj->type == object_type) {
\r
948 /* Are there enough instances defined in the FW? */
\r
949 if (obj->instances >= instance) {
\r
950 address = obj->chip_addr +
\r
951 (obj->size + 1) * instance;
\r
956 object_table_index++;
\r
963 * Reads a block of bytes from given address from mXT chip. If we are
\r
964 * reading from message window, and previous read was from message window,
\r
965 * there's no need to write the address pointer: the mXT chip will
\r
966 * automatically set the address pointer back to message window start.
\r
969 static int mxt_read_block(struct i2c_client *client,
\r
974 struct i2c_adapter *adapter = client->adapter;
\r
975 struct i2c_msg msg[2];
\r
977 struct mxt_data *mxt;
\r
979 mxt = i2c_get_clientdata(client);
\r
982 MXT1386_LOG(KERN_INFO "%s: msg addr test, mxt->msg_proc_addr = 0x%x, mxt->last_read_addr = 0x%x, current addr = 0x%x\n",
\r
983 __func__, mxt->msg_proc_addr, mxt->last_read_addr, addr);
\r
985 if ((mxt->last_read_addr == addr) &&
\r
986 (addr == mxt->msg_proc_addr)) {
\r
987 if (i2c_master_recv(client, value, length) == length) {
\r
988 MXT1386_LOG(KERN_INFO "%s: Host is reading from chip, addr = 0x%x, length = %d, *value = %d\n",
\r
989 __func__, addr, length, *value);
\r
993 MXT1386_LOG(KERN_INFO "%s: Host read failed!\n", __func__);
\r
997 mxt->last_read_addr = addr;
\r
1001 le_addr = cpu_to_le16(addr);
\r
1002 MXT1386_LOG(KERN_INFO "%s: Writing address pointer & reading, addr = 0x%02x, , le_addr = 0x%02x, length = %d, *value = %d\n",
\r
1003 __func__, addr, le_addr, length, *value);
\r
1005 msg[0].addr = client->addr;
\r
1006 msg[0].flags = 0x00;
\r
1008 msg[0].buf = (u8 *) &le_addr;
\r
1010 msg[1].addr = client->addr;
\r
1011 msg[1].flags = I2C_M_RD;
\r
1012 msg[1].len = length;
\r
1013 msg[1].buf = (u8 *) value;
\r
1014 if (i2c_transfer(adapter, msg, 2) == 2)
\r
1020 /* Reads a block of bytes from current address from mXT chip. */
\r
1021 static int mxt_read_block_wo_addr(struct i2c_client *client,
\r
1025 if (i2c_master_recv(client, value, length) == length) {
\r
1026 MXT1386_LOG(KERN_INFO "%s: I2C block read ok\n", __func__);
\r
1029 MXT1386_LOG(KERN_INFO "%s: I2C block read failed\n", __func__);
\r
1034 /* Writes one byte to given address in mXT chip. */
\r
1035 static int mxt_write_byte(struct i2c_client *client, u16 addr, u8 value)
\r
1041 } i2c_byte_transfer;
\r
1043 struct mxt_data *mxt;
\r
1045 mxt = i2c_get_clientdata(client);
\r
1047 mxt->last_read_addr = -1;
\r
1048 i2c_byte_transfer.le_addr = cpu_to_le16(addr);
\r
1049 i2c_byte_transfer.data = value;
\r
1050 if (i2c_master_send(client, (u8 *) &i2c_byte_transfer, 3) == 3)
\r
1056 /* Writes a block of bytes (max 256) to given address in mXT chip. */
\r
1057 static int mxt_write_block(struct i2c_client *client,
\r
1067 } i2c_block_transfer;
\r
1069 struct mxt_data *mxt;
\r
1071 MXT1386_LOG("Writing %d bytes to %d...\n", length, addr);
\r
1074 mxt = i2c_get_clientdata(client);
\r
1076 mxt->last_read_addr = -1;
\r
1077 for (i = 0; i < length; i++)
\r
1078 i2c_block_transfer.data[i] = *value++;
\r
1079 i2c_block_transfer.le_addr = cpu_to_le16(addr);
\r
1080 i = i2c_master_send(client, (u8 *) &i2c_block_transfer, length + 2);
\r
1081 if (i == (length + 2))
\r
1087 /* Calculates the CRC value for mXT infoblock. */
\r
1088 int calculate_infoblock_crc(u32 *crc_result, u8 *data, int crc_area_size)
\r
1093 for (i = 0; i < (crc_area_size - 1); i = i + 2)
\r
1094 crc = CRC_24(crc, *(data + i), *(data + i + 1));
\r
1095 /* If uneven size, pad with zero */
\r
1096 if (crc_area_size & 0x0001)
\r
1097 crc = CRC_24(crc, *(data + i), 0);
\r
1098 /* Return only 24 bits of CRC. */
\r
1099 *crc_result = (crc & 0x00FFFFFF);
\r
1104 int find_touch_key_value( struct mxt_data *mxt, int status, u16 ypos)
\r
1107 for(i=0; i<ARRAY_SIZE(key_info); i++)
\r
1109 if((ypos > key_info[i].start) && (ypos < key_info[i].end))
\r
1111 printk("%s key_code = %d \n",__func__,key_info[i].code);
\r
1112 if(status & MXT_MSGB_T9_DETECT)
\r
1114 input_report_key(mxt->input, key_info[i].code, 1);
\r
1115 input_sync(mxt->input);
\r
1116 last_key = key_info[i].code;
\r
1120 printk("%s key_code = %d relase\n",__func__,key_info[i].code);
\r
1121 input_report_key(mxt->input, key_info[i].code, 0);
\r
1122 input_sync(mxt->input);
\r
1135 void process_T9_message(u8 *message, struct mxt_data *mxt)
\r
1137 struct input_dev *input;
\r
1139 u16 xpos = 0xFFFF;
\r
1140 u16 ypos = 0xFFFF;
\r
1141 u8 touch_size = 255;
\r
1147 input = mxt->input;
\r
1148 status = message[MXT_MSG_T9_STATUS];
\r
1149 report_id = message[0];
\r
1151 if (status & MXT_MSGB_T9_SUPPRESS) {
\r
1152 /* Touch has been suppressed by grip/face */
\r
1154 MXT1386_LOG(KERN_INFO "SUPRESS\n", __func__);
\r
1156 MXT1386_LOG("XPOSMSB = 0x%02x, YPOSMSB = 0x%02x, XYPOSLSB = 0x%02x\n",
\r
1157 message[MXT_MSG_T9_XPOSMSB], message[MXT_MSG_T9_YPOSMSB], message[MXT_MSG_T9_XYPOSLSB]);
\r
1159 xpos = message[MXT_MSG_T9_XPOSMSB] * 16 +
\r
1160 ((message[MXT_MSG_T9_XYPOSLSB] >> 4) & 0xF);
\r
1161 ypos = message[MXT_MSG_T9_YPOSMSB] * 16 +
\r
1162 ((message[MXT_MSG_T9_XYPOSLSB] >> 0) & 0xF);
\r
1164 MXT1386_LOG("Before Reverse: xpos = %d, ypos = %d\n", xpos, ypos);
\r
1167 if( xpos < CONFIG_ATMEL_MXT1386_MAX_X)
\r
1168 xpos = CONFIG_ATMEL_MXT1386_MAX_X - xpos;
\r
1173 if( ypos < CONFIG_ATMEL_MXT1386_MAX_Y)
\r
1174 ypos = CONFIG_ATMEL_MXT1386_MAX_Y - ypos;
\r
1180 if( xpos < 8 && xpos >= 0)
\r
1182 find_touch_key_value(mxt, status, ypos);
\r
1188 printk("%s key_code = %d relase\n",__func__,last_key);
\r
1189 input_report_key(mxt->input, last_key, 0);
\r
1190 input_sync(mxt->input);
\r
1195 MXT1386_LOG("After Reverse: xpos = %d, ypos = %d\n", xpos, ypos);
\r
1197 touch_number = message[MXT_MSG_REPORTID] -
\r
1198 mxt->rid_map[report_id].first_rid;
\r
1200 if (status & MXT_MSGB_T9_DETECT) {
\r
1202 * TODO: more precise touch size calculation?
\r
1203 * mXT224 reports the number of touched nodes,
\r
1204 * so the exact value for touch ellipse major
\r
1205 * axis length would be 2*sqrt(touch_size/pi)
\r
1206 * (assuming round touch shape).
\r
1208 MXT1386_LOG(KERN_INFO " ----process_T9_message --MXT_MSGB_T9_DETECT--- \n", __func__);
\r
1209 touch_size = message[MXT_MSG_T9_TCHAREA];
\r
1210 touch_size = touch_size >> 2;
\r
1213 report_mt(touch_number, touch_size, xpos, ypos, mxt);
\r
1214 if (status & MXT_MSGB_T9_AMP)
\r
1215 /* Amplitude of touch has changed */
\r
1216 amplitude = message[MXT_MSG_T9_TCHAMPLITUDE];
\r
1217 } else if (status & MXT_MSGB_T9_RELEASE) {
\r
1218 /* The previously reported touch has been removed.*/
\r
1219 MXT1386_LOG(KERN_INFO " ----process_T9_message --MXT_MSGB_T9_RELEASE--- \n", __func__);
\r
1220 report_mt(touch_number, 0, xpos, ypos, mxt);
\r
1222 #ifdef EFFICIENT_REPORT
\r
1228 if (status & MXT_MSGB_T9_SUPPRESS) {
\r
1229 MXT1386_LOG(KERN_INFO "SUPRESS", __func__);
\r
1231 if (status & MXT_MSGB_T9_DETECT) {
\r
1232 MXT1386_LOG(KERN_INFO "DETECT:%s%s%s%s", __func__,
\r
1233 ((status & MXT_MSGB_T9_PRESS) ? " PRESS" : ""),
\r
1234 ((status & MXT_MSGB_T9_MOVE) ? " MOVE" : ""),
\r
1235 ((status & MXT_MSGB_T9_AMP) ? " AMP" : ""),
\r
1236 ((status & MXT_MSGB_T9_VECTOR) ? " VECT" : ""));
\r
1238 } else if (status & MXT_MSGB_T9_RELEASE) {
\r
1239 MXT1386_LOG(KERN_INFO "RELEASE");
\r
1242 MXT1386_LOG(KERN_INFO "X=%d, Y=%d, TOUCHSIZE=%d", __func__,
\r
1243 xpos, ypos, touch_size);
\r
1248 int process_message(u8 *message, u8 object, struct mxt_data *mxt)
\r
1250 struct i2c_client *client;
\r
1252 u16 xpos = 0xFFFF;
\r
1253 u16 ypos = 0xFFFF;
\r
1261 client = mxt->client;
\r
1262 length = mxt->message_size;
\r
1263 report_id = message[0];
\r
1265 if ((mxt->nontouch_msg_only == 0) ||
\r
1266 (!IS_TOUCH_OBJECT(object))){
\r
1267 mutex_lock(&mxt->msg_mutex);
\r
1268 /* Copy the message to buffer */
\r
1269 if (mxt->msg_buffer_startp < MXT_MESSAGE_BUFFER_SIZE) {
\r
1270 mxt->msg_buffer_startp++;
\r
1272 mxt->msg_buffer_startp = 0;
\r
1275 if (mxt->msg_buffer_startp == mxt->msg_buffer_endp) {
\r
1276 MXT1386_LOG(KERN_INFO "Message buf full, discarding last entry.\n", __func__);
\r
1277 if (mxt->msg_buffer_endp < MXT_MESSAGE_BUFFER_SIZE) {
\r
1278 mxt->msg_buffer_endp++;
\r
1280 mxt->msg_buffer_endp = 0;
\r
1283 memcpy((mxt->messages + mxt->msg_buffer_startp * length),
\r
1286 mutex_unlock(&mxt->msg_mutex);
\r
1290 case MXT_GEN_COMMANDPROCESSOR_T6:
\r
1291 status = message[1];
\r
1292 if (status & MXT_MSGB_T6_COMSERR) {
\r
1293 dev_err(&client->dev,
\r
1294 "maXTouch checksum error\n");
\r
1296 if (status & MXT_MSGB_T6_CFGERR) {
\r
1298 * Configuration error. A proper configuration
\r
1299 * needs to be written to chip and backed up. Refer
\r
1300 * to protocol document for further info.
\r
1302 dev_err(&client->dev,
\r
1303 "maXTouch configuration error\n");
\r
1305 if (status & MXT_MSGB_T6_CAL) {
\r
1306 /* Calibration in action, no need to react */
\r
1307 dev_info(&client->dev,
\r
1308 "maXTouch calibration in progress\n");
\r
1310 if (status & MXT_MSGB_T6_SIGERR) {
\r
1312 * Signal acquisition error, something is seriously
\r
1313 * wrong, not much we can in the driver to correct
\r
1316 dev_err(&client->dev,
\r
1317 "maXTouch acquisition error\n");
\r
1319 if (status & MXT_MSGB_T6_OFL) {
\r
1321 * Cycle overflow, the acquisition is too short.
\r
1322 * Can happen temporarily when there's a complex
\r
1323 * touch shape on the screen requiring lots of
\r
1326 dev_err(&client->dev,
\r
1327 "maXTouch cycle overflow\n");
\r
1329 if (status & MXT_MSGB_T6_RESET) {
\r
1330 /* Chip has reseted, no need to react. */
\r
1331 dev_info(&client->dev,
\r
1332 "maXTouch chip reset\n");
\r
1334 if (status == 0) {
\r
1335 /* Chip status back to normal. */
\r
1336 dev_info(&client->dev,
\r
1337 "maXTouch status normal\n");
\r
1341 case MXT_TOUCH_MULTITOUCHSCREEN_T9:
\r
1342 process_T9_message(message, mxt);
\r
1345 case MXT_SPT_GPIOPWM_T19:
\r
1346 if (debug >= DEBUG_TRACE)
\r
1347 dev_info(&client->dev,
\r
1348 "Receiving GPIO message\n");
\r
1351 case MXT_PROCI_GRIPFACESUPPRESSION_T20:
\r
1352 if (debug >= DEBUG_TRACE)
\r
1353 dev_info(&client->dev,
\r
1354 "Receiving face suppression msg\n");
\r
1357 case MXT_PROCG_NOISESUPPRESSION_T22:
\r
1358 printk("--------- MXT_PROCG_NOISESUPPRESSION_T22 enter! ---------\n");
\r
1359 //if (debug >= DEBUG_TRACE)
\r
1360 dev_info(&client->dev,
\r
1361 "Receiving noise suppression msg\n");
\r
1362 status = message[MXT_MSG_T22_STATUS];
\r
1363 if (status & MXT_MSGB_T22_FHCHG) {
\r
1364 //if (debug >= DEBUG_TRACE)
\r
1365 dev_info(&client->dev,
\r
1366 "maXTouch: Freq changed\n");
\r
1368 if (status & MXT_MSGB_T22_GCAFERR) {
\r
1369 //if (debug >= DEBUG_TRACE)
\r
1370 dev_info(&client->dev,
\r
1371 "maXTouch: High noise "
\r
1374 if (status & MXT_MSGB_T22_FHERR) {
\r
1375 //if (debug >= DEBUG_TRACE)
\r
1376 dev_info(&client->dev,
\r
1377 "maXTouch: Freq changed - "
\r
1378 "Noise level too high\n");
\r
1382 case MXT_PROCI_ONETOUCHGESTUREPROCESSOR_T24:
\r
1383 if (debug >= DEBUG_TRACE)
\r
1384 dev_info(&client->dev,
\r
1385 "Receiving one-touch gesture msg\n");
\r
1387 event = message[MXT_MSG_T24_STATUS] & 0x0F;
\r
1388 xpos = message[MXT_MSG_T24_XPOSMSB] * 16 +
\r
1389 ((message[MXT_MSG_T24_XYPOSLSB] >> 4) & 0x0F);
\r
1390 ypos = message[MXT_MSG_T24_YPOSMSB] * 16 +
\r
1391 ((message[MXT_MSG_T24_XYPOSLSB] >> 0) & 0x0F);
\r
1394 direction = message[MXT_MSG_T24_DIR];
\r
1395 distance = message[MXT_MSG_T24_DIST] +
\r
1396 (message[MXT_MSG_T24_DIST + 1] << 16);
\r
1398 report_gesture((event << 24) | (direction << 16) | distance,
\r
1400 report_gesture((xpos << 16) | ypos, mxt);
\r
1404 case MXT_SPT_SELFTEST_T25:
\r
1405 if (debug >= DEBUG_TRACE)
\r
1406 dev_info(&client->dev,
\r
1407 "Receiving Self-Test msg\n");
\r
1409 if (message[MXT_MSG_T25_STATUS] == MXT_MSGR_T25_OK) {
\r
1410 if (debug >= DEBUG_TRACE)
\r
1411 dev_info(&client->dev,
\r
1412 "maXTouch: Self-Test OK\n");
\r
1415 dev_err(&client->dev,
\r
1416 "maXTouch: Self-Test Failed [%02x]:"
\r
1417 "{%02x,%02x,%02x,%02x,%02x}\n",
\r
1418 message[MXT_MSG_T25_STATUS],
\r
1419 message[MXT_MSG_T25_STATUS + 0],
\r
1420 message[MXT_MSG_T25_STATUS + 1],
\r
1421 message[MXT_MSG_T25_STATUS + 2],
\r
1422 message[MXT_MSG_T25_STATUS + 3],
\r
1423 message[MXT_MSG_T25_STATUS + 4]
\r
1428 case MXT_PROCI_TWOTOUCHGESTUREPROCESSOR_T27:
\r
1429 if (debug >= DEBUG_TRACE)
\r
1430 dev_info(&client->dev,
\r
1431 "Receiving 2-touch gesture message\n");
\r
1433 event = message[MXT_MSG_T27_STATUS] & 0xF0;
\r
1434 xpos = message[MXT_MSG_T27_XPOSMSB] * 16 +
\r
1435 ((message[MXT_MSG_T27_XYPOSLSB] >> 4) & 0x0F);
\r
1436 ypos = message[MXT_MSG_T27_YPOSMSB] * 16 +
\r
1437 ((message[MXT_MSG_T27_XYPOSLSB] >> 0) & 0x0F);
\r
1440 direction = message[MXT_MSG_T27_ANGLE];
\r
1441 distance = message[MXT_MSG_T27_SEPARATION] +
\r
1442 (message[MXT_MSG_T27_SEPARATION + 1] << 16);
\r
1444 report_gesture((event << 24) | (direction << 16) | distance,
\r
1446 report_gesture((xpos << 16) | ypos, mxt);
\r
1451 case MXT_SPT_CTECONFIG_T28:
\r
1452 if (debug >= DEBUG_TRACE)
\r
1453 dev_info(&client->dev,
\r
1454 "Receiving CTE message...\n");
\r
1455 status = message[MXT_MSG_T28_STATUS];
\r
1456 if (status & MXT_MSGB_T28_CHKERR)
\r
1457 dev_err(&client->dev,
\r
1458 "maXTouch: Power-Up CRC failure\n");
\r
1463 if (debug >= DEBUG_TRACE)
\r
1464 dev_info(&client->dev,
\r
1465 "maXTouch: Unknown message!\n");
\r
1475 * Processes messages when the interrupt line (CHG) is asserted. Keeps
\r
1476 * reading messages until a message with report ID 0xFF is received,
\r
1477 * which indicates that there is no more new messages.
\r
1481 static void ts_thread_1386(struct work_struct *work)
\r
1483 struct mxt_data *mxt;
\r
1484 struct i2c_client *client;
\r
1487 u16 message_length;
\r
1491 #ifdef EFFICIENT_REPORT
\r
1492 u8 has_multitouch_msg = 0;
\r
1496 char *message_string;
\r
1497 char *message_start;
\r
1501 //mxt = container_of(work, struct mxt_data, dwork.work);
\r
1503 //disable_irq(mxt->irq);
\r
1504 client = mxt->client;
\r
1505 message_addr = mxt->msg_proc_addr;
\r
1506 message_length = mxt->message_size;
\r
1508 MXT1386_LOG(KERN_INFO "%s: ts_thread_1386 entry %d times!\n", __func__, ++count);
\r
1510 if (message_length < 256) {
\r
1511 message = kmalloc(message_length, GFP_KERNEL);
\r
1512 if (message == NULL) {
\r
1513 dev_err(&client->dev, "Error allocating memory\n");
\r
1517 dev_err(&client->dev,
\r
1518 "Message length larger than 256 bytes not supported\n");
\r
1523 /* Read next message, reread on failure. */
\r
1524 mxt->message_counter++;
\r
1525 for (i = 1; i < I2C_RETRY_COUNT; i++) {
\r
1526 error = mxt_read_block(client,
\r
1532 mxt->read_fail_counter++;
\r
1533 dev_err(&client->dev,
\r
1534 "Failure reading maxTouch device\n");
\r
1541 if (mxt->address_pointer != message_addr)
\r
1542 mxt->valid_ap = 0;
\r
1543 report_id = message[0];
\r
1545 if (debug >= DEBUG_RAW) {
\r
1546 MXT1386_LOG(KERN_INFO "%s: %s message [msg count: %08x]:", __func__,
\r
1547 REPORT_ID_TO_OBJECT_NAME(report_id, mxt),
\r
1548 mxt->message_counter
\r
1550 /* 5 characters per one byte */
\r
1551 message_string = kmalloc(message_length * 5,
\r
1553 if (message_string == NULL) {
\r
1554 dev_err(&client->dev,
\r
1555 "Error allocating memory\n");
\r
1559 message_start = message_string;
\r
1560 for (i = 0; i < message_length; i++) {
\r
1561 message_string +=
\r
1562 sprintf(message_string,
\r
1563 "0x%02X ", message[i]);
\r
1565 MXT1386_LOG(KERN_INFO "%s", message_start, __func__);
\r
1566 kfree(message_start);
\r
1569 if ((report_id != MXT_END_OF_MESSAGES) && (report_id != 0)) {
\r
1570 memcpy(mxt->last_message, message, message_length);
\r
1571 mxt->new_msgs = 1;
\r
1573 /* Get type of object and process the message */
\r
1574 object = mxt->rid_map[report_id].object;
\r
1576 MXT1386_LOG(KERN_INFO "current value: mxt->rid_map[%d].object = %d, object = %d\n",
\r
1577 __func__, report_id, mxt->rid_map[report_id].object, object);
\r
1578 mxt_buf_test(message, message_length);
\r
1580 process_message(message, object, mxt);
\r
1581 MXT1386_LOG(KERN_INFO "trace 0\n", __func__);
\r
1584 #ifdef EFFICIENT_REPORT
\r
1585 if(object == MXT_TOUCH_MULTITOUCHSCREEN_T9)
\r
1587 has_multitouch_msg = 1;
\r
1589 else if( has_multitouch_msg == 1)
\r
1591 has_multitouch_msg = 0;
\r
1597 } while (comms ? (mxt->read_chg() == 0) :
\r
1598 ((report_id != MXT_END_OF_MESSAGES) && (report_id != 0)));
\r
1599 //} while ((report_id != MXT_END_OF_MESSAGES) && (report_id != 0));
\r
1602 #ifdef EFFICIENT_REPORT
\r
1609 MXT1386_LOG(KERN_INFO "%s: Now will enable the irq, ts_irq = %d\n", __func__, ts_irq);
\r
1610 enable_irq(mxt->irq);
\r
1611 //printk("%s, int_pin = %d \n",__func__,gpio_get_value(client->irq));
\r
1615 * The maXTouch device will signal the host about a new message by asserting
\r
1616 * the CHG line. This ISR schedules a worker routine to read the message when
\r
1620 //static struct workqueue_struct *queue = NULL;
\r
1621 //static struct work_struct work;
\r
1623 static irqreturn_t mxt_irq_handler(int irq, void *dev_id)
\r
1625 struct mxt_data *mxt = (struct mxt_data *)dev_id;
\r
1626 struct i2c_client *client = mxt->client;
\r
1627 int int_value = client->irq;
\r
1628 static u8 wakeup_flag;
\r
1629 static u32 counter;
\r
1630 /* Ä¿Ç°TPµÄÖжÏÐÐΪÈçÏÂ: µ±LCD½øÈëstandbyģʽºó£¬±³¹â¿ØÖƽÅLCDC_CS½«ÀµÍ£¬´ËʱLCDC_CS¿ØÖƵı³¹âÉýѹÊäÈë¶Ë£¨DCtoDCÊäÈë¶Ë£©TPVCCÒ²½«±»ÀµÍ£¬
\r
1631 ʹ±³¹â¹Ø±Õ£»ÓÉÓÚTPVCCͬʱҲ×÷ΪTPµÄµçÔ´ÊäÈë¶Ë£¬´ËʱϵͳÈôÔÚTPVCCΪµÍµçƽµÄÇé¿öϽøÈëTPµÄISRº¯Êý£¬TPÉ豸½«²»Ó¦´ð£¬²¢ÇÒ½«²»±»»½ÐÑ¡£ Òò´Ë£¬
\r
1632 ÔÚ´ËÔö¼ÓÒ»¸ö¾²Ì¬±êÖ¾£¬Åжϵ±LCDS½ÅΪµÍʱ£¬²»Æô¶¯¹¤×÷¶ÓÁУ¬Í¬Ê±½«wakeup_flag±êÖ¾ÖÃ1£¬Ï´νøÈëÖжÏʱ£¬²»ÔÙ½ûÖ¹Öжϣ¬Ö±½ÓÆô¶¯¹¤×÷¶ÓÁÐ*/
\r
1635 MXT1386_LOG(KERN_INFO "mxt_irq_handler() IN\n");
\r
1637 mxt->irq_counter++;
\r
1638 if (mxt->valid_interrupt()) {
\r
1639 /* Send the signal only if falling edge generated the irq. */
\r
1640 cancel_delayed_work(&mxt->dwork);
\r
1641 schedule_delayed_work(&mxt->dwork, 0);
\r
1642 mxt->valid_irq_counter++;
\r
1644 mxt->invalid_irq_counter++;
\r
1648 MXT1386_LOG(KERN_INFO "-------------- Be carefull MXC_touchscreen interrupt comes! --------------\n", __func__);
\r
1649 MXT1386_LOG(KERN_INFO "interrupt counter road\n");
\r
1650 disable_irq_nosync(mxt->irq);
\r
1652 queue_work(mxt->queue,&mxt->work);
\r
1656 MXT1386_LOG(KERN_INFO "-------------- Be carefull MXC_touchscreen interrupt comes! --------------\n", __func__);
\r
1657 MXT1386_LOG(KERN_INFO "ts_irq = %d, irq = %d, mxt->irq = %d, TOUCH_INT_PIN = %d\n", __func__, ts_irq, irq, mxt->irq, int_value);
\r
1659 if(gpio_get_value(LCDC_STANDBY_PIN)) {
\r
1660 MXT1386_LOG(KERN_INFO "%s: LCDC_STANDBY_PIN test, value is high\n", __func__);
\r
1662 if (0==wakeup_flag) {
\r
1663 disable_irq_nosync(mxt->irq);
\r
1669 #if WORKQ_RIGHTNOW
\r
1670 MXT1386_LOG(KERN_INFO "%s: queue_work start\n", __func__);
\r
1671 queue_work(mxt->queue,&mxt->work);
\r
1673 MXT1386_LOG(KERN_INFO "%s: queue_delayed_work start\n", __func__);
\r
1674 queue_delayed_work(mxt->queue, &mxt->dwork, 0);
\r
1678 MXT1386_LOG(KERN_INFO "%s: LCDC_STANDBY_PIN test, value is low\n", __func__);
\r
1683 return IRQ_HANDLED;
\r
1686 /******************************************************************************/
\r
1687 /* Initialization of driver */
\r
1688 /******************************************************************************/
\r
1690 static int __devinit mxt_identify(struct i2c_client *client,
\r
1691 struct mxt_data *mxt,
\r
1692 u8 *id_block_data)
\r
1700 /* Read Device info to check if chip is valid */
\r
1701 error = mxt_read_block(client, MXT_ADDR_INFO_BLOCK, MXT_ID_BLOCK_SIZE,
\r
1705 mxt->read_fail_counter++;
\r
1706 dev_err(&client->dev, "Failure accessing maXTouch device\n");
\r
1710 memcpy(id_block_data, buf, MXT_ID_BLOCK_SIZE);
\r
1712 mxt->device_info.family_id = buf[0];
\r
1713 mxt->device_info.variant_id = buf[1];
\r
1714 mxt->device_info.major = ((buf[2] >> 4) & 0x0F);
\r
1715 mxt->device_info.minor = (buf[2] & 0x0F);
\r
1716 mxt->device_info.build = buf[3];
\r
1717 mxt->device_info.x_size = buf[4];
\r
1718 mxt->device_info.y_size = buf[5];
\r
1719 mxt->device_info.num_objs = buf[6];
\r
1720 mxt->device_info.num_nodes = mxt->device_info.x_size *
\r
1721 mxt->device_info.y_size;
\r
1724 * Check Family & Variant Info; warn if not recognized but
\r
1729 if (mxt->device_info.family_id == MXT224_FAMILYID) {
\r
1730 strcpy(mxt->device_info.family_name, "mXT224");
\r
1732 if (mxt->device_info.variant_id == MXT224_CAL_VARIANTID) {
\r
1733 strcpy(mxt->device_info.variant_name, "Calibrated");
\r
1734 } else if (mxt->device_info.variant_id ==
\r
1735 MXT224_UNCAL_VARIANTID) {
\r
1736 strcpy(mxt->device_info.variant_name, "Uncalibrated");
\r
1738 dev_err(&client->dev,
\r
1739 "Warning: maXTouch Variant ID [%d] not "
\r
1741 mxt->device_info.variant_id);
\r
1742 strcpy(mxt->device_info.variant_name, "UNKNOWN");
\r
1743 /* identified = -ENXIO; */
\r
1747 } else if (mxt->device_info.family_id == MXT1386_FAMILYID) {
\r
1748 strcpy(mxt->device_info.family_name, "mXT1386");
\r
1750 if (mxt->device_info.variant_id == MXT1386_CAL_VARIANTID) {
\r
1751 strcpy(mxt->device_info.variant_name, "Calibrated");
\r
1753 dev_err(&client->dev,
\r
1754 "Warning: maXTouch Variant ID [%d] not "
\r
1756 mxt->device_info.variant_id);
\r
1757 strcpy(mxt->device_info.variant_name, "UNKNOWN");
\r
1758 /* identified = -ENXIO; */
\r
1760 /* Unknown family ID! */
\r
1762 dev_err(&client->dev,
\r
1763 "Warning: maXTouch Family ID [%d] not supported\n",
\r
1764 mxt->device_info.family_id);
\r
1765 strcpy(mxt->device_info.family_name, "UNKNOWN");
\r
1766 strcpy(mxt->device_info.variant_name, "UNKNOWN");
\r
1767 /* identified = -ENXIO; */
\r
1772 "Atmel maXTouch (Family %s (%X), Variant %s (%X)) Firmware "
\r
1773 "version [%d.%d] Build %d, num_objs = %d\n",
\r
1774 mxt->device_info.family_name,
\r
1775 mxt->device_info.family_id,
\r
1776 mxt->device_info.variant_name,
\r
1777 mxt->device_info.variant_id,
\r
1778 mxt->device_info.major,
\r
1779 mxt->device_info.minor,
\r
1780 mxt->device_info.build,
\r
1781 mxt->device_info.num_objs
\r
1785 "Atmel maXTouch Configuration "
\r
1786 "[X: %d] x [Y: %d]\n",
\r
1787 mxt->device_info.x_size,
\r
1788 mxt->device_info.y_size
\r
1790 return identified;
\r
1794 * Reads the object table from maXTouch chip to get object data like
\r
1795 * address, size, report id. For Info Block CRC calculation, already read
\r
1796 * id data is passed to this function too (Info Block consists of the ID
\r
1797 * block and object table).
\r
1800 static int __devinit mxt_read_object_table(struct i2c_client *client,
\r
1801 struct mxt_data *mxt,
\r
1804 u16 report_id_count;
\r
1805 u8 buf[MXT_OBJECT_TABLE_ELEMENT_SIZE];
\r
1808 u16 object_address;
\r
1810 u8 object_instances;
\r
1811 u8 object_report_ids;
\r
1812 u16 object_info_address;
\r
1814 u32 calculated_crc;
\r
1818 u8 object_instance;
\r
1819 u8 object_report_id;
\r
1821 int first_report_id;
\r
1823 struct mxt_object *object_table;
\r
1825 MXT1386_LOG(KERN_INFO "maXTouch driver reading configuration\n", __func__);
\r
1827 object_table = kzalloc(sizeof(struct mxt_object) *
\r
1828 mxt->device_info.num_objs,
\r
1830 if (object_table == NULL) {
\r
1831 MXT1386_LOG(KERN_INFO "maXTouch: Memory allocation failed!\n", __func__);
\r
1833 goto err_object_table_alloc;
\r
1836 raw_ib_data = kmalloc(MXT_OBJECT_TABLE_ELEMENT_SIZE *
\r
1837 mxt->device_info.num_objs + MXT_ID_BLOCK_SIZE,
\r
1839 if (raw_ib_data == NULL) {
\r
1840 MXT1386_LOG(KERN_INFO "maXTouch: Memory allocation failed!\n", __func__);
\r
1842 goto err_ib_alloc;
\r
1845 /* Copy the ID data for CRC calculation. */
\r
1846 memcpy(raw_ib_data, raw_id_data, MXT_ID_BLOCK_SIZE);
\r
1847 ib_pointer = MXT_ID_BLOCK_SIZE;
\r
1849 mxt->object_table = object_table;
\r
1851 MXT1386_LOG(KERN_INFO "maXTouch driver Memory allocated\n", __func__);
\r
1853 object_info_address = MXT_ADDR_OBJECT_TABLE;
\r
1855 report_id_count = 0;
\r
1856 for (i = 0; i < mxt->device_info.num_objs; i++) {
\r
1857 MXT1386_LOG(KERN_INFO "Reading maXTouch at [0x%04x]: ", __func__,
\r
1858 object_info_address);
\r
1860 error = mxt_read_block(client, object_info_address,
\r
1861 MXT_OBJECT_TABLE_ELEMENT_SIZE, buf);
\r
1864 mxt->read_fail_counter++;
\r
1865 dev_err(&client->dev,
\r
1866 "maXTouch Object %d could not be read\n", __func__, i);
\r
1868 goto err_object_read;
\r
1871 memcpy(raw_ib_data + ib_pointer, buf,
\r
1872 MXT_OBJECT_TABLE_ELEMENT_SIZE);
\r
1873 ib_pointer += MXT_OBJECT_TABLE_ELEMENT_SIZE;
\r
1875 object_type = buf[0];
\r
1876 object_address = (buf[2] << 8) + buf[1];
\r
1877 object_size = buf[3] + 1;
\r
1878 object_instances = buf[4] + 1;
\r
1879 object_report_ids = buf[5];
\r
1880 MXT1386_LOG(KERN_INFO "Type=%03d, Address=0x%04x, "
\r
1881 "Size=0x%02x, %d instances, %d report id's\n", __func__,
\r
1889 /* TODO: check whether object is known and supported? */
\r
1891 /* Save frequently needed info. */
\r
1892 if (object_type == MXT_GEN_MESSAGEPROCESSOR_T5) {
\r
1893 mxt->msg_proc_addr = object_address;
\r
1894 mxt->message_size = object_size;
\r
1897 object_table[i].type = object_type;
\r
1898 object_table[i].chip_addr = object_address;
\r
1899 object_table[i].size = object_size;
\r
1900 object_table[i].instances = object_instances;
\r
1901 object_table[i].num_report_ids = object_report_ids;
\r
1902 report_id_count += object_instances * object_report_ids;
\r
1904 object_info_address += MXT_OBJECT_TABLE_ELEMENT_SIZE;
\r
1908 kzalloc(sizeof(struct report_id_map) * (report_id_count + 1),
\r
1909 /* allocate for report_id 0, even if not used */
\r
1911 if (mxt->rid_map == NULL) {
\r
1912 MXT1386_LOG(KERN_INFO "maXTouch: Can't allocate memory!\n", __func__);
\r
1914 goto err_rid_map_alloc;
\r
1917 mxt->messages = kzalloc(mxt->message_size * MXT_MESSAGE_BUFFER_SIZE,
\r
1919 if (mxt->messages == NULL) {
\r
1920 MXT1386_LOG(KERN_INFO "maXTouch: Can't allocate memory!\n", __func__);
\r
1922 goto err_msg_alloc;
\r
1925 mxt->last_message = kzalloc(mxt->message_size, GFP_KERNEL);
\r
1926 if (mxt->last_message == NULL) {
\r
1927 MXT1386_LOG(KERN_INFO "maXTouch: Can't allocate memory!\n", __func__);
\r
1929 goto err_msg_alloc;
\r
1932 mxt->report_id_count = report_id_count;
\r
1933 if (report_id_count > 254) { /* 0 & 255 are reserved */
\r
1934 dev_err(&client->dev,
\r
1935 "Too many maXTouch report id's [%d]\n",
\r
1941 /* Create a mapping from report id to object type */
\r
1942 report_id = 1; /* Start from 1, 0 is reserved. */
\r
1944 /* Create table associating report id's with objects & instances */
\r
1945 for (i = 0; i < mxt->device_info.num_objs; i++) {
\r
1946 for (object_instance = 0;
\r
1947 object_instance < object_table[i].instances;
\r
1948 object_instance++){
\r
1949 first_report_id = report_id;
\r
1950 for (object_report_id = 0;
\r
1951 object_report_id < object_table[i].num_report_ids;
\r
1952 object_report_id++) {
\r
1953 mxt->rid_map[report_id].object =
\r
1954 object_table[i].type;
\r
1955 mxt->rid_map[report_id].instance =
\r
1957 mxt->rid_map[report_id].first_rid =
\r
1964 /* Read 3 byte CRC */
\r
1965 error = mxt_read_block(client, object_info_address, 3, buf);
\r
1967 mxt->read_fail_counter++;
\r
1968 dev_err(&client->dev, "Error reading CRC\n");
\r
1971 crc = (buf[2] << 16) | (buf[1] << 8) | buf[0];
\r
1973 if (calculate_infoblock_crc(&calculated_crc, raw_ib_data,
\r
1975 MXT1386_LOG(KERN_INFO "Error while calculating CRC!\n");
\r
1976 calculated_crc = 0;
\r
1978 kfree(raw_ib_data);
\r
1980 MXT1386_LOG(KERN_INFO "Reported info block CRC = 0x%6X\n", __func__, crc);
\r
1981 MXT1386_LOG(KERN_INFO "Calculated info block CRC = 0x%6X\n\n", __func__, calculated_crc);
\r
1983 if (crc == calculated_crc) {
\r
1984 mxt->info_block_crc = crc;
\r
1986 mxt->info_block_crc = 0;
\r
1987 MXT1386_LOG(KERN_INFO "maXTouch: Info block CRC invalid!\n"), __func__;
\r
1990 if (debug >= DEBUG_VERBOSE) {
\r
1992 dev_info(&client->dev, "maXTouch: %d Objects\n",
\r
1993 mxt->device_info.num_objs);
\r
1995 for (i = 0; i < mxt->device_info.num_objs; i++) {
\r
1996 dev_info(&client->dev, "Type:\t\t\t[%d]: %s\n",
\r
1997 object_table[i].type,
\r
1998 object_type_name[object_table[i].type]);
\r
1999 dev_info(&client->dev, "\tAddress:\t0x%04X\n",
\r
2000 object_table[i].chip_addr);
\r
2001 dev_info(&client->dev, "\tSize:\t\t%d Bytes\n",
\r
2002 object_table[i].size);
\r
2003 dev_info(&client->dev, "\tInstances:\t%d\n",
\r
2004 object_table[i].instances);
\r
2005 dev_info(&client->dev, "\tReport Id's:\t%d\n",
\r
2006 object_table[i].num_report_ids);
\r
2013 kfree(mxt->last_message);
\r
2015 kfree(mxt->rid_map);
\r
2016 err_rid_map_alloc:
\r
2018 kfree(raw_ib_data);
\r
2020 kfree(object_table);
\r
2021 err_object_table_alloc:
\r
2025 //#define TS_PEN_IRQ_GPIO RK29_PIN0_PA2//61
\r
2027 static int Gpio_TS_request_irq(struct mxt_data *mxt)
\r
2030 struct i2c_client *client = mxt->client;
\r
2032 MXT1386_LOG(KERN_INFO "Gpio_TS_request_irq enter!\n", __func__);
\r
2033 MXT1386_LOG(KERN_INFO "%s: times 1 ts_irq value is %d\n", __func__, ts_irq);
\r
2035 if (gpio_get_value(client->irq)) {
\r
2036 MXT1386_LOG(KERN_INFO "%s: mxt1386 GPIO value is high\n", __func__);
\r
2039 MXT1386_LOG(KERN_INFO "%s: mxt1386 GPIO value is low\n", __func__);
\r
2042 MXT1386_LOG(KERN_INFO "%s: times 2 ts_irq value is %d\n", __func__, ts_irq);
\r
2043 rc = request_irq(mxt->irq, mxt_irq_handler,
\r
2044 IRQF_TRIGGER_LOW,//IRQF_TRIGGER_FALLING, //
\r
2045 "mxc_ts_i2c", mxt);
\r
2047 pr_err("could not request irq\n");
\r
2048 goto error_req_irq_fail;
\r
2051 MXT1386_LOG(KERN_INFO "Gpio_TS_request_irq ok!\n", __func__);
\r
2054 error_req_irq_fail:
\r
2055 error_irq_gpio_dir:
\r
2056 gpio_free(client->irq);
\r
2057 error_irq_gpio_req:
\r
2058 if (client->irq >= 0)
\r
2059 gpio_free(client->irq);
\r
2063 static int mxt1386_platform_data_init(struct atmel_1386_platform_data *pdata)
\r
2065 MXT1386_LOG(KERN_INFO "%s: mxt1386_platform_data_init enter!\n", __func__);
\r
2067 pdata->max_x = CONFIG_ATMEL_MXT1386_MAX_X;
\r
2068 pdata->max_y = CONFIG_ATMEL_MXT1386_MAX_Y;
\r
2073 static int __devinit mxt_probe(struct i2c_client *client,
\r
2074 const struct i2c_device_id *id)
\r
2076 struct atmel_1386_platform_data *pdata = (struct atmel_1386_platform_data *)client->dev.platform_data;
\r
2077 struct mxt_data *mxt;
\r
2078 struct input_dev *input;
\r
2081 u8 buf[MXT_ACK_BUFFER_SIZE] = {0};
\r
2082 u8 buf_size = MXT_MAKE_HIGH_CHG_SIZE_MIN;
\r
2085 MXT1386_LOG(" ---------------- mxt_probe start ------------ \n");
\r
2086 MXT1386_LOG(KERN_INFO "%s: mxt_probe enter, debug level is = %d\n", __func__, debug);
\r
2088 if (client == NULL) {
\r
2089 MXT1386_LOG("maXTouch: client == NULL\n");
\r
2091 } else if (client->adapter == NULL) {
\r
2092 MXT1386_LOG("maXTouch: client->adapter == NULL\n");
\r
2094 } else if (&client->dev == NULL) {
\r
2095 MXT1386_LOG("maXTouch: client->dev == NULL\n");
\r
2097 } else if (&client->adapter->dev == NULL) {
\r
2098 MXT1386_LOG("maXTouch: client->adapter->dev == NULL\n");
\r
2100 } else if (id == NULL) {
\r
2101 MXT1386_LOG("maXTouch: id == NULL\n");
\r
2105 mxt1386_platform_data_init(pdata);
\r
2107 MXT1386_LOG(KERN_INFO "%s: maXTouch driver v. %s\n", __func__, DRIVER_VERSION);
\r
2108 MXT1386_LOG(KERN_INFO "%s: \t \"%s\"\n", __func__, client->name);
\r
2109 MXT1386_LOG(KERN_INFO "%s: \taddr:\t0x%04x\n", __func__, client->addr);
\r
2110 MXT1386_LOG(KERN_INFO "%s: \tirq:\t%d\n", __func__, client->irq);
\r
2111 MXT1386_LOG(KERN_INFO "%s: \tflags:\t0x%04x\n", __func__, client->flags);
\r
2112 MXT1386_LOG(KERN_INFO "%s: \tadapter:\"%s\"\n", __func__, client->adapter->name);
\r
2113 MXT1386_LOG(KERN_INFO "%s: \tdevice:\t\"%s\"\n", __func__, client->dev.init_name);
\r
2116 MXT1386_LOG("TS i2c_probe no platform data\n");
\r
2119 MXT1386_LOG("TS i2c_probe platform data OK\n");
\r
2122 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {
\r
2123 MXT1386_LOG("TS i2c_probe I2C_FUNC_I2C Failed\n");
\r
2126 MXT1386_LOG("TS i2c_probe I2C_FUNC_I2C OK\n");
\r
2129 if (pdata->init_platform_hw != NULL) {
\r
2130 error = pdata->init_platform_hw(&(client->dev));
\r
2132 MXT1386_LOG("TS i2c_probe power on Failed\n");
\r
2136 MXT1386_LOG("TS i2c_probe power on OK\n");
\r
2139 else { /* ---------------- add by acgzx test ---------------- */
\r
2140 MXT1386_LOG("TS init_platform_hw is NULL\n");
\r
2143 /* Allocate structure - we need it to identify device */
\r
2144 mxt = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
\r
2145 if (mxt == NULL) {
\r
2146 dev_err(&client->dev, "insufficient memory\n");
\r
2148 goto err_mxt_alloc;
\r
2151 id_data = kmalloc(MXT_ID_BLOCK_SIZE, GFP_KERNEL);
\r
2152 if (id_data == NULL) {
\r
2153 dev_err(&client->dev, "insufficient memory\n");
\r
2155 goto err_id_alloc;
\r
2158 input = input_allocate_device();
\r
2160 dev_err(&client->dev, "error allocating input device\n");
\r
2162 goto err_input_dev_alloc;
\r
2167 mxt->read_fail_counter = 0;
\r
2168 mxt->message_counter = 0;
\r
2169 mxt->max_x_val = pdata->max_x;
\r
2170 mxt->max_y_val = pdata->max_y;
\r
2172 /* Get data that is defined in board specific code. */
\r
2173 mxt->init_hw = pdata->init_platform_hw;
\r
2174 mxt->exit_hw = pdata->exit_platform_hw;
\r
2175 mxt->read_chg = pdata->read_chg;
\r
2177 if (pdata->valid_interrupt != NULL)
\r
2178 mxt->valid_interrupt = pdata->valid_interrupt;
\r
2181 mxt->valid_interrupt = mxt_valid_interrupt_dummy;
\r
2182 MXT1386_LOG("TS valid_interrupt is dummy\n"); /* ---------------- add by acgzx test ---------------- */
\r
2185 if (debug >= DEBUG_TRACE)
\r
2186 MXT1386_LOG("maXTouch driver identifying chip\n");
\r
2188 if (mxt_identify(client, mxt, id_data) < 0) {
\r
2189 dev_err(&client->dev, "Chip could not be identified\n");
\r
2191 goto err_identify;
\r
2193 /* Chip is valid and active. */
\r
2194 if (debug >= DEBUG_TRACE)
\r
2195 MXT1386_LOG("maXTouch driver allocating input device\n");
\r
2197 mxt->client = client;
\r
2198 mxt->input = input;
\r
2200 mutex_init(&mxt->debug_mutex);
\r
2201 mutex_init(&mxt->msg_mutex);
\r
2202 MXT1386_LOG("maXTouch driver creating device name\n");
\r
2206 sizeof(mxt->phys_name),
\r
2208 dev_name(&client->dev)
\r
2210 input->name = "mxc_ts_i2c"; // "Atmel maXTouch Touchscreen controller";
\r
2211 input->phys = mxt->phys_name;
\r
2212 input->id.bustype = BUS_I2C;
\r
2213 input->dev.parent = &client->dev;
\r
2215 MXT1386_LOG("maXTouch name: \"%s\"\n", input->name);
\r
2216 MXT1386_LOG("maXTouch phys: \"%s\"\n", input->phys);
\r
2217 MXT1386_LOG("maXTouch driver setting abs parameters\n");
\r
2219 MXT1386_LOG(KERN_INFO "%s: mxt->max_x_val = %d\n", __func__, mxt->max_x_val);
\r
2220 MXT1386_LOG(KERN_INFO "%s: mxt->max_y_val = %d\n", __func__, mxt->max_y_val);
\r
2222 /* Single touch */
\r
2223 input_set_abs_params(input, ABS_X, 0, mxt->max_x_val, 0, 0);
\r
2224 input_set_abs_params(input, ABS_Y, 0, mxt->max_y_val, 0, 0);
\r
2225 input_set_abs_params(input, ABS_PRESSURE, 0, MXT_MAX_REPORTED_PRESSURE,
\r
2227 input_set_abs_params(input, ABS_TOOL_WIDTH, 0, MXT_MAX_REPORTED_WIDTH,
\r
2231 input_set_abs_params(input, ABS_MT_POSITION_X, 0, mxt->max_x_val, 0, 0);
\r
2232 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, mxt->max_y_val, 0, 0);
\r
2233 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, MXT_MAX_TOUCH_SIZE,
\r
2235 input_set_abs_params(input, ABS_MT_TRACKING_ID, 0, MXT_MAX_NUM_TOUCHES,
\r
2238 __set_bit(EV_ABS, input->evbit);
\r
2239 __set_bit(EV_SYN, input->evbit);
\r
2240 __set_bit(EV_KEY, input->evbit);
\r
2241 __set_bit(EV_MSC, input->evbit);
\r
2244 __set_bit(KEY_SEARCH, input->keybit);
\r
2245 __set_bit(KEY_HOME, input->keybit);
\r
2246 __set_bit(KEY_MENU, input->keybit);
\r
2247 __set_bit(KEY_BACK, input->keybit);
\r
2250 input->mscbit[0] = BIT_MASK(MSC_GESTURE);
\r
2252 MXT1386_LOG("maXTouch driver setting client data\n");
\r
2253 i2c_set_clientdata(client, mxt);
\r
2254 MXT1386_LOG("maXTouch driver setting drv data\n");
\r
2255 input_set_drvdata(input, mxt);
\r
2256 MXT1386_LOG("maXTouch driver input register device\n");
\r
2257 error = input_register_device(mxt->input);
\r
2259 dev_err(&client->dev,
\r
2260 "Failed to register input device\n");
\r
2261 goto err_register_device;
\r
2264 error = mxt_read_object_table(client, mxt, id_data);
\r
2268 /* Create debugfs entries. */
\r
2269 mxt->debug_dir = debugfs_create_dir("maXTouch", NULL);
\r
2270 if (mxt->debug_dir == ERR_PTR(-ENODEV)){
\r
2271 /* debugfs is not enabled. */
\r
2272 MXT1386_LOG("debugfs not enabled in kernel\n");
\r
2273 } else if (mxt->debug_dir == NULL) {
\r
2274 MXT1386_LOG("error creating debugfs dir\n");
\r
2276 MXT1386_LOG("created \"maXTouch\" debugfs dir\n");
\r
2278 debugfs_create_file("deltas", S_IRUSR, mxt->debug_dir, mxt,
\r
2280 debugfs_create_file("refs", S_IRUSR, mxt->debug_dir, mxt,
\r
2284 /* Create character device nodes for reading & writing registers */
\r
2285 mxt->mxt_class = class_create(THIS_MODULE, "maXTouch_memory");
\r
2286 /* 2 numbers; one for memory and one for messages */
\r
2287 error = alloc_chrdev_region(&mxt->dev_num, 0, 2,
\r
2288 "maXTouch_memory");
\r
2289 MXT1386_LOG("device number %d allocated!\n", MAJOR(mxt->dev_num));
\r
2291 MXT1386_LOG("Error registering device\n");
\r
2293 cdev_init(&mxt->cdev, &mxt_memory_fops);
\r
2294 cdev_init(&mxt->cdev_messages, &mxt_message_fops);
\r
2296 MXT1386_LOG("cdev initialized\n");
\r
2297 mxt->cdev.owner = THIS_MODULE;
\r
2298 mxt->cdev_messages.owner = THIS_MODULE;
\r
2300 error = cdev_add(&mxt->cdev, mxt->dev_num, 1);
\r
2302 MXT1386_LOG("Bad cdev\n");
\r
2305 error = cdev_add(&mxt->cdev_messages, mxt->dev_num + 1, 1);
\r
2307 MXT1386_LOG("Bad cdev\n");
\r
2310 MXT1386_LOG("cdev added\n");
\r
2312 device_create(mxt->mxt_class, NULL, MKDEV(MAJOR(mxt->dev_num), 0), NULL,
\r
2315 device_create(mxt->mxt_class, NULL, MKDEV(MAJOR(mxt->dev_num), 1), NULL,
\r
2316 "maXTouch_messages");
\r
2318 mxt->msg_buffer_startp = 0;
\r
2319 mxt->msg_buffer_endp = 0;
\r
2321 /* Allocate the interrupt */
\r
2322 MXT1386_LOG("maXTouch driver allocating interrupt...\n");
\r
2323 mxt->irq = gpio_to_irq(client->irq);
\r
2324 ts_irq = mxt->irq;
\r
2325 mxt->valid_irq_counter = 0;
\r
2326 mxt->invalid_irq_counter = 0;
\r
2327 mxt->irq_counter = 0;
\r
2331 #if WORKQ_RIGHTNOW
\r
2332 MXT1386_LOG(KERN_INFO "%s: INIT_WORK set\n", __func__);
\r
2333 mxt->queue = create_singlethread_workqueue("mxc_ts_handler"); /*´´½¨Ò»¸öµ¥Ï̵߳Ť×÷¶ÓÁÐ*/
\r
2334 INIT_WORK(&mxt->work, ts_thread_1386);
\r
2336 MXT1386_LOG(KERN_INFO "%s: INIT_DELAYED_WORK set\n", __func__);
\r
2337 mxt->queue = create_rt_workqueue("mxc_ts_handler"); /*´´½¨Ò»¸öʵʱµÄ¹¤×÷¶ÓÁÐ*/
\r
2338 INIT_DELAYED_WORK(&mxt->dwork, ts_thread_1386);
\r
2341 /*--------------------------------------------------------------------------------*/
\r
2342 /* Now the chip pull the irq pin to down waiting the host ack */
\r
2343 if(gpio_get_value(client->irq)) {
\r
2344 MXT1386_LOG(KERN_INFO "%s: TOUCH_INT_PIN test, value is high, error\n", __func__);
\r
2348 MXT1386_LOG(KERN_INFO "%s: TOUCH_INT_PIN test, value is low, need host ack\n", __func__);
\r
2351 /* TP MCU Ó²¼þ¸´Î»ºó£¬´ËʱINTÒý½ÅΪµÍµçƽ£¬Ö÷¿ØÐè´ÓT5¼Ä´æÆ÷¶ÁÒ»¶ÎÖÁÉÙ10bytes´óС(²»ÄÜСÓÚ´ËÖµ)µÄÊý¾Ý·´À¡¸øMCU£¬´ËʱINTÒý½Å²ÅÀ¸ß acgzx 2011.03.30 */
\r
2352 /* Read dummy message to make high CHG pin (Make CHG line high after the interrupts are enabled) */
\r
2353 error = mxt_read_block(client, mxt->msg_proc_addr, buf_size, (u8 *)buf); /* ---!!!!!!!!!!!!!!!!!!!!!!!!!!!!!--- */
\r
2355 MXT1386_LOG(KERN_INFO "%s: host first ack msg err!\n", __func__);
\r
2358 MXT1386_LOG(KERN_INFO "%s: host first ack msg ok!\n", __func__);
\r
2360 mxt_buf_test(buf, buf_size);
\r
2363 if(gpio_get_value(client->irq)) {
\r
2364 MXT1386_LOG(KERN_INFO "%s: TOUCH_INT_PIN test, value is high, host acked chip successively\n", __func__);
\r
2367 MXT1386_LOG(KERN_INFO "%s: TOUCH_INT_PIN test, value is low, host acked chip fail\n", __func__);
\r
2370 /*--------------------------------------------------------------------------------*/
\r
2371 atmel_1386_write_config(mxt);
\r
2373 error = Gpio_TS_request_irq(mxt);
\r
2375 MXT1386_LOG("TS i2c_probe request irq failed\n");
\r
2379 MXT1386_LOG("TS i2c_probe request irq ok\n");
\r
2383 device_init_wakeup(&client->dev, 0);
\r
2386 if (debug > DEBUG_INFO)
\r
2387 dev_info(&client->dev, "touchscreen, irq %d\n", mxt->irq);
\r
2391 MXT1386_LOG(KERN_INFO "%s: mxt_probe init ok\n", __func__);
\r
2392 MXT1386_LOG(" ---------------- mxt_probe end ------------ \n");
\r
2396 kfree(mxt->rid_map);
\r
2397 kfree(mxt->object_table);
\r
2398 kfree(mxt->last_message);
\r
2400 err_register_device:
\r
2402 err_input_dev_alloc:
\r
2405 if (mxt->exit_hw != NULL)
\r
2406 mxt->exit_hw(&(client->dev));
\r
2412 static int __devexit mxt_remove(struct i2c_client *client)
\r
2414 struct mxt_data *mxt;
\r
2416 MXT1386_LOG(KERN_INFO "%s: ----------- mxt_remove enter now -----------\n", __func__);
\r
2418 mxt = i2c_get_clientdata(client);
\r
2420 /* Remove debug dir entries */
\r
2421 debugfs_remove_recursive(mxt->debug_dir);
\r
2423 if (mxt != NULL) {
\r
2425 if (mxt->exit_hw != NULL)
\r
2426 mxt->exit_hw(&(client->dev));
\r
2429 free_irq(mxt->irq, mxt);
\r
2432 #if (!WORKQ_RIGHTNOW)
\r
2433 if (cancel_delayed_work_sync(&mxt->dwork)) {
\r
2435 * Work was pending, therefore we need to enable
2436 * IRQ here to balance the disable_irq() done in the
2437 * interrupt handler.
2439 MXT1386_LOG(KERN_INFO "%s: cancel_delayed_work_sync set\n", __func__);
\r
2440 enable_irq(mxt->irq);
\r
2444 unregister_chrdev_region(mxt->dev_num, 2);
\r
2445 device_destroy(mxt->mxt_class, MKDEV(MAJOR(mxt->dev_num), 0));
\r
2446 device_destroy(mxt->mxt_class, MKDEV(MAJOR(mxt->dev_num), 1));
\r
2447 cdev_del(&mxt->cdev);
\r
2448 cdev_del(&mxt->cdev_messages);
\r
2449 cancel_delayed_work_sync(&mxt->dwork);
\r
2450 input_unregister_device(mxt->input);
\r
2451 class_destroy(mxt->mxt_class);
\r
2452 debugfs_remove(mxt->debug_dir);
\r
2454 kfree(mxt->rid_map);
\r
2455 kfree(mxt->object_table);
\r
2456 kfree(mxt->last_message);
\r
2460 i2c_set_clientdata(client, NULL);
\r
2461 if (debug >= DEBUG_TRACE)
\r
2462 dev_info(&client->dev, "Touchscreen unregistered\n");
\r
2467 #if defined(CONFIG_PM)
\r
2468 static int mxt_suspend(struct i2c_client *client, pm_message_t mesg)
\r
2470 struct mxt_data *mxt = i2c_get_clientdata(client);
\r
2472 MXT1386_LOG(KERN_INFO "%s: ----------- mxt_suspend enter now -----------\n", __func__);
\r
2475 if (device_may_wakeup(&client->dev)) {
\r
2476 MXT1386_LOG(KERN_INFO "%s: mxt_suspend ok\n", __func__);
\r
2477 enable_irq_wake(mxt->irq);
\r
2479 MXT1386_LOG(KERN_INFO "%s: mxt_suspend failed\n", __func__);
\r
2482 disable_irq(mxt->irq);
\r
2483 cancel_work_sync(&mxt->work);
\r
2485 if (device_may_wakeup(&client->dev)) {
\r
2486 printk(KERN_INFO "%s: mxt_suspend ok\n", __func__);
\r
2487 enable_irq_wake(mxt->irq);
\r
2489 printk(KERN_INFO "%s: mxt_suspend failed\n", __func__);
\r
2496 static int mxt_wakeup_controller(int gpio)
\r
2502 if((ret = gpio_request(gpio, "mxc_irq_gpio"))!=0) {
\r
2503 MXT1386_LOG(KERN_INFO "Failed to request GPIO for mxc_irq_gpio. Err:%d\n", ret);
\r
2506 gpio_direction_output(gpio, 0);
\r
2508 for(i=0; i<100; i++);
\r
2509 gpio_direction_input(gpio);
\r
2510 MXT1386_LOG(KERN_INFO "INT wakeup touch controller done\n");
\r
2517 static int mxt_resume(struct i2c_client *client)
\r
2519 struct mxt_data *mxt = i2c_get_clientdata(client);
\r
2521 MXT1386_LOG(KERN_INFO "%s: ----------- mxt_resume enter now ----------- \n", __func__);
\r
2524 if (device_may_wakeup(&client->dev)) {
\r
2525 MXT1386_LOG(KERN_INFO "%s: mxt_resume ok\n", __func__);
\r
2526 disable_irq_wake(mxt->irq);
\r
2528 MXT1386_LOG(KERN_INFO "%s: mxt_resume failed\n", __func__);
\r
2531 if (device_may_wakeup(&client->dev)) {
\r
2532 printk(KERN_INFO "%s: mxt_resume ok\n", __func__);
\r
2533 disable_irq_wake(mxt->irq);
\r
2535 printk(KERN_INFO "%s: mxt_resume failed\n", __func__);
\r
2537 mxt_wakeup_controller(irq_to_gpio(mxt->irq));
\r
2538 enable_irq(mxt->irq);
\r
2544 #define mxt_suspend NULL
\r
2545 #define mxt_resume NULL
\r
2548 static const struct i2c_device_id mxt_idtable[] = {
\r
2549 {"mxc_ts_i2c", 0,},
\r
2553 MODULE_DEVICE_TABLE(i2c, mxt_idtable);
\r
2555 static struct i2c_driver mxt_driver = {
\r
2557 .name = "mxc_ts_i2c",
\r
2558 .owner = THIS_MODULE,
\r
2561 .id_table = mxt_idtable,
\r
2562 .probe = mxt_probe,
\r
2563 .remove = __devexit_p(mxt_remove),
\r
2564 .suspend = mxt_suspend,
\r
2565 .resume = mxt_resume,
\r
2570 static void __init mxt_init_async(void *unused, async_cookie_t cookie)
\r
2574 MXT1386_LOG(KERN_INFO "%s: ----------- mxt_init_async enter now ----------- \n", __func__);
\r
2576 err = i2c_add_driver(&mxt_driver);
\r
2578 MXT1386_LOG("Adding maXTouch driver failed "
\r
2579 "(errno = %d)\n", err);
\r
2581 MXT1386_LOG(KERN_INFO "Successfully added driver %s\n", __func__,
\r
2582 mxt_driver.driver.name);
\r
2585 static int __init mxt_init(void)
\r
2587 MXT1386_LOG(KERN_INFO "%s: ----------- mxt_init enter now ----------- \n", __func__);
\r
2589 async_schedule(mxt_init_async, NULL);
\r
2593 static int __init mxt_init(void)
\r
2597 MXT1386_LOG(KERN_INFO "%s: ----------- mxt_init enter now ----------- \n", __func__);
\r
2599 err = i2c_add_driver(&mxt_driver);
\r
2601 MXT1386_LOG("Adding maXTouch driver failed "
\r
2602 "(errno = %d)\n", err);
\r
2604 MXT1386_LOG(KERN_INFO "Successfully added driver %s\n", __func__,
\r
2605 mxt_driver.driver.name);
\r
2608 MXT1386_LOG(KERN_INFO "Adding maXTouch driver \n");
\r
2614 static void __exit mxt_cleanup(void)
\r
2616 MXT1386_LOG(KERN_INFO "%s: ----------- mxt_cleanup enter now ----------- \n", __func__);
\r
2617 i2c_del_driver(&mxt_driver);
\r
2620 module_init(mxt_init);
\r
2621 module_exit(mxt_cleanup);
\r
2623 MODULE_AUTHOR("Iiro Valkonen");
\r
2624 MODULE_DESCRIPTION("Driver for Atmel maXTouch Touchscreen Controller");
\r
2625 MODULE_LICENSE("GPL");
\r