blob: a9f987b59f9a4cea23ce436ac80db701e3f4190d [file] [log] [blame]
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001/*
Iiro Valkonen7686b102011-02-02 23:21:58 -08002 * Atmel maXTouch Touchscreen driver
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003 *
4 * Copyright (C) 2010 Samsung Electronics Co.Ltd
Nick Dyer50a77c62014-07-23 12:38:48 -07005 * Copyright (C) 2011-2014 Atmel Corporation
Daniel Kurtz1e0c0c52014-05-18 23:01:12 -07006 * Copyright (C) 2012 Google, Inc.
7 *
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07008 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 *
15 */
16
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -070017#include <linux/acpi.h>
18#include <linux/dmi.h>
Joonyoung Shim4cf51c32010-07-14 21:55:30 -070019#include <linux/module.h>
Benson Leungd79e7e42014-05-18 23:02:52 -070020#include <linux/init.h>
21#include <linux/completion.h>
Joonyoung Shim4cf51c32010-07-14 21:55:30 -070022#include <linux/delay.h>
23#include <linux/firmware.h>
24#include <linux/i2c.h>
Nick Dyer7f3884f72015-08-04 16:36:29 -070025#include <linux/platform_data/atmel_mxt_ts.h>
Joonyoung Shim8b86c1c2011-04-12 23:18:59 -070026#include <linux/input/mt.h>
Joonyoung Shim4cf51c32010-07-14 21:55:30 -070027#include <linux/interrupt.h>
Stephen Warren78188be2014-07-23 12:23:23 -070028#include <linux/of.h>
Joonyoung Shim4cf51c32010-07-14 21:55:30 -070029#include <linux/slab.h>
Nick Dyerb23157d2015-04-06 11:25:13 -070030#include <asm/unaligned.h>
Nick Dyerecfdd7e2016-07-18 18:10:32 -030031#include <media/v4l2-device.h>
32#include <media/v4l2-ioctl.h>
33#include <media/videobuf2-v4l2.h>
34#include <media/videobuf2-vmalloc.h>
Joonyoung Shim4cf51c32010-07-14 21:55:30 -070035
Nick Dyer50a77c62014-07-23 12:38:48 -070036/* Firmware files */
Iiro Valkonen7686b102011-02-02 23:21:58 -080037#define MXT_FW_NAME "maxtouch.fw"
Nick Dyer50a77c62014-07-23 12:38:48 -070038#define MXT_CFG_NAME "maxtouch.cfg"
39#define MXT_CFG_MAGIC "OBP_RAW V1"
Joonyoung Shim4cf51c32010-07-14 21:55:30 -070040
41/* Registers */
Iiro Valkonen7686b102011-02-02 23:21:58 -080042#define MXT_OBJECT_START 0x07
Iiro Valkonen7686b102011-02-02 23:21:58 -080043#define MXT_OBJECT_SIZE 6
Nick Dyer4ce6fa02014-07-23 12:40:09 -070044#define MXT_INFO_CHECKSUM_SIZE 3
45#define MXT_MAX_BLOCK_WRITE 256
Joonyoung Shim4cf51c32010-07-14 21:55:30 -070046
47/* Object types */
Iiro Valkonen81c88a72011-07-04 03:08:25 -070048#define MXT_DEBUG_DIAGNOSTIC_T37 37
49#define MXT_GEN_MESSAGE_T5 5
50#define MXT_GEN_COMMAND_T6 6
51#define MXT_GEN_POWER_T7 7
52#define MXT_GEN_ACQUIRE_T8 8
53#define MXT_GEN_DATASOURCE_T53 53
54#define MXT_TOUCH_MULTI_T9 9
55#define MXT_TOUCH_KEYARRAY_T15 15
56#define MXT_TOUCH_PROXIMITY_T23 23
57#define MXT_TOUCH_PROXKEY_T52 52
58#define MXT_PROCI_GRIPFACE_T20 20
59#define MXT_PROCG_NOISE_T22 22
60#define MXT_PROCI_ONETOUCH_T24 24
61#define MXT_PROCI_TWOTOUCH_T27 27
62#define MXT_PROCI_GRIP_T40 40
63#define MXT_PROCI_PALM_T41 41
64#define MXT_PROCI_TOUCHSUPPRESSION_T42 42
65#define MXT_PROCI_STYLUS_T47 47
66#define MXT_PROCG_NOISESUPPRESSION_T48 48
67#define MXT_SPT_COMMSCONFIG_T18 18
68#define MXT_SPT_GPIOPWM_T19 19
69#define MXT_SPT_SELFTEST_T25 25
70#define MXT_SPT_CTECONFIG_T28 28
71#define MXT_SPT_USERDATA_T38 38
72#define MXT_SPT_DIGITIZER_T43 43
73#define MXT_SPT_MESSAGECOUNT_T44 44
74#define MXT_SPT_CTECONFIG_T46 46
Nick Dyerb23157d2015-04-06 11:25:13 -070075#define MXT_TOUCH_MULTITOUCHSCREEN_T100 100
Joonyoung Shim4cf51c32010-07-14 21:55:30 -070076
Nick Dyer5f3f9bc2014-07-23 12:46:55 -070077/* MXT_GEN_MESSAGE_T5 object */
78#define MXT_RPTID_NOMSG 0xff
79
Iiro Valkonen81c88a72011-07-04 03:08:25 -070080/* MXT_GEN_COMMAND_T6 field */
Iiro Valkonen7686b102011-02-02 23:21:58 -080081#define MXT_COMMAND_RESET 0
82#define MXT_COMMAND_BACKUPNV 1
83#define MXT_COMMAND_CALIBRATE 2
84#define MXT_COMMAND_REPORTALL 3
85#define MXT_COMMAND_DIAGNOSTIC 5
Joonyoung Shim4cf51c32010-07-14 21:55:30 -070086
Iiro Valkonena4a2ef42014-05-18 23:03:44 -070087/* Define for T6 status byte */
88#define MXT_T6_STATUS_RESET (1 << 7)
Nick Dyer497767d2014-07-23 12:47:50 -070089#define MXT_T6_STATUS_OFL (1 << 6)
90#define MXT_T6_STATUS_SIGERR (1 << 5)
91#define MXT_T6_STATUS_CAL (1 << 4)
92#define MXT_T6_STATUS_CFGERR (1 << 3)
93#define MXT_T6_STATUS_COMSERR (1 << 2)
Iiro Valkonena4a2ef42014-05-18 23:03:44 -070094
Iiro Valkonen81c88a72011-07-04 03:08:25 -070095/* MXT_GEN_POWER_T7 field */
Nick Dyer7f3884f72015-08-04 16:36:29 -070096struct t7_config {
97 u8 idle;
98 u8 active;
99} __packed;
100
101#define MXT_POWER_CFG_RUN 0
102#define MXT_POWER_CFG_DEEPSLEEP 1
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700103
Iiro Valkonen81c88a72011-07-04 03:08:25 -0700104/* MXT_TOUCH_MULTI_T9 field */
Nick Dyer7f3884f72015-08-04 16:36:29 -0700105#define MXT_T9_CTRL 0
Nick Dyer61dc1ab2014-05-18 23:16:49 -0700106#define MXT_T9_ORIENT 9
107#define MXT_T9_RANGE 18
108
Nick Dyerf3889ed2014-05-18 23:22:04 -0700109/* MXT_TOUCH_MULTI_T9 status */
110#define MXT_T9_UNGRIP (1 << 0)
111#define MXT_T9_SUPPRESS (1 << 1)
112#define MXT_T9_AMP (1 << 2)
113#define MXT_T9_VECTOR (1 << 3)
114#define MXT_T9_MOVE (1 << 4)
115#define MXT_T9_RELEASE (1 << 5)
116#define MXT_T9_PRESS (1 << 6)
117#define MXT_T9_DETECT (1 << 7)
118
Nick Dyer61dc1ab2014-05-18 23:16:49 -0700119struct t9_range {
Nick Dyer1c0276d2016-01-10 18:29:34 -0800120 __le16 x;
121 __le16 y;
Nick Dyer61dc1ab2014-05-18 23:16:49 -0700122} __packed;
123
Nick Dyerf3889ed2014-05-18 23:22:04 -0700124/* MXT_TOUCH_MULTI_T9 orient */
125#define MXT_T9_ORIENT_SWITCH (1 << 0)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700126
Iiro Valkonen81c88a72011-07-04 03:08:25 -0700127/* MXT_SPT_COMMSCONFIG_T18 */
Iiro Valkonen7686b102011-02-02 23:21:58 -0800128#define MXT_COMMS_CTRL 0
129#define MXT_COMMS_CMD 1
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700130
Nick Dyerd6a39402016-07-18 18:10:31 -0300131/* MXT_DEBUG_DIAGNOSTIC_T37 */
132#define MXT_DIAGNOSTIC_PAGEUP 0x01
133#define MXT_DIAGNOSTIC_DELTAS 0x10
134#define MXT_DIAGNOSTIC_SIZE 128
135
136struct t37_debug {
137#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
138 u8 mode;
139 u8 page;
140 u8 data[MXT_DIAGNOSTIC_SIZE];
141#endif
142};
143
Iiro Valkonen81c88a72011-07-04 03:08:25 -0700144/* Define for MXT_GEN_COMMAND_T6 */
Iiro Valkonen7686b102011-02-02 23:21:58 -0800145#define MXT_BOOT_VALUE 0xa5
Iiro Valkonena4a2ef42014-05-18 23:03:44 -0700146#define MXT_RESET_VALUE 0x01
Iiro Valkonen7686b102011-02-02 23:21:58 -0800147#define MXT_BACKUP_VALUE 0x55
Iiro Valkonena4a2ef42014-05-18 23:03:44 -0700148
Nick Dyerb23157d2015-04-06 11:25:13 -0700149/* T100 Multiple Touch Touchscreen */
150#define MXT_T100_CTRL 0
151#define MXT_T100_CFG1 1
152#define MXT_T100_TCHAUX 3
153#define MXT_T100_XRANGE 13
154#define MXT_T100_YRANGE 24
155
156#define MXT_T100_CFG_SWITCHXY BIT(5)
157
158#define MXT_T100_TCHAUX_VECT BIT(0)
159#define MXT_T100_TCHAUX_AMPL BIT(1)
160#define MXT_T100_TCHAUX_AREA BIT(2)
161
162#define MXT_T100_DETECT BIT(7)
163#define MXT_T100_TYPE_MASK 0x70
164
165enum t100_type {
166 MXT_T100_TYPE_FINGER = 1,
167 MXT_T100_TYPE_PASSIVE_STYLUS = 2,
168 MXT_T100_TYPE_HOVERING_FINGER = 4,
169 MXT_T100_TYPE_GLOVE = 5,
170 MXT_T100_TYPE_LARGE_TOUCH = 6,
171};
172
173#define MXT_DISTANCE_ACTIVE_TOUCH 0
174#define MXT_DISTANCE_HOVERING 1
175
176#define MXT_TOUCH_MAJOR_DEFAULT 1
177#define MXT_PRESSURE_DEFAULT 1
178
Iiro Valkonena4a2ef42014-05-18 23:03:44 -0700179/* Delay times */
Linus Torvalds8343bce2013-03-09 10:31:01 -0800180#define MXT_BACKUP_TIME 50 /* msec */
181#define MXT_RESET_TIME 200 /* msec */
Iiro Valkonena4a2ef42014-05-18 23:03:44 -0700182#define MXT_RESET_TIMEOUT 3000 /* msec */
Nick Dyerc3f78042014-05-18 23:04:46 -0700183#define MXT_CRC_TIMEOUT 1000 /* msec */
Benson Leunga0434b72014-05-18 23:03:09 -0700184#define MXT_FW_RESET_TIME 3000 /* msec */
185#define MXT_FW_CHG_TIMEOUT 300 /* msec */
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700186
187/* Command to unlock bootloader */
Iiro Valkonen7686b102011-02-02 23:21:58 -0800188#define MXT_UNLOCK_CMD_MSB 0xaa
189#define MXT_UNLOCK_CMD_LSB 0xdc
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700190
191/* Bootloader mode status */
Iiro Valkonen7686b102011-02-02 23:21:58 -0800192#define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */
193#define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */
194#define MXT_FRAME_CRC_CHECK 0x02
195#define MXT_FRAME_CRC_FAIL 0x03
196#define MXT_FRAME_CRC_PASS 0x04
197#define MXT_APP_CRC_FAIL 0x40 /* valid 7 8 bit only */
198#define MXT_BOOT_STATUS_MASK 0x3f
Nick Dyere57a66a2014-05-18 23:13:40 -0700199#define MXT_BOOT_EXTENDED_ID (1 << 5)
200#define MXT_BOOT_ID_MASK 0x1f
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700201
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700202/* Touchscreen absolute values */
Iiro Valkonen7686b102011-02-02 23:21:58 -0800203#define MXT_MAX_AREA 0xff
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700204
Daniel Kurtz22dfab72013-03-07 19:43:33 -0800205#define MXT_PIXELS_PER_MM 20
206
Iiro Valkonen7686b102011-02-02 23:21:58 -0800207struct mxt_info {
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700208 u8 family_id;
209 u8 variant_id;
210 u8 version;
211 u8 build;
212 u8 matrix_xsize;
213 u8 matrix_ysize;
214 u8 object_num;
215};
216
Iiro Valkonen7686b102011-02-02 23:21:58 -0800217struct mxt_object {
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700218 u8 type;
219 u16 start_address;
Daniel Kurtz1e0c0c52014-05-18 23:01:12 -0700220 u8 size_minus_one;
221 u8 instances_minus_one;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700222 u8 num_report_ids;
Daniel Kurtz333e5a92012-06-28 21:08:20 +0800223} __packed;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700224
Nick Dyerd6a39402016-07-18 18:10:31 -0300225struct mxt_dbg {
226 u16 t37_address;
227 u16 diag_cmd_address;
228 struct t37_debug *t37_buf;
229 unsigned int t37_pages;
230 unsigned int t37_nodes;
Nick Dyerecfdd7e2016-07-18 18:10:32 -0300231
232 struct v4l2_device v4l2;
233 struct v4l2_pix_format format;
234 struct video_device vdev;
235 struct vb2_queue queue;
236 struct mutex lock;
237 int input;
238};
239
240static const struct v4l2_file_operations mxt_video_fops = {
241 .owner = THIS_MODULE,
242 .open = v4l2_fh_open,
243 .release = vb2_fop_release,
244 .unlocked_ioctl = video_ioctl2,
245 .read = vb2_fop_read,
246 .mmap = vb2_fop_mmap,
247 .poll = vb2_fop_poll,
Nick Dyerd6a39402016-07-18 18:10:31 -0300248};
249
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700250/* Each client has this additional data */
Iiro Valkonen7686b102011-02-02 23:21:58 -0800251struct mxt_data {
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700252 struct i2c_client *client;
253 struct input_dev *input_dev;
Daniel Kurtzec02ac22012-06-28 21:08:02 +0800254 char phys[64]; /* device physical location */
Iiro Valkonen7686b102011-02-02 23:21:58 -0800255 const struct mxt_platform_data *pdata;
256 struct mxt_object *object_table;
257 struct mxt_info info;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700258 unsigned int irq;
Joonyoung Shim910d8052011-04-12 23:14:38 -0700259 unsigned int max_x;
260 unsigned int max_y;
Nick Dyer1c0276d2016-01-10 18:29:34 -0800261 bool xy_switch;
Benson Leungd79e7e42014-05-18 23:02:52 -0700262 bool in_bootloader;
Nick Dyer4ce6fa02014-07-23 12:40:09 -0700263 u16 mem_size;
Nick Dyerb23157d2015-04-06 11:25:13 -0700264 u8 t100_aux_ampl;
265 u8 t100_aux_area;
266 u8 t100_aux_vect;
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700267 u8 max_reportid;
Nick Dyerc3f78042014-05-18 23:04:46 -0700268 u32 config_crc;
Nick Dyer4ce6fa02014-07-23 12:40:09 -0700269 u32 info_crc;
Nick Dyerf28a8422014-05-18 23:10:49 -0700270 u8 bootloader_addr;
Nick Dyer5f3f9bc2014-07-23 12:46:55 -0700271 u8 *msg_buf;
Nick Dyer497767d2014-07-23 12:47:50 -0700272 u8 t6_status;
Nick Dyerb9b05a82014-07-23 12:48:13 -0700273 bool update_input;
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700274 u8 last_message_count;
275 u8 num_touchids;
Nick Dyerb23157d2015-04-06 11:25:13 -0700276 u8 multitouch;
Nick Dyer7f3884f72015-08-04 16:36:29 -0700277 struct t7_config t7_cfg;
Nick Dyerd6a39402016-07-18 18:10:31 -0300278 struct mxt_dbg dbg;
Daniel Kurtz333e5a92012-06-28 21:08:20 +0800279
280 /* Cached parameters from object table */
Nick Dyerb9b05a82014-07-23 12:48:13 -0700281 u16 T5_address;
Nick Dyer5f3f9bc2014-07-23 12:46:55 -0700282 u8 T5_msg_size;
Daniel Kurtzfdf804212012-06-28 21:08:24 +0800283 u8 T6_reportid;
Iiro Valkonena4a2ef42014-05-18 23:03:44 -0700284 u16 T6_address;
Nick Dyer4ce6fa02014-07-23 12:40:09 -0700285 u16 T7_address;
Daniel Kurtz333e5a92012-06-28 21:08:20 +0800286 u8 T9_reportid_min;
287 u8 T9_reportid_max;
Daniel Kurtz22dfab72013-03-07 19:43:33 -0800288 u8 T19_reportid;
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700289 u16 T44_address;
Nick Dyerb23157d2015-04-06 11:25:13 -0700290 u8 T100_reportid_min;
291 u8 T100_reportid_max;
Benson Leungd79e7e42014-05-18 23:02:52 -0700292
293 /* for fw update in bootloader */
294 struct completion bl_completion;
Iiro Valkonena4a2ef42014-05-18 23:03:44 -0700295
296 /* for reset handling */
297 struct completion reset_completion;
Nick Dyerc3f78042014-05-18 23:04:46 -0700298
299 /* for config update handling */
300 struct completion crc_completion;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700301};
302
Nick Dyerecfdd7e2016-07-18 18:10:32 -0300303struct mxt_vb2_buffer {
304 struct vb2_buffer vb;
305 struct list_head list;
306};
307
Daniel Kurtz1e0c0c52014-05-18 23:01:12 -0700308static size_t mxt_obj_size(const struct mxt_object *obj)
309{
310 return obj->size_minus_one + 1;
311}
312
313static size_t mxt_obj_instances(const struct mxt_object *obj)
314{
315 return obj->instances_minus_one + 1;
316}
317
Iiro Valkonen7686b102011-02-02 23:21:58 -0800318static bool mxt_object_readable(unsigned int type)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700319{
320 switch (type) {
Iiro Valkonen81c88a72011-07-04 03:08:25 -0700321 case MXT_GEN_COMMAND_T6:
322 case MXT_GEN_POWER_T7:
323 case MXT_GEN_ACQUIRE_T8:
324 case MXT_GEN_DATASOURCE_T53:
325 case MXT_TOUCH_MULTI_T9:
326 case MXT_TOUCH_KEYARRAY_T15:
327 case MXT_TOUCH_PROXIMITY_T23:
328 case MXT_TOUCH_PROXKEY_T52:
329 case MXT_PROCI_GRIPFACE_T20:
330 case MXT_PROCG_NOISE_T22:
331 case MXT_PROCI_ONETOUCH_T24:
332 case MXT_PROCI_TWOTOUCH_T27:
333 case MXT_PROCI_GRIP_T40:
334 case MXT_PROCI_PALM_T41:
335 case MXT_PROCI_TOUCHSUPPRESSION_T42:
336 case MXT_PROCI_STYLUS_T47:
337 case MXT_PROCG_NOISESUPPRESSION_T48:
338 case MXT_SPT_COMMSCONFIG_T18:
339 case MXT_SPT_GPIOPWM_T19:
340 case MXT_SPT_SELFTEST_T25:
341 case MXT_SPT_CTECONFIG_T28:
342 case MXT_SPT_USERDATA_T38:
343 case MXT_SPT_DIGITIZER_T43:
344 case MXT_SPT_CTECONFIG_T46:
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700345 return true;
346 default:
347 return false;
348 }
349}
350
Nick Dyer5f3f9bc2014-07-23 12:46:55 -0700351static void mxt_dump_message(struct mxt_data *data, u8 *message)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700352{
Nick Dyer5f3f9bc2014-07-23 12:46:55 -0700353 dev_dbg(&data->client->dev, "message: %*ph\n",
354 data->T5_msg_size, message);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700355}
356
Iiro Valkonena4a2ef42014-05-18 23:03:44 -0700357static int mxt_wait_for_completion(struct mxt_data *data,
358 struct completion *comp,
359 unsigned int timeout_ms)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700360{
Benson Leungd79e7e42014-05-18 23:02:52 -0700361 struct device *dev = &data->client->dev;
Benson Leungd79e7e42014-05-18 23:02:52 -0700362 unsigned long timeout = msecs_to_jiffies(timeout_ms);
363 long ret;
364
365 ret = wait_for_completion_interruptible_timeout(comp, timeout);
366 if (ret < 0) {
367 return ret;
368 } else if (ret == 0) {
369 dev_err(dev, "Wait for completion timed out.\n");
370 return -ETIMEDOUT;
371 }
372 return 0;
373}
374
Nick Dyerf28a8422014-05-18 23:10:49 -0700375static int mxt_bootloader_read(struct mxt_data *data,
376 u8 *val, unsigned int count)
377{
378 int ret;
379 struct i2c_msg msg;
380
381 msg.addr = data->bootloader_addr;
382 msg.flags = data->client->flags & I2C_M_TEN;
383 msg.flags |= I2C_M_RD;
384 msg.len = count;
385 msg.buf = val;
386
387 ret = i2c_transfer(data->client->adapter, &msg, 1);
Nick Dyerf28a8422014-05-18 23:10:49 -0700388 if (ret == 1) {
389 ret = 0;
390 } else {
391 ret = ret < 0 ? ret : -EIO;
392 dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n",
393 __func__, ret);
394 }
395
396 return ret;
397}
398
399static int mxt_bootloader_write(struct mxt_data *data,
400 const u8 * const val, unsigned int count)
401{
402 int ret;
403 struct i2c_msg msg;
404
405 msg.addr = data->bootloader_addr;
406 msg.flags = data->client->flags & I2C_M_TEN;
407 msg.len = count;
408 msg.buf = (u8 *)val;
409
410 ret = i2c_transfer(data->client->adapter, &msg, 1);
411 if (ret == 1) {
412 ret = 0;
413 } else {
414 ret = ret < 0 ? ret : -EIO;
415 dev_err(&data->client->dev, "%s: i2c send failed (%d)\n",
416 __func__, ret);
417 }
418
419 return ret;
420}
421
Nick Dyer8efaa5e2014-07-23 12:45:49 -0700422static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
Nick Dyerf28a8422014-05-18 23:10:49 -0700423{
424 u8 appmode = data->client->addr;
425 u8 bootloader;
426
427 switch (appmode) {
428 case 0x4a:
429 case 0x4b:
Nick Dyer44a0bab2014-07-23 12:45:26 -0700430 /* Chips after 1664S use different scheme */
Nick Dyer8efaa5e2014-07-23 12:45:49 -0700431 if (retry || data->info.family_id >= 0xa2) {
Nick Dyer44a0bab2014-07-23 12:45:26 -0700432 bootloader = appmode - 0x24;
433 break;
434 }
435 /* Fall through for normal case */
Nick Dyerf28a8422014-05-18 23:10:49 -0700436 case 0x4c:
437 case 0x4d:
438 case 0x5a:
439 case 0x5b:
440 bootloader = appmode - 0x26;
441 break;
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -0700442
Nick Dyerf28a8422014-05-18 23:10:49 -0700443 default:
444 dev_err(&data->client->dev,
445 "Appmode i2c address 0x%02x not found\n",
446 appmode);
447 return -EINVAL;
448 }
449
450 data->bootloader_addr = bootloader;
451 return 0;
452}
453
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -0700454static int mxt_probe_bootloader(struct mxt_data *data, bool alt_address)
Nick Dyera9fdd1e2014-07-23 12:41:58 -0700455{
456 struct device *dev = &data->client->dev;
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -0700457 int error;
Nick Dyera9fdd1e2014-07-23 12:41:58 -0700458 u8 val;
459 bool crc_failure;
460
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -0700461 error = mxt_lookup_bootloader_address(data, alt_address);
462 if (error)
463 return error;
Nick Dyera9fdd1e2014-07-23 12:41:58 -0700464
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -0700465 error = mxt_bootloader_read(data, &val, 1);
466 if (error)
467 return error;
Nick Dyera9fdd1e2014-07-23 12:41:58 -0700468
469 /* Check app crc fail mode */
470 crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
471
472 dev_err(dev, "Detected bootloader, status:%02X%s\n",
473 val, crc_failure ? ", APP_CRC_FAIL" : "");
474
475 return 0;
476}
477
Nick Dyere57a66a2014-05-18 23:13:40 -0700478static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
479{
480 struct device *dev = &data->client->dev;
481 u8 buf[3];
482
483 if (val & MXT_BOOT_EXTENDED_ID) {
484 if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
485 dev_err(dev, "%s: i2c failure\n", __func__);
Nick Dyer68807a02014-06-07 23:17:26 -0700486 return val;
Nick Dyere57a66a2014-05-18 23:13:40 -0700487 }
488
489 dev_dbg(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]);
490
491 return buf[0];
492 } else {
493 dev_dbg(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK);
494
495 return val;
496 }
497}
498
Nick Dyer385deb92014-07-23 12:42:40 -0700499static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
500 bool wait)
Benson Leungd79e7e42014-05-18 23:02:52 -0700501{
Nick Dyerf28a8422014-05-18 23:10:49 -0700502 struct device *dev = &data->client->dev;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700503 u8 val;
Benson Leungd79e7e42014-05-18 23:02:52 -0700504 int ret;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700505
506recheck:
Nick Dyer385deb92014-07-23 12:42:40 -0700507 if (wait) {
Benson Leungd79e7e42014-05-18 23:02:52 -0700508 /*
509 * In application update mode, the interrupt
510 * line signals state transitions. We must wait for the
511 * CHG assertion before reading the status byte.
512 * Once the status byte has been read, the line is deasserted.
513 */
Iiro Valkonena4a2ef42014-05-18 23:03:44 -0700514 ret = mxt_wait_for_completion(data, &data->bl_completion,
515 MXT_FW_CHG_TIMEOUT);
Benson Leungd79e7e42014-05-18 23:02:52 -0700516 if (ret) {
517 /*
518 * TODO: handle -ERESTARTSYS better by terminating
519 * fw update process before returning to userspace
520 * by writing length 0x000 to device (iff we are in
521 * WAITING_FRAME_DATA state).
522 */
Nick Dyerf28a8422014-05-18 23:10:49 -0700523 dev_err(dev, "Update wait error %d\n", ret);
Benson Leungd79e7e42014-05-18 23:02:52 -0700524 return ret;
525 }
526 }
527
Nick Dyerf28a8422014-05-18 23:10:49 -0700528 ret = mxt_bootloader_read(data, &val, 1);
529 if (ret)
530 return ret;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700531
Nick Dyere57a66a2014-05-18 23:13:40 -0700532 if (state == MXT_WAITING_BOOTLOAD_CMD)
533 val = mxt_get_bootloader_version(data, val);
534
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700535 switch (state) {
Iiro Valkonen7686b102011-02-02 23:21:58 -0800536 case MXT_WAITING_BOOTLOAD_CMD:
537 case MXT_WAITING_FRAME_DATA:
Nick Dyera9fdd1e2014-07-23 12:41:58 -0700538 case MXT_APP_CRC_FAIL:
Iiro Valkonen7686b102011-02-02 23:21:58 -0800539 val &= ~MXT_BOOT_STATUS_MASK;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700540 break;
Iiro Valkonen7686b102011-02-02 23:21:58 -0800541 case MXT_FRAME_CRC_PASS:
Nick Dyerf943c742014-05-18 23:14:20 -0700542 if (val == MXT_FRAME_CRC_CHECK) {
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700543 goto recheck;
Nick Dyerf943c742014-05-18 23:14:20 -0700544 } else if (val == MXT_FRAME_CRC_FAIL) {
545 dev_err(dev, "Bootloader CRC fail\n");
546 return -EINVAL;
547 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700548 break;
549 default:
550 return -EINVAL;
551 }
552
553 if (val != state) {
Nick Dyerf28a8422014-05-18 23:10:49 -0700554 dev_err(dev, "Invalid bootloader state %02X != %02X\n",
Nick Dyer7bed6802014-05-18 23:04:09 -0700555 val, state);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700556 return -EINVAL;
557 }
558
559 return 0;
560}
561
Nick Dyer8efaa5e2014-07-23 12:45:49 -0700562static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700563{
Nick Dyerf28a8422014-05-18 23:10:49 -0700564 int ret;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700565 u8 buf[2];
566
Nick Dyer8efaa5e2014-07-23 12:45:49 -0700567 if (unlock) {
568 buf[0] = MXT_UNLOCK_CMD_LSB;
569 buf[1] = MXT_UNLOCK_CMD_MSB;
570 } else {
571 buf[0] = 0x01;
572 buf[1] = 0x01;
573 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700574
Nick Dyerf28a8422014-05-18 23:10:49 -0700575 ret = mxt_bootloader_write(data, buf, 2);
576 if (ret)
577 return ret;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700578
579 return 0;
580}
581
Iiro Valkonen7686b102011-02-02 23:21:58 -0800582static int __mxt_read_reg(struct i2c_client *client,
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700583 u16 reg, u16 len, void *val)
584{
585 struct i2c_msg xfer[2];
586 u8 buf[2];
Daniel Kurtz771733e2012-06-28 21:08:11 +0800587 int ret;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700588
589 buf[0] = reg & 0xff;
590 buf[1] = (reg >> 8) & 0xff;
591
592 /* Write register */
593 xfer[0].addr = client->addr;
594 xfer[0].flags = 0;
595 xfer[0].len = 2;
596 xfer[0].buf = buf;
597
598 /* Read data */
599 xfer[1].addr = client->addr;
600 xfer[1].flags = I2C_M_RD;
601 xfer[1].len = len;
602 xfer[1].buf = val;
603
Daniel Kurtz771733e2012-06-28 21:08:11 +0800604 ret = i2c_transfer(client->adapter, xfer, 2);
605 if (ret == 2) {
606 ret = 0;
607 } else {
608 if (ret >= 0)
609 ret = -EIO;
610 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
611 __func__, ret);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700612 }
613
Daniel Kurtz771733e2012-06-28 21:08:11 +0800614 return ret;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700615}
616
Daniel Kurtz9638ab72012-06-28 21:08:12 +0800617static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
618 const void *val)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700619{
Daniel Kurtz9638ab72012-06-28 21:08:12 +0800620 u8 *buf;
621 size_t count;
Daniel Kurtz771733e2012-06-28 21:08:11 +0800622 int ret;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700623
Daniel Kurtz9638ab72012-06-28 21:08:12 +0800624 count = len + 2;
625 buf = kmalloc(count, GFP_KERNEL);
626 if (!buf)
627 return -ENOMEM;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700628
629 buf[0] = reg & 0xff;
630 buf[1] = (reg >> 8) & 0xff;
Daniel Kurtz9638ab72012-06-28 21:08:12 +0800631 memcpy(&buf[2], val, len);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700632
Daniel Kurtz9638ab72012-06-28 21:08:12 +0800633 ret = i2c_master_send(client, buf, count);
634 if (ret == count) {
Daniel Kurtz771733e2012-06-28 21:08:11 +0800635 ret = 0;
636 } else {
637 if (ret >= 0)
638 ret = -EIO;
639 dev_err(&client->dev, "%s: i2c send failed (%d)\n",
640 __func__, ret);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700641 }
642
Daniel Kurtz9638ab72012-06-28 21:08:12 +0800643 kfree(buf);
Daniel Kurtz771733e2012-06-28 21:08:11 +0800644 return ret;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700645}
646
Daniel Kurtz9638ab72012-06-28 21:08:12 +0800647static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700648{
Daniel Kurtz9638ab72012-06-28 21:08:12 +0800649 return __mxt_write_reg(client, reg, 1, &val);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700650}
651
Iiro Valkonen7686b102011-02-02 23:21:58 -0800652static struct mxt_object *
653mxt_get_object(struct mxt_data *data, u8 type)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700654{
Iiro Valkonen7686b102011-02-02 23:21:58 -0800655 struct mxt_object *object;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700656 int i;
657
658 for (i = 0; i < data->info.object_num; i++) {
659 object = data->object_table + i;
660 if (object->type == type)
661 return object;
662 }
663
Nick Dyer50a77c62014-07-23 12:38:48 -0700664 dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700665 return NULL;
666}
667
Nick Dyer497767d2014-07-23 12:47:50 -0700668static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
669{
670 struct device *dev = &data->client->dev;
671 u8 status = msg[1];
672 u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16);
673
674 complete(&data->crc_completion);
675
676 if (crc != data->config_crc) {
677 data->config_crc = crc;
678 dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc);
679 }
680
681 /* Detect reset */
682 if (status & MXT_T6_STATUS_RESET)
683 complete(&data->reset_completion);
684
685 /* Output debug if status has changed */
686 if (status != data->t6_status)
687 dev_dbg(dev, "T6 Status 0x%02X%s%s%s%s%s%s%s\n",
688 status,
689 status == 0 ? " OK" : "",
690 status & MXT_T6_STATUS_RESET ? " RESET" : "",
691 status & MXT_T6_STATUS_OFL ? " OFL" : "",
692 status & MXT_T6_STATUS_SIGERR ? " SIGERR" : "",
693 status & MXT_T6_STATUS_CAL ? " CAL" : "",
694 status & MXT_T6_STATUS_CFGERR ? " CFGERR" : "",
695 status & MXT_T6_STATUS_COMSERR ? " COMSERR" : "");
696
697 /* Save current status */
698 data->t6_status = status;
699}
700
Linus Torvalds7f405482014-12-31 12:59:34 -0800701static int mxt_write_object(struct mxt_data *data,
702 u8 type, u8 offset, u8 val)
703{
704 struct mxt_object *object;
705 u16 reg;
706
707 object = mxt_get_object(data, type);
708 if (!object || offset >= mxt_obj_size(object))
709 return -EINVAL;
710
711 reg = object->start_address;
712 return mxt_write_reg(data->client, reg + offset, val);
713}
714
Nick Dyer5f3f9bc2014-07-23 12:46:55 -0700715static void mxt_input_button(struct mxt_data *data, u8 *message)
Daniel Kurtz22dfab72013-03-07 19:43:33 -0800716{
717 struct input_dev *input = data->input_dev;
Nick Dyerfb5e4c3e2014-05-18 23:00:15 -0700718 const struct mxt_platform_data *pdata = data->pdata;
Daniel Kurtz22dfab72013-03-07 19:43:33 -0800719 int i;
720
Nick Dyerfb5e4c3e2014-05-18 23:00:15 -0700721 for (i = 0; i < pdata->t19_num_keys; i++) {
722 if (pdata->t19_keymap[i] == KEY_RESERVED)
Daniel Kurtz22dfab72013-03-07 19:43:33 -0800723 continue;
Dmitry Torokhovc37f6d32015-04-15 10:31:10 -0700724
725 /* Active-low switch */
726 input_report_key(input, pdata->t19_keymap[i],
727 !(message[1] & BIT(i)));
Daniel Kurtz22dfab72013-03-07 19:43:33 -0800728 }
729}
730
Benson Leungb735fbe2014-07-23 12:22:27 -0700731static void mxt_input_sync(struct mxt_data *data)
Nick Dyereef820d2014-05-18 23:22:22 -0700732{
Benson Leungb735fbe2014-07-23 12:22:27 -0700733 input_mt_report_pointer_emulation(data->input_dev,
734 data->pdata->t19_num_keys);
735 input_sync(data->input_dev);
Nick Dyereef820d2014-05-18 23:22:22 -0700736}
737
Nick Dyerb9b05a82014-07-23 12:48:13 -0700738static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700739{
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700740 struct device *dev = &data->client->dev;
Daniel Kurtzfba5bc32012-06-28 21:08:17 +0800741 struct input_dev *input_dev = data->input_dev;
Nick Dyer5f3f9bc2014-07-23 12:46:55 -0700742 int id;
743 u8 status;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700744 int x;
745 int y;
746 int area;
Nick Dyerfea9e462014-05-18 23:21:48 -0700747 int amplitude;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700748
Nick Dyer5f3f9bc2014-07-23 12:46:55 -0700749 id = message[0] - data->T9_reportid_min;
750 status = message[1];
751 x = (message[2] << 4) | ((message[4] >> 4) & 0xf);
752 y = (message[3] << 4) | ((message[4] & 0xf));
Nick Dyereef820d2014-05-18 23:22:22 -0700753
754 /* Handle 10/12 bit switching */
Joonyoung Shim910d8052011-04-12 23:14:38 -0700755 if (data->max_x < 1024)
Nick Dyereef820d2014-05-18 23:22:22 -0700756 x >>= 2;
Joonyoung Shim910d8052011-04-12 23:14:38 -0700757 if (data->max_y < 1024)
Nick Dyereef820d2014-05-18 23:22:22 -0700758 y >>= 2;
Joonyoung Shim910d8052011-04-12 23:14:38 -0700759
Nick Dyer5f3f9bc2014-07-23 12:46:55 -0700760 area = message[5];
761 amplitude = message[6];
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700762
Daniel Kurtzb2e459b2012-06-28 21:08:18 +0800763 dev_dbg(dev,
764 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
765 id,
Nick Dyerf3889ed2014-05-18 23:22:04 -0700766 (status & MXT_T9_DETECT) ? 'D' : '.',
767 (status & MXT_T9_PRESS) ? 'P' : '.',
768 (status & MXT_T9_RELEASE) ? 'R' : '.',
769 (status & MXT_T9_MOVE) ? 'M' : '.',
770 (status & MXT_T9_VECTOR) ? 'V' : '.',
771 (status & MXT_T9_AMP) ? 'A' : '.',
772 (status & MXT_T9_SUPPRESS) ? 'S' : '.',
773 (status & MXT_T9_UNGRIP) ? 'U' : '.',
Nick Dyerfea9e462014-05-18 23:21:48 -0700774 x, y, area, amplitude);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700775
Daniel Kurtzfba5bc32012-06-28 21:08:17 +0800776 input_mt_slot(input_dev, id);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700777
Nick Dyerf3889ed2014-05-18 23:22:04 -0700778 if (status & MXT_T9_DETECT) {
Nick Dyereef820d2014-05-18 23:22:22 -0700779 /*
780 * Multiple bits may be set if the host is slow to read
781 * the status messages, indicating all the events that
782 * have happened.
783 */
784 if (status & MXT_T9_RELEASE) {
785 input_mt_report_slot_state(input_dev,
786 MT_TOOL_FINGER, 0);
Benson Leungb735fbe2014-07-23 12:22:27 -0700787 mxt_input_sync(data);
Nick Dyereef820d2014-05-18 23:22:22 -0700788 }
789
790 /* Touch active */
791 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
Daniel Kurtzfba5bc32012-06-28 21:08:17 +0800792 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
793 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
Nick Dyerfea9e462014-05-18 23:21:48 -0700794 input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
Daniel Kurtzfba5bc32012-06-28 21:08:17 +0800795 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
Nick Dyereef820d2014-05-18 23:22:22 -0700796 } else {
797 /* Touch no longer active, close out slot */
798 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
Daniel Kurtzfba5bc32012-06-28 21:08:17 +0800799 }
Nick Dyerb9b05a82014-07-23 12:48:13 -0700800
801 data->update_input = true;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700802}
803
Nick Dyerb23157d2015-04-06 11:25:13 -0700804static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
805{
806 struct device *dev = &data->client->dev;
807 struct input_dev *input_dev = data->input_dev;
808 int id;
809 u8 status;
810 u8 type = 0;
811 u16 x;
812 u16 y;
813 int distance = 0;
814 int tool = 0;
815 u8 major = 0;
816 u8 pressure = 0;
817 u8 orientation = 0;
818
819 id = message[0] - data->T100_reportid_min - 2;
820
821 /* ignore SCRSTATUS events */
822 if (id < 0)
823 return;
824
825 status = message[1];
826 x = get_unaligned_le16(&message[2]);
827 y = get_unaligned_le16(&message[4]);
828
829 if (status & MXT_T100_DETECT) {
830 type = (status & MXT_T100_TYPE_MASK) >> 4;
831
832 switch (type) {
833 case MXT_T100_TYPE_HOVERING_FINGER:
834 tool = MT_TOOL_FINGER;
835 distance = MXT_DISTANCE_HOVERING;
836
837 if (data->t100_aux_vect)
838 orientation = message[data->t100_aux_vect];
839
840 break;
841
842 case MXT_T100_TYPE_FINGER:
843 case MXT_T100_TYPE_GLOVE:
844 tool = MT_TOOL_FINGER;
845 distance = MXT_DISTANCE_ACTIVE_TOUCH;
846
847 if (data->t100_aux_area)
848 major = message[data->t100_aux_area];
849
850 if (data->t100_aux_ampl)
851 pressure = message[data->t100_aux_ampl];
852
853 if (data->t100_aux_vect)
854 orientation = message[data->t100_aux_vect];
855
856 break;
857
858 case MXT_T100_TYPE_PASSIVE_STYLUS:
859 tool = MT_TOOL_PEN;
860
861 /*
862 * Passive stylus is reported with size zero so
863 * hardcode.
864 */
865 major = MXT_TOUCH_MAJOR_DEFAULT;
866
867 if (data->t100_aux_ampl)
868 pressure = message[data->t100_aux_ampl];
869
870 break;
871
872 case MXT_T100_TYPE_LARGE_TOUCH:
873 /* Ignore suppressed touch */
874 break;
875
876 default:
877 dev_dbg(dev, "Unexpected T100 type\n");
878 return;
879 }
880 }
881
882 /*
883 * Values reported should be non-zero if tool is touching the
884 * device
885 */
886 if (!pressure && type != MXT_T100_TYPE_HOVERING_FINGER)
887 pressure = MXT_PRESSURE_DEFAULT;
888
889 input_mt_slot(input_dev, id);
890
891 if (status & MXT_T100_DETECT) {
892 dev_dbg(dev, "[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
893 id, type, x, y, major, pressure, orientation);
894
895 input_mt_report_slot_state(input_dev, tool, 1);
896 input_report_abs(input_dev, ABS_MT_POSITION_X, x);
897 input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
898 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, major);
899 input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
900 input_report_abs(input_dev, ABS_MT_DISTANCE, distance);
901 input_report_abs(input_dev, ABS_MT_ORIENTATION, orientation);
902 } else {
903 dev_dbg(dev, "[%u] release\n", id);
904
905 /* close out slot */
906 input_mt_report_slot_state(input_dev, 0, 0);
907 }
908
909 data->update_input = true;
910}
911
Nick Dyerb9b05a82014-07-23 12:48:13 -0700912static int mxt_proc_message(struct mxt_data *data, u8 *message)
Daniel Kurtz04a79182012-06-28 21:08:21 +0800913{
Nick Dyerb9b05a82014-07-23 12:48:13 -0700914 u8 report_id = message[0];
915
916 if (report_id == MXT_RPTID_NOMSG)
917 return 0;
918
919 if (report_id == data->T6_reportid) {
920 mxt_proc_t6_messages(data, message);
921 } else if (!data->input_dev) {
922 /*
923 * Do not report events if input device
924 * is not yet registered.
925 */
926 mxt_dump_message(data, message);
Nick Dyerb23157d2015-04-06 11:25:13 -0700927 } else if (report_id >= data->T9_reportid_min &&
928 report_id <= data->T9_reportid_max) {
Nick Dyerb9b05a82014-07-23 12:48:13 -0700929 mxt_proc_t9_message(data, message);
Nick Dyerb23157d2015-04-06 11:25:13 -0700930 } else if (report_id >= data->T100_reportid_min &&
931 report_id <= data->T100_reportid_max) {
932 mxt_proc_t100_message(data, message);
Nick Dyerb9b05a82014-07-23 12:48:13 -0700933 } else if (report_id == data->T19_reportid) {
934 mxt_input_button(data, message);
935 data->update_input = true;
936 } else {
937 mxt_dump_message(data, message);
938 }
939
940 return 1;
941}
942
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700943static int mxt_read_and_process_messages(struct mxt_data *data, u8 count)
Nick Dyerb9b05a82014-07-23 12:48:13 -0700944{
945 struct device *dev = &data->client->dev;
946 int ret;
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700947 int i;
948 u8 num_valid = 0;
Nick Dyerb9b05a82014-07-23 12:48:13 -0700949
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700950 /* Safety check for msg_buf */
951 if (count > data->max_reportid)
952 return -EINVAL;
953
954 /* Process remaining messages if necessary */
Nick Dyerb9b05a82014-07-23 12:48:13 -0700955 ret = __mxt_read_reg(data->client, data->T5_address,
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700956 data->T5_msg_size * count, data->msg_buf);
Nick Dyerb9b05a82014-07-23 12:48:13 -0700957 if (ret) {
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700958 dev_err(dev, "Failed to read %u messages (%d)\n", count, ret);
Nick Dyerb9b05a82014-07-23 12:48:13 -0700959 return ret;
960 }
961
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700962 for (i = 0; i < count; i++) {
963 ret = mxt_proc_message(data,
964 data->msg_buf + data->T5_msg_size * i);
965
966 if (ret == 1)
967 num_valid++;
968 }
969
970 /* return number of messages read */
971 return num_valid;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700972}
973
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700974static irqreturn_t mxt_process_messages_t44(struct mxt_data *data)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700975{
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700976 struct device *dev = &data->client->dev;
Nick Dyerb9b05a82014-07-23 12:48:13 -0700977 int ret;
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700978 u8 count, num_left;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -0700979
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700980 /* Read T44 and T5 together */
981 ret = __mxt_read_reg(data->client, data->T44_address,
982 data->T5_msg_size + 1, data->msg_buf);
983 if (ret) {
984 dev_err(dev, "Failed to read T44 and T5 (%d)\n", ret);
985 return IRQ_NONE;
986 }
987
988 count = data->msg_buf[0];
989
Nick Dyer507584e2015-08-04 16:58:05 -0700990 /*
991 * This condition may be caused by the CHG line being configured in
992 * Mode 0. It results in unnecessary I2C operations but it is benign.
993 */
994 if (count == 0)
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700995 return IRQ_NONE;
Nick Dyer507584e2015-08-04 16:58:05 -0700996
997 if (count > data->max_reportid) {
998 dev_warn(dev, "T44 count %d exceeded max report id\n", count);
Nick Dyer9d8dc3e2014-07-23 12:49:04 -0700999 count = data->max_reportid;
1000 }
1001
1002 /* Process first message */
1003 ret = mxt_proc_message(data, data->msg_buf + 1);
1004 if (ret < 0) {
1005 dev_warn(dev, "Unexpected invalid message\n");
1006 return IRQ_NONE;
1007 }
1008
1009 num_left = count - 1;
1010
1011 /* Process remaining messages if necessary */
1012 if (num_left) {
1013 ret = mxt_read_and_process_messages(data, num_left);
Nick Dyerb9b05a82014-07-23 12:48:13 -07001014 if (ret < 0)
Nick Dyer9d8dc3e2014-07-23 12:49:04 -07001015 goto end;
1016 else if (ret != num_left)
1017 dev_warn(dev, "Unexpected invalid message\n");
1018 }
1019
1020end:
1021 if (data->update_input) {
1022 mxt_input_sync(data);
1023 data->update_input = false;
1024 }
1025
1026 return IRQ_HANDLED;
1027}
1028
1029static int mxt_process_messages_until_invalid(struct mxt_data *data)
1030{
1031 struct device *dev = &data->client->dev;
1032 int count, read;
1033 u8 tries = 2;
1034
1035 count = data->max_reportid;
1036
1037 /* Read messages until we force an invalid */
1038 do {
1039 read = mxt_read_and_process_messages(data, count);
1040 if (read < count)
1041 return 0;
1042 } while (--tries);
1043
1044 if (data->update_input) {
1045 mxt_input_sync(data);
1046 data->update_input = false;
1047 }
1048
1049 dev_err(dev, "CHG pin isn't cleared\n");
1050 return -EBUSY;
1051}
1052
1053static irqreturn_t mxt_process_messages(struct mxt_data *data)
1054{
1055 int total_handled, num_handled;
1056 u8 count = data->last_message_count;
1057
1058 if (count < 1 || count > data->max_reportid)
1059 count = 1;
1060
1061 /* include final invalid message */
1062 total_handled = mxt_read_and_process_messages(data, count + 1);
1063 if (total_handled < 0)
1064 return IRQ_NONE;
1065 /* if there were invalid messages, then we are done */
1066 else if (total_handled <= count)
1067 goto update_count;
1068
1069 /* keep reading two msgs until one is invalid or reportid limit */
1070 do {
1071 num_handled = mxt_read_and_process_messages(data, 2);
1072 if (num_handled < 0)
Nick Dyer8d4e1632014-05-18 23:00:56 -07001073 return IRQ_NONE;
Nick Dyer9d8dc3e2014-07-23 12:49:04 -07001074
1075 total_handled += num_handled;
1076
1077 if (num_handled < 2)
1078 break;
1079 } while (total_handled < data->num_touchids);
1080
1081update_count:
1082 data->last_message_count = total_handled;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001083
Nick Dyerb9b05a82014-07-23 12:48:13 -07001084 if (data->update_input) {
Benson Leungb735fbe2014-07-23 12:22:27 -07001085 mxt_input_sync(data);
Nick Dyerb9b05a82014-07-23 12:48:13 -07001086 data->update_input = false;
1087 }
Daniel Kurtz64464ae2012-06-28 21:08:23 +08001088
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001089 return IRQ_HANDLED;
1090}
1091
Benson Leungd79e7e42014-05-18 23:02:52 -07001092static irqreturn_t mxt_interrupt(int irq, void *dev_id)
1093{
1094 struct mxt_data *data = dev_id;
1095
1096 if (data->in_bootloader) {
1097 /* bootloader state transition completion */
1098 complete(&data->bl_completion);
1099 return IRQ_HANDLED;
1100 }
1101
Nick Dyerdd24dcf2014-07-23 11:25:55 -07001102 if (!data->object_table)
1103 return IRQ_HANDLED;
1104
Nick Dyer9d8dc3e2014-07-23 12:49:04 -07001105 if (data->T44_address) {
1106 return mxt_process_messages_t44(data);
1107 } else {
1108 return mxt_process_messages(data);
1109 }
Benson Leungd79e7e42014-05-18 23:02:52 -07001110}
1111
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07001112static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
1113 u8 value, bool wait)
1114{
1115 u16 reg;
1116 u8 command_register;
1117 int timeout_counter = 0;
1118 int ret;
1119
1120 reg = data->T6_address + cmd_offset;
1121
1122 ret = mxt_write_reg(data->client, reg, value);
1123 if (ret)
1124 return ret;
1125
1126 if (!wait)
1127 return 0;
1128
1129 do {
1130 msleep(20);
1131 ret = __mxt_read_reg(data->client, reg, 1, &command_register);
1132 if (ret)
1133 return ret;
1134 } while (command_register != 0 && timeout_counter++ <= 100);
1135
1136 if (timeout_counter > 100) {
1137 dev_err(&data->client->dev, "Command failed!\n");
1138 return -EIO;
1139 }
1140
1141 return 0;
1142}
1143
Nick Dyereb433352016-04-25 14:18:52 -07001144static int mxt_acquire_irq(struct mxt_data *data)
1145{
1146 int error;
1147
1148 enable_irq(data->irq);
1149
1150 error = mxt_process_messages_until_invalid(data);
1151 if (error)
1152 return error;
1153
1154 return 0;
1155}
1156
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07001157static int mxt_soft_reset(struct mxt_data *data)
1158{
1159 struct device *dev = &data->client->dev;
1160 int ret = 0;
1161
Nick Dyer885f3fb2015-08-04 16:57:25 -07001162 dev_info(dev, "Resetting device\n");
1163
1164 disable_irq(data->irq);
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07001165
1166 reinit_completion(&data->reset_completion);
1167
1168 ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false);
1169 if (ret)
1170 return ret;
1171
Nick Dyer885f3fb2015-08-04 16:57:25 -07001172 /* Ignore CHG line for 100ms after reset */
1173 msleep(100);
1174
Nick Dyereb433352016-04-25 14:18:52 -07001175 mxt_acquire_irq(data);
Nick Dyer885f3fb2015-08-04 16:57:25 -07001176
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07001177 ret = mxt_wait_for_completion(data, &data->reset_completion,
1178 MXT_RESET_TIMEOUT);
1179 if (ret)
1180 return ret;
1181
1182 return 0;
1183}
1184
Nick Dyerc3f78042014-05-18 23:04:46 -07001185static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
1186{
1187 /*
1188 * On failure, CRC is set to 0 and config will always be
1189 * downloaded.
1190 */
1191 data->config_crc = 0;
1192 reinit_completion(&data->crc_completion);
1193
1194 mxt_t6_command(data, cmd, value, true);
1195
1196 /*
1197 * Wait for crc message. On failure, CRC is set to 0 and config will
1198 * always be downloaded.
1199 */
1200 mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
1201}
1202
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001203static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte)
1204{
1205 static const unsigned int crcpoly = 0x80001B;
1206 u32 result;
1207 u32 data_word;
1208
1209 data_word = (secondbyte << 8) | firstbyte;
1210 result = ((*crc << 1) ^ data_word);
1211
1212 if (result & 0x1000000)
1213 result ^= crcpoly;
1214
1215 *crc = result;
1216}
1217
1218static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off)
1219{
1220 u32 crc = 0;
1221 u8 *ptr = base + start_off;
1222 u8 *last_val = base + end_off - 1;
1223
1224 if (end_off < start_off)
1225 return -EINVAL;
1226
1227 while (ptr < last_val) {
1228 mxt_calc_crc24(&crc, *ptr, *(ptr + 1));
1229 ptr += 2;
1230 }
1231
1232 /* if len is odd, fill the last byte with 0 */
1233 if (ptr == last_val)
1234 mxt_calc_crc24(&crc, *ptr, 0);
1235
1236 /* Mask to 24-bit */
1237 crc &= 0x00FFFFFF;
1238
1239 return crc;
1240}
1241
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001242static int mxt_prepare_cfg_mem(struct mxt_data *data,
1243 const struct firmware *cfg,
1244 unsigned int data_pos,
1245 unsigned int cfg_start_ofs,
1246 u8 *config_mem,
1247 size_t config_mem_size)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001248{
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001249 struct device *dev = &data->client->dev;
Nick Dyer50a77c62014-07-23 12:38:48 -07001250 struct mxt_object *object;
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001251 unsigned int type, instance, size, byte_offset;
Nick Dyer50a77c62014-07-23 12:38:48 -07001252 int offset;
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001253 int ret;
Nick Dyer50a77c62014-07-23 12:38:48 -07001254 int i;
Nick Dyer50a77c62014-07-23 12:38:48 -07001255 u16 reg;
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001256 u8 val;
Nick Dyer50a77c62014-07-23 12:38:48 -07001257
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001258 while (data_pos < cfg->size) {
Nick Dyer50a77c62014-07-23 12:38:48 -07001259 /* Read type, instance, length */
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001260 ret = sscanf(cfg->data + data_pos, "%x %x %x%n",
Nick Dyer50a77c62014-07-23 12:38:48 -07001261 &type, &instance, &size, &offset);
1262 if (ret == 0) {
1263 /* EOF */
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001264 break;
Nick Dyer50a77c62014-07-23 12:38:48 -07001265 } else if (ret != 3) {
1266 dev_err(dev, "Bad format: failed to parse object\n");
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001267 return -EINVAL;
Nick Dyer50a77c62014-07-23 12:38:48 -07001268 }
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001269 data_pos += offset;
Nick Dyer50a77c62014-07-23 12:38:48 -07001270
1271 object = mxt_get_object(data, type);
1272 if (!object) {
1273 /* Skip object */
1274 for (i = 0; i < size; i++) {
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001275 ret = sscanf(cfg->data + data_pos, "%hhx%n",
Dmitry Torokhov041fa152014-08-11 10:58:29 -07001276 &val, &offset);
1277 if (ret != 1) {
1278 dev_err(dev, "Bad format in T%d at %d\n",
1279 type, i);
1280 return -EINVAL;
1281 }
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001282 data_pos += offset;
Nick Dyer50a77c62014-07-23 12:38:48 -07001283 }
1284 continue;
1285 }
1286
1287 if (size > mxt_obj_size(object)) {
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001288 /*
1289 * Either we are in fallback mode due to wrong
1290 * config or config from a later fw version,
1291 * or the file is corrupt or hand-edited.
1292 */
1293 dev_warn(dev, "Discarding %zu byte(s) in T%u\n",
1294 size - mxt_obj_size(object), type);
1295 } else if (mxt_obj_size(object) > size) {
1296 /*
1297 * If firmware is upgraded, new bytes may be added to
1298 * end of objects. It is generally forward compatible
1299 * to zero these bytes - previous behaviour will be
1300 * retained. However this does invalidate the CRC and
1301 * will force fallback mode until the configuration is
1302 * updated. We warn here but do nothing else - the
1303 * malloc has zeroed the entire configuration.
1304 */
1305 dev_warn(dev, "Zeroing %zu byte(s) in T%d\n",
1306 mxt_obj_size(object) - size, type);
Nick Dyer50a77c62014-07-23 12:38:48 -07001307 }
1308
1309 if (instance >= mxt_obj_instances(object)) {
1310 dev_err(dev, "Object instances exceeded!\n");
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001311 return -EINVAL;
Nick Dyer50a77c62014-07-23 12:38:48 -07001312 }
1313
1314 reg = object->start_address + mxt_obj_size(object) * instance;
1315
1316 for (i = 0; i < size; i++) {
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001317 ret = sscanf(cfg->data + data_pos, "%hhx%n",
Nick Dyer50a77c62014-07-23 12:38:48 -07001318 &val,
1319 &offset);
1320 if (ret != 1) {
Dmitry Torokhov041fa152014-08-11 10:58:29 -07001321 dev_err(dev, "Bad format in T%d at %d\n",
1322 type, i);
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001323 return -EINVAL;
Nick Dyer50a77c62014-07-23 12:38:48 -07001324 }
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001325 data_pos += offset;
Nick Dyer50a77c62014-07-23 12:38:48 -07001326
1327 if (i > mxt_obj_size(object))
1328 continue;
1329
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001330 byte_offset = reg + i - cfg_start_ofs;
Nick Dyer50a77c62014-07-23 12:38:48 -07001331
Dmitry Torokhov041fa152014-08-11 10:58:29 -07001332 if (byte_offset >= 0 && byte_offset < config_mem_size) {
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001333 *(config_mem + byte_offset) = val;
1334 } else {
1335 dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
1336 reg, object->type, byte_offset);
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001337 return -EINVAL;
Nick Dyer50a77c62014-07-23 12:38:48 -07001338 }
1339 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001340 }
1341
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001342 return 0;
1343}
1344
1345static int mxt_upload_cfg_mem(struct mxt_data *data, unsigned int cfg_start,
1346 u8 *config_mem, size_t config_mem_size)
1347{
1348 unsigned int byte_offset = 0;
1349 int error;
1350
1351 /* Write configuration as blocks */
1352 while (byte_offset < config_mem_size) {
1353 unsigned int size = config_mem_size - byte_offset;
1354
1355 if (size > MXT_MAX_BLOCK_WRITE)
1356 size = MXT_MAX_BLOCK_WRITE;
1357
1358 error = __mxt_write_reg(data->client,
1359 cfg_start + byte_offset,
1360 size, config_mem + byte_offset);
1361 if (error) {
1362 dev_err(&data->client->dev,
1363 "Config write error, ret=%d\n", error);
1364 return error;
1365 }
1366
1367 byte_offset += size;
1368 }
1369
1370 return 0;
1371}
1372
Nick Dyer7f3884f72015-08-04 16:36:29 -07001373static int mxt_init_t7_power_cfg(struct mxt_data *data);
1374
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001375/*
1376 * mxt_update_cfg - download configuration to chip
1377 *
1378 * Atmel Raw Config File Format
1379 *
1380 * The first four lines of the raw config file contain:
1381 * 1) Version
1382 * 2) Chip ID Information (first 7 bytes of device memory)
1383 * 3) Chip Information Block 24-bit CRC Checksum
1384 * 4) Chip Configuration 24-bit CRC Checksum
1385 *
1386 * The rest of the file consists of one line per object instance:
1387 * <TYPE> <INSTANCE> <SIZE> <CONTENTS>
1388 *
1389 * <TYPE> - 2-byte object type as hex
1390 * <INSTANCE> - 2-byte object instance number as hex
1391 * <SIZE> - 2-byte object size as hex
1392 * <CONTENTS> - array of <SIZE> 1-byte hex values
1393 */
1394static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
1395{
1396 struct device *dev = &data->client->dev;
1397 struct mxt_info cfg_info;
1398 int ret;
1399 int offset;
1400 int data_pos;
1401 int i;
1402 int cfg_start_ofs;
1403 u32 info_crc, config_crc, calculated_crc;
1404 u8 *config_mem;
1405 size_t config_mem_size;
1406
1407 mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
1408
1409 if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
1410 dev_err(dev, "Unrecognised config file\n");
1411 return -EINVAL;
1412 }
1413
1414 data_pos = strlen(MXT_CFG_MAGIC);
1415
1416 /* Load information block and check */
1417 for (i = 0; i < sizeof(struct mxt_info); i++) {
1418 ret = sscanf(cfg->data + data_pos, "%hhx%n",
1419 (unsigned char *)&cfg_info + i,
1420 &offset);
1421 if (ret != 1) {
1422 dev_err(dev, "Bad format\n");
1423 return -EINVAL;
1424 }
1425
1426 data_pos += offset;
1427 }
1428
1429 if (cfg_info.family_id != data->info.family_id) {
1430 dev_err(dev, "Family ID mismatch!\n");
1431 return -EINVAL;
1432 }
1433
1434 if (cfg_info.variant_id != data->info.variant_id) {
1435 dev_err(dev, "Variant ID mismatch!\n");
1436 return -EINVAL;
1437 }
1438
1439 /* Read CRCs */
1440 ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset);
1441 if (ret != 1) {
1442 dev_err(dev, "Bad format: failed to parse Info CRC\n");
1443 return -EINVAL;
1444 }
1445 data_pos += offset;
1446
1447 ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset);
1448 if (ret != 1) {
1449 dev_err(dev, "Bad format: failed to parse Config CRC\n");
1450 return -EINVAL;
1451 }
1452 data_pos += offset;
1453
1454 /*
1455 * The Info Block CRC is calculated over mxt_info and the object
1456 * table. If it does not match then we are trying to load the
1457 * configuration from a different chip or firmware version, so
1458 * the configuration CRC is invalid anyway.
1459 */
1460 if (info_crc == data->info_crc) {
1461 if (config_crc == 0 || data->config_crc == 0) {
1462 dev_info(dev, "CRC zero, attempting to apply config\n");
1463 } else if (config_crc == data->config_crc) {
1464 dev_dbg(dev, "Config CRC 0x%06X: OK\n",
1465 data->config_crc);
1466 return 0;
1467 } else {
1468 dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
1469 data->config_crc, config_crc);
1470 }
1471 } else {
1472 dev_warn(dev,
1473 "Warning: Info CRC error - device=0x%06X file=0x%06X\n",
1474 data->info_crc, info_crc);
1475 }
1476
1477 /* Malloc memory to store configuration */
1478 cfg_start_ofs = MXT_OBJECT_START +
1479 data->info.object_num * sizeof(struct mxt_object) +
1480 MXT_INFO_CHECKSUM_SIZE;
1481 config_mem_size = data->mem_size - cfg_start_ofs;
1482 config_mem = kzalloc(config_mem_size, GFP_KERNEL);
1483 if (!config_mem) {
1484 dev_err(dev, "Failed to allocate memory\n");
1485 return -ENOMEM;
1486 }
1487
1488 ret = mxt_prepare_cfg_mem(data, cfg, data_pos, cfg_start_ofs,
1489 config_mem, config_mem_size);
1490 if (ret)
1491 goto release_mem;
1492
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001493 /* Calculate crc of the received configs (not the raw config file) */
1494 if (data->T7_address < cfg_start_ofs) {
1495 dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n",
1496 data->T7_address, cfg_start_ofs);
1497 ret = 0;
1498 goto release_mem;
1499 }
1500
1501 calculated_crc = mxt_calculate_crc(config_mem,
1502 data->T7_address - cfg_start_ofs,
1503 config_mem_size);
1504
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001505 if (config_crc > 0 && config_crc != calculated_crc)
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001506 dev_warn(dev, "Config CRC error, calculated=%06X, file=%06X\n",
1507 calculated_crc, config_crc);
1508
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001509 ret = mxt_upload_cfg_mem(data, cfg_start_ofs,
1510 config_mem, config_mem_size);
1511 if (ret)
1512 goto release_mem;
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001513
Nick Dyerc3f78042014-05-18 23:04:46 -07001514 mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1515
1516 ret = mxt_soft_reset(data);
1517 if (ret)
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001518 goto release_mem;
Nick Dyerc3f78042014-05-18 23:04:46 -07001519
1520 dev_info(dev, "Config successfully updated\n");
1521
Nick Dyer7f3884f72015-08-04 16:36:29 -07001522 /* T7 config may have changed */
1523 mxt_init_t7_power_cfg(data);
1524
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001525release_mem:
1526 kfree(config_mem);
Nick Dyer50a77c62014-07-23 12:38:48 -07001527 return ret;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001528}
1529
Iiro Valkonen7686b102011-02-02 23:21:58 -08001530static int mxt_get_info(struct mxt_data *data)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001531{
1532 struct i2c_client *client = data->client;
Iiro Valkonen7686b102011-02-02 23:21:58 -08001533 struct mxt_info *info = &data->info;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001534 int error;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001535
Daniel Kurtz23003a842012-06-28 21:08:14 +08001536 /* Read 7-byte info block starting at address 0 */
Nick Dyer146c6a62015-08-04 16:49:34 -07001537 error = __mxt_read_reg(client, 0, sizeof(*info), info);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001538 if (error)
1539 return error;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001540
1541 return 0;
1542}
1543
Stephen Warren58e4aeee2014-09-10 10:01:10 -07001544static void mxt_free_input_device(struct mxt_data *data)
1545{
1546 if (data->input_dev) {
1547 input_unregister_device(data->input_dev);
1548 data->input_dev = NULL;
1549 }
1550}
1551
Nick Dyer5f3f9bc2014-07-23 12:46:55 -07001552static void mxt_free_object_table(struct mxt_data *data)
1553{
Nick Dyerecfdd7e2016-07-18 18:10:32 -03001554#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
1555 video_unregister_device(&data->dbg.vdev);
1556 v4l2_device_unregister(&data->dbg.v4l2);
1557#endif
1558
Nick Dyer5f3f9bc2014-07-23 12:46:55 -07001559 kfree(data->object_table);
1560 data->object_table = NULL;
1561 kfree(data->msg_buf);
1562 data->msg_buf = NULL;
Nick Dyerb9b05a82014-07-23 12:48:13 -07001563 data->T5_address = 0;
Nick Dyer5f3f9bc2014-07-23 12:46:55 -07001564 data->T5_msg_size = 0;
1565 data->T6_reportid = 0;
1566 data->T7_address = 0;
1567 data->T9_reportid_min = 0;
1568 data->T9_reportid_max = 0;
1569 data->T19_reportid = 0;
Nick Dyer9d8dc3e2014-07-23 12:49:04 -07001570 data->T44_address = 0;
Nick Dyerb23157d2015-04-06 11:25:13 -07001571 data->T100_reportid_min = 0;
1572 data->T100_reportid_max = 0;
Nick Dyer9d8dc3e2014-07-23 12:49:04 -07001573 data->max_reportid = 0;
Nick Dyer5f3f9bc2014-07-23 12:46:55 -07001574}
1575
Iiro Valkonen7686b102011-02-02 23:21:58 -08001576static int mxt_get_object_table(struct mxt_data *data)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001577{
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001578 struct i2c_client *client = data->client;
1579 size_t table_size;
Nick Dyerdd24dcf2014-07-23 11:25:55 -07001580 struct mxt_object *object_table;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001581 int error;
1582 int i;
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001583 u8 reportid;
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001584 u16 end_address;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001585
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001586 table_size = data->info.object_num * sizeof(struct mxt_object);
Nick Dyerdd24dcf2014-07-23 11:25:55 -07001587 object_table = kzalloc(table_size, GFP_KERNEL);
1588 if (!object_table) {
1589 dev_err(&data->client->dev, "Failed to allocate memory\n");
1590 return -ENOMEM;
1591 }
1592
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001593 error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
Nick Dyerdd24dcf2014-07-23 11:25:55 -07001594 object_table);
1595 if (error) {
1596 kfree(object_table);
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001597 return error;
Nick Dyerdd24dcf2014-07-23 11:25:55 -07001598 }
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001599
1600 /* Valid Report IDs start counting from 1 */
1601 reportid = 1;
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001602 data->mem_size = 0;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001603 for (i = 0; i < data->info.object_num; i++) {
Nick Dyerdd24dcf2014-07-23 11:25:55 -07001604 struct mxt_object *object = object_table + i;
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001605 u8 min_id, max_id;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001606
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001607 le16_to_cpus(&object->start_address);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001608
1609 if (object->num_report_ids) {
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001610 min_id = reportid;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001611 reportid += object->num_report_ids *
Daniel Kurtz1e0c0c52014-05-18 23:01:12 -07001612 mxt_obj_instances(object);
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001613 max_id = reportid - 1;
1614 } else {
1615 min_id = 0;
1616 max_id = 0;
1617 }
1618
1619 dev_dbg(&data->client->dev,
Nick Dyer7bed6802014-05-18 23:04:09 -07001620 "T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n",
Daniel Kurtz1e0c0c52014-05-18 23:01:12 -07001621 object->type, object->start_address,
1622 mxt_obj_size(object), mxt_obj_instances(object),
1623 min_id, max_id);
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001624
1625 switch (object->type) {
Nick Dyer5f3f9bc2014-07-23 12:46:55 -07001626 case MXT_GEN_MESSAGE_T5:
Nick Dyer437d4f32014-08-07 09:56:01 -07001627 if (data->info.family_id == 0x80 &&
1628 data->info.version < 0x20) {
Nick Dyer9d8dc3e2014-07-23 12:49:04 -07001629 /*
Nick Dyer437d4f32014-08-07 09:56:01 -07001630 * On mXT224 firmware versions prior to V2.0
1631 * read and discard unused CRC byte otherwise
1632 * DMA reads are misaligned.
Nick Dyer9d8dc3e2014-07-23 12:49:04 -07001633 */
1634 data->T5_msg_size = mxt_obj_size(object);
1635 } else {
1636 /* CRC not enabled, so skip last byte */
1637 data->T5_msg_size = mxt_obj_size(object) - 1;
1638 }
Nick Dyerb9b05a82014-07-23 12:48:13 -07001639 data->T5_address = object->start_address;
Dmitry Torokhov041fa152014-08-11 10:58:29 -07001640 break;
Daniel Kurtzfdf804212012-06-28 21:08:24 +08001641 case MXT_GEN_COMMAND_T6:
1642 data->T6_reportid = min_id;
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07001643 data->T6_address = object->start_address;
Daniel Kurtzfdf804212012-06-28 21:08:24 +08001644 break;
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001645 case MXT_GEN_POWER_T7:
1646 data->T7_address = object->start_address;
1647 break;
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001648 case MXT_TOUCH_MULTI_T9:
Nick Dyerb23157d2015-04-06 11:25:13 -07001649 data->multitouch = MXT_TOUCH_MULTI_T9;
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001650 data->T9_reportid_min = min_id;
1651 data->T9_reportid_max = max_id;
Nick Dyer9d8dc3e2014-07-23 12:49:04 -07001652 data->num_touchids = object->num_report_ids
1653 * mxt_obj_instances(object);
1654 break;
1655 case MXT_SPT_MESSAGECOUNT_T44:
1656 data->T44_address = object->start_address;
Daniel Kurtz333e5a92012-06-28 21:08:20 +08001657 break;
Daniel Kurtz22dfab72013-03-07 19:43:33 -08001658 case MXT_SPT_GPIOPWM_T19:
1659 data->T19_reportid = min_id;
1660 break;
Nick Dyerb23157d2015-04-06 11:25:13 -07001661 case MXT_TOUCH_MULTITOUCHSCREEN_T100:
1662 data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100;
1663 data->T100_reportid_min = min_id;
1664 data->T100_reportid_max = max_id;
1665 /* first two report IDs reserved */
1666 data->num_touchids = object->num_report_ids - 2;
1667 break;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001668 }
Nick Dyer4ce6fa02014-07-23 12:40:09 -07001669
1670 end_address = object->start_address
1671 + mxt_obj_size(object) * mxt_obj_instances(object) - 1;
1672
1673 if (end_address >= data->mem_size)
1674 data->mem_size = end_address + 1;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001675 }
1676
Nick Dyer9d8dc3e2014-07-23 12:49:04 -07001677 /* Store maximum reportid */
1678 data->max_reportid = reportid;
1679
1680 /* If T44 exists, T5 position has to be directly after */
1681 if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
1682 dev_err(&client->dev, "Invalid T44 position\n");
1683 error = -EINVAL;
1684 goto free_object_table;
1685 }
1686
1687 data->msg_buf = kcalloc(data->max_reportid,
1688 data->T5_msg_size, GFP_KERNEL);
Nick Dyer5f3f9bc2014-07-23 12:46:55 -07001689 if (!data->msg_buf) {
1690 dev_err(&client->dev, "Failed to allocate message buffer\n");
1691 error = -ENOMEM;
1692 goto free_object_table;
1693 }
1694
Nick Dyerdd24dcf2014-07-23 11:25:55 -07001695 data->object_table = object_table;
1696
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001697 return 0;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001698
Nick Dyer5f3f9bc2014-07-23 12:46:55 -07001699free_object_table:
1700 mxt_free_object_table(data);
1701 return error;
Daniel Kurtz7d4fa102012-06-28 21:08:19 +08001702}
1703
Nick Dyer61dc1ab2014-05-18 23:16:49 -07001704static int mxt_read_t9_resolution(struct mxt_data *data)
1705{
1706 struct i2c_client *client = data->client;
1707 int error;
1708 struct t9_range range;
1709 unsigned char orient;
1710 struct mxt_object *object;
1711
1712 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
1713 if (!object)
1714 return -EINVAL;
1715
1716 error = __mxt_read_reg(client,
1717 object->start_address + MXT_T9_RANGE,
1718 sizeof(range), &range);
1719 if (error)
1720 return error;
1721
Nick Dyer1c0276d2016-01-10 18:29:34 -08001722 data->max_x = get_unaligned_le16(&range.x);
1723 data->max_y = get_unaligned_le16(&range.y);
Nick Dyer61dc1ab2014-05-18 23:16:49 -07001724
1725 error = __mxt_read_reg(client,
1726 object->start_address + MXT_T9_ORIENT,
1727 1, &orient);
1728 if (error)
1729 return error;
1730
Nick Dyer1c0276d2016-01-10 18:29:34 -08001731 data->xy_switch = orient & MXT_T9_ORIENT_SWITCH;
Nick Dyer61dc1ab2014-05-18 23:16:49 -07001732
1733 return 0;
1734}
1735
Nick Dyerb23157d2015-04-06 11:25:13 -07001736static int mxt_read_t100_config(struct mxt_data *data)
1737{
1738 struct i2c_client *client = data->client;
1739 int error;
1740 struct mxt_object *object;
1741 u16 range_x, range_y;
1742 u8 cfg, tchaux;
1743 u8 aux;
1744
1745 object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100);
1746 if (!object)
1747 return -EINVAL;
1748
Nick Dyer1c0276d2016-01-10 18:29:34 -08001749 /* read touchscreen dimensions */
Nick Dyerb23157d2015-04-06 11:25:13 -07001750 error = __mxt_read_reg(client,
1751 object->start_address + MXT_T100_XRANGE,
1752 sizeof(range_x), &range_x);
1753 if (error)
1754 return error;
1755
Nick Dyer1c0276d2016-01-10 18:29:34 -08001756 data->max_x = get_unaligned_le16(&range_x);
Nick Dyerb23157d2015-04-06 11:25:13 -07001757
1758 error = __mxt_read_reg(client,
1759 object->start_address + MXT_T100_YRANGE,
1760 sizeof(range_y), &range_y);
1761 if (error)
1762 return error;
1763
Nick Dyer1c0276d2016-01-10 18:29:34 -08001764 data->max_y = get_unaligned_le16(&range_y);
Nick Dyerb23157d2015-04-06 11:25:13 -07001765
Nick Dyer1c0276d2016-01-10 18:29:34 -08001766 /* read orientation config */
Nick Dyerb23157d2015-04-06 11:25:13 -07001767 error = __mxt_read_reg(client,
1768 object->start_address + MXT_T100_CFG1,
1769 1, &cfg);
1770 if (error)
1771 return error;
1772
Nick Dyer1c0276d2016-01-10 18:29:34 -08001773 data->xy_switch = cfg & MXT_T100_CFG_SWITCHXY;
1774
1775 /* allocate aux bytes */
Nick Dyerb23157d2015-04-06 11:25:13 -07001776 error = __mxt_read_reg(client,
1777 object->start_address + MXT_T100_TCHAUX,
1778 1, &tchaux);
1779 if (error)
1780 return error;
1781
Nick Dyerb23157d2015-04-06 11:25:13 -07001782 aux = 6;
1783
1784 if (tchaux & MXT_T100_TCHAUX_VECT)
1785 data->t100_aux_vect = aux++;
1786
1787 if (tchaux & MXT_T100_TCHAUX_AMPL)
1788 data->t100_aux_ampl = aux++;
1789
1790 if (tchaux & MXT_T100_TCHAUX_AREA)
1791 data->t100_aux_area = aux++;
1792
1793 dev_dbg(&client->dev,
1794 "T100 aux mappings vect:%u ampl:%u area:%u\n",
1795 data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area);
1796
Nick Dyerb23157d2015-04-06 11:25:13 -07001797 return 0;
1798}
1799
Nick Dyer7a53d602014-07-23 12:21:26 -07001800static int mxt_input_open(struct input_dev *dev);
1801static void mxt_input_close(struct input_dev *dev);
1802
Sjoerd Simonsb6d2d322015-04-06 13:10:30 -07001803static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
1804 struct mxt_data *data)
1805{
1806 const struct mxt_platform_data *pdata = data->pdata;
1807 int i;
1808
1809 input_dev->name = "Atmel maXTouch Touchpad";
1810
1811 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1812
1813 input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1814 input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1815 input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1816 MXT_PIXELS_PER_MM);
1817 input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1818 MXT_PIXELS_PER_MM);
1819
1820 for (i = 0; i < pdata->t19_num_keys; i++)
1821 if (pdata->t19_keymap[i] != KEY_RESERVED)
1822 input_set_capability(input_dev, EV_KEY,
1823 pdata->t19_keymap[i]);
1824}
1825
Nick Dyerb23157d2015-04-06 11:25:13 -07001826static int mxt_initialize_input_device(struct mxt_data *data)
Nick Dyer7a53d602014-07-23 12:21:26 -07001827{
Nick Dyer7a53d602014-07-23 12:21:26 -07001828 const struct mxt_platform_data *pdata = data->pdata;
Sjoerd Simonsb6d2d322015-04-06 13:10:30 -07001829 struct device *dev = &data->client->dev;
Nick Dyer7a53d602014-07-23 12:21:26 -07001830 struct input_dev *input_dev;
1831 int error;
1832 unsigned int num_mt_slots;
1833 unsigned int mt_flags = 0;
Nick Dyer7a53d602014-07-23 12:21:26 -07001834
Nick Dyerb23157d2015-04-06 11:25:13 -07001835 switch (data->multitouch) {
1836 case MXT_TOUCH_MULTI_T9:
1837 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1838 error = mxt_read_t9_resolution(data);
1839 if (error)
1840 dev_warn(dev, "Failed to initialize T9 resolution\n");
1841 break;
1842
1843 case MXT_TOUCH_MULTITOUCHSCREEN_T100:
1844 num_mt_slots = data->num_touchids;
1845 error = mxt_read_t100_config(data);
1846 if (error)
1847 dev_warn(dev, "Failed to read T100 config\n");
1848 break;
1849
1850 default:
1851 dev_err(dev, "Invalid multitouch object\n");
1852 return -EINVAL;
1853 }
Nick Dyer7a53d602014-07-23 12:21:26 -07001854
Nick Dyer1c0276d2016-01-10 18:29:34 -08001855 /* Handle default values and orientation switch */
1856 if (data->max_x == 0)
1857 data->max_x = 1023;
1858
1859 if (data->max_y == 0)
1860 data->max_y = 1023;
1861
1862 if (data->xy_switch)
1863 swap(data->max_x, data->max_y);
1864
1865 dev_info(dev, "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
1866
1867 /* Register input device */
Nick Dyer7a53d602014-07-23 12:21:26 -07001868 input_dev = input_allocate_device();
1869 if (!input_dev) {
1870 dev_err(dev, "Failed to allocate memory\n");
1871 return -ENOMEM;
1872 }
1873
1874 input_dev->name = "Atmel maXTouch Touchscreen";
1875 input_dev->phys = data->phys;
1876 input_dev->id.bustype = BUS_I2C;
1877 input_dev->dev.parent = dev;
1878 input_dev->open = mxt_input_open;
1879 input_dev->close = mxt_input_close;
1880
Nick Dyerb23157d2015-04-06 11:25:13 -07001881 input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
Nick Dyer7a53d602014-07-23 12:21:26 -07001882
Nick Dyer7a53d602014-07-23 12:21:26 -07001883 /* For single touch */
Nick Dyerb23157d2015-04-06 11:25:13 -07001884 input_set_abs_params(input_dev, ABS_X, 0, data->max_x, 0, 0);
1885 input_set_abs_params(input_dev, ABS_Y, 0, data->max_y, 0, 0);
1886
1887 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1888 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1889 data->t100_aux_ampl)) {
1890 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0);
1891 }
Nick Dyer7a53d602014-07-23 12:21:26 -07001892
Sjoerd Simonsb6d2d322015-04-06 13:10:30 -07001893 /* If device has buttons we assume it is a touchpad */
1894 if (pdata->t19_num_keys) {
1895 mxt_set_up_as_touchpad(input_dev, data);
1896 mt_flags |= INPUT_MT_POINTER;
Nick Dyereafc0c82015-08-04 16:57:40 -07001897 } else {
1898 mt_flags |= INPUT_MT_DIRECT;
Sjoerd Simonsb6d2d322015-04-06 13:10:30 -07001899 }
1900
Nick Dyer7a53d602014-07-23 12:21:26 -07001901 /* For multi touch */
Nick Dyer7a53d602014-07-23 12:21:26 -07001902 error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
1903 if (error) {
1904 dev_err(dev, "Error %d initialising slots\n", error);
1905 goto err_free_mem;
1906 }
1907
Nick Dyerb23157d2015-04-06 11:25:13 -07001908 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) {
1909 input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
1910 0, MT_TOOL_MAX, 0, 0);
1911 input_set_abs_params(input_dev, ABS_MT_DISTANCE,
1912 MXT_DISTANCE_ACTIVE_TOUCH,
1913 MXT_DISTANCE_HOVERING,
1914 0, 0);
1915 }
1916
Nick Dyer7a53d602014-07-23 12:21:26 -07001917 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1918 0, data->max_x, 0, 0);
1919 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1920 0, data->max_y, 0, 0);
Nick Dyerb23157d2015-04-06 11:25:13 -07001921
1922 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1923 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1924 data->t100_aux_area)) {
1925 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1926 0, MXT_MAX_AREA, 0, 0);
1927 }
1928
1929 if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1930 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1931 data->t100_aux_ampl)) {
1932 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1933 0, 255, 0, 0);
1934 }
1935
1936 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1937 data->t100_aux_vect) {
1938 input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
1939 0, 255, 0, 0);
1940 }
1941
1942 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1943 data->t100_aux_ampl) {
1944 input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1945 0, 255, 0, 0);
1946 }
1947
1948 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1949 data->t100_aux_vect) {
1950 input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
1951 0, 255, 0, 0);
1952 }
Nick Dyer7a53d602014-07-23 12:21:26 -07001953
1954 input_set_drvdata(input_dev, data);
1955
1956 error = input_register_device(input_dev);
1957 if (error) {
1958 dev_err(dev, "Error %d registering input device\n", error);
1959 goto err_free_mem;
1960 }
1961
1962 data->input_dev = input_dev;
1963
1964 return 0;
1965
1966err_free_mem:
1967 input_free_device(input_dev);
1968 return error;
1969}
1970
Nick Dyer50a77c62014-07-23 12:38:48 -07001971static int mxt_configure_objects(struct mxt_data *data,
1972 const struct firmware *cfg);
1973
1974static void mxt_config_cb(const struct firmware *cfg, void *ctx)
1975{
1976 mxt_configure_objects(ctx, cfg);
Dmitry Torokhovefdbd7a2014-08-08 09:29:06 -07001977 release_firmware(cfg);
Nick Dyer50a77c62014-07-23 12:38:48 -07001978}
1979
Iiro Valkonen7686b102011-02-02 23:21:58 -08001980static int mxt_initialize(struct mxt_data *data)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001981{
1982 struct i2c_client *client = data->client;
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -07001983 int recovery_attempts = 0;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001984 int error;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07001985
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -07001986 while (1) {
1987 error = mxt_get_info(data);
1988 if (!error)
1989 break;
1990
1991 /* Check bootloader state */
1992 error = mxt_probe_bootloader(data, false);
Nick Dyer8efaa5e2014-07-23 12:45:49 -07001993 if (error) {
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -07001994 dev_info(&client->dev, "Trying alternate bootloader address\n");
1995 error = mxt_probe_bootloader(data, true);
1996 if (error) {
Nick Dyer8efaa5e2014-07-23 12:45:49 -07001997 /* Chip is not in appmode or bootloader mode */
1998 return error;
1999 }
Nick Dyer8efaa5e2014-07-23 12:45:49 -07002000 }
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -07002001
2002 /* OK, we are in bootloader, see if we can recover */
2003 if (++recovery_attempts > 1) {
2004 dev_err(&client->dev, "Could not recover from bootloader mode\n");
2005 /*
2006 * We can reflash from this state, so do not
2007 * abort initialization.
2008 */
2009 data->in_bootloader = true;
2010 return 0;
2011 }
2012
2013 /* Attempt to exit bootloader into app mode */
2014 mxt_send_bootloader_cmd(data, false);
2015 msleep(MXT_FW_RESET_TIME);
Nick Dyera9fdd1e2014-07-23 12:41:58 -07002016 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002017
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002018 /* Get object table information */
Iiro Valkonen7686b102011-02-02 23:21:58 -08002019 error = mxt_get_object_table(data);
Nick Dyer7bed6802014-05-18 23:04:09 -07002020 if (error) {
2021 dev_err(&client->dev, "Error %d reading object table\n", error);
Nick Dyerdd24dcf2014-07-23 11:25:55 -07002022 return error;
Nick Dyer7bed6802014-05-18 23:04:09 -07002023 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002024
Dmitry Torokhov041fa152014-08-11 10:58:29 -07002025 error = mxt_acquire_irq(data);
Nick Dyerdd24dcf2014-07-23 11:25:55 -07002026 if (error)
2027 goto err_free_object_table;
2028
Dmitry Torokhov6cd1ab02014-08-08 09:28:45 -07002029 error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
2030 &client->dev, GFP_KERNEL, data,
2031 mxt_config_cb);
2032 if (error) {
2033 dev_err(&client->dev, "Failed to invoke firmware loader: %d\n",
2034 error);
2035 goto err_free_object_table;
2036 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002037
2038 return 0;
Daniel Kurtz7d4fa102012-06-28 21:08:19 +08002039
2040err_free_object_table:
2041 mxt_free_object_table(data);
2042 return error;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002043}
2044
Nick Dyer7f3884f72015-08-04 16:36:29 -07002045static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep)
2046{
2047 struct device *dev = &data->client->dev;
2048 int error;
2049 struct t7_config *new_config;
2050 struct t7_config deepsleep = { .active = 0, .idle = 0 };
2051
2052 if (sleep == MXT_POWER_CFG_DEEPSLEEP)
2053 new_config = &deepsleep;
2054 else
2055 new_config = &data->t7_cfg;
2056
2057 error = __mxt_write_reg(data->client, data->T7_address,
2058 sizeof(data->t7_cfg), new_config);
2059 if (error)
2060 return error;
2061
2062 dev_dbg(dev, "Set T7 ACTV:%d IDLE:%d\n",
2063 new_config->active, new_config->idle);
2064
2065 return 0;
2066}
2067
2068static int mxt_init_t7_power_cfg(struct mxt_data *data)
2069{
2070 struct device *dev = &data->client->dev;
2071 int error;
2072 bool retry = false;
2073
2074recheck:
2075 error = __mxt_read_reg(data->client, data->T7_address,
2076 sizeof(data->t7_cfg), &data->t7_cfg);
2077 if (error)
2078 return error;
2079
2080 if (data->t7_cfg.active == 0 || data->t7_cfg.idle == 0) {
2081 if (!retry) {
2082 dev_dbg(dev, "T7 cfg zero, resetting\n");
2083 mxt_soft_reset(data);
2084 retry = true;
2085 goto recheck;
2086 } else {
2087 dev_dbg(dev, "T7 cfg zero after reset, overriding\n");
2088 data->t7_cfg.active = 20;
2089 data->t7_cfg.idle = 100;
2090 return mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
2091 }
2092 }
2093
2094 dev_dbg(dev, "Initialized power cfg: ACTV %d, IDLE %d\n",
2095 data->t7_cfg.active, data->t7_cfg.idle);
2096 return 0;
2097}
2098
Nick Dyerd6a39402016-07-18 18:10:31 -03002099#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
2100static u16 mxt_get_debug_value(struct mxt_data *data, unsigned int x,
2101 unsigned int y)
2102{
2103 struct mxt_dbg *dbg = &data->dbg;
2104 unsigned int ofs, page;
2105
2106 ofs = (y + (x * data->info.matrix_ysize)) * sizeof(u16);
2107 page = ofs / MXT_DIAGNOSTIC_SIZE;
2108 ofs %= MXT_DIAGNOSTIC_SIZE;
2109
2110 return get_unaligned_le16(&dbg->t37_buf[page].data[ofs]);
2111}
2112
2113static int mxt_convert_debug_pages(struct mxt_data *data, u16 *outbuf)
2114{
2115 struct mxt_dbg *dbg = &data->dbg;
2116 unsigned int x = 0;
2117 unsigned int y = 0;
2118 unsigned int i;
2119
2120 for (i = 0; i < dbg->t37_nodes; i++) {
2121 outbuf[i] = mxt_get_debug_value(data, x, y);
2122
2123 /* Next value */
2124 if (++x >= data->info.matrix_xsize) {
2125 x = 0;
2126 y++;
2127 }
2128 }
2129
2130 return 0;
2131}
2132
2133static int mxt_read_diagnostic_debug(struct mxt_data *data, u8 mode,
2134 u16 *outbuf)
2135{
2136 struct mxt_dbg *dbg = &data->dbg;
2137 int retries = 0;
2138 int page;
2139 int ret;
2140 u8 cmd = mode;
2141 struct t37_debug *p;
2142 u8 cmd_poll;
2143
2144 for (page = 0; page < dbg->t37_pages; page++) {
2145 p = dbg->t37_buf + page;
2146
2147 ret = mxt_write_reg(data->client, dbg->diag_cmd_address,
2148 cmd);
2149 if (ret)
2150 return ret;
2151
2152 retries = 0;
2153 msleep(20);
2154wait_cmd:
2155 /* Read back command byte */
2156 ret = __mxt_read_reg(data->client, dbg->diag_cmd_address,
2157 sizeof(cmd_poll), &cmd_poll);
2158 if (ret)
2159 return ret;
2160
2161 /* Field is cleared once the command has been processed */
2162 if (cmd_poll) {
2163 if (retries++ > 100)
2164 return -EINVAL;
2165
2166 msleep(20);
2167 goto wait_cmd;
2168 }
2169
2170 /* Read T37 page */
2171 ret = __mxt_read_reg(data->client, dbg->t37_address,
2172 sizeof(struct t37_debug), p);
2173 if (ret)
2174 return ret;
2175
2176 if (p->mode != mode || p->page != page) {
2177 dev_err(&data->client->dev, "T37 page mismatch\n");
2178 return -EINVAL;
2179 }
2180
2181 dev_dbg(&data->client->dev, "%s page:%d retries:%d\n",
2182 __func__, page, retries);
2183
2184 /* For remaining pages, write PAGEUP rather than mode */
2185 cmd = MXT_DIAGNOSTIC_PAGEUP;
2186 }
2187
2188 return mxt_convert_debug_pages(data, outbuf);
2189}
2190
Nick Dyerecfdd7e2016-07-18 18:10:32 -03002191static int mxt_queue_setup(struct vb2_queue *q,
2192 unsigned int *nbuffers, unsigned int *nplanes,
2193 unsigned int sizes[], struct device *alloc_devs[])
2194{
2195 struct mxt_data *data = q->drv_priv;
2196 size_t size = data->dbg.t37_nodes * sizeof(u16);
2197
2198 if (*nplanes)
2199 return sizes[0] < size ? -EINVAL : 0;
2200
2201 *nplanes = 1;
2202 sizes[0] = size;
2203
2204 return 0;
2205}
2206
2207static void mxt_buffer_queue(struct vb2_buffer *vb)
2208{
2209 struct mxt_data *data = vb2_get_drv_priv(vb->vb2_queue);
2210 u16 *ptr;
2211 int ret;
2212
2213 ptr = vb2_plane_vaddr(vb, 0);
2214 if (!ptr) {
2215 dev_err(&data->client->dev, "Error acquiring frame ptr\n");
2216 goto fault;
2217 }
2218
2219 ret = mxt_read_diagnostic_debug(data, MXT_DIAGNOSTIC_DELTAS, ptr);
2220 if (ret)
2221 goto fault;
2222
2223 vb2_set_plane_payload(vb, 0, data->dbg.t37_nodes * sizeof(u16));
2224 vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
2225 return;
2226
2227fault:
2228 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2229}
2230
2231/* V4L2 structures */
2232static const struct vb2_ops mxt_queue_ops = {
2233 .queue_setup = mxt_queue_setup,
2234 .buf_queue = mxt_buffer_queue,
2235 .wait_prepare = vb2_ops_wait_prepare,
2236 .wait_finish = vb2_ops_wait_finish,
2237};
2238
2239static const struct vb2_queue mxt_queue = {
2240 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
2241 .io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ,
2242 .buf_struct_size = sizeof(struct mxt_vb2_buffer),
2243 .ops = &mxt_queue_ops,
2244 .mem_ops = &vb2_vmalloc_memops,
2245 .timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC,
2246 .min_buffers_needed = 1,
2247};
2248
2249static int mxt_vidioc_querycap(struct file *file, void *priv,
2250 struct v4l2_capability *cap)
2251{
2252 struct mxt_data *data = video_drvdata(file);
2253
2254 strlcpy(cap->driver, "atmel_mxt_ts", sizeof(cap->driver));
2255 strlcpy(cap->card, "atmel_mxt_ts touch", sizeof(cap->card));
2256 snprintf(cap->bus_info, sizeof(cap->bus_info),
2257 "I2C:%s", dev_name(&data->client->dev));
2258 return 0;
2259}
2260
2261static int mxt_vidioc_enum_input(struct file *file, void *priv,
2262 struct v4l2_input *i)
2263{
2264 if (i->index > 0)
2265 return -EINVAL;
2266
2267 i->type = V4L2_INPUT_TYPE_TOUCH;
2268 strlcpy(i->name, "Mutual Capacitance Deltas", sizeof(i->name));
2269 return 0;
2270}
2271
2272static int mxt_set_input(struct mxt_data *data, unsigned int i)
2273{
2274 struct v4l2_pix_format *f = &data->dbg.format;
2275
2276 if (i > 0)
2277 return -EINVAL;
2278
2279 f->width = data->info.matrix_xsize;
2280 f->height = data->info.matrix_ysize;
2281 f->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
2282 f->field = V4L2_FIELD_NONE;
2283 f->colorspace = V4L2_COLORSPACE_RAW;
2284 f->bytesperline = f->width * sizeof(u16);
2285 f->sizeimage = f->width * f->height * sizeof(u16);
2286
2287 data->dbg.input = i;
2288
2289 return 0;
2290}
2291
2292static int mxt_vidioc_s_input(struct file *file, void *priv, unsigned int i)
2293{
2294 return mxt_set_input(video_drvdata(file), i);
2295}
2296
2297static int mxt_vidioc_g_input(struct file *file, void *priv, unsigned int *i)
2298{
2299 struct mxt_data *data = video_drvdata(file);
2300
2301 *i = data->dbg.input;
2302
2303 return 0;
2304}
2305
2306static int mxt_vidioc_fmt(struct file *file, void *priv, struct v4l2_format *f)
2307{
2308 struct mxt_data *data = video_drvdata(file);
2309
2310 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2311 f->fmt.pix = data->dbg.format;
2312
2313 return 0;
2314}
2315
2316static int mxt_vidioc_enum_fmt(struct file *file, void *priv,
2317 struct v4l2_fmtdesc *fmt)
2318{
2319 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2320 return -EINVAL;
2321
2322 fmt->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
2323 return 0;
2324}
2325
2326static int mxt_vidioc_g_parm(struct file *file, void *fh,
2327 struct v4l2_streamparm *a)
2328{
2329 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2330 return -EINVAL;
2331
2332 a->parm.capture.readbuffers = 1;
2333 a->parm.capture.timeperframe.numerator = 1;
2334 a->parm.capture.timeperframe.denominator = 10;
2335 return 0;
2336}
2337
2338static const struct v4l2_ioctl_ops mxt_video_ioctl_ops = {
2339 .vidioc_querycap = mxt_vidioc_querycap,
2340
2341 .vidioc_enum_fmt_vid_cap = mxt_vidioc_enum_fmt,
2342 .vidioc_s_fmt_vid_cap = mxt_vidioc_fmt,
2343 .vidioc_g_fmt_vid_cap = mxt_vidioc_fmt,
2344 .vidioc_try_fmt_vid_cap = mxt_vidioc_fmt,
2345 .vidioc_g_parm = mxt_vidioc_g_parm,
2346
2347 .vidioc_enum_input = mxt_vidioc_enum_input,
2348 .vidioc_g_input = mxt_vidioc_g_input,
2349 .vidioc_s_input = mxt_vidioc_s_input,
2350
2351 .vidioc_reqbufs = vb2_ioctl_reqbufs,
2352 .vidioc_create_bufs = vb2_ioctl_create_bufs,
2353 .vidioc_querybuf = vb2_ioctl_querybuf,
2354 .vidioc_qbuf = vb2_ioctl_qbuf,
2355 .vidioc_dqbuf = vb2_ioctl_dqbuf,
2356 .vidioc_expbuf = vb2_ioctl_expbuf,
2357
2358 .vidioc_streamon = vb2_ioctl_streamon,
2359 .vidioc_streamoff = vb2_ioctl_streamoff,
2360};
2361
2362static const struct video_device mxt_video_device = {
2363 .name = "Atmel maxTouch",
2364 .fops = &mxt_video_fops,
2365 .ioctl_ops = &mxt_video_ioctl_ops,
2366 .release = video_device_release_empty,
2367 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TOUCH |
2368 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING,
2369};
2370
Nick Dyerd6a39402016-07-18 18:10:31 -03002371static void mxt_debug_init(struct mxt_data *data)
2372{
2373 struct mxt_dbg *dbg = &data->dbg;
2374 struct mxt_object *object;
Nick Dyerecfdd7e2016-07-18 18:10:32 -03002375 int error;
Nick Dyerd6a39402016-07-18 18:10:31 -03002376
2377 object = mxt_get_object(data, MXT_GEN_COMMAND_T6);
2378 if (!object)
2379 goto error;
2380
2381 dbg->diag_cmd_address = object->start_address + MXT_COMMAND_DIAGNOSTIC;
2382
2383 object = mxt_get_object(data, MXT_DEBUG_DIAGNOSTIC_T37);
2384 if (!object)
2385 goto error;
2386
2387 if (mxt_obj_size(object) != sizeof(struct t37_debug)) {
2388 dev_warn(&data->client->dev, "Bad T37 size");
2389 goto error;
2390 }
2391
2392 dbg->t37_address = object->start_address;
2393
2394 /* Calculate size of data and allocate buffer */
2395 dbg->t37_nodes = data->info.matrix_xsize * data->info.matrix_ysize;
2396 dbg->t37_pages = DIV_ROUND_UP(dbg->t37_nodes * sizeof(u16),
2397 sizeof(dbg->t37_buf->data));
2398
2399 dbg->t37_buf = devm_kmalloc_array(&data->client->dev, dbg->t37_pages,
2400 sizeof(struct t37_debug), GFP_KERNEL);
2401 if (!dbg->t37_buf)
2402 goto error;
2403
Nick Dyerecfdd7e2016-07-18 18:10:32 -03002404 /* init channel to zero */
2405 mxt_set_input(data, 0);
2406
2407 /* register video device */
2408 snprintf(dbg->v4l2.name, sizeof(dbg->v4l2.name), "%s", "atmel_mxt_ts");
2409 error = v4l2_device_register(&data->client->dev, &dbg->v4l2);
2410 if (error)
2411 goto error;
2412
2413 /* initialize the queue */
2414 mutex_init(&dbg->lock);
2415 dbg->queue = mxt_queue;
2416 dbg->queue.drv_priv = data;
2417 dbg->queue.lock = &dbg->lock;
2418 dbg->queue.dev = &data->client->dev;
2419
2420 error = vb2_queue_init(&dbg->queue);
2421 if (error)
2422 goto error_unreg_v4l2;
2423
2424 dbg->vdev = mxt_video_device;
2425 dbg->vdev.v4l2_dev = &dbg->v4l2;
2426 dbg->vdev.lock = &dbg->lock;
2427 dbg->vdev.vfl_dir = VFL_DIR_RX;
2428 dbg->vdev.queue = &dbg->queue;
2429 video_set_drvdata(&dbg->vdev, data);
2430
2431 error = video_register_device(&dbg->vdev, VFL_TYPE_TOUCH, -1);
2432 if (error)
2433 goto error_unreg_v4l2;
2434
Nick Dyerd6a39402016-07-18 18:10:31 -03002435 return;
2436
Nick Dyerecfdd7e2016-07-18 18:10:32 -03002437error_unreg_v4l2:
2438 v4l2_device_unregister(&dbg->v4l2);
Nick Dyerd6a39402016-07-18 18:10:31 -03002439error:
2440 dev_warn(&data->client->dev, "Error initializing T37\n");
2441}
2442#else
2443static void mxt_debug_init(struct mxt_data *data)
2444{
2445}
2446#endif
2447
Nick Dyer50a77c62014-07-23 12:38:48 -07002448static int mxt_configure_objects(struct mxt_data *data,
2449 const struct firmware *cfg)
2450{
2451 struct device *dev = &data->client->dev;
2452 struct mxt_info *info = &data->info;
2453 int error;
2454
Nick Dyer7f3884f72015-08-04 16:36:29 -07002455 error = mxt_init_t7_power_cfg(data);
2456 if (error) {
2457 dev_err(dev, "Failed to initialize power cfg\n");
2458 return error;
2459 }
2460
Nick Dyer50a77c62014-07-23 12:38:48 -07002461 if (cfg) {
2462 error = mxt_update_cfg(data, cfg);
2463 if (error)
2464 dev_warn(dev, "Error %d updating config\n", error);
2465 }
2466
Nick Dyerb23157d2015-04-06 11:25:13 -07002467 if (data->multitouch) {
2468 error = mxt_initialize_input_device(data);
2469 if (error)
2470 return error;
2471 } else {
2472 dev_warn(dev, "No touch object detected\n");
2473 }
Nick Dyer50a77c62014-07-23 12:38:48 -07002474
Nick Dyerd6a39402016-07-18 18:10:31 -03002475 mxt_debug_init(data);
2476
Nick Dyer50a77c62014-07-23 12:38:48 -07002477 dev_info(dev,
2478 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
2479 info->family_id, info->variant_id, info->version >> 4,
2480 info->version & 0xf, info->build, info->object_num);
2481
2482 return 0;
2483}
2484
Daniel Kurtzb19fc9e2012-06-28 21:08:16 +08002485/* Firmware Version is returned as Major.Minor.Build */
2486static ssize_t mxt_fw_version_show(struct device *dev,
2487 struct device_attribute *attr, char *buf)
2488{
2489 struct mxt_data *data = dev_get_drvdata(dev);
2490 struct mxt_info *info = &data->info;
2491 return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
2492 info->version >> 4, info->version & 0xf, info->build);
2493}
2494
2495/* Hardware Version is returned as FamilyID.VariantID */
2496static ssize_t mxt_hw_version_show(struct device *dev,
2497 struct device_attribute *attr, char *buf)
2498{
2499 struct mxt_data *data = dev_get_drvdata(dev);
2500 struct mxt_info *info = &data->info;
2501 return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
2502 info->family_id, info->variant_id);
2503}
2504
Daniel Kurtz794eb672012-06-28 21:08:10 +08002505static ssize_t mxt_show_instance(char *buf, int count,
2506 struct mxt_object *object, int instance,
2507 const u8 *val)
2508{
2509 int i;
2510
Daniel Kurtz1e0c0c52014-05-18 23:01:12 -07002511 if (mxt_obj_instances(object) > 1)
Daniel Kurtz794eb672012-06-28 21:08:10 +08002512 count += scnprintf(buf + count, PAGE_SIZE - count,
2513 "Instance %u\n", instance);
2514
Daniel Kurtz1e0c0c52014-05-18 23:01:12 -07002515 for (i = 0; i < mxt_obj_size(object); i++)
Daniel Kurtz794eb672012-06-28 21:08:10 +08002516 count += scnprintf(buf + count, PAGE_SIZE - count,
2517 "\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
2518 count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
2519
2520 return count;
2521}
2522
Iiro Valkonen7686b102011-02-02 23:21:58 -08002523static ssize_t mxt_object_show(struct device *dev,
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002524 struct device_attribute *attr, char *buf)
2525{
Iiro Valkonen7686b102011-02-02 23:21:58 -08002526 struct mxt_data *data = dev_get_drvdata(dev);
2527 struct mxt_object *object;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002528 int count = 0;
2529 int i, j;
2530 int error;
Daniel Kurtz43a91d52012-06-28 21:08:08 +08002531 u8 *obuf;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002532
Daniel Kurtz43a91d52012-06-28 21:08:08 +08002533 /* Pre-allocate buffer large enough to hold max sized object. */
2534 obuf = kmalloc(256, GFP_KERNEL);
2535 if (!obuf)
2536 return -ENOMEM;
2537
2538 error = 0;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002539 for (i = 0; i < data->info.object_num; i++) {
2540 object = data->object_table + i;
2541
Daniel Kurtz91630952012-06-28 21:08:09 +08002542 if (!mxt_object_readable(object->type))
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002543 continue;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002544
Daniel Kurtz91630952012-06-28 21:08:09 +08002545 count += scnprintf(buf + count, PAGE_SIZE - count,
2546 "T%u:\n", object->type);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002547
Daniel Kurtz1e0c0c52014-05-18 23:01:12 -07002548 for (j = 0; j < mxt_obj_instances(object); j++) {
2549 u16 size = mxt_obj_size(object);
Daniel Kurtz794eb672012-06-28 21:08:10 +08002550 u16 addr = object->start_address + j * size;
Daniel Kurtz43a91d52012-06-28 21:08:08 +08002551
Daniel Kurtz794eb672012-06-28 21:08:10 +08002552 error = __mxt_read_reg(data->client, addr, size, obuf);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002553 if (error)
Daniel Kurtz794eb672012-06-28 21:08:10 +08002554 goto done;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002555
Daniel Kurtz794eb672012-06-28 21:08:10 +08002556 count = mxt_show_instance(buf, count, object, j, obuf);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002557 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002558 }
2559
Daniel Kurtz794eb672012-06-28 21:08:10 +08002560done:
Daniel Kurtz43a91d52012-06-28 21:08:08 +08002561 kfree(obuf);
2562 return error ?: count;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002563}
2564
Nick Dyerf2ac6cb2014-05-18 23:15:01 -07002565static int mxt_check_firmware_format(struct device *dev,
2566 const struct firmware *fw)
2567{
2568 unsigned int pos = 0;
2569 char c;
2570
2571 while (pos < fw->size) {
2572 c = *(fw->data + pos);
2573
2574 if (c < '0' || (c > '9' && c < 'A') || c > 'F')
2575 return 0;
2576
2577 pos++;
2578 }
2579
2580 /*
2581 * To convert file try:
2582 * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw
2583 */
2584 dev_err(dev, "Aborting: firmware file must be in binary format\n");
2585
2586 return -EINVAL;
2587}
2588
Iiro Valkonen7686b102011-02-02 23:21:58 -08002589static int mxt_load_fw(struct device *dev, const char *fn)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002590{
Iiro Valkonen7686b102011-02-02 23:21:58 -08002591 struct mxt_data *data = dev_get_drvdata(dev);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002592 const struct firmware *fw = NULL;
2593 unsigned int frame_size;
2594 unsigned int pos = 0;
Nick Dyerf943c742014-05-18 23:14:20 -07002595 unsigned int retry = 0;
Nick Dyerf477c752014-05-18 23:14:45 -07002596 unsigned int frame = 0;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002597 int ret;
2598
2599 ret = request_firmware(&fw, fn, dev);
2600 if (ret) {
2601 dev_err(dev, "Unable to open firmware %s\n", fn);
2602 return ret;
2603 }
2604
Nick Dyerf2ac6cb2014-05-18 23:15:01 -07002605 /* Check for incorrect enc file */
2606 ret = mxt_check_firmware_format(dev, fw);
2607 if (ret)
2608 goto release_firmware;
2609
Nick Dyera9fdd1e2014-07-23 12:41:58 -07002610 if (!data->in_bootloader) {
2611 /* Change to the bootloader mode */
2612 data->in_bootloader = true;
Benson Leungd79e7e42014-05-18 23:02:52 -07002613
Nick Dyera9fdd1e2014-07-23 12:41:58 -07002614 ret = mxt_t6_command(data, MXT_COMMAND_RESET,
2615 MXT_BOOT_VALUE, false);
2616 if (ret)
2617 goto release_firmware;
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07002618
Nick Dyera9fdd1e2014-07-23 12:41:58 -07002619 msleep(MXT_RESET_TIME);
Nick Dyer8efaa5e2014-07-23 12:45:49 -07002620
2621 /* Do not need to scan since we know family ID */
2622 ret = mxt_lookup_bootloader_address(data, 0);
2623 if (ret)
2624 goto release_firmware;
Stephen Warren58e4aeee2014-09-10 10:01:10 -07002625
2626 mxt_free_input_device(data);
2627 mxt_free_object_table(data);
Nick Dyer8efaa5e2014-07-23 12:45:49 -07002628 } else {
2629 enable_irq(data->irq);
Nick Dyera9fdd1e2014-07-23 12:41:58 -07002630 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002631
Benson Leungd79e7e42014-05-18 23:02:52 -07002632 reinit_completion(&data->bl_completion);
2633
Nick Dyer385deb92014-07-23 12:42:40 -07002634 ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
2635 if (ret) {
2636 /* Bootloader may still be unlocked from previous attempt */
2637 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false);
2638 if (ret)
2639 goto disable_irq;
2640 } else {
2641 dev_info(dev, "Unlocking bootloader\n");
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002642
Nick Dyer385deb92014-07-23 12:42:40 -07002643 /* Unlock bootloader */
Nick Dyer8efaa5e2014-07-23 12:45:49 -07002644 ret = mxt_send_bootloader_cmd(data, true);
Nick Dyer385deb92014-07-23 12:42:40 -07002645 if (ret)
2646 goto disable_irq;
2647 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002648
2649 while (pos < fw->size) {
Nick Dyer385deb92014-07-23 12:42:40 -07002650 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002651 if (ret)
Benson Leungd79e7e42014-05-18 23:02:52 -07002652 goto disable_irq;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002653
2654 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
2655
Nick Dyerf943c742014-05-18 23:14:20 -07002656 /* Take account of CRC bytes */
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002657 frame_size += 2;
2658
2659 /* Write one frame to device */
Nick Dyerf28a8422014-05-18 23:10:49 -07002660 ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
2661 if (ret)
2662 goto disable_irq;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002663
Nick Dyer385deb92014-07-23 12:42:40 -07002664 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
Nick Dyerf943c742014-05-18 23:14:20 -07002665 if (ret) {
2666 retry++;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002667
Nick Dyerf943c742014-05-18 23:14:20 -07002668 /* Back off by 20ms per retry */
2669 msleep(retry * 20);
2670
2671 if (retry > 20) {
2672 dev_err(dev, "Retry count exceeded\n");
2673 goto disable_irq;
2674 }
2675 } else {
2676 retry = 0;
2677 pos += frame_size;
Nick Dyerf477c752014-05-18 23:14:45 -07002678 frame++;
Nick Dyerf943c742014-05-18 23:14:20 -07002679 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002680
Nick Dyerf477c752014-05-18 23:14:45 -07002681 if (frame % 50 == 0)
2682 dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n",
2683 frame, pos, fw->size);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002684 }
2685
Benson Leunga0434b72014-05-18 23:03:09 -07002686 /* Wait for flash. */
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07002687 ret = mxt_wait_for_completion(data, &data->bl_completion,
2688 MXT_FW_RESET_TIME);
Benson Leunga0434b72014-05-18 23:03:09 -07002689 if (ret)
2690 goto disable_irq;
2691
Nick Dyerf477c752014-05-18 23:14:45 -07002692 dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos);
2693
Benson Leunga0434b72014-05-18 23:03:09 -07002694 /*
2695 * Wait for device to reset. Some bootloader versions do not assert
2696 * the CHG line after bootloading has finished, so ignore potential
2697 * errors.
2698 */
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07002699 mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
Benson Leunga0434b72014-05-18 23:03:09 -07002700
Benson Leungd79e7e42014-05-18 23:02:52 -07002701 data->in_bootloader = false;
2702
2703disable_irq:
2704 disable_irq(data->irq);
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07002705release_firmware:
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002706 release_firmware(fw);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002707 return ret;
2708}
2709
Iiro Valkonen7686b102011-02-02 23:21:58 -08002710static ssize_t mxt_update_fw_store(struct device *dev,
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002711 struct device_attribute *attr,
2712 const char *buf, size_t count)
2713{
Iiro Valkonen7686b102011-02-02 23:21:58 -08002714 struct mxt_data *data = dev_get_drvdata(dev);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002715 int error;
2716
Iiro Valkonen7686b102011-02-02 23:21:58 -08002717 error = mxt_load_fw(dev, MXT_FW_NAME);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002718 if (error) {
2719 dev_err(dev, "The firmware update failed(%d)\n", error);
2720 count = error;
2721 } else {
Nick Dyer7bed6802014-05-18 23:04:09 -07002722 dev_info(dev, "The firmware update succeeded\n");
2723
Nick Dyerdd24dcf2014-07-23 11:25:55 -07002724 error = mxt_initialize(data);
Benson Leungd79e7e42014-05-18 23:02:52 -07002725 if (error)
2726 return error;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002727 }
2728
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002729 return count;
2730}
2731
Daniel Kurtzb19fc9e2012-06-28 21:08:16 +08002732static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
2733static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
Daniel Kurtz71b3e932012-05-08 22:30:14 -07002734static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
2735static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002736
Iiro Valkonen7686b102011-02-02 23:21:58 -08002737static struct attribute *mxt_attrs[] = {
Daniel Kurtzb19fc9e2012-06-28 21:08:16 +08002738 &dev_attr_fw_version.attr,
2739 &dev_attr_hw_version.attr,
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002740 &dev_attr_object.attr,
2741 &dev_attr_update_fw.attr,
2742 NULL
2743};
2744
Iiro Valkonen7686b102011-02-02 23:21:58 -08002745static const struct attribute_group mxt_attr_group = {
2746 .attrs = mxt_attrs,
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002747};
2748
Iiro Valkonen7686b102011-02-02 23:21:58 -08002749static void mxt_start(struct mxt_data *data)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002750{
Nick Dyer7f3884f72015-08-04 16:36:29 -07002751 switch (data->pdata->suspend_mode) {
2752 case MXT_SUSPEND_T9_CTRL:
2753 mxt_soft_reset(data);
2754
2755 /* Touch enable */
2756 /* 0x83 = SCANEN | RPTEN | ENABLE */
2757 mxt_write_object(data,
2758 MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0x83);
2759 break;
2760
2761 case MXT_SUSPEND_DEEP_SLEEP:
2762 default:
2763 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
2764
2765 /* Recalibrate since chip has been in deep sleep */
2766 mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false);
2767 break;
2768 }
2769
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002770}
2771
Iiro Valkonen7686b102011-02-02 23:21:58 -08002772static void mxt_stop(struct mxt_data *data)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002773{
Nick Dyer7f3884f72015-08-04 16:36:29 -07002774 switch (data->pdata->suspend_mode) {
2775 case MXT_SUSPEND_T9_CTRL:
2776 /* Touch disable */
2777 mxt_write_object(data,
2778 MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0);
2779 break;
2780
2781 case MXT_SUSPEND_DEEP_SLEEP:
2782 default:
2783 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP);
2784 break;
2785 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002786}
2787
Iiro Valkonen7686b102011-02-02 23:21:58 -08002788static int mxt_input_open(struct input_dev *dev)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002789{
Iiro Valkonen7686b102011-02-02 23:21:58 -08002790 struct mxt_data *data = input_get_drvdata(dev);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002791
Iiro Valkonen7686b102011-02-02 23:21:58 -08002792 mxt_start(data);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002793
2794 return 0;
2795}
2796
Iiro Valkonen7686b102011-02-02 23:21:58 -08002797static void mxt_input_close(struct input_dev *dev)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002798{
Iiro Valkonen7686b102011-02-02 23:21:58 -08002799 struct mxt_data *data = input_get_drvdata(dev);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002800
Iiro Valkonen7686b102011-02-02 23:21:58 -08002801 mxt_stop(data);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002802}
2803
Stephen Warren78188be2014-07-23 12:23:23 -07002804#ifdef CONFIG_OF
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07002805static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
Stephen Warren78188be2014-07-23 12:23:23 -07002806{
2807 struct mxt_platform_data *pdata;
Nick Dyer20447662015-08-04 16:53:16 -07002808 struct device_node *np = client->dev.of_node;
Stephen Warren78188be2014-07-23 12:23:23 -07002809 u32 *keymap;
Nick Dyer20447662015-08-04 16:53:16 -07002810 int proplen, ret;
Stephen Warren78188be2014-07-23 12:23:23 -07002811
Nick Dyer20447662015-08-04 16:53:16 -07002812 if (!np)
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07002813 return ERR_PTR(-ENOENT);
Stephen Warren78188be2014-07-23 12:23:23 -07002814
2815 pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
2816 if (!pdata)
2817 return ERR_PTR(-ENOMEM);
2818
Nick Dyer20447662015-08-04 16:53:16 -07002819 if (of_find_property(np, "linux,gpio-keymap", &proplen)) {
Stephen Warren78188be2014-07-23 12:23:23 -07002820 pdata->t19_num_keys = proplen / sizeof(u32);
2821
2822 keymap = devm_kzalloc(&client->dev,
2823 pdata->t19_num_keys * sizeof(keymap[0]),
2824 GFP_KERNEL);
2825 if (!keymap)
2826 return ERR_PTR(-ENOMEM);
2827
Nick Dyer20447662015-08-04 16:53:16 -07002828 ret = of_property_read_u32_array(np, "linux,gpio-keymap",
2829 keymap, pdata->t19_num_keys);
2830 if (ret)
2831 dev_warn(&client->dev,
2832 "Couldn't read linux,gpio-keymap: %d\n", ret);
Stephen Warren78188be2014-07-23 12:23:23 -07002833
2834 pdata->t19_keymap = keymap;
2835 }
2836
Nick Dyer7f3884f72015-08-04 16:36:29 -07002837 pdata->suspend_mode = MXT_SUSPEND_DEEP_SLEEP;
2838
Stephen Warren78188be2014-07-23 12:23:23 -07002839 return pdata;
2840}
2841#else
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07002842static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
Stephen Warren78188be2014-07-23 12:23:23 -07002843{
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07002844 return ERR_PTR(-ENOENT);
Stephen Warren78188be2014-07-23 12:23:23 -07002845}
2846#endif
2847
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07002848#ifdef CONFIG_ACPI
2849
2850struct mxt_acpi_platform_data {
2851 const char *hid;
2852 struct mxt_platform_data pdata;
2853};
2854
2855static unsigned int samus_touchpad_buttons[] = {
2856 KEY_RESERVED,
2857 KEY_RESERVED,
2858 KEY_RESERVED,
2859 BTN_LEFT
2860};
2861
2862static struct mxt_acpi_platform_data samus_platform_data[] = {
2863 {
2864 /* Touchpad */
2865 .hid = "ATML0000",
2866 .pdata = {
2867 .t19_num_keys = ARRAY_SIZE(samus_touchpad_buttons),
2868 .t19_keymap = samus_touchpad_buttons,
2869 },
2870 },
2871 {
2872 /* Touchscreen */
2873 .hid = "ATML0001",
2874 },
2875 { }
2876};
2877
Dmitry Torokhovc67566c2015-11-20 10:58:07 -08002878static unsigned int chromebook_tp_buttons[] = {
2879 KEY_RESERVED,
2880 KEY_RESERVED,
2881 KEY_RESERVED,
2882 KEY_RESERVED,
2883 KEY_RESERVED,
2884 BTN_LEFT
2885};
2886
2887static struct mxt_acpi_platform_data chromebook_platform_data[] = {
2888 {
2889 /* Touchpad */
2890 .hid = "ATML0000",
2891 .pdata = {
2892 .t19_num_keys = ARRAY_SIZE(chromebook_tp_buttons),
2893 .t19_keymap = chromebook_tp_buttons,
2894 },
2895 },
2896 {
2897 /* Touchscreen */
2898 .hid = "ATML0001",
2899 },
2900 { }
2901};
2902
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07002903static const struct dmi_system_id mxt_dmi_table[] = {
2904 {
2905 /* 2015 Google Pixel */
2906 .ident = "Chromebook Pixel 2",
2907 .matches = {
2908 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
2909 DMI_MATCH(DMI_PRODUCT_NAME, "Samus"),
2910 },
2911 .driver_data = samus_platform_data,
2912 },
Dmitry Torokhovc67566c2015-11-20 10:58:07 -08002913 {
2914 /* Other Google Chromebooks */
2915 .ident = "Chromebook",
2916 .matches = {
2917 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
2918 },
2919 .driver_data = chromebook_platform_data,
2920 },
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07002921 { }
2922};
2923
2924static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
2925{
2926 struct acpi_device *adev;
2927 const struct dmi_system_id *system_id;
2928 const struct mxt_acpi_platform_data *acpi_pdata;
2929
2930 /*
2931 * Ignore ACPI devices representing bootloader mode.
2932 *
2933 * This is a bit of a hack: Google Chromebook BIOS creates ACPI
2934 * devices for both application and bootloader modes, but we are
2935 * interested in application mode only (if device is in bootloader
2936 * mode we'll end up switching into application anyway). So far
2937 * application mode addresses were all above 0x40, so we'll use it
2938 * as a threshold.
2939 */
2940 if (client->addr < 0x40)
2941 return ERR_PTR(-ENXIO);
2942
2943 adev = ACPI_COMPANION(&client->dev);
2944 if (!adev)
2945 return ERR_PTR(-ENOENT);
2946
2947 system_id = dmi_first_match(mxt_dmi_table);
2948 if (!system_id)
2949 return ERR_PTR(-ENOENT);
2950
2951 acpi_pdata = system_id->driver_data;
2952 if (!acpi_pdata)
2953 return ERR_PTR(-ENOENT);
2954
2955 while (acpi_pdata->hid) {
2956 if (!strcmp(acpi_device_hid(adev), acpi_pdata->hid))
2957 return &acpi_pdata->pdata;
2958
2959 acpi_pdata++;
2960 }
2961
2962 return ERR_PTR(-ENOENT);
2963}
2964#else
2965static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
2966{
2967 return ERR_PTR(-ENOENT);
2968}
2969#endif
2970
2971static const struct mxt_platform_data *
2972mxt_get_platform_data(struct i2c_client *client)
2973{
2974 const struct mxt_platform_data *pdata;
2975
2976 pdata = dev_get_platdata(&client->dev);
2977 if (pdata)
2978 return pdata;
2979
2980 pdata = mxt_parse_dt(client);
2981 if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
2982 return pdata;
2983
2984 pdata = mxt_parse_acpi(client);
2985 if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
2986 return pdata;
2987
2988 dev_err(&client->dev, "No platform data specified\n");
2989 return ERR_PTR(-EINVAL);
2990}
2991
Stephen Warren78188be2014-07-23 12:23:23 -07002992static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002993{
Iiro Valkonen7686b102011-02-02 23:21:58 -08002994 struct mxt_data *data;
Stephen Warren78188be2014-07-23 12:23:23 -07002995 const struct mxt_platform_data *pdata;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07002996 int error;
2997
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07002998 pdata = mxt_get_platform_data(client);
2999 if (IS_ERR(pdata))
3000 return PTR_ERR(pdata);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003001
Iiro Valkonen7686b102011-02-02 23:21:58 -08003002 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
Nick Dyer7a53d602014-07-23 12:21:26 -07003003 if (!data) {
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003004 dev_err(&client->dev, "Failed to allocate memory\n");
Nick Dyer7a53d602014-07-23 12:21:26 -07003005 return -ENOMEM;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003006 }
3007
Daniel Kurtzec02ac22012-06-28 21:08:02 +08003008 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
3009 client->adapter->nr, client->addr);
Daniel Kurtz22dfab72013-03-07 19:43:33 -08003010
Joonyoung Shim910d8052011-04-12 23:14:38 -07003011 data->client = client;
Joonyoung Shim910d8052011-04-12 23:14:38 -07003012 data->pdata = pdata;
3013 data->irq = client->irq;
Nick Dyer7a53d602014-07-23 12:21:26 -07003014 i2c_set_clientdata(client, data);
Joonyoung Shim910d8052011-04-12 23:14:38 -07003015
Benson Leungd79e7e42014-05-18 23:02:52 -07003016 init_completion(&data->bl_completion);
Iiro Valkonena4a2ef42014-05-18 23:03:44 -07003017 init_completion(&data->reset_completion);
Nick Dyerc3f78042014-05-18 23:04:46 -07003018 init_completion(&data->crc_completion);
Benson Leungd79e7e42014-05-18 23:02:52 -07003019
Nick Dyerdd24dcf2014-07-23 11:25:55 -07003020 error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
3021 pdata->irqflags | IRQF_ONESHOT,
3022 client->name, data);
3023 if (error) {
3024 dev_err(&client->dev, "Failed to register interrupt\n");
3025 goto err_free_mem;
3026 }
3027
3028 disable_irq(client->irq);
3029
Daniel Kurtzcb159112012-06-28 21:08:22 +08003030 error = mxt_initialize(data);
3031 if (error)
Nick Dyer7a53d602014-07-23 12:21:26 -07003032 goto err_free_irq;
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003033
Iiro Valkonen7686b102011-02-02 23:21:58 -08003034 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
Nick Dyer7bed6802014-05-18 23:04:09 -07003035 if (error) {
3036 dev_err(&client->dev, "Failure %d creating sysfs group\n",
3037 error);
Nick Dyer7a53d602014-07-23 12:21:26 -07003038 goto err_free_object;
Nick Dyer7bed6802014-05-18 23:04:09 -07003039 }
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003040
3041 return 0;
3042
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003043err_free_object:
Stephen Warren58e4aeee2014-09-10 10:01:10 -07003044 mxt_free_input_device(data);
Nick Dyer5f3f9bc2014-07-23 12:46:55 -07003045 mxt_free_object_table(data);
Nick Dyerdd24dcf2014-07-23 11:25:55 -07003046err_free_irq:
3047 free_irq(client->irq, data);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003048err_free_mem:
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003049 kfree(data);
3050 return error;
3051}
3052
Bill Pembertone2619cf2012-11-23 21:50:47 -08003053static int mxt_remove(struct i2c_client *client)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003054{
Iiro Valkonen7686b102011-02-02 23:21:58 -08003055 struct mxt_data *data = i2c_get_clientdata(client);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003056
Iiro Valkonen7686b102011-02-02 23:21:58 -08003057 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003058 free_irq(data->irq, data);
Stephen Warren58e4aeee2014-09-10 10:01:10 -07003059 mxt_free_input_device(data);
Nick Dyer5f3f9bc2014-07-23 12:46:55 -07003060 mxt_free_object_table(data);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003061 kfree(data);
3062
3063 return 0;
3064}
3065
Jingoo Han02b6a582014-11-02 00:04:14 -07003066static int __maybe_unused mxt_suspend(struct device *dev)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003067{
Dmitry Torokhov8b5fce02010-11-18 00:14:03 -08003068 struct i2c_client *client = to_i2c_client(dev);
Iiro Valkonen7686b102011-02-02 23:21:58 -08003069 struct mxt_data *data = i2c_get_clientdata(client);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003070 struct input_dev *input_dev = data->input_dev;
3071
Pan Xinhui50fabb02015-08-04 16:53:04 -07003072 if (!input_dev)
3073 return 0;
3074
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003075 mutex_lock(&input_dev->mutex);
3076
3077 if (input_dev->users)
Iiro Valkonen7686b102011-02-02 23:21:58 -08003078 mxt_stop(data);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003079
3080 mutex_unlock(&input_dev->mutex);
3081
3082 return 0;
3083}
3084
Jingoo Han02b6a582014-11-02 00:04:14 -07003085static int __maybe_unused mxt_resume(struct device *dev)
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003086{
Dmitry Torokhov8b5fce02010-11-18 00:14:03 -08003087 struct i2c_client *client = to_i2c_client(dev);
Iiro Valkonen7686b102011-02-02 23:21:58 -08003088 struct mxt_data *data = i2c_get_clientdata(client);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003089 struct input_dev *input_dev = data->input_dev;
3090
Pan Xinhui50fabb02015-08-04 16:53:04 -07003091 if (!input_dev)
3092 return 0;
3093
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003094 mutex_lock(&input_dev->mutex);
3095
3096 if (input_dev->users)
Iiro Valkonen7686b102011-02-02 23:21:58 -08003097 mxt_start(data);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003098
3099 mutex_unlock(&input_dev->mutex);
3100
3101 return 0;
3102}
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003103
Daniel Kurtz3a73c812012-05-08 22:29:14 -07003104static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
3105
Stephen Warren78188be2014-07-23 12:23:23 -07003106static const struct of_device_id mxt_of_match[] = {
3107 { .compatible = "atmel,maxtouch", },
3108 {},
3109};
3110MODULE_DEVICE_TABLE(of, mxt_of_match);
3111
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07003112#ifdef CONFIG_ACPI
3113static const struct acpi_device_id mxt_acpi_id[] = {
3114 { "ATML0000", 0 }, /* Touchpad */
3115 { "ATML0001", 0 }, /* Touchscreen */
3116 { }
3117};
3118MODULE_DEVICE_TABLE(acpi, mxt_acpi_id);
3119#endif
3120
Iiro Valkonen7686b102011-02-02 23:21:58 -08003121static const struct i2c_device_id mxt_id[] = {
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003122 { "qt602240_ts", 0 },
Iiro Valkonen7686b102011-02-02 23:21:58 -08003123 { "atmel_mxt_ts", 0 },
Daniel Kurtz22dfab72013-03-07 19:43:33 -08003124 { "atmel_mxt_tp", 0 },
Javier Martinez Canillasb7d21052015-12-11 13:22:39 -08003125 { "maxtouch", 0 },
Chris Leech46ee2a02011-02-15 13:36:52 -08003126 { "mXT224", 0 },
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003127 { }
3128};
Iiro Valkonen7686b102011-02-02 23:21:58 -08003129MODULE_DEVICE_TABLE(i2c, mxt_id);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003130
Iiro Valkonen7686b102011-02-02 23:21:58 -08003131static struct i2c_driver mxt_driver = {
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003132 .driver = {
Iiro Valkonen7686b102011-02-02 23:21:58 -08003133 .name = "atmel_mxt_ts",
Stephen Warren78188be2014-07-23 12:23:23 -07003134 .of_match_table = of_match_ptr(mxt_of_match),
Dmitry Torokhov4f8d8082015-04-07 16:30:01 -07003135 .acpi_match_table = ACPI_PTR(mxt_acpi_id),
Iiro Valkonen7686b102011-02-02 23:21:58 -08003136 .pm = &mxt_pm_ops,
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003137 },
Iiro Valkonen7686b102011-02-02 23:21:58 -08003138 .probe = mxt_probe,
Bill Pemberton1cb0aa82012-11-23 21:27:39 -08003139 .remove = mxt_remove,
Iiro Valkonen7686b102011-02-02 23:21:58 -08003140 .id_table = mxt_id,
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003141};
3142
Axel Lin1b92c1c2012-03-16 23:05:41 -07003143module_i2c_driver(mxt_driver);
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003144
3145/* Module information */
3146MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
Iiro Valkonen7686b102011-02-02 23:21:58 -08003147MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
Joonyoung Shim4cf51c32010-07-14 21:55:30 -07003148MODULE_LICENSE("GPL");