Treiber für atmel_mxt_ts backport von 4.19

board/GfA/Display001/BUILD

@@ -1 +1 @@
-643
+645

board/GfA/Display001/linux_4.4.94_rt19/linux-030-atmel_mxt_ts_backport.patch

@@ -0,0 +1,3583 @@
+diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
+index 700ae2f..2979cf3 100644
+--- a/drivers/input/touchscreen/atmel_mxt_ts.c
++++ b/drivers/input/touchscreen/atmel_mxt_ts.c
+@@ -4,6 +4,7 @@
+  * Copyright (C) 2010 Samsung Electronics Co.Ltd
+  * Copyright (C) 2011-2014 Atmel Corporation
+  * Copyright (C) 2012 Google, Inc.
++ * Copyright (C) 2016 Zodiac Inflight Innovations
+  *
+  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
+  *
+@@ -22,16 +23,22 @@
+ #include <linux/delay.h>
+ #include <linux/firmware.h>
+ #include <linux/i2c.h>
+-#include <linux/platform_data/atmel_mxt_ts.h>
+ #include <linux/input/mt.h>
+-#include <linux/input/touchscreen.h>
+ #include <linux/interrupt.h>
+ #include <linux/of.h>
++#include <linux/property.h>
+ #include <linux/slab.h>
++#include <linux/gpio/consumer.h>
+ #include <asm/unaligned.h>
++#include <media/v4l2-device.h>
++#include <media/v4l2-ioctl.h>
++#include <media/videobuf2-v4l2.h>
++#include <media/videobuf2-vmalloc.h>
+ 
+ /* Firmware files */
+ #define MXT_FW_NAME		"maxtouch.fw"
++
++/* Configuration file */
+ #define MXT_CFG_NAME		"maxtouch.cfg"
+ #define MXT_CFG_MAGIC		"OBP_RAW V1"
+ 
+@@ -41,35 +48,62 @@
+ #define MXT_INFO_CHECKSUM_SIZE	3
+ #define MXT_MAX_BLOCK_WRITE	256
+ 
+-/* Object types */
+-#define MXT_DEBUG_DIAGNOSTIC_T37	37
++/* Objects */
+ #define MXT_GEN_MESSAGE_T5		5
+ #define MXT_GEN_COMMAND_T6		6
+ #define MXT_GEN_POWER_T7		7
+ #define MXT_GEN_ACQUIRE_T8		8
+-#define MXT_GEN_DATASOURCE_T53		53
+ #define MXT_TOUCH_MULTI_T9		9
++#define MXT_PROCI_KEYTHRESHOLD_T14	14
+ #define MXT_TOUCH_KEYARRAY_T15		15
++#define MXT_SPT_COMMSCONFIG_T18		18
++#define MXT_SPT_GPIOPWM_T19		19
+ #define MXT_TOUCH_PROXIMITY_T23		23
+ #define MXT_TOUCH_PROXKEY_T52		52
+ #define MXT_PROCI_GRIPFACE_T20		20
+ #define MXT_PROCG_NOISE_T22		22
+ #define MXT_PROCI_ONETOUCH_T24		24
++#define MXT_SPT_SELFTEST_T25		25
+ #define MXT_PROCI_TWOTOUCH_T27		27
++#define MXT_SPT_CTECONFIG_T28		28
++#define MXT_DEBUG_DIAGNOSTIC_T37	37
++#define MXT_SPT_USERDATA_T38		38
+ #define MXT_PROCI_GRIP_T40		40
+ #define MXT_PROCI_PALM_T41		41
+ #define MXT_PROCI_TOUCHSUPPRESSION_T42	42
+-#define MXT_PROCI_STYLUS_T47		47
+-#define MXT_PROCG_NOISESUPPRESSION_T48	48
+-#define MXT_SPT_COMMSCONFIG_T18		18
+-#define MXT_SPT_GPIOPWM_T19		19
+-#define MXT_SPT_SELFTEST_T25		25
+-#define MXT_SPT_CTECONFIG_T28		28
+-#define MXT_SPT_USERDATA_T38		38
+ #define MXT_SPT_DIGITIZER_T43		43
+ #define MXT_SPT_MESSAGECOUNT_T44	44
+ #define MXT_SPT_CTECONFIG_T46		46
+-#define MXT_TOUCH_MULTITOUCHSCREEN_T100 100
++#define MXT_PROCI_STYLUS_T47		47
++#define MXT_PROCG_NOISESUPPRESSION_T48	48
++#define MXT_GEN_DATASOURCE_T53		53
++#define MXT_PROCI_SHIELDLESS_T56	56
++#define MXT_SPT_TIMER_T61		61
++#define MXT_PROCI_LENSBENDING_T65	65
++#define MXT_SPT_SERIALDATACOMMAND_T68	68
++#define MXT_SPT_DYNAMICCONFIGURATIONCONTROLLER_T70 70
++#define MXT_SPT_DYNAMICCONFIGURATIONCONTAINER_T71  71
++#define MXT_NOISESUPPRESSION_T72		   72
++#define MXT_SPT_CTESCANCONFIG_T77		   77
++#define MXT_PROCI_GLOVEDETECTION_T78		   78
++#define MXT_SPT_TOUCHEVENTTRIGGER_T79		   79
++#define MXT_PROCI_RETRANSMISSIONCOMPENSATION_T80   80
++#define MXT_PROCG_NOISESUPACTIVESTYLUS_T86	   86
++#define MXT_PROCI_SYMBOLGESTUREPROCESSOR_T92	   92
++#define MXT_PROCI_TOUCHSEQUENCELOGGER_T93	   93
++#define MXT_TOUCH_MULTITOUCHSCREEN_T100 	   100
++#define MXT_SPT_AUXTOUCHCONFIG_T104		   104
++#define MXT_PROCG_NOISESUPSELFCAP_T108		   108
++#define MXT_SPT_SELFCAPGLOBALCONFIG_T109	   109
++#define MXT_PROCI_ACTIVESTYLUS_T107		   107
++#define MXT_SPT_CAPTUNINGPARAMS_T110		   110
++#define MXT_SPT_SELFCAPCONFIG_T111		   111
++#define MXT_PROCI_SELFCAPGRIPSUPPRESSION_T112	   112
++#define MXT_SPT_PROXMEASURECONFIG_T113		   113
++#define MXT_ACTIVESTYLUSMEASCONFIG_T114		   114
++#define MXT_SPT_DATACONTAINERCTRL_T118		   118
++#define MXT_PROCI_HOVERGESTUREPROCESSOR_T129	   129
++#define MXT_SPT_SELCAPVOLTAGEMODE_T133		   133
+ 
+ /* MXT_GEN_MESSAGE_T5 object */
+ #define MXT_RPTID_NOMSG		0xff
+@@ -82,12 +116,12 @@
+ #define MXT_COMMAND_DIAGNOSTIC	5
+ 
+ /* Define for T6 status byte */
+-#define MXT_T6_STATUS_RESET	(1 << 7)
+-#define MXT_T6_STATUS_OFL	(1 << 6)
+-#define MXT_T6_STATUS_SIGERR	(1 << 5)
+-#define MXT_T6_STATUS_CAL	(1 << 4)
+-#define MXT_T6_STATUS_CFGERR	(1 << 3)
+-#define MXT_T6_STATUS_COMSERR	(1 << 2)
++#define MXT_T6_STATUS_RESET	BIT(7)
++#define MXT_T6_STATUS_OFL	BIT(6)
++#define MXT_T6_STATUS_SIGERR	BIT(5)
++#define MXT_T6_STATUS_CAL	BIT(4)
++#define MXT_T6_STATUS_CFGERR	BIT(3)
++#define MXT_T6_STATUS_COMSERR	BIT(2)
+ 
+ /* MXT_GEN_POWER_T7 field */
+ struct t7_config {
+@@ -100,18 +134,20 @@ struct t7_config {
+ 
+ /* MXT_TOUCH_MULTI_T9 field */
+ #define MXT_T9_CTRL		0
++#define MXT_T9_XSIZE		3
++#define MXT_T9_YSIZE		4
+ #define MXT_T9_ORIENT		9
+ #define MXT_T9_RANGE		18
+ 
+ /* MXT_TOUCH_MULTI_T9 status */
+-#define MXT_T9_UNGRIP		(1 << 0)
+-#define MXT_T9_SUPPRESS		(1 << 1)
+-#define MXT_T9_AMP		(1 << 2)
+-#define MXT_T9_VECTOR		(1 << 3)
+-#define MXT_T9_MOVE		(1 << 4)
+-#define MXT_T9_RELEASE		(1 << 5)
+-#define MXT_T9_PRESS		(1 << 6)
+-#define MXT_T9_DETECT		(1 << 7)
++#define MXT_T9_UNGRIP		BIT(0)
++#define MXT_T9_SUPPRESS		BIT(1)
++#define MXT_T9_AMP		BIT(2)
++#define MXT_T9_VECTOR		BIT(3)
++#define MXT_T9_MOVE		BIT(4)
++#define MXT_T9_RELEASE		BIT(5)
++#define MXT_T9_PRESS		BIT(6)
++#define MXT_T9_DETECT		BIT(7)
+ 
+ struct t9_range {
+ 	__le16 x;
+@@ -119,36 +155,70 @@ struct t9_range {
+ } __packed;
+ 
+ /* MXT_TOUCH_MULTI_T9 orient */
+-#define MXT_T9_ORIENT_SWITCH	(1 << 0)
++#define MXT_T9_ORIENT_SWITCH	BIT(0)
++#define MXT_T9_ORIENT_INVERTX	BIT(1)
++#define MXT_T9_ORIENT_INVERTY	BIT(2)
+ 
+ /* MXT_SPT_COMMSCONFIG_T18 */
+ #define MXT_COMMS_CTRL		0
+ #define MXT_COMMS_CMD		1
+ 
++/* MXT_DEBUG_DIAGNOSTIC_T37 */
++#define MXT_DIAGNOSTIC_PAGEUP	0x01
++#define MXT_DIAGNOSTIC_DELTAS	0x10
++#define MXT_DIAGNOSTIC_REFS	0x11
++#define MXT_DIAGNOSTIC_SIZE	128
++
++#define MXT_FAMILY_1386			160
++#define MXT1386_COLUMNS			3
++#define MXT1386_PAGES_PER_COLUMN	8
++
++struct t37_debug {
++#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
++	u8 mode;
++	u8 page;
++	u8 data[MXT_DIAGNOSTIC_SIZE];
++#endif
++};
++
+ /* Define for MXT_GEN_COMMAND_T6 */
+ #define MXT_BOOT_VALUE		0xa5
+ #define MXT_RESET_VALUE		0x01
+ #define MXT_BACKUP_VALUE	0x55
++#define MXT_BACKUP_W_STOP	0x33
++
++/* Define for MXT_PROCI_TOUCHSUPPRESSION_T42 */
++#define MXT_T42_MSG_TCHSUP	BIT(0)
+ 
+ /* T100 Multiple Touch Touchscreen */
+ #define MXT_T100_CTRL		0
+ #define MXT_T100_CFG1		1
+ #define MXT_T100_TCHAUX		3
++#define MXT_T100_XSIZE		9
+ #define MXT_T100_XRANGE		13
++#define MXT_T100_YSIZE		20
+ #define MXT_T100_YRANGE		24
++#define MXT_T100_AUX_OFFSET	6
++#define MXT_RSVD_RPTIDS		2
++#define MXT_MIN_RPTID_SEC	18
+ 
+ #define MXT_T100_CFG_SWITCHXY	BIT(5)
++#define MXT_T100_CFG_INVERTY	BIT(6)
++#define MXT_T100_CFG_INVERTX	BIT(7)
+ 
+ #define MXT_T100_TCHAUX_VECT	BIT(0)
+ #define MXT_T100_TCHAUX_AMPL	BIT(1)
+ #define MXT_T100_TCHAUX_AREA	BIT(2)
+-
+ #define MXT_T100_DETECT		BIT(7)
+-#define MXT_T100_TYPE_MASK	0x70
++
++#define MXT_T100_TYPE_MASK		0x70
++#define MXT_T100_ENABLE_BIT_MASK	0x01
++
+ 
+ enum t100_type {
+ 	MXT_T100_TYPE_FINGER		= 1,
+ 	MXT_T100_TYPE_PASSIVE_STYLUS	= 2,
++	MXT_T100_TYPE_ACTIVE_STYLUS	= 3,
+ 	MXT_T100_TYPE_HOVERING_FINGER	= 4,
+ 	MXT_T100_TYPE_GLOVE		= 5,
+ 	MXT_T100_TYPE_LARGE_TOUCH	= 6,
+@@ -160,13 +230,27 @@ enum t100_type {
+ #define MXT_TOUCH_MAJOR_DEFAULT		1
+ #define MXT_PRESSURE_DEFAULT		1
+ 
++/* Gen2 Active Stylus */
++#define MXT_T107_STYLUS_STYAUX		42
++#define MXT_T107_STYLUS_STYAUX_PRESSURE	BIT(0)
++#define MXT_T107_STYLUS_STYAUX_PEAK	BIT(4)
++
++#define MXT_T107_STYLUS_HOVER		BIT(0)
++#define MXT_T107_STYLUS_TIPSWITCH	BIT(1)
++#define MXT_T107_STYLUS_BUTTON0		BIT(2)
++#define MXT_T107_STYLUS_BUTTON1		BIT(3)
++
+ /* Delay times */
+ #define MXT_BACKUP_TIME		50	/* msec */
++#define MXT_RESET_GPIO_TIME	20	/* msec */
++#define MXT_RESET_INVALID_CHG	100	/* msec */
+ #define MXT_RESET_TIME		200	/* msec */
+ #define MXT_RESET_TIMEOUT	3000	/* msec */
+ #define MXT_CRC_TIMEOUT		1000	/* msec */
++#define MXT_FW_FLASH_TIME	1000	/* msec */
+ #define MXT_FW_RESET_TIME	3000	/* msec */
+ #define MXT_FW_CHG_TIMEOUT	300	/* msec */
++#define MXT_BOOTLOADER_WAIT	3000	/* msec */
+ 
+ /* Command to unlock bootloader */
+ #define MXT_UNLOCK_CMD_MSB	0xaa
+@@ -180,14 +264,16 @@ enum t100_type {
+ #define MXT_FRAME_CRC_PASS	0x04
+ #define MXT_APP_CRC_FAIL	0x40	/* valid 7 8 bit only */
+ #define MXT_BOOT_STATUS_MASK	0x3f
+-#define MXT_BOOT_EXTENDED_ID	(1 << 5)
++#define MXT_BOOT_EXTENDED_ID	BIT(5)
+ #define MXT_BOOT_ID_MASK	0x1f
+ 
+ /* Touchscreen absolute values */
+ #define MXT_MAX_AREA		0xff
+-
+ #define MXT_PIXELS_PER_MM	20
+ 
++/* Debug message size max */
++#define DEBUG_MSG_MAX		200
++
+ struct mxt_info {
+ 	u8 family_id;
+ 	u8 variant_id;
+@@ -206,26 +292,84 @@ struct mxt_object {
+ 	u8 num_report_ids;
+ } __packed;
+ 
++struct mxt_dbg {
++	u16 t37_address;
++	u16 diag_cmd_address;
++	struct t37_debug *t37_buf;
++	unsigned int t37_pages;
++	unsigned int t37_nodes;
++
++	struct v4l2_device v4l2;
++	struct v4l2_pix_format format;
++	struct video_device vdev;
++	struct vb2_queue queue;
++	struct mutex lock;
++	int input;
++};
++
++enum v4l_dbg_inputs {
++	MXT_V4L_INPUT_DELTAS,
++	MXT_V4L_INPUT_REFS,
++	MXT_V4L_INPUT_MAX,
++};
++
++static const struct v4l2_file_operations mxt_video_fops = {
++	.owner = THIS_MODULE,
++	.open = v4l2_fh_open,
++	.release = vb2_fop_release,
++	.unlocked_ioctl = video_ioctl2,
++	.read = vb2_fop_read,
++	.mmap = vb2_fop_mmap,
++	.poll = vb2_fop_poll,
++};
++
++enum mxt_suspend_mode {
++	MXT_SUSPEND_DEEP_SLEEP	= 0,
++	MXT_SUSPEND_T9_CTRL	= 1,
++};
++
++/* Config update context */
++struct mxt_cfg {
++	u8 *raw;
++	size_t raw_size;
++	off_t raw_pos;
++
++	u8 *mem;
++	size_t mem_size;
++	int start_ofs;
++
++	struct mxt_info info;
++};
++
+ /* Each client has this additional data */
+ struct mxt_data {
+ 	struct i2c_client *client;
+ 	struct input_dev *input_dev;
++	struct input_dev *input_dev_sec;
+ 	char phys[64];		/* device physical location */
+-	const struct mxt_platform_data *pdata;
+ 	struct mxt_object *object_table;
+-	struct mxt_info info;
++	struct mxt_info *info;
++	void *raw_info_block;
+ 	unsigned int irq;
+ 	unsigned int max_x;
+ 	unsigned int max_y;
+-	bool invert_x;
+-	bool invert_y;
+-	bool swap_x_y;
++	bool invertx;
++	bool inverty;
+ 	bool xy_switch;
++	u8 xsize;
++	u8 ysize;
+ 	bool in_bootloader;
+ 	u16 mem_size;
+ 	u8 t100_aux_ampl;
+ 	u8 t100_aux_area;
+ 	u8 t100_aux_vect;
++	struct bin_attribute mem_access_attr;
++	bool debug_enabled;
++	bool debug_v2_enabled;
++	u8 *debug_msg_data;
++	u16 debug_msg_count;
++	struct bin_attribute debug_msg_attr;
++	struct mutex debug_msg_lock;
+ 	u8 max_reportid;
+ 	u32 config_crc;
+ 	u32 info_crc;
+@@ -233,10 +377,16 @@ struct mxt_data {
+ 	u8 *msg_buf;
+ 	u8 t6_status;
+ 	bool update_input;
++	bool update_input_sec;
+ 	u8 last_message_count;
+ 	u8 num_touchids;
+ 	u8 multitouch;
+ 	struct t7_config t7_cfg;
++	unsigned long t15_keystatus;
++	u8 stylus_aux_pressure;
++	u8 stylus_aux_peak;
++	struct mxt_dbg dbg;
++	struct gpio_desc *reset_gpio;
+ 
+ 	/* Cached parameters from object table */
+ 	u16 T5_address;
+@@ -244,12 +394,52 @@ struct mxt_data {
+ 	u8 T6_reportid;
+ 	u16 T6_address;
+ 	u16 T7_address;
++	u16 T14_address;
++	u16 T71_address;
+ 	u8 T9_reportid_min;
+ 	u8 T9_reportid_max;
+-	u8 T19_reportid;
++	u8 T15_reportid_min;
++	u8 T15_reportid_max;
++	u16 T18_address;
++	u8 T19_reportid_min;
++	u8 T24_reportid_min;
++	u8 T24_reportid_max;
++	u8 T25_reportid_min;
++	u8 T27_reportid_min;
++	u8 T27_reportid_max;
++	u8 T42_reportid_min;
++	u8 T42_reportid_max;
+ 	u16 T44_address;
++	u8 T46_reportid_min;	
++	u8 T48_reportid_min;
++	u8 T56_reportid_min;
++	u8 T61_reportid_min;
++	u8 T61_reportid_max;
++	u8 T65_reportid_min;
++	u8 T65_reportid_max;
++	u8 T68_reportid_min;
++	u8 T70_reportid_min;
++	u8 T70_reportid_max;
++	u8 T72_reportid_min;
++	u8 T80_reportid_min;
++	u8 T80_reportid_max;
++	u16 T92_address;
++	u8 T92_reportid_min;
++	u16 T93_address;
++	u8 T93_reportid_min;
+ 	u8 T100_reportid_min;
+ 	u8 T100_reportid_max;
++	u16 T107_address;
++	u8 T108_reportid_min;
++	u8 T109_reportid_min;
++	u8 T112_reportid_min;
++	u8 T112_reportid_max;
++	u8 T129_reportid_min;
++	u8 T133_reportid_min;
++	
++	/* Cached instance parameter */
++	u8 T100_instances;
++	u8 T15_instances;
+ 
+ 	/* for fw update in bootloader */
+ 	struct completion bl_completion;
+@@ -259,23 +449,24 @@ struct mxt_data {
+ 
+ 	/* for config update handling */
+ 	struct completion crc_completion;
+-};
+ 
+-static void mxt_apply_prop_to_x_y(const struct mxt_data *data,
+-                             int *x, int *y)
+-{
+-        if (data->invert_x)
+-                *x = data->max_x - *x;
++	u32 *t19_keymap;
++	unsigned int t19_num_keys;
+ 
+-        if (data->invert_y)
+-                *y = data->max_y - *y;
++	u32 *t15_keymap;
++	unsigned int t15_num_keys;
+ 
+-        if (data->swap_x_y)
+-                swap(*x, *y);
+-}
++	enum mxt_suspend_mode suspend_mode;
+ 
++	/* Indicates whether device is updating configuration */
++	bool sysfs_updating_config;
+ 
++};
+ 
++struct mxt_vb2_buffer {
++	struct vb2_buffer	vb;
++	struct list_head	list;
++};
+ 
+ static size_t mxt_obj_size(const struct mxt_object *obj)
+ {
+@@ -298,6 +489,7 @@ static bool mxt_object_readable(unsigned int type)
+ 	case MXT_TOUCH_KEYARRAY_T15:
+ 	case MXT_TOUCH_PROXIMITY_T23:
+ 	case MXT_TOUCH_PROXKEY_T52:
++	case MXT_TOUCH_MULTITOUCHSCREEN_T100:
+ 	case MXT_PROCI_GRIPFACE_T20:
+ 	case MXT_PROCG_NOISE_T22:
+ 	case MXT_PROCI_ONETOUCH_T24:
+@@ -314,6 +506,16 @@ static bool mxt_object_readable(unsigned int type)
+ 	case MXT_SPT_USERDATA_T38:
+ 	case MXT_SPT_DIGITIZER_T43:
+ 	case MXT_SPT_CTECONFIG_T46:
++	case MXT_PROCI_SHIELDLESS_T56:
++	case MXT_SPT_TIMER_T61:
++	case MXT_PROCI_LENSBENDING_T65:
++	case MXT_SPT_DYNAMICCONFIGURATIONCONTROLLER_T70:
++	case MXT_SPT_DYNAMICCONFIGURATIONCONTAINER_T71:
++	case MXT_NOISESUPPRESSION_T72:
++	case MXT_PROCI_GLOVEDETECTION_T78:
++	case MXT_SPT_TOUCHEVENTTRIGGER_T79:
++	case MXT_PROCI_RETRANSMISSIONCOMPENSATION_T80:
++
+ 		return true;
+ 	default:
+ 		return false;
+@@ -326,6 +528,136 @@ static void mxt_dump_message(struct mxt_data *data, u8 *message)
+ 		data->T5_msg_size, message);
+ }
+ 
++static void mxt_debug_msg_enable(struct mxt_data *data)
++{
++	struct device *dev = &data->client->dev;
++
++	if (data->debug_v2_enabled)
++		return;
++
++	mutex_lock(&data->debug_msg_lock);
++
++	data->debug_msg_data = kcalloc(DEBUG_MSG_MAX,
++				data->T5_msg_size, GFP_KERNEL);
++	if (!data->debug_msg_data)
++		return;
++
++	data->debug_v2_enabled = true;
++	mutex_unlock(&data->debug_msg_lock);
++
++	dev_dbg(dev, "Enabled message output\n");
++}
++
++static void mxt_debug_msg_disable(struct mxt_data *data)
++{
++	struct device *dev = &data->client->dev;
++
++	if (!data->debug_v2_enabled)
++		return;
++
++	data->debug_v2_enabled = false;
++
++	mutex_lock(&data->debug_msg_lock);
++	kfree(data->debug_msg_data);
++	data->debug_msg_data = NULL;
++	data->debug_msg_count = 0;
++	mutex_unlock(&data->debug_msg_lock);
++	dev_dbg(dev, "Disabled message output\n");
++}
++
++static void mxt_debug_msg_add(struct mxt_data *data, u8 *msg)
++{
++	struct device *dev = &data->client->dev;
++
++	mutex_lock(&data->debug_msg_lock);
++
++	if (!data->debug_msg_data) {
++		dev_err(dev, "No buffer!\n");
++		return;
++	}
++
++	if (data->debug_msg_count < DEBUG_MSG_MAX) {
++		memcpy(data->debug_msg_data +
++		       data->debug_msg_count * data->T5_msg_size,
++		       msg,
++		       data->T5_msg_size);
++		data->debug_msg_count++;
++	} else {
++		dev_dbg(dev, "Discarding %u messages\n", data->debug_msg_count);
++		data->debug_msg_count = 0;
++	}
++
++	mutex_unlock(&data->debug_msg_lock);
++
++	sysfs_notify(&data->client->dev.kobj, NULL, "debug_notify");
++}
++
++static ssize_t mxt_debug_msg_write(struct file *filp, struct kobject *kobj,
++	struct bin_attribute *bin_attr, char *buf, loff_t off,
++	size_t count)
++{
++	return -EIO;
++}
++
++static ssize_t mxt_debug_msg_read(struct file *filp, struct kobject *kobj,
++	struct bin_attribute *bin_attr, char *buf, loff_t off, size_t bytes)
++{
++	struct device *dev = container_of(kobj, struct device, kobj);
++	struct mxt_data *data = dev_get_drvdata(dev);
++	int count;
++	size_t bytes_read;
++
++	if (!data->debug_msg_data) {
++		dev_err(dev, "No buffer!\n");
++		return 0;
++	}
++
++	count = bytes / data->T5_msg_size;
++
++	if (count > DEBUG_MSG_MAX)
++		count = DEBUG_MSG_MAX;
++
++	mutex_lock(&data->debug_msg_lock);
++
++	if (count > data->debug_msg_count)
++		count = data->debug_msg_count;
++
++	bytes_read = count * data->T5_msg_size;
++
++	memcpy(buf, data->debug_msg_data, bytes_read);
++	data->debug_msg_count = 0;
++
++	mutex_unlock(&data->debug_msg_lock);
++
++	return bytes_read;
++}
++
++static int mxt_debug_msg_init(struct mxt_data *data)
++{
++	sysfs_bin_attr_init(&data->debug_msg_attr);
++	data->debug_msg_attr.attr.name = "debug_msg";
++	data->debug_msg_attr.attr.mode = 0666;
++	data->debug_msg_attr.read = mxt_debug_msg_read;
++	data->debug_msg_attr.write = mxt_debug_msg_write;
++	data->debug_msg_attr.size = data->T5_msg_size * DEBUG_MSG_MAX;
++
++	if (sysfs_create_bin_file(&data->client->dev.kobj,
++				  &data->debug_msg_attr) < 0) {
++		dev_err(&data->client->dev, "Failed to create %s\n",
++			data->debug_msg_attr.attr.name);
++		return -EINVAL;
++	}
++
++	return 0;
++}
++
++static void mxt_debug_msg_remove(struct mxt_data *data)
++{
++	if (data->debug_msg_attr.attr.name)
++		sysfs_remove_bin_file(&data->client->dev.kobj,
++				      &data->debug_msg_attr);
++}
++
+ static int mxt_wait_for_completion(struct mxt_data *data,
+ 				   struct completion *comp,
+ 				   unsigned int timeout_ms)
+@@ -373,13 +705,21 @@ static int mxt_bootloader_write(struct mxt_data *data,
+ {
+ 	int ret;
+ 	struct i2c_msg msg;
++	u8 *data_buf;
++
++	data_buf = kmalloc(count, GFP_KERNEL);
++	if (!data_buf)
++		return -ENOMEM;
++	
++	memcpy(&data_buf[0], val, count);
+ 
+ 	msg.addr = data->bootloader_addr;
+ 	msg.flags = data->client->flags & I2C_M_TEN;
+ 	msg.len = count;
+-	msg.buf = (u8 *)val;
++	msg.buf = data_buf;
+ 
+ 	ret = i2c_transfer(data->client->adapter, &msg, 1);
++
+ 	if (ret == 1) {
+ 		ret = 0;
+ 	} else {
+@@ -395,12 +735,13 @@ static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
+ {
+ 	u8 appmode = data->client->addr;
+ 	u8 bootloader;
++	u8 family_id = data->info ? data->info->family_id : 0;
+ 
+ 	switch (appmode) {
+ 	case 0x4a:
+ 	case 0x4b:
+ 		/* Chips after 1664S use different scheme */
+-		if (retry || data->info.family_id >= 0xa2) {
++		if (retry || family_id >= 0xa2) {
+ 			bootloader = appmode - 0x24;
+ 			break;
+ 		}
+@@ -420,6 +761,9 @@ static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
+ 	}
+ 
+ 	data->bootloader_addr = bootloader;
++
++	dev_info(&data->client->dev, "Bootloader address: %x\n", bootloader);
++
+ 	return 0;
+ }
+ 
+@@ -621,13 +965,12 @@ static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
+ 	return __mxt_write_reg(client, reg, 1, &val);
+ }
+ 
+-static struct mxt_object *
+-mxt_get_object(struct mxt_data *data, u8 type)
++static struct mxt_object *mxt_get_object(struct mxt_data *data, u8 type)
+ {
+ 	struct mxt_object *object;
+ 	int i;
+ 
+-	for (i = 0; i < data->info.object_num; i++) {
++	for (i = 0; i < data->info->object_num; i++) {
+ 		object = data->object_table + i;
+ 		if (object->type == type)
+ 			return object;
+@@ -643,13 +986,13 @@ static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
+ 	u8 status = msg[1];
+ 	u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16);
+ 
+-	complete(&data->crc_completion);
+-
+ 	if (crc != data->config_crc) {
+ 		data->config_crc = crc;
+ 		dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc);
+ 	}
+ 
++	complete(&data->crc_completion);
++
+ 	/* Detect reset */
+ 	if (status & MXT_T6_STATUS_RESET)
+ 		complete(&data->reset_completion);
+@@ -687,15 +1030,14 @@ static int mxt_write_object(struct mxt_data *data,
+ static void mxt_input_button(struct mxt_data *data, u8 *message)
+ {
+ 	struct input_dev *input = data->input_dev;
+-	const struct mxt_platform_data *pdata = data->pdata;
+ 	int i;
+ 
+-	for (i = 0; i < pdata->t19_num_keys; i++) {
+-		if (pdata->t19_keymap[i] == KEY_RESERVED)
++	for (i = 0; i < data->t19_num_keys; i++) {
++		if (data->t19_keymap[i] == KEY_RESERVED)
+ 			continue;
+ 
+ 		/* Active-low switch */
+-		input_report_key(input, pdata->t19_keymap[i],
++		input_report_key(input, data->t19_keymap[i],
+ 				 !(message[1] & BIT(i)));
+ 	}
+ }
+@@ -703,8 +1045,14 @@ static void mxt_input_button(struct mxt_data *data, u8 *message)
+ static void mxt_input_sync(struct mxt_data *data)
+ {
+ 	input_mt_report_pointer_emulation(data->input_dev,
+-					  data->pdata->t19_num_keys);
+-	input_sync(data->input_dev);
++					  data->t19_num_keys);
++	
++	if (data->update_input) 
++		input_sync(data->input_dev);
++	
++	if (data->update_input_sec)
++		input_sync(data->input_dev_sec);
++	
+ }
+ 
+ static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
+@@ -717,6 +1065,7 @@ static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
+ 	int y;
+ 	int area;
+ 	int amplitude;
++	int tool;
+ 
+ 	id = message[0] - data->T9_reportid_min;
+ 	status = message[1];
+@@ -759,10 +1108,20 @@ static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
+ 			mxt_input_sync(data);
+ 		}
+ 
++		/* A size of zero indicates touch is from a linked T47 Stylus */
++		if (area == 0) {
++			area = MXT_TOUCH_MAJOR_DEFAULT;
++			tool = MT_TOOL_PEN;
++		} else {
++			tool = MT_TOOL_FINGER;
++		}
++
++		/* if active, pressure must be non-zero */
++		if (!amplitude)
++			amplitude = MXT_PRESSURE_DEFAULT;
++
+ 		/* Touch active */
+-		input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
+-		mxt_apply_prop_to_x_y(data, &x, &y);
+-		
++		input_mt_report_slot_state(input_dev, tool, 1);
+ 		input_report_abs(input_dev, ABS_MT_POSITION_X, x);
+ 		input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
+ 		input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
+@@ -779,27 +1138,38 @@ static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
+ {
+ 	struct device *dev = &data->client->dev;
+ 	struct input_dev *input_dev = data->input_dev;
+-	int id;
++	struct input_dev *input_dev_sec = data->input_dev_sec;
++	int id = 0;
++	int id_sec = 0;
+ 	u8 status;
+ 	u8 type = 0;
+-	/*u16*/ int x;
+-	/*u16*/ int y;
++	u16 x;
++	u16 y;
+ 	int distance = 0;
+ 	int tool = 0;
+ 	u8 major = 0;
+ 	u8 pressure = 0;
+ 	u8 orientation = 0;
++	bool hover = false;
++	
++	/* Determine id of touch messages only */
++	id = (message[0] - data->T100_reportid_min - MXT_RSVD_RPTIDS);
++	
++	if (id >= MXT_MIN_RPTID_SEC) {
++		id_sec = (message[0] - data->T100_reportid_min - MXT_MIN_RPTID_SEC - 
++			MXT_RSVD_RPTIDS);
++	}
+ 
+-	id = message[0] - data->T100_reportid_min - 2;
+-
+-	/* ignore SCRSTATUS events */
+-	if (id < 0)
++	/* Skip SCRSTATUS events */
++	if (id < 0 || id_sec < 0)
+ 		return;
+ 
+ 	status = message[1];
+ 	x = get_unaligned_le16(&message[2]);
+ 	y = get_unaligned_le16(&message[4]);
+-
++	
++	/* Get other auxdata[] bytes if present */
++	
+ 	if (status & MXT_T100_DETECT) {
+ 		type = (status & MXT_T100_TYPE_MASK) >> 4;
+ 
+@@ -807,6 +1177,7 @@ static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
+ 		case MXT_T100_TYPE_HOVERING_FINGER:
+ 			tool = MT_TOOL_FINGER;
+ 			distance = MXT_DISTANCE_HOVERING;
++			hover = true;
+ 
+ 			if (data->t100_aux_vect)
+ 				orientation = message[data->t100_aux_vect];
+@@ -817,6 +1188,7 @@ static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
+ 		case MXT_T100_TYPE_GLOVE:
+ 			tool = MT_TOOL_FINGER;
+ 			distance = MXT_DISTANCE_ACTIVE_TOUCH;
++			hover = false;
+ 
+ 			if (data->t100_aux_area)
+ 				major = message[data->t100_aux_area];
+@@ -831,6 +1203,8 @@ static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
+ 
+ 		case MXT_T100_TYPE_PASSIVE_STYLUS:
+ 			tool = MT_TOOL_PEN;
++			distance = MXT_DISTANCE_ACTIVE_TOUCH;
++			hover = false;
+ 
+ 			/*
+ 			 * Passive stylus is reported with size zero so
+@@ -843,6 +1217,30 @@ static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
+ 
+ 			break;
+ 
++		case MXT_T100_TYPE_ACTIVE_STYLUS:
++			/* Report input buttons */
++			input_report_key(input_dev, BTN_STYLUS,
++					 message[6] & MXT_T107_STYLUS_BUTTON0);
++			input_report_key(input_dev, BTN_STYLUS2,
++					 message[6] & MXT_T107_STYLUS_BUTTON1);
++
++			/* stylus in range, but position unavailable */
++			if (!(message[6] & MXT_T107_STYLUS_HOVER))
++				break;
++
++			tool = MT_TOOL_PEN;
++			distance = MXT_DISTANCE_ACTIVE_TOUCH;
++			major = MXT_TOUCH_MAJOR_DEFAULT;
++
++			if (!(message[6] & MXT_T107_STYLUS_TIPSWITCH)) {
++				hover = true;
++				distance = MXT_DISTANCE_HOVERING;
++			} else if (data->stylus_aux_pressure) {
++				pressure = message[data->stylus_aux_pressure];
++			}
++
++			break;
++
+ 		case MXT_T100_TYPE_LARGE_TOUCH:
+ 			/* Ignore suppressed touch */
+ 			break;
+@@ -857,42 +1255,169 @@ static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
+ 	 * Values reported should be non-zero if tool is touching the
+ 	 * device
+ 	 */
+-	if (!pressure && type != MXT_T100_TYPE_HOVERING_FINGER)
++	if (!pressure && !hover)
+ 		pressure = MXT_PRESSURE_DEFAULT;
+ 
+-	input_mt_slot(input_dev, id);
+-
++	if (id >= MXT_MIN_RPTID_SEC) {
++		input_mt_slot(input_dev_sec, id_sec);
++	} else {
++		input_mt_slot(input_dev, id);
++	}
++		
+ 	if (status & MXT_T100_DETECT) {
+-		dev_dbg(dev, "[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
++		
++		if (id >= MXT_MIN_RPTID_SEC) {
++			dev_dbg(dev, "id:[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
++			id_sec, type, x, y, major, pressure, orientation);
++		} else {
++			dev_dbg(dev, "id:[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
+ 			id, type, x, y, major, pressure, orientation);
++		}
++		
++		if (id >= MXT_MIN_RPTID_SEC) {	
++			input_mt_report_slot_state(input_dev_sec, tool, 1);
++		  	input_report_abs(input_dev_sec, ABS_MT_POSITION_X, x);
++		  	input_report_abs(input_dev_sec, ABS_MT_POSITION_Y, y);
++		  	input_report_abs(input_dev_sec, ABS_MT_TOUCH_MAJOR, major);
++		  	input_report_abs(input_dev_sec, ABS_MT_PRESSURE, pressure);
++		  	input_report_abs(input_dev_sec, ABS_MT_DISTANCE, distance);
++		  	input_report_abs(input_dev_sec, ABS_MT_ORIENTATION, orientation);
++			
++			if (id == MXT_MIN_RPTID_SEC) {
++				input_report_abs(input_dev_sec, ABS_X, x);
++				input_report_abs(input_dev_sec, ABS_Y, y);
++				input_report_key(input_dev_sec, BTN_TOUCH, 1);
++			}
++		} else {
++		  	input_mt_report_slot_state(input_dev, tool, 1);
++		  	input_report_abs(input_dev, ABS_MT_POSITION_X, x);
++		  	input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
++		  	input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, major);
++		  	input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
++		  	input_report_abs(input_dev, ABS_MT_DISTANCE, distance);
++		  	input_report_abs(input_dev, ABS_MT_ORIENTATION, orientation);
++		}
++	} else {
++		 
++		if (id >= MXT_MIN_RPTID_SEC){
++			dev_dbg(dev, "[%u] release\n", id_sec);
+ 
+-		input_mt_report_slot_state(input_dev, tool, 1);
+-		mxt_apply_prop_to_x_y(data, &x, &y);
+-		input_report_abs(input_dev, ABS_MT_POSITION_X, x);
+-		input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
+-		input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, major);
+-		input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
+-		input_report_abs(input_dev, ABS_MT_DISTANCE, distance);
+-		input_report_abs(input_dev, ABS_MT_ORIENTATION, orientation);
++			/* close out slot */
++			input_mt_report_slot_state(input_dev_sec, 0, 0);
++
++			/* Set BTN_TOUCH to 0 */
++			if (id == MXT_MIN_RPTID_SEC)
++				input_report_key(input_dev_sec, BTN_TOUCH, 0);
++
++		} else {
++			dev_dbg(dev, "[%u] release\n", id);
++
++			/* close out slot */
++		  	input_mt_report_slot_state(input_dev, 0, 0);
++		}
++	}
++	
++	if (id >= MXT_MIN_RPTID_SEC) {
++		data->update_input_sec = true;
+ 	} else {
+-		dev_dbg(dev, "[%u] release\n", id);
++		data->update_input = true;
++	}
++}
+ 
+-		/* close out slot */
+-		input_mt_report_slot_state(input_dev, 0, 0);
++static void mxt_proc_t15_messages(struct mxt_data *data, u8 *msg)
++{
++	struct input_dev *input_dev = data->input_dev;
++	struct device *dev = &data->client->dev;
++	int key;
++	bool curr_state, new_state;
++	bool sync = false;
++	unsigned long keystates = le32_to_cpu(msg[2]);
++
++	for (key = 0; key < data->t15_num_keys; key++) {
++		curr_state = test_bit(key, &data->t15_keystatus);
++		new_state = test_bit(key, &keystates);
++
++		if (!curr_state && new_state) {
++			dev_dbg(dev, "T15 key press: %u\n", key);
++			__set_bit(key, &data->t15_keystatus);
++			input_event(input_dev, EV_KEY,
++				    data->t15_keymap[key], 1);
++			sync = true;
++		} else if (curr_state && !new_state) {
++			dev_dbg(dev, "T15 key release: %u\n", key);
++			__clear_bit(key, &data->t15_keystatus);
++			input_event(input_dev, EV_KEY,
++				    data->t15_keymap[key], 0);
++			sync = true;
++		}
+ 	}
+ 
+-	data->update_input = true;
++	if (sync)
++		input_sync(input_dev);
++}
++
++static void mxt_proc_t42_messages(struct mxt_data *data, u8 *msg)
++{
++	struct device *dev = &data->client->dev;
++	u8 status = msg[1];
++
++	if (status & MXT_T42_MSG_TCHSUP)
++		dev_info(dev, "T42 suppress\n");
++	else
++		dev_info(dev, "T42 normal\n");
++}
++
++static int mxt_proc_t48_messages(struct mxt_data *data, u8 *msg)
++{
++	struct device *dev = &data->client->dev;
++	u8 status, state;
++
++	status = msg[1];
++	state  = msg[4];
++
++	dev_dbg(dev, "T48 state %d status %02X %s%s%s%s%s\n", state, status,
++		status & 0x01 ? "FREQCHG " : "",
++		status & 0x02 ? "APXCHG " : "",
++		status & 0x04 ? "ALGOERR " : "",
++		status & 0x10 ? "STATCHG " : "",
++		status & 0x20 ? "NLVLCHG " : "");
++
++	return 0;
++}
++
++static void mxt_proc_t92_messages(struct mxt_data *data, u8 *msg)
++{
++	struct device *dev = &data->client->dev;
++	u8 status = msg[1];
++
++	dev_info(dev, "T92 long stroke LSTR=%d %d\n",
++		 (status & 0x80) ? 1 : 0,
++		 status & 0x0F);
++}
++
++static void mxt_proc_t93_messages(struct mxt_data *data, u8 *msg)
++{
++	struct device *dev = &data->client->dev;
++	u8 status = msg[1];
++
++	dev_info(dev, "T93 report double tap %d\n", status);
+ }
+ 
+ static int mxt_proc_message(struct mxt_data *data, u8 *message)
+ {
+ 	u8 report_id = message[0];
++	bool dump = data->debug_enabled;
+ 
+ 	if (report_id == MXT_RPTID_NOMSG)
+ 		return 0;
+ 
+ 	if (report_id == data->T6_reportid) {
+ 		mxt_proc_t6_messages(data, message);
++	} else if (report_id >= data->T42_reportid_min
++		   && report_id <= data->T42_reportid_max) {
++		mxt_proc_t42_messages(data, message);
++	} else if (report_id == data->T48_reportid_min) {
++		mxt_proc_t48_messages(data, message);
+ 	} else if (!data->input_dev) {
+ 		/*
+ 		 * Do not report events if input device
+@@ -905,13 +1430,26 @@ static int mxt_proc_message(struct mxt_data *data, u8 *message)
+ 	} else if (report_id >= data->T100_reportid_min &&
+ 		   report_id <= data->T100_reportid_max) {
+ 		mxt_proc_t100_message(data, message);
+-	} else if (report_id == data->T19_reportid) {
++	} else if (report_id == data->T19_reportid_min) {
+ 		mxt_input_button(data, message);
+ 		data->update_input = true;
++	} else if (report_id >= data->T15_reportid_min
++		   && report_id <= data->T15_reportid_max) {
++		mxt_proc_t15_messages(data, message);
++	} else if (report_id == data->T92_reportid_min) {
++		mxt_proc_t92_messages(data, message);
++	} else if (report_id == data->T93_reportid_min) {
++		mxt_proc_t93_messages(data, message);
+ 	} else {
+ 		mxt_dump_message(data, message);
+ 	}
+ 
++	if (dump)
++		mxt_dump_message(data, message);
++
++	if (data->debug_v2_enabled)
++		mxt_debug_msg_add(data, message);
++
+ 	return 1;
+ }
+ 
+@@ -993,9 +1531,14 @@ static irqreturn_t mxt_process_messages_t44(struct mxt_data *data)
+ 	}
+ 
+ end:
+-	if (data->update_input) {
++	if (data->update_input || data->update_input_sec) {
+ 		mxt_input_sync(data);
+-		data->update_input = false;
++		
++		if (data->update_input)
++			data->update_input = false;
++		
++		if (data->update_input_sec)
++			data->update_input_sec = false;
+ 	}
+ 
+ 	return IRQ_HANDLED;
+@@ -1016,9 +1559,14 @@ static int mxt_process_messages_until_invalid(struct mxt_data *data)
+ 			return 0;
+ 	} while (--tries);
+ 
+-	if (data->update_input) {
++	if (data->update_input || data->update_input_sec ) {
+ 		mxt_input_sync(data);
+-		data->update_input = false;
++		
++		if(data->update_input)
++			data->update_input = false;
++		
++		if(data->update_input_sec)
++			data->update_input_sec = false;
+ 	}
+ 
+ 	dev_err(dev, "CHG pin isn't cleared\n");
+@@ -1056,9 +1604,14 @@ static irqreturn_t mxt_process_messages(struct mxt_data *data)
+ update_count:
+ 	data->last_message_count = total_handled;
+ 
+-	if (data->update_input) {
++	if (data->update_input || data->update_input_sec) {
+ 		mxt_input_sync(data);
+-		data->update_input = false;
++		
++		if(data->update_input)
++			data->update_input = false;
++		
++		if(data->update_input_sec)
++			data->update_input_sec = false;
+ 	}
+ 
+ 	return IRQ_HANDLED;
+@@ -1145,7 +1698,7 @@ static int mxt_soft_reset(struct mxt_data *data)
+ 		return ret;
+ 
+ 	/* Ignore CHG line for 100ms after reset */
+-	msleep(100);
++	msleep(MXT_RESET_INVALID_CHG);
+ 
+ 	mxt_acquire_irq(data);
+ 
+@@ -1214,12 +1767,7 @@ static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off)
+ 	return crc;
+ }
+ 
+-static int mxt_prepare_cfg_mem(struct mxt_data *data,
+-			       const struct firmware *cfg,
+-			       unsigned int data_pos,
+-			       unsigned int cfg_start_ofs,
+-			       u8 *config_mem,
+-			       size_t config_mem_size)
++static int mxt_prepare_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg)
+ {
+ 	struct device *dev = &data->client->dev;
+ 	struct mxt_object *object;
+@@ -1230,9 +1778,9 @@ static int mxt_prepare_cfg_mem(struct mxt_data *data,
+ 	u16 reg;
+ 	u8 val;
+ 
+-	while (data_pos < cfg->size) {
++	while (cfg->raw_pos < cfg->raw_size) {
+ 		/* Read type, instance, length */
+-		ret = sscanf(cfg->data + data_pos, "%x %x %x%n",
++		ret = sscanf(cfg->raw + cfg->raw_pos, "%x %x %x%n",
+ 			     &type, &instance, &size, &offset);
+ 		if (ret == 0) {
+ 			/* EOF */
+@@ -1241,20 +1789,20 @@ static int mxt_prepare_cfg_mem(struct mxt_data *data,
+ 			dev_err(dev, "Bad format: failed to parse object\n");
+ 			return -EINVAL;
+ 		}
+-		data_pos += offset;
++		cfg->raw_pos += offset;
+ 
+ 		object = mxt_get_object(data, type);
+ 		if (!object) {
+ 			/* Skip object */
+ 			for (i = 0; i < size; i++) {
+-				ret = sscanf(cfg->data + data_pos, "%hhx%n",
++				ret = sscanf(cfg->raw + cfg->raw_pos, "%hhx%n",
+ 					     &val, &offset);
+ 				if (ret != 1) {
+ 					dev_err(dev, "Bad format in T%d at %d\n",
+ 						type, i);
+ 					return -EINVAL;
+ 				}
+-				data_pos += offset;
++				cfg->raw_pos += offset;
+ 			}
+ 			continue;
+ 		}
+@@ -1289,7 +1837,7 @@ static int mxt_prepare_cfg_mem(struct mxt_data *data,
+ 		reg = object->start_address + mxt_obj_size(object) * instance;
+ 
+ 		for (i = 0; i < size; i++) {
+-			ret = sscanf(cfg->data + data_pos, "%hhx%n",
++			ret = sscanf(cfg->raw + cfg->raw_pos, "%hhx%n",
+ 				     &val,
+ 				     &offset);
+ 			if (ret != 1) {
+@@ -1297,15 +1845,15 @@ static int mxt_prepare_cfg_mem(struct mxt_data *data,
+ 					type, i);
+ 				return -EINVAL;
+ 			}
+-			data_pos += offset;
++			cfg->raw_pos += offset;
+ 
+ 			if (i > mxt_obj_size(object))
+ 				continue;
+ 
+-			byte_offset = reg + i - cfg_start_ofs;
++			byte_offset = reg + i - cfg->start_ofs;
+ 
+-			if (byte_offset >= 0 && byte_offset < config_mem_size) {
+-				*(config_mem + byte_offset) = val;
++			if (byte_offset >= 0 && byte_offset < cfg->mem_size) {
++				*(cfg->mem + byte_offset) = val;
+ 			} else {
+ 				dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
+ 					reg, object->type, byte_offset);
+@@ -1317,22 +1865,21 @@ static int mxt_prepare_cfg_mem(struct mxt_data *data,
+ 	return 0;
+ }
+ 
+-static int mxt_upload_cfg_mem(struct mxt_data *data, unsigned int cfg_start,
+-			      u8 *config_mem, size_t config_mem_size)
++static int mxt_upload_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg)
+ {
+ 	unsigned int byte_offset = 0;
+ 	int error;
+ 
+ 	/* Write configuration as blocks */
+-	while (byte_offset < config_mem_size) {
+-		unsigned int size = config_mem_size - byte_offset;
++	while (byte_offset < cfg->mem_size) {
++		unsigned int size = cfg->mem_size - byte_offset;
+ 
+ 		if (size > MXT_MAX_BLOCK_WRITE)
+ 			size = MXT_MAX_BLOCK_WRITE;
+ 
+ 		error = __mxt_write_reg(data->client,
+-					cfg_start + byte_offset,
+-					size, config_mem + byte_offset);
++					cfg->start_ofs + byte_offset,
++					size, cfg->mem + byte_offset);
+ 		if (error) {
+ 			dev_err(&data->client->dev,
+ 				"Config write error, ret=%d\n", error);
+@@ -1366,65 +1913,76 @@ static int mxt_init_t7_power_cfg(struct mxt_data *data);
+  *   <SIZE> - 2-byte object size as hex
+  *   <CONTENTS> - array of <SIZE> 1-byte hex values
+  */
+-static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
++static int mxt_update_cfg(struct mxt_data *data, const struct firmware *fw)
+ {
+ 	struct device *dev = &data->client->dev;
+-	struct mxt_info cfg_info;
++	struct mxt_cfg cfg;
+ 	int ret;
+ 	int offset;
+-	int data_pos;
+ 	int i;
+-	int cfg_start_ofs;
+ 	u32 info_crc, config_crc, calculated_crc;
+-	u8 *config_mem;
+-	size_t config_mem_size;
++	u16 crc_start = 0;
++
++	/* Make zero terminated copy of the OBP_RAW file */
++	cfg.raw = kmemdup(fw->data, fw->size + 1, GFP_KERNEL);
++	if (!cfg.raw)
++		return -ENOMEM;
++	cfg.raw[fw->size] = '\0';
++	
++	cfg.raw_size = fw->size;
+ 
+ 	mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
+ 
+-	if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
++	if (strncmp(cfg.raw, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
+ 		dev_err(dev, "Unrecognised config file\n");
+-		return -EINVAL;
++		ret = -EINVAL;
++		goto release_raw;
+ 	}
+ 
+-	data_pos = strlen(MXT_CFG_MAGIC);
++	cfg.raw_pos = strlen(MXT_CFG_MAGIC);
+ 
+ 	/* Load information block and check */
+ 	for (i = 0; i < sizeof(struct mxt_info); i++) {
+-		ret = sscanf(cfg->data + data_pos, "%hhx%n",
+-			     (unsigned char *)&cfg_info + i,
++		ret = sscanf(cfg.raw + cfg.raw_pos, "%hhx%n",
++			     (unsigned char *)&cfg.info + i,
+ 			     &offset);
+ 		if (ret != 1) {
+ 			dev_err(dev, "Bad format\n");
+-			return -EINVAL;
++			ret = -EINVAL;
++			goto release_raw;
+ 		}
+ 
+-		data_pos += offset;
++		cfg.raw_pos += offset;
+ 	}
+ 
+-	if (cfg_info.family_id != data->info.family_id) {
++	if (cfg.info.family_id != data->info->family_id) {
+ 		dev_err(dev, "Family ID mismatch!\n");
+-		return -EINVAL;
++		ret = -EINVAL;
++		goto release_raw;
+ 	}
+ 
+-	if (cfg_info.variant_id != data->info.variant_id) {
++	if (cfg.info.variant_id != data->info->variant_id) {
+ 		dev_err(dev, "Variant ID mismatch!\n");
+-		return -EINVAL;
++		ret = -EINVAL;
++		goto release_raw;
+ 	}
+ 
+ 	/* Read CRCs */
+-	ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset);
++	ret = sscanf(cfg.raw + cfg.raw_pos, "%x%n", &info_crc, &offset);
+ 	if (ret != 1) {
+ 		dev_err(dev, "Bad format: failed to parse Info CRC\n");
+-		return -EINVAL;
++		ret = -EINVAL;
++		goto release_raw;
+ 	}
+-	data_pos += offset;
++	cfg.raw_pos += offset;
+ 
+-	ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset);
++	ret = sscanf(cfg.raw + cfg.raw_pos, "%x%n", &config_crc, &offset);
+ 	if (ret != 1) {
+ 		dev_err(dev, "Bad format: failed to parse Config CRC\n");
+-		return -EINVAL;
++		ret = -EINVAL;
++		goto release_raw;
+ 	}
+-	data_pos += offset;
++	cfg.raw_pos += offset;
+ 
+ 	/*
+ 	 * The Info Block CRC is calculated over mxt_info and the object
+@@ -1436,7 +1994,7 @@ static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
+ 		if (config_crc == 0 || data->config_crc == 0) {
+ 			dev_info(dev, "CRC zero, attempting to apply config\n");
+ 		} else if (config_crc == data->config_crc) {
+-			dev_dbg(dev, "Config CRC 0x%06X: OK\n",
++			dev_info(dev, "Config CRC 0x%06X: OK. No update required.\n",
+ 				 data->config_crc);
+ 			return 0;
+ 		} else {
+@@ -1449,40 +2007,48 @@ static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
+ 			 data->info_crc, info_crc);
+ 	}
+ 
++	/* Stop T70 Dynamic Configuration before calculation of CRC */
++
++	mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_W_STOP);
++
+ 	/* Malloc memory to store configuration */
+-	cfg_start_ofs = MXT_OBJECT_START +
+-			data->info.object_num * sizeof(struct mxt_object) +
++	cfg.start_ofs = MXT_OBJECT_START +
++			data->info->object_num * sizeof(struct mxt_object) +
+ 			MXT_INFO_CHECKSUM_SIZE;
+-	config_mem_size = data->mem_size - cfg_start_ofs;
+-	config_mem = kzalloc(config_mem_size, GFP_KERNEL);
+-	if (!config_mem) {
+-		dev_err(dev, "Failed to allocate memory\n");
+-		return -ENOMEM;
++	cfg.mem_size = data->mem_size - cfg.start_ofs;
++	cfg.mem = kzalloc(cfg.mem_size, GFP_KERNEL);
++	if (!cfg.mem) {
++		ret = -ENOMEM;
++		goto release_raw;
+ 	}
+ 
+-	ret = mxt_prepare_cfg_mem(data, cfg, data_pos, cfg_start_ofs,
+-				  config_mem, config_mem_size);
++	ret = mxt_prepare_cfg_mem(data, &cfg);
+ 	if (ret)
+ 		goto release_mem;
+ 
++
+ 	/* Calculate crc of the received configs (not the raw config file) */
+-	if (data->T7_address < cfg_start_ofs) {
+-		dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n",
+-			data->T7_address, cfg_start_ofs);
+-		ret = 0;
+-		goto release_mem;
+-	}
++	
++	if (data->T14_address)
++		crc_start = data->T14_address;
++	else if (data->T71_address)
++		crc_start = data->T71_address;
++	else if (data->T7_address)
++		crc_start = data->T7_address;
++	else
++		dev_warn(dev, "Could not find CRC start\n");
+ 
+-	calculated_crc = mxt_calculate_crc(config_mem,
+-					   data->T7_address - cfg_start_ofs,
+-					   config_mem_size);
++	if (crc_start > cfg.start_ofs) {
++		calculated_crc = mxt_calculate_crc(cfg.mem,
++						   crc_start - cfg.start_ofs,
++						   cfg.mem_size);
+ 
+-	if (config_crc > 0 && config_crc != calculated_crc)
+-		dev_warn(dev, "Config CRC error, calculated=%06X, file=%06X\n",
+-			 calculated_crc, config_crc);
++		if (config_crc > 0 && config_crc != calculated_crc)
++			dev_warn(dev, "Config CRC in file inconsistent, calculated=%06X, file=%06X\n",
++				 calculated_crc, config_crc);
++	}
+ 
+-	ret = mxt_upload_cfg_mem(data, cfg_start_ofs,
+-				 config_mem, config_mem_size);
++	ret = mxt_upload_cfg_mem(data, &cfg);
+ 	if (ret)
+ 		goto release_mem;
+ 
+@@ -1497,25 +2063,13 @@ static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
+ 	/* T7 config may have changed */
+ 	mxt_init_t7_power_cfg(data);
+ 
++release_raw:
++	kfree(cfg.raw);
+ release_mem:
+-	kfree(config_mem);
++	kfree(cfg.mem);
+ 	return ret;
+ }
+ 
+-static int mxt_get_info(struct mxt_data *data)
+-{
+-	struct i2c_client *client = data->client;
+-	struct mxt_info *info = &data->info;
+-	int error;
+-
+-	/* Read 7-byte info block starting at address 0 */
+-	error = __mxt_read_reg(client, 0, sizeof(*info), info);
+-	if (error)
+-		return error;
+-
+-	return 0;
+-}
+-
+ static void mxt_free_input_device(struct mxt_data *data)
+ {
+ 	if (data->input_dev) {
+@@ -1526,60 +2080,65 @@ static void mxt_free_input_device(struct mxt_data *data)
+ 
+ static void mxt_free_object_table(struct mxt_data *data)
+ {
+-	kfree(data->object_table);
++#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
++	video_unregister_device(&data->dbg.vdev);
++	v4l2_device_unregister(&data->dbg.v4l2);
++#endif
+ 	data->object_table = NULL;
++	data->info = NULL;
++	kfree(data->raw_info_block);
++	data->raw_info_block = NULL;
+ 	kfree(data->msg_buf);
+ 	data->msg_buf = NULL;
+ 	data->T5_address = 0;
+ 	data->T5_msg_size = 0;
+ 	data->T6_reportid = 0;
+ 	data->T7_address = 0;
++	data->T14_address = 0;
++	data->T71_address = 0;
+ 	data->T9_reportid_min = 0;
+ 	data->T9_reportid_max = 0;
+-	data->T19_reportid = 0;
++	data->T15_reportid_min = 0;
++	data->T15_reportid_max = 0;
++	data->T18_address = 0;
++	data->T19_reportid_min = 0;
++	data->T42_reportid_min = 0;
++	data->T42_reportid_max = 0;
+ 	data->T44_address = 0;
++	data->T48_reportid_min = 0;
++	data->T92_reportid_min = 0;
++	data->T92_address = 0;
++	data->T93_reportid_min = 0;
++	data->T93_address = 0;
+ 	data->T100_reportid_min = 0;
+ 	data->T100_reportid_max = 0;
+ 	data->max_reportid = 0;
+ }
+ 
+-static int mxt_get_object_table(struct mxt_data *data)
++static int mxt_parse_object_table(struct mxt_data *data,
++				  struct mxt_object *object_table)
+ {
+ 	struct i2c_client *client = data->client;
+-	size_t table_size;
+-	struct mxt_object *object_table;
+-	int error;
+ 	int i;
+ 	u8 reportid;
+ 	u16 end_address;
+-
+-	table_size = data->info.object_num * sizeof(struct mxt_object);
+-	object_table = kzalloc(table_size, GFP_KERNEL);
+-	if (!object_table) {
+-		dev_err(&data->client->dev, "Failed to allocate memory\n");
+-		return -ENOMEM;
+-	}
+-
+-	error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
+-			object_table);
+-	if (error) {
+-		kfree(object_table);
+-		return error;
+-	}
++	u8 num_instances;
+ 
+ 	/* Valid Report IDs start counting from 1 */
+ 	reportid = 1;
+ 	data->mem_size = 0;
+-	for (i = 0; i < data->info.object_num; i++) {
++	for (i = 0; i < data->info->object_num; i++) {
+ 		struct mxt_object *object = object_table + i;
+ 		u8 min_id, max_id;
+ 
+ 		le16_to_cpus(&object->start_address);
+ 
++		num_instances = mxt_obj_instances(object);
++		
+ 		if (object->num_report_ids) {
+ 			min_id = reportid;
+ 			reportid += object->num_report_ids *
+-					mxt_obj_instances(object);
++					num_instances;
+ 			max_id = reportid - 1;
+ 		} else {
+ 			min_id = 0;
+@@ -1594,8 +2153,8 @@ static int mxt_get_object_table(struct mxt_data *data)
+ 
+ 		switch (object->type) {
+ 		case MXT_GEN_MESSAGE_T5:
+-			if (data->info.family_id == 0x80 &&
+-			    data->info.version < 0x20) {
++			if (data->info->family_id == 0x80 &&
++			    data->info->version < 0x20) {
+ 				/*
+ 				 * On mXT224 firmware versions prior to V2.0
+ 				 * read and discard unused CRC byte otherwise
+@@ -1615,25 +2174,114 @@ static int mxt_get_object_table(struct mxt_data *data)
+ 		case MXT_GEN_POWER_T7:
+ 			data->T7_address = object->start_address;
+ 			break;
++		case MXT_PROCI_KEYTHRESHOLD_T14:
++			data->T14_address = object->start_address;
++			break;
++		case MXT_SPT_DYNAMICCONFIGURATIONCONTAINER_T71:
++			data->T71_address = object->start_address;
++			break;
+ 		case MXT_TOUCH_MULTI_T9:
+ 			data->multitouch = MXT_TOUCH_MULTI_T9;
++			/* Only handle messages from first T9 instance */
+ 			data->T9_reportid_min = min_id;
+-			data->T9_reportid_max = max_id;
+-			data->num_touchids = object->num_report_ids
+-						* mxt_obj_instances(object);
++			data->T9_reportid_max = min_id +
++						object->num_report_ids - 1;
++			data->num_touchids = object->num_report_ids;
++			break;
++		case MXT_TOUCH_KEYARRAY_T15:
++			data->T15_reportid_min = min_id;
++			data->T15_reportid_max = max_id;
++			data->T15_instances = num_instances;
++			break;
++		case MXT_SPT_COMMSCONFIG_T18:
++			data->T18_address = object->start_address;
++			break;
++		case MXT_SPT_GPIOPWM_T19:
++			data->T19_reportid_min = min_id;
++			break;
++		case MXT_PROCI_ONETOUCH_T24:
++			data->T24_reportid_min = min_id;
++			data->T24_reportid_max = max_id;
++			break;
++		case MXT_SPT_SELFTEST_T25:
++			data->T25_reportid_min = min_id;
++			break;
++		case MXT_PROCI_TWOTOUCH_T27:
++			data->T27_reportid_min = min_id;
++			data->T27_reportid_max = max_id;
++			break;
++		case MXT_PROCI_TOUCHSUPPRESSION_T42:
++			data->T42_reportid_min = min_id;
++			data->T42_reportid_max = max_id;
+ 			break;
+ 		case MXT_SPT_MESSAGECOUNT_T44:
+ 			data->T44_address = object->start_address;
+ 			break;
+-		case MXT_SPT_GPIOPWM_T19:
+-			data->T19_reportid = min_id;
++		case MXT_SPT_CTECONFIG_T46:
++			data->T46_reportid_min = min_id;
++			break;
++		case MXT_PROCG_NOISESUPPRESSION_T48:
++			data->T48_reportid_min = min_id;
++			break;
++		case MXT_PROCI_SHIELDLESS_T56:
++			data->T56_reportid_min = min_id;
++			break;
++		case MXT_SPT_TIMER_T61:
++			data->T61_reportid_min = min_id;
++			data->T61_reportid_max = max_id;
++			break;
++		case MXT_PROCI_LENSBENDING_T65:
++			data->T65_reportid_min = min_id;
++			data->T65_reportid_max = max_id;
++			break;
++		case MXT_SPT_SERIALDATACOMMAND_T68:
++			data->T68_reportid_min = min_id;
++			break;
++			case MXT_SPT_DYNAMICCONFIGURATIONCONTROLLER_T70:
++			data->T70_reportid_min = min_id;
++			data->T70_reportid_max = max_id;
++			break;
++		case MXT_NOISESUPPRESSION_T72:
++			data->T72_reportid_min = min_id;
++			break;
++		case MXT_PROCI_RETRANSMISSIONCOMPENSATION_T80:
++			data->T80_reportid_min = min_id;
++			data->T80_reportid_max = max_id;
++			break;				
++		case MXT_PROCI_SYMBOLGESTUREPROCESSOR_T92:
++			data->T92_reportid_min = min_id;
++			data->T92_address = object->start_address;
++			break;
++		case MXT_PROCI_TOUCHSEQUENCELOGGER_T93:
++			data->T93_reportid_min = min_id;
++			data->T93_address = object->start_address;
+ 			break;
+ 		case MXT_TOUCH_MULTITOUCHSCREEN_T100:
+ 			data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100;
+ 			data->T100_reportid_min = min_id;
+ 			data->T100_reportid_max = max_id;
++			data->T100_instances = num_instances;
+ 			/* first two report IDs reserved */
+-			data->num_touchids = object->num_report_ids - 2;
++			data->num_touchids = object->num_report_ids - MXT_RSVD_RPTIDS;
++			break;
++		case MXT_PROCI_ACTIVESTYLUS_T107:
++			data->T107_address = object->start_address;
++			break;
++		case MXT_PROCG_NOISESUPSELFCAP_T108:
++			data->T108_reportid_min = min_id;
++			break;
++		case MXT_SPT_SELFCAPGLOBALCONFIG_T109:
++			data->T109_reportid_min = min_id;
++			break;
++		case MXT_PROCI_SELFCAPGRIPSUPPRESSION_T112:
++			data->T112_reportid_min = min_id;
++			data->T112_reportid_max = max_id;
++			break;
++		case MXT_SPT_SELCAPVOLTAGEMODE_T133:
++			data->T133_reportid_min = min_id;
++			break;
++		case MXT_PROCI_HOVERGESTUREPROCESSOR_T129:
++			data->T129_reportid_min = min_id;
+ 			break;
+ 		}
+ 
+@@ -1646,28 +2294,106 @@ static int mxt_get_object_table(struct mxt_data *data)
+ 
+ 	/* Store maximum reportid */
+ 	data->max_reportid = reportid;
+-
++	
+ 	/* If T44 exists, T5 position has to be directly after */
+ 	if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
+ 		dev_err(&client->dev, "Invalid T44 position\n");
+-		error = -EINVAL;
+-		goto free_object_table;
++		return -EINVAL;
+ 	}
+ 
+ 	data->msg_buf = kcalloc(data->max_reportid,
+ 				data->T5_msg_size, GFP_KERNEL);
+-	if (!data->msg_buf) {
+-		dev_err(&client->dev, "Failed to allocate message buffer\n");
++	if (!data->msg_buf)
++		return -ENOMEM;
++
++	return 0;
++}
++
++static int mxt_read_info_block(struct mxt_data *data)
++{
++	struct i2c_client *client = data->client;
++	int error;
++	size_t size;
++	void *id_buf, *buf;
++	uint8_t num_objects;
++	u32 calculated_crc;
++	u8 *crc_ptr;
++
++	/* If info block already allocated, free it */
++	if (data->raw_info_block)
++		mxt_free_object_table(data);
++
++	/* Read 7-byte ID information block starting at address 0 */
++	size = sizeof(struct mxt_info);
++	id_buf = kzalloc(size, GFP_KERNEL);
++	if (!id_buf)
++		return -ENOMEM;
++
++	error = __mxt_read_reg(client, 0, size, id_buf);
++	if (error)
++		goto err_free_mem;
++
++	/* Resize buffer to give space for rest of info block */
++	num_objects = ((struct mxt_info *)id_buf)->object_num;
++	size += (num_objects * sizeof(struct mxt_object))
++		+ MXT_INFO_CHECKSUM_SIZE;
++
++	buf = krealloc(id_buf, size, GFP_KERNEL);
++	if (!buf) {
+ 		error = -ENOMEM;
+-		goto free_object_table;
++		goto err_free_mem;
++	}
++	id_buf = buf;
++
++	/* Read rest of info block */
++	error = __mxt_read_reg(client, MXT_OBJECT_START,
++			       size - MXT_OBJECT_START,
++			       id_buf + MXT_OBJECT_START);
++	if (error)
++		goto err_free_mem;
++
++	/* Extract & calculate checksum */
++	crc_ptr = id_buf + size - MXT_INFO_CHECKSUM_SIZE;
++	data->info_crc = crc_ptr[0] | (crc_ptr[1] << 8) | (crc_ptr[2] << 16);
++
++	calculated_crc = mxt_calculate_crc(id_buf, 0,
++					   size - MXT_INFO_CHECKSUM_SIZE);
++
++	/*
++	 * CRC mismatch can be caused by data corruption due to I2C comms
++	 * issue or else device is not using Object Based Protocol (eg i2c-hid)
++	 */
++	if ((data->info_crc == 0) || (data->info_crc != calculated_crc)) {
++		dev_err(&client->dev,
++			"Info Block CRC error calculated=0x%06X read=0x%06X\n",
++			calculated_crc, data->info_crc);
++		error = -EIO;
++		goto err_free_mem;
++	}
++
++	data->raw_info_block = id_buf;
++	data->info = (struct mxt_info *)id_buf;
++
++	dev_info(&client->dev,
++		 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
++		 data->info->family_id, data->info->variant_id,
++		 data->info->version >> 4, data->info->version & 0xf,
++		 data->info->build, data->info->object_num);
++
++	/* Parse object table information */
++	error = mxt_parse_object_table(data, id_buf + MXT_OBJECT_START);
++	if (error) {
++		dev_err(&client->dev, "Error %d parsing object table\n", error);
++		mxt_free_object_table(data);
++		goto err_free_mem;
+ 	}
+ 
+-	data->object_table = object_table;
++	data->object_table = (struct mxt_object *)(id_buf + MXT_OBJECT_START);
+ 
+ 	return 0;
+ 
+-free_object_table:
+-	mxt_free_object_table(data);
++err_free_mem:
++	kfree(id_buf);
+ 	return error;
+ }
+ 
+@@ -1684,6 +2410,18 @@ static int mxt_read_t9_resolution(struct mxt_data *data)
+ 		return -EINVAL;
+ 
+ 	error = __mxt_read_reg(client,
++			       object->start_address + MXT_T9_XSIZE,
++			       sizeof(data->xsize), &data->xsize);
++	if (error)
++		return error;
++
++	error = __mxt_read_reg(client,
++			       object->start_address + MXT_T9_YSIZE,
++			       sizeof(data->ysize), &data->ysize);
++	if (error)
++		return error;
++
++	error = __mxt_read_reg(client,
+ 			       object->start_address + MXT_T9_RANGE,
+ 			       sizeof(range), &range);
+ 	if (error)
+@@ -1699,11 +2437,61 @@ static int mxt_read_t9_resolution(struct mxt_data *data)
+ 		return error;
+ 
+ 	data->xy_switch = orient & MXT_T9_ORIENT_SWITCH;
++	data->invertx = orient & MXT_T9_ORIENT_INVERTX;
++	data->inverty = orient & MXT_T9_ORIENT_INVERTY;
++
++	return 0;
++}
++
++static int mxt_set_up_active_stylus(struct input_dev *input_dev,
++				    struct mxt_data *data)
++{
++	struct i2c_client *client = data->client;
++	int error;
++	struct mxt_object *object;
++	u8 styaux;
++	int aux;
++	u8 ctrl;
++
++	object = mxt_get_object(data, MXT_PROCI_ACTIVESTYLUS_T107);
++	if (!object)
++		return 0;
++
++	error = __mxt_read_reg(client, object->start_address, 1, &ctrl);
++	if (error)
++		return error;
++
++	/* Check enable bit */
++	if (!(ctrl & 0x01))
++		return 0;
++
++	error = __mxt_read_reg(client,
++			       object->start_address + MXT_T107_STYLUS_STYAUX,
++			       1, &styaux);
++	if (error)
++		return error;
++
++	/* map aux bits */
++	aux = 7;
++
++	if (styaux & MXT_T107_STYLUS_STYAUX_PRESSURE)
++		data->stylus_aux_pressure = aux++;
++
++	if (styaux & MXT_T107_STYLUS_STYAUX_PEAK)
++		data->stylus_aux_peak = aux++;
++
++	input_set_capability(input_dev, EV_KEY, BTN_STYLUS);
++	input_set_capability(input_dev, EV_KEY, BTN_STYLUS2);
++	input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE, 0, MT_TOOL_MAX, 0, 0);
++
++	dev_dbg(&client->dev,
++		"T107 active stylus, aux map pressure:%u peak:%u\n",
++		data->stylus_aux_pressure, data->stylus_aux_peak);
+ 
+ 	return 0;
+ }
+ 
+-static int mxt_read_t100_config(struct mxt_data *data)
++static int mxt_read_t100_config(struct mxt_data *data, u8 instance)
+ {
+ 	struct i2c_client *client = data->client;
+ 	int error;
+@@ -1711,14 +2499,28 @@ static int mxt_read_t100_config(struct mxt_data *data)
+ 	u16 range_x, range_y;
+ 	u8 cfg, tchaux;
+ 	u8 aux;
++	u16 obj_size = 0;
++	u8 T100_enable;
+ 
+ 	object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100);
+ 	if (!object)
+ 		return -EINVAL;
+-
++	
++	if (instance == 2) {
++		T100_enable = object->start_address + mxt_obj_size(object) + MXT_T100_CTRL;
++		
++		if ((T100_enable & MXT_T100_ENABLE_BIT_MASK) == 0x01 ){
++			obj_size = mxt_obj_size(object);
++		} else {
++			dev_info(&client->dev, "T100 secondary input device not enabled\n");
++			
++			return 1;
++		}	
++	}
++				
+ 	/* read touchscreen dimensions */
+ 	error = __mxt_read_reg(client,
+-			       object->start_address + MXT_T100_XRANGE,
++			       object->start_address + obj_size + MXT_T100_XRANGE,
+ 			       sizeof(range_x), &range_x);
+ 	if (error)
+ 		return error;
+@@ -1726,30 +2528,44 @@ static int mxt_read_t100_config(struct mxt_data *data)
+ 	data->max_x = get_unaligned_le16(&range_x);
+ 
+ 	error = __mxt_read_reg(client,
+-			       object->start_address + MXT_T100_YRANGE,
++			       object->start_address + obj_size + MXT_T100_YRANGE,
+ 			       sizeof(range_y), &range_y);
+ 	if (error)
+ 		return error;
+ 
+ 	data->max_y = get_unaligned_le16(&range_y);
+ 
++	error = __mxt_read_reg(client,
++			       object->start_address + obj_size + MXT_T100_XSIZE,
++			       sizeof(data->xsize), &data->xsize);
++	if (error)
++		return error;
++
++	error = __mxt_read_reg(client,
++			       object->start_address + obj_size + MXT_T100_YSIZE,
++			       sizeof(data->ysize), &data->ysize);
++	if (error)
++		return error;
++
+ 	/* read orientation config */
+ 	error =  __mxt_read_reg(client,
+-				object->start_address + MXT_T100_CFG1,
++				object->start_address + obj_size + MXT_T100_CFG1,
+ 				1, &cfg);
+ 	if (error)
+ 		return error;
+ 
+ 	data->xy_switch = cfg & MXT_T100_CFG_SWITCHXY;
++	data->invertx = cfg & MXT_T100_CFG_INVERTX;
++	data->inverty = cfg & MXT_T100_CFG_INVERTY;
+ 
+ 	/* allocate aux bytes */
+ 	error =  __mxt_read_reg(client,
+-				object->start_address + MXT_T100_TCHAUX,
++				object->start_address + obj_size+ MXT_T100_TCHAUX,
+ 				1, &tchaux);
+ 	if (error)
+ 		return error;
+ 
+-	aux = 6;
++	aux = MXT_T100_AUX_OFFSET;
+ 
+ 	if (tchaux & MXT_T100_TCHAUX_VECT)
+ 		data->t100_aux_vect = aux++;
+@@ -1763,7 +2579,7 @@ static int mxt_read_t100_config(struct mxt_data *data)
+ 	dev_dbg(&client->dev,
+ 		"T100 aux mappings vect:%u ampl:%u area:%u\n",
+ 		data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area);
+-
++				
+ 	return 0;
+ }
+ 
+@@ -1773,7 +2589,6 @@ static void mxt_input_close(struct input_dev *dev);
+ static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
+ 				   struct mxt_data *data)
+ {
+-	const struct mxt_platform_data *pdata = data->pdata;
+ 	int i;
+ 
+ 	input_dev->name = "Atmel maXTouch Touchpad";
+@@ -1787,21 +2602,136 @@ static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
+ 	input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
+ 			  MXT_PIXELS_PER_MM);
+ 
+-	for (i = 0; i < pdata->t19_num_keys; i++)
+-		if (pdata->t19_keymap[i] != KEY_RESERVED)
++	for (i = 0; i < data->t19_num_keys; i++)
++		if (data->t19_keymap[i] != KEY_RESERVED)
+ 			input_set_capability(input_dev, EV_KEY,
+-					     pdata->t19_keymap[i]);
++					     data->t19_keymap[i]);
++}
++
++static int mxt_init_secondary_input(struct mxt_data *data)
++{
++	struct device *dev = &data->client->dev;
++	struct input_dev *input_dev_sec;
++	unsigned int num_mt_slots;
++	unsigned int mt_flags = 0;
++	int error;
++	
++	switch (data->multitouch) {
++	case MXT_TOUCH_MULTITOUCHSCREEN_T100:
++		num_mt_slots = data->num_touchids; 
++		error = mxt_read_t100_config(data, 2);
++		if (error) {
++			dev_info(dev, "Failed to read T100 config\n");
++			return -ENXIO;
++		}
++		break;
++
++	default:
++		dev_err(dev, "Invalid multitouch object\n");
++		return -EINVAL;
++	}
++
++	/* Handle default values and orientation switch */
++	if (data->max_x == 0)
++		data->max_x = 1023;
++
++	if (data->max_y == 0)
++		data->max_y = 1023;
++
++	if (data->xy_switch)
++		swap(data->max_x, data->max_y);
++
++	dev_info(dev, "Secondary touchscreen size {x,y} = {%u,%u}\n", data->max_x, data->max_y);
++
++	/* Register input device */
++	input_dev_sec = input_allocate_device();
++	if (!input_dev_sec)
++		return -ENOMEM;
++
++	input_dev_sec->name = "maXTouch Secondary Touchscreen";
++	input_dev_sec->phys = data->phys;
++	input_dev_sec->id.bustype = BUS_I2C;
++	input_dev_sec->dev.parent = dev;
++	input_dev_sec->open = mxt_input_open;
++	input_dev_sec->close = mxt_input_close;
++
++	input_set_capability(input_dev_sec, EV_KEY, BTN_TOUCH);
++
++	/* For single touch */
++	input_set_abs_params(input_dev_sec, ABS_X, 0, data->max_x, 0, 0);
++	input_set_abs_params(input_dev_sec, ABS_Y, 0, data->max_y, 0, 0);
++
++	if ((data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
++	     data->t100_aux_ampl)) {
++		input_set_abs_params(input_dev_sec, ABS_PRESSURE, 0, 255, 0, 0);
++	}
++
++	mt_flags |= INPUT_MT_DIRECT;
++
++	/* For multi touch */
++	error = input_mt_init_slots(input_dev_sec, num_mt_slots, mt_flags);
++	if (error) {
++		dev_err(dev, "Error %d initialising slots\n", error);
++		goto err_free_mem;
++	}
++
++	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) {
++		input_set_abs_params(input_dev_sec, ABS_MT_TOOL_TYPE,
++				     0, MT_TOOL_MAX, 0, 0);
++		input_set_abs_params(input_dev_sec, ABS_MT_DISTANCE,
++				     MXT_DISTANCE_ACTIVE_TOUCH,
++				     MXT_DISTANCE_HOVERING,
++				     0, 0);
++	}
++
++	input_set_abs_params(input_dev_sec, ABS_MT_POSITION_X,
++			     0, data->max_x, 0, 0);
++	input_set_abs_params(input_dev_sec, ABS_MT_POSITION_Y,
++			     0, data->max_y, 0, 0);
++
++	if ((data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
++	     data->t100_aux_area)) {
++		input_set_abs_params(input_dev_sec, ABS_MT_TOUCH_MAJOR,
++				     0, MXT_MAX_AREA, 0, 0);
++	}
++
++	if ((data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
++	     data->t100_aux_ampl)) {
++		input_set_abs_params(input_dev_sec, ABS_MT_PRESSURE,
++				     0, 255, 0, 0);
++	}
++
++	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
++	    data->t100_aux_vect) {
++		input_set_abs_params(input_dev_sec, ABS_MT_ORIENTATION,
++				     0, 255, 0, 0);
++	}
++
++	input_set_drvdata(input_dev_sec, data);
++
++	error = input_register_device(input_dev_sec);
++	if (error) {
++		dev_err(dev, "Error %d registering input device\n", error);
++		goto err_free_mem;
++	}
++
++	data->input_dev_sec = input_dev_sec;
++
++	return 0;
++
++err_free_mem:
++	input_free_device(input_dev_sec);
++	return error;
+ }
+ 
+ static int mxt_initialize_input_device(struct mxt_data *data)
+ {
+-	const struct mxt_platform_data *pdata = data->pdata;
+ 	struct device *dev = &data->client->dev;
+ 	struct input_dev *input_dev;
+ 	int error;
+ 	unsigned int num_mt_slots;
+ 	unsigned int mt_flags = 0;
+-	struct device_node *np = dev->of_node;
++	int i;
+ 	
+ 	switch (data->multitouch) {
+ 	case MXT_TOUCH_MULTI_T9:
+@@ -1812,8 +2742,8 @@ static int mxt_initialize_input_device(struct mxt_data *data)
+ 		break;
+ 
+ 	case MXT_TOUCH_MULTITOUCHSCREEN_T100:
+-		num_mt_slots = data->num_touchids;
+-		error = mxt_read_t100_config(data);
++		num_mt_slots = (data->num_touchids);
++		error = mxt_read_t100_config(data, 1);
+ 		if (error)
+ 			dev_warn(dev, "Failed to read T100 config\n");
+ 		break;
+@@ -1833,15 +2763,12 @@ static int mxt_initialize_input_device(struct mxt_data *data)
+ 	if (data->xy_switch)
+ 		swap(data->max_x, data->max_y);
+ 
+-	dev_info(dev, "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
++	dev_info(dev, "Touchscreen size {x,y} = {%u,%u}\n", data->max_x, data->max_y);
+ 
+ 	/* Register input device */
+ 	input_dev = input_allocate_device();
+-	if (!input_dev) {
+-		dev_err(dev, "Failed to allocate memory\n");
++	if (!input_dev)
+ 		return -ENOMEM;
+-	}
+-
+ 
+ 	input_dev->name = "Atmel maXTouch Touchscreen";
+ 	input_dev->phys = data->phys;
+@@ -1863,7 +2790,7 @@ static int mxt_initialize_input_device(struct mxt_data *data)
+ 	}
+ 
+ 	/* If device has buttons we assume it is a touchpad */
+-	if (pdata->t19_num_keys) {
++	if (data->t19_num_keys) {
+ 		mxt_set_up_as_touchpad(input_dev, data);
+ 		mt_flags |= INPUT_MT_POINTER;
+ 	} else {
+@@ -1905,22 +2832,28 @@ static int mxt_initialize_input_device(struct mxt_data *data)
+ 				     0, 255, 0, 0);
+ 	}
+ 
+-	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
+-	    data->t100_aux_vect) {
++	if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
++	    (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
++	    data->t100_aux_vect)) {
+ 		input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
+ 				     0, 255, 0, 0);
+ 	}
+ 
++	/* For T107 Active Stylus */
+ 	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
+-	    data->t100_aux_ampl) {
+-		input_set_abs_params(input_dev, ABS_MT_PRESSURE,
+-				     0, 255, 0, 0);
++	    data->T107_address) {
++		error = mxt_set_up_active_stylus(input_dev, data);
++		if (error)
++			dev_warn(dev, "Failed to read T107 config\n");
+ 	}
+ 
+-	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
+-	    data->t100_aux_vect) {
+-		input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
+-				     0, 255, 0, 0);
++	/* For T15 Key Array */
++	if (data->T15_reportid_min) {
++		data->t15_keystatus = 0;
++
++		for (i = 0; i < data->t15_num_keys; i++)
++			input_set_capability(input_dev, EV_KEY,
++					data->t15_keymap[i]);
+ 	}
+ 
+ 	input_set_drvdata(input_dev, data);
+@@ -1933,17 +2866,6 @@ static int mxt_initialize_input_device(struct mxt_data *data)
+ 
+ 	data->input_dev = input_dev;
+ 
+-	if (np) {
+-		data->invert_x = of_property_read_bool(np, "invert_x")?1:0;
+-		data->invert_y = of_property_read_bool(np, "invert_y")?1:0;
+-        	data->swap_x_y = of_property_read_bool(np, "swap_x_y")?1:0;
+-        	
+-        	dev_info(dev, "loaded toucscreen properties\n");
+-        	dev_info(dev, "touchscreen-inverted-x %d\n", data->invert_x);
+-        	dev_info(dev, "touchscreen-inverted-y %d\n", data->invert_y);
+-        	dev_info(dev, "touchscreen-swap-x-y %d\n", data->swap_x_y);
+-        }
+-
+ 	return 0;
+ 
+ err_free_mem:
+@@ -1951,6 +2873,8 @@ err_free_mem:
+ 	return error;
+ }
+ 
++static int mxt_sysfs_init(struct mxt_data *data);
++static void mxt_sysfs_remove(struct mxt_data *data);
+ static int mxt_configure_objects(struct mxt_data *data,
+ 				 const struct firmware *cfg);
+ 
+@@ -1967,7 +2891,7 @@ static int mxt_initialize(struct mxt_data *data)
+ 	int error;
+ 
+ 	while (1) {
+-		error = mxt_get_info(data);
++		error = mxt_read_info_block(data);
+ 		if (!error)
+ 			break;
+ 
+@@ -1998,31 +2922,21 @@ static int mxt_initialize(struct mxt_data *data)
+ 		msleep(MXT_FW_RESET_TIME);
+ 	}
+ 
+-	/* Get object table information */
+-	error = mxt_get_object_table(data);
+-	if (error) {
+-		dev_err(&client->dev, "Error %d reading object table\n", error);
+-		return error;
+-	}
+-
+ 	error = mxt_acquire_irq(data);
+ 	if (error)
+-		goto err_free_object_table;
++		return error;
+ 
++	/* Only works when driver compiled as module */
+ 	error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
+ 					&client->dev, GFP_KERNEL, data,
+ 					mxt_config_cb);
+ 	if (error) {
+ 		dev_err(&client->dev, "Failed to invoke firmware loader: %d\n",
+ 			error);
+-		goto err_free_object_table;
++		return error;
+ 	}
+ 
+ 	return 0;
+-
+-err_free_object_table:
+-	mxt_free_object_table(data);
+-	return error;
+ }
+ 
+ static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep)
+@@ -2042,7 +2956,7 @@ static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep)
+ 	if (error)
+ 		return error;
+ 
+-	dev_dbg(dev, "Set T7 ACTV:%d IDLE:%d\n",
++	dev_dbg(dev, "Set T7 ACTV:%d IDLE:%d\n",	
+ 		new_config->active, new_config->idle);
+ 
+ 	return 0;
+@@ -2079,48 +2993,478 @@ recheck:
+ 	return 0;
+ }
+ 
+-static int mxt_configure_objects(struct mxt_data *data,
+-				 const struct firmware *cfg)
++#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
++static u16 mxt_get_debug_value(struct mxt_data *data, unsigned int x,
++			       unsigned int y)
+ {
+-	struct device *dev = &data->client->dev;
+-	struct mxt_info *info = &data->info;
+-	int error;
+-
+-	error = mxt_init_t7_power_cfg(data);
+-	if (error) {
+-		dev_err(dev, "Failed to initialize power cfg\n");
+-		return error;
++	struct mxt_info *info = data->info;
++	struct mxt_dbg *dbg = &data->dbg;
++	unsigned int ofs, page;
++	unsigned int col = 0;
++	unsigned int col_width;
++
++	if (info->family_id == MXT_FAMILY_1386) {
++		col_width = info->matrix_ysize / MXT1386_COLUMNS;
++		col = y / col_width;
++		y = y % col_width;
++	} else {
++		col_width = info->matrix_ysize;
+ 	}
+ 
+-	if (cfg) {
+-		error = mxt_update_cfg(data, cfg);
+-		if (error)
+-			dev_warn(dev, "Error %d updating config\n", error);
+-	}
++	ofs = (y + (x * col_width)) * sizeof(u16);
++	page = ofs / MXT_DIAGNOSTIC_SIZE;
++	ofs %= MXT_DIAGNOSTIC_SIZE;
+ 
+-	if (data->multitouch) {
+-		error = mxt_initialize_input_device(data);
+-		if (error)
+-			return error;
+-	} else {
+-		dev_warn(dev, "No touch object detected\n");
+-	}
++	if (info->family_id == MXT_FAMILY_1386)
++		page += col * MXT1386_PAGES_PER_COLUMN;
+ 
+-	dev_info(dev,
+-		 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
+-		 info->family_id, info->variant_id, info->version >> 4,
+-		 info->version & 0xf, info->build, info->object_num);
++	return get_unaligned_le16(&dbg->t37_buf[page].data[ofs]);
++}
++
++static int mxt_convert_debug_pages(struct mxt_data *data, u16 *outbuf)
++{
++	struct mxt_dbg *dbg = &data->dbg;
++	unsigned int x = 0;
++	unsigned int y = 0;
++	unsigned int i, rx, ry;
++
++	for (i = 0; i < dbg->t37_nodes; i++) {
++		/* Handle orientation */
++		rx = data->xy_switch ? y : x;
++		ry = data->xy_switch ? x : y;
++		rx = data->invertx ? (data->xsize - 1 - rx) : rx;
++		ry = data->inverty ? (data->ysize - 1 - ry) : ry;
++
++		outbuf[i] = mxt_get_debug_value(data, rx, ry);
++
++		/* Next value */
++		if (++x >= (data->xy_switch ? data->ysize : data->xsize)) {
++			x = 0;
++			y++;
++		}
++	}
+ 
+ 	return 0;
+ }
+ 
+-/* Firmware Version is returned as Major.Minor.Build */
+-static ssize_t mxt_fw_version_show(struct device *dev,
+-				   struct device_attribute *attr, char *buf)
++static int mxt_read_diagnostic_debug(struct mxt_data *data, u8 mode,
++				     u16 *outbuf)
+ {
+-	struct mxt_data *data = dev_get_drvdata(dev);
+-	struct mxt_info *info = &data->info;
+-	return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
++	struct mxt_dbg *dbg = &data->dbg;
++	int retries = 0;
++	int page;
++	int ret;
++	u8 cmd = mode;
++	struct t37_debug *p;
++	u8 cmd_poll;
++
++	for (page = 0; page < dbg->t37_pages; page++) {
++		p = dbg->t37_buf + page;
++
++		ret = mxt_write_reg(data->client, dbg->diag_cmd_address,
++				    cmd);
++		if (ret)
++			return ret;
++
++		retries = 0;
++		msleep(20);
++wait_cmd:
++		/* Read back command byte */
++		ret = __mxt_read_reg(data->client, dbg->diag_cmd_address,
++				     sizeof(cmd_poll), &cmd_poll);
++		if (ret)
++			return ret;
++
++		/* Field is cleared once the command has been processed */
++		if (cmd_poll) {
++			if (retries++ > 100)
++				return -EINVAL;
++
++			msleep(20);
++			goto wait_cmd;
++		}
++
++		/* Read T37 page */
++		ret = __mxt_read_reg(data->client, dbg->t37_address,
++				     sizeof(struct t37_debug), p);
++		if (ret)
++			return ret;
++
++		if (p->mode != mode || p->page != page) {
++			dev_err(&data->client->dev, "T37 page mismatch\n");
++			return -EINVAL;
++		}
++
++		dev_dbg(&data->client->dev, "%s page:%d retries:%d\n",
++			__func__, page, retries);
++
++		/* For remaining pages, write PAGEUP rather than mode */
++		cmd = MXT_DIAGNOSTIC_PAGEUP;
++	}
++
++	return mxt_convert_debug_pages(data, outbuf);
++}
++
++static int mxt_queue_setup(struct vb2_queue *q,
++		       unsigned int *nbuffers, unsigned int *nplanes,
++		       unsigned int sizes[], struct device *alloc_devs[])
++{
++	struct mxt_data *data = q->drv_priv;
++	size_t size = data->dbg.t37_nodes * sizeof(u16);
++
++	if (*nplanes)
++		return sizes[0] < size ? -EINVAL : 0;
++
++	*nplanes = 1;
++	sizes[0] = size;
++
++	return 0;
++}
++
++static void mxt_buffer_queue(struct vb2_buffer *vb)
++{
++	struct mxt_data *data = vb2_get_drv_priv(vb->vb2_queue);
++	u16 *ptr;
++	int ret;
++	u8 mode;
++
++	ptr = vb2_plane_vaddr(vb, 0);
++	if (!ptr) {
++		dev_err(&data->client->dev, "Error acquiring frame ptr\n");
++		goto fault;
++	}
++
++	switch (data->dbg.input) {
++	case MXT_V4L_INPUT_DELTAS:
++	default:
++		mode = MXT_DIAGNOSTIC_DELTAS;
++		break;
++
++	case MXT_V4L_INPUT_REFS:
++		mode = MXT_DIAGNOSTIC_REFS;
++		break;
++	}
++
++	ret = mxt_read_diagnostic_debug(data, mode, ptr);
++	if (ret)
++		goto fault;
++
++	vb2_set_plane_payload(vb, 0, data->dbg.t37_nodes * sizeof(u16));
++	vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
++	return;
++
++fault:
++	vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
++}
++
++/* V4L2 structures */
++static const struct vb2_ops mxt_queue_ops = {
++	.queue_setup		= mxt_queue_setup,
++	.buf_queue		= mxt_buffer_queue,
++	.wait_prepare		= vb2_ops_wait_prepare,
++	.wait_finish		= vb2_ops_wait_finish,
++};
++
++static const struct vb2_queue mxt_queue = {
++	.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
++	.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ,
++	.buf_struct_size = sizeof(struct mxt_vb2_buffer),
++	.ops = &mxt_queue_ops,
++	.mem_ops = &vb2_vmalloc_memops,
++	.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC,
++	.min_buffers_needed = 1,
++};
++
++static int mxt_vidioc_querycap(struct file *file, void *priv,
++				 struct v4l2_capability *cap)
++{
++	struct mxt_data *data = video_drvdata(file);
++
++	strlcpy(cap->driver, "atmel_mxt_ts", sizeof(cap->driver));
++	strlcpy(cap->card, "atmel_mxt_ts touch", sizeof(cap->card));
++	snprintf(cap->bus_info, sizeof(cap->bus_info),
++		 "I2C:%s", dev_name(&data->client->dev));
++	return 0;
++}
++
++static int mxt_vidioc_enum_input(struct file *file, void *priv,
++				   struct v4l2_input *i)
++{
++	if (i->index >= MXT_V4L_INPUT_MAX)
++		return -EINVAL;
++
++	i->type = V4L2_INPUT_TYPE_TOUCH;
++
++	switch (i->index) {
++	case MXT_V4L_INPUT_REFS:
++		strlcpy(i->name, "Mutual Capacitance References",
++			sizeof(i->name));
++		break;
++	case MXT_V4L_INPUT_DELTAS:
++		strlcpy(i->name, "Mutual Capacitance Deltas", sizeof(i->name));
++		break;
++	}
++
++	return 0;
++}
++
++static int mxt_set_input(struct mxt_data *data, unsigned int i)
++{
++	struct v4l2_pix_format *f = &data->dbg.format;
++
++	if (i >= MXT_V4L_INPUT_MAX)
++		return -EINVAL;
++
++	if (i == MXT_V4L_INPUT_DELTAS)
++		f->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
++	else
++		f->pixelformat = V4L2_TCH_FMT_TU16;
++
++	f->width = data->xy_switch ? data->ysize : data->xsize;
++	f->height = data->xy_switch ? data->xsize : data->ysize;
++	f->field = V4L2_FIELD_NONE;
++	f->colorspace = V4L2_COLORSPACE_RAW;
++	f->bytesperline = f->width * sizeof(u16);
++	f->sizeimage = f->width * f->height * sizeof(u16);
++
++	data->dbg.input = i;
++
++	return 0;
++}
++
++static int mxt_vidioc_s_input(struct file *file, void *priv, unsigned int i)
++{
++	return mxt_set_input(video_drvdata(file), i);
++}
++
++static int mxt_vidioc_g_input(struct file *file, void *priv, unsigned int *i)
++{
++	struct mxt_data *data = video_drvdata(file);
++
++	*i = data->dbg.input;
++
++	return 0;
++}
++
++static int mxt_vidioc_fmt(struct file *file, void *priv, struct v4l2_format *f)
++{
++	struct mxt_data *data = video_drvdata(file);
++
++	f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
++	f->fmt.pix = data->dbg.format;
++
++	return 0;
++}
++
++static int mxt_vidioc_enum_fmt(struct file *file, void *priv,
++				 struct v4l2_fmtdesc *fmt)
++{
++	if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
++		return -EINVAL;
++
++	switch (fmt->index) {
++	case 0:
++		fmt->pixelformat = V4L2_TCH_FMT_TU16;
++		break;
++
++	case 1:
++		fmt->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
++		break;
++
++	default:
++		return -EINVAL;
++	}
++
++	return 0;
++}
++
++static int mxt_vidioc_g_parm(struct file *file, void *fh,
++			     struct v4l2_streamparm *a)
++{
++	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
++		return -EINVAL;
++
++	a->parm.capture.readbuffers = 1;
++	a->parm.capture.timeperframe.numerator = 1;
++	a->parm.capture.timeperframe.denominator = 10;
++	return 0;
++}
++
++static const struct v4l2_ioctl_ops mxt_video_ioctl_ops = {
++	.vidioc_querycap        = mxt_vidioc_querycap,
++
++	.vidioc_enum_fmt_vid_cap = mxt_vidioc_enum_fmt,
++	.vidioc_s_fmt_vid_cap   = mxt_vidioc_fmt,
++	.vidioc_g_fmt_vid_cap   = mxt_vidioc_fmt,
++	.vidioc_try_fmt_vid_cap	= mxt_vidioc_fmt,
++	.vidioc_g_parm		= mxt_vidioc_g_parm,
++
++	.vidioc_enum_input      = mxt_vidioc_enum_input,
++	.vidioc_g_input         = mxt_vidioc_g_input,
++	.vidioc_s_input         = mxt_vidioc_s_input,
++
++	.vidioc_reqbufs         = vb2_ioctl_reqbufs,
++	.vidioc_create_bufs     = vb2_ioctl_create_bufs,
++	.vidioc_querybuf        = vb2_ioctl_querybuf,
++	.vidioc_qbuf            = vb2_ioctl_qbuf,
++	.vidioc_dqbuf           = vb2_ioctl_dqbuf,
++	.vidioc_expbuf          = vb2_ioctl_expbuf,
++
++	.vidioc_streamon        = vb2_ioctl_streamon,
++	.vidioc_streamoff       = vb2_ioctl_streamoff,
++};
++
++static const struct video_device mxt_video_device = {
++	.name = "Atmel maxTouch",
++	.fops = &mxt_video_fops,
++	.ioctl_ops = &mxt_video_ioctl_ops,
++	.release = video_device_release_empty,
++	.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TOUCH |
++		       V4L2_CAP_READWRITE | V4L2_CAP_STREAMING,
++};
++
++static void mxt_debug_init(struct mxt_data *data)
++{
++	struct mxt_info *info = data->info;
++	struct mxt_dbg *dbg = &data->dbg;
++	struct mxt_object *object;
++	int error;
++
++	object = mxt_get_object(data, MXT_GEN_COMMAND_T6);
++	if (!object)
++		goto error;
++
++	dbg->diag_cmd_address = object->start_address + MXT_COMMAND_DIAGNOSTIC;
++
++	object = mxt_get_object(data, MXT_DEBUG_DIAGNOSTIC_T37);
++	if (!object)
++		goto error;
++
++	if (mxt_obj_size(object) != sizeof(struct t37_debug)) {
++		dev_warn(&data->client->dev, "Bad T37 size");
++		goto error;
++	}
++
++	dbg->t37_address = object->start_address;
++
++	/* Calculate size of data and allocate buffer */
++	dbg->t37_nodes = data->xsize * data->ysize;
++
++	if (info->family_id == MXT_FAMILY_1386)
++		dbg->t37_pages = MXT1386_COLUMNS * MXT1386_PAGES_PER_COLUMN;
++	else
++		dbg->t37_pages = DIV_ROUND_UP(data->xsize *
++					      info->matrix_ysize *
++					      sizeof(u16),
++					      sizeof(dbg->t37_buf->data));
++
++	dbg->t37_buf = devm_kmalloc_array(&data->client->dev, dbg->t37_pages,
++					  sizeof(struct t37_debug), GFP_KERNEL);
++	if (!dbg->t37_buf)
++		goto error;
++
++	/* init channel to zero */
++	mxt_set_input(data, 0);
++
++	/* register video device */
++	snprintf(dbg->v4l2.name, sizeof(dbg->v4l2.name), "%s", "atmel_mxt_ts");
++	error = v4l2_device_register(&data->client->dev, &dbg->v4l2);
++	if (error)
++		goto error;
++
++	/* initialize the queue */
++	mutex_init(&dbg->lock);
++	dbg->queue = mxt_queue;
++	dbg->queue.drv_priv = data;
++	dbg->queue.lock = &dbg->lock;
++	dbg->queue.dev = &data->client->dev;
++
++	error = vb2_queue_init(&dbg->queue);
++	if (error)
++		goto error_unreg_v4l2;
++
++	dbg->vdev = mxt_video_device;
++	dbg->vdev.v4l2_dev = &dbg->v4l2;
++	dbg->vdev.lock = &dbg->lock;
++	dbg->vdev.vfl_dir = VFL_DIR_RX;
++	dbg->vdev.queue = &dbg->queue;
++	video_set_drvdata(&dbg->vdev, data);
++
++	error = video_register_device(&dbg->vdev, VFL_TYPE_TOUCH, -1);
++	if (error)
++		goto error_unreg_v4l2;
++
++	return;
++
++error_unreg_v4l2:
++	v4l2_device_unregister(&dbg->v4l2);
++error:
++	dev_warn(&data->client->dev, "Error initializing T37\n");
++}
++#else
++static void mxt_debug_init(struct mxt_data *data)
++{
++}
++#endif
++
++static int mxt_configure_objects(struct mxt_data *data,
++				 const struct firmware *cfg)
++{
++	struct device *dev = &data->client->dev;
++	int error;
++
++	error = mxt_init_t7_power_cfg(data);
++	if (error) {
++		dev_err(dev, "Failed to initialize power cfg\n");
++		return error;
++	}
++
++	if (cfg) {
++		error = mxt_update_cfg(data, cfg);
++		if (error)
++			dev_warn(dev, "Error %d updating config\n", error);
++	}
++	
++	if (!data->sysfs_updating_config) {
++		if (data->multitouch) {
++			dev_info(dev, "Registering devices\n");
++			error = mxt_initialize_input_device(data);
++			if (error)
++				return error;
++			
++			if (data->T100_instances > 1) {
++			    error = mxt_init_secondary_input(data);
++			    if (error)
++				    dev_warn(dev, "Error %d registering secondary device\n", error);
++			}
++		} else {
++			dev_warn(dev, "No touch object detected\n");
++		}
++	}
++	
++	data->sysfs_updating_config = false;
++	
++	mxt_debug_init(data);
++
++	return 0;
++}
++
++/* Configuration crc check sum is returned as hex xxxxxx */
++static ssize_t mxt_config_crc_show(struct device *dev,
++		struct device_attribute *attr, char *buf)
++{
++	struct mxt_data *data = dev_get_drvdata(dev);
++
++	return scnprintf(buf, PAGE_SIZE, "%06x\n", data->config_crc);
++}
++
++/* Firmware Version is returned as Major.Minor.Build */
++static ssize_t mxt_fw_version_show(struct device *dev,
++				   struct device_attribute *attr, char *buf)
++{
++	struct mxt_data *data = dev_get_drvdata(dev);
++	struct mxt_info *info = data->info;
++	return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
+ 			 info->version >> 4, info->version & 0xf, info->build);
+ }
+ 
+@@ -2129,7 +3473,7 @@ static ssize_t mxt_hw_version_show(struct device *dev,
+ 				   struct device_attribute *attr, char *buf)
+ {
+ 	struct mxt_data *data = dev_get_drvdata(dev);
+-	struct mxt_info *info = &data->info;
++	struct mxt_info *info = data->info;
+ 	return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
+ 			 info->family_id, info->variant_id);
+ }
+@@ -2168,7 +3512,7 @@ static ssize_t mxt_object_show(struct device *dev,
+ 		return -ENOMEM;
+ 
+ 	error = 0;
+-	for (i = 0; i < data->info.object_num; i++) {
++	for (i = 0; i < data->info->object_num; i++) {
+ 		object = data->object_table + i;
+ 
+ 		if (!mxt_object_readable(object->type))
+@@ -2232,12 +3576,19 @@ static int mxt_load_fw(struct device *dev, const char *fn)
+ 	if (ret) {
+ 		dev_err(dev, "Unable to open firmware %s\n", fn);
+ 		return ret;
+-	}
++	} else {
++
++		dev_info(dev, "Opened firmware file: %s\n", fn);
++	}  
+ 
+ 	/* Check for incorrect enc file */
+ 	ret = mxt_check_firmware_format(dev, fw);
+-	if (ret)
++
++	if (ret) {
+ 		goto release_firmware;
++	} else {
++		dev_info(dev, "File format is okay\n");		
++	}
+ 
+ 	if (!data->in_bootloader) {
+ 		/* Change to the bootloader mode */
+@@ -2245,18 +3596,21 @@ static int mxt_load_fw(struct device *dev, const char *fn)
+ 
+ 		ret = mxt_t6_command(data, MXT_COMMAND_RESET,
+ 				     MXT_BOOT_VALUE, false);
+-		if (ret)
++		if (ret) {
+ 			goto release_firmware;
++		} else {
++			dev_info(dev, "Sent bootloader command.\n");
++		}
+ 
+ 		msleep(MXT_RESET_TIME);
+ 
+ 		/* Do not need to scan since we know family ID */
+ 		ret = mxt_lookup_bootloader_address(data, 0);
+-		if (ret)
++		if (ret) {
+ 			goto release_firmware;
+-
+-		mxt_free_input_device(data);
+-		mxt_free_object_table(data);
++		} else {
++			dev_info(dev, "Found bootloader I2C address\n");
++		}	
+ 	} else {
+ 		enable_irq(data->irq);
+ 	}
+@@ -2289,7 +3643,7 @@ static int mxt_load_fw(struct device *dev, const char *fn)
+ 		frame_size += 2;
+ 
+ 		/* Write one frame to device */
+-		ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
++		ret = mxt_bootloader_write(data, &fw->data[pos], frame_size);
+ 		if (ret)
+ 			goto disable_irq;
+ 
+@@ -2310,17 +3664,16 @@ static int mxt_load_fw(struct device *dev, const char *fn)
+ 			frame++;
+ 		}
+ 
+-		if (frame % 50 == 0)
+-			dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n",
++		if (pos >= fw->size) {
++			dev_info(dev, "Sent %u frames, %zu bytes\n",
++				frame, fw->size);
++		}
++		else if (frame % 50 == 0) {
++			dev_info(dev, "Sent %u frames, %d/%zu bytes\n",
+ 				frame, pos, fw->size);
++		}
+ 	}
+ 
+-	/* Wait for flash. */
+-	ret = mxt_wait_for_completion(data, &data->bl_completion,
+-				      MXT_FW_RESET_TIME);
+-	if (ret)
+-		goto disable_irq;
+-
+ 	dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos);
+ 
+ 	/*
+@@ -2328,7 +3681,13 @@ static int mxt_load_fw(struct device *dev, const char *fn)
+ 	 * the CHG line after bootloading has finished, so ignore potential
+ 	 * errors.
+ 	 */
+-	mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
++
++	msleep(MXT_BOOTLOADER_WAIT);	/* Wait for chip to leave bootloader*/
++	
++	ret = mxt_wait_for_completion(data, &data->bl_completion,
++				      MXT_BOOTLOADER_WAIT);
++	if (ret)
++		goto disable_irq;
+ 
+ 	data->in_bootloader = false;
+ 
+@@ -2345,32 +3704,204 @@ static ssize_t mxt_update_fw_store(struct device *dev,
+ {
+ 	struct mxt_data *data = dev_get_drvdata(dev);
+ 	int error;
+-
++	
+ 	error = mxt_load_fw(dev, MXT_FW_NAME);
+ 	if (error) {
+ 		dev_err(dev, "The firmware update failed(%d)\n", error);
+ 		count = error;
+ 	} else {
+ 		dev_info(dev, "The firmware update succeeded\n");
++	}
++	
++	data->sysfs_updating_config = true;		
++	
++	msleep(MXT_FW_FLASH_TIME);
++	
++	error = mxt_acquire_irq(data);
++	if (error)
++		return error;
++	
++	/* Only works when driver compiled as module */
++	error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
++					dev, GFP_KERNEL, data,
++					mxt_config_cb);
++	if (error) {
++		dev_err(dev, "Failed to invoke firmware loader: %d\n",
++			error);
++		return error;
++		
++	}
++	
++	return count;
++}
+ 
+-		error = mxt_initialize(data);
+-		if (error)
+-			return error;
++static ssize_t mxt_update_cfg_store(struct device *dev,
++		struct device_attribute *attr,
++		const char *buf, size_t count)
++{
++	struct mxt_data *data = dev_get_drvdata(dev);
++	const struct firmware *cfg;
++	int ret;
++
++	ret = request_firmware(&cfg, MXT_CFG_NAME, dev);
++	if (ret < 0) {
++		dev_err(dev, "Failure to request config file %s\n",
++			MXT_CFG_NAME);
++		ret = -ENOENT;
++		goto out;
++	} else {
++		dev_info(dev, "Found configuration file: %s\n",
++			MXT_CFG_NAME);
+ 	}
++	
++	data->sysfs_updating_config = true;
+ 
+-	return count;
++	if (data->suspend_mode == MXT_SUSPEND_DEEP_SLEEP) {
++		mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
++	}
++
++	ret = mxt_configure_objects(data, cfg);
++	if (ret)
++		goto release;
++
++	ret = count;
++
++release:
++	release_firmware(cfg);
++out:
++	return ret;
++}
++
++static ssize_t mxt_debug_enable_show(struct device *dev,
++	struct device_attribute *attr, char *buf)
++{
++	struct mxt_data *data = dev_get_drvdata(dev);
++	char c;
++
++	c = data->debug_enabled ? '1' : '0';
++	return scnprintf(buf, PAGE_SIZE, "%c\n", c);
++}
++
++static ssize_t mxt_debug_notify_show(struct device *dev,
++	struct device_attribute *attr, char *buf)
++{
++	return sprintf(buf, "0\n");
++}
++
++static ssize_t mxt_debug_v2_enable_store(struct device *dev,
++	struct device_attribute *attr, const char *buf, size_t count)
++{
++	struct mxt_data *data = dev_get_drvdata(dev);
++	u8 i;
++	ssize_t ret;
++
++	if (kstrtou8(buf, 0, &i) == 0 && i < 2) {
++		if (i == 1)
++			mxt_debug_msg_enable(data);
++		else
++			mxt_debug_msg_disable(data);
++
++		ret = count;
++	} else {
++		dev_dbg(dev, "debug_enabled write error\n");
++		ret = -EINVAL;
++	}
++
++	return ret;
++}
++
++static ssize_t mxt_debug_enable_store(struct device *dev,
++	struct device_attribute *attr, const char *buf, size_t count)
++{
++	struct mxt_data *data = dev_get_drvdata(dev);
++	u8 i;
++	ssize_t ret;
++
++	if (kstrtou8(buf, 0, &i) == 0 && i < 2) {
++		data->debug_enabled = (i == 1);
++
++		dev_dbg(dev, "%s\n", i ? "debug enabled" : "debug disabled");
++		ret = count;
++	} else {
++		dev_dbg(dev, "debug_enabled write error\n");
++		ret = -EINVAL;
++	}
++
++	return ret;
++}
++
++static int mxt_check_mem_access_params(struct mxt_data *data, loff_t off,
++				       size_t *count)
++{
++	if (off >= data->mem_size)
++		return -EIO;
++
++	if (off + *count > data->mem_size)
++		*count = data->mem_size - off;
++
++	if (*count > MXT_MAX_BLOCK_WRITE)
++		*count = MXT_MAX_BLOCK_WRITE;
++
++	return 0;
++}
++
++static ssize_t mxt_mem_access_read(struct file *filp, struct kobject *kobj,
++	struct bin_attribute *bin_attr, char *buf, loff_t off, size_t count)
++{
++	struct device *dev = container_of(kobj, struct device, kobj);
++	struct mxt_data *data = dev_get_drvdata(dev);
++	int ret = 0;
++
++	ret = mxt_check_mem_access_params(data, off, &count);
++	if (ret < 0)
++		return ret;
++
++	if (count > 0)
++		ret = __mxt_read_reg(data->client, off, count, buf);
++
++	return ret == 0 ? count : ret;
++}
++
++static ssize_t mxt_mem_access_write(struct file *filp, struct kobject *kobj,
++	struct bin_attribute *bin_attr, char *buf, loff_t off,
++	size_t count)
++{
++	struct device *dev = container_of(kobj, struct device, kobj);
++	struct mxt_data *data = dev_get_drvdata(dev);
++	int ret = 0;
++
++	ret = mxt_check_mem_access_params(data, off, &count);
++	if (ret < 0)
++		return ret;
++
++	if (count > 0)
++		ret = __mxt_write_reg(data->client, off, count, buf);
++
++	return ret == 0 ? count : ret;
+ }
+ 
+ static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
+ static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
+ static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
++static DEVICE_ATTR(update_cfg, S_IWUSR, NULL, mxt_update_cfg_store);
++static DEVICE_ATTR(config_crc, S_IRUGO, mxt_config_crc_show, NULL);
+ static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
++static DEVICE_ATTR(debug_enable, S_IWUSR | S_IRUSR, mxt_debug_enable_show,
++		   mxt_debug_enable_store);
++static DEVICE_ATTR(debug_v2_enable, S_IWUSR | S_IRUSR, NULL,
++		   mxt_debug_v2_enable_store);
++static DEVICE_ATTR(debug_notify, S_IRUGO, mxt_debug_notify_show, NULL);
+ 
+ static struct attribute *mxt_attrs[] = {
+ 	&dev_attr_fw_version.attr,
+ 	&dev_attr_hw_version.attr,
+ 	&dev_attr_object.attr,
++	&dev_attr_update_cfg.attr,
++	&dev_attr_config_crc.attr,
+ 	&dev_attr_update_fw.attr,
++	&dev_attr_debug_enable.attr,
++	&dev_attr_debug_v2_enable.attr,
++	&dev_attr_debug_notify.attr,
+ 	NULL
+ };
+ 
+@@ -2378,9 +3909,54 @@ static const struct attribute_group mxt_attr_group = {
+ 	.attrs = mxt_attrs,
+ };
+ 
++static int mxt_sysfs_init(struct mxt_data *data)
++{
++	struct i2c_client *client = data->client;
++	int error;
++
++	error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
++	if (error) {
++		dev_err(&client->dev, "Failure %d creating sysfs group\n",
++			error);
++		return error;
++	}
++
++	sysfs_bin_attr_init(&data->mem_access_attr);
++	data->mem_access_attr.attr.name = "mem_access";
++	data->mem_access_attr.attr.mode = S_IRUGO | S_IWUSR;
++	data->mem_access_attr.read = mxt_mem_access_read;
++	data->mem_access_attr.write = mxt_mem_access_write;
++	data->mem_access_attr.size = data->mem_size;
++
++	error = sysfs_create_bin_file(&client->dev.kobj,
++				  &data->mem_access_attr);
++	if (error) {
++		dev_err(&client->dev, "Failed to create %s\n",
++			data->mem_access_attr.attr.name);
++		goto err_remove_sysfs_group;
++	}
++
++	return 0;
++
++err_remove_sysfs_group:
++	sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
++	return error;
++}
++
++static void mxt_sysfs_remove(struct mxt_data *data)
++{
++	struct i2c_client *client = data->client;
++
++	if (data->mem_access_attr.attr.name)
++		sysfs_remove_bin_file(&client->dev.kobj,
++				      &data->mem_access_attr);
++
++	sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
++}
++
+ static void mxt_start(struct mxt_data *data)
+ {
+-	switch (data->pdata->suspend_mode) {
++	switch (data->suspend_mode) {
+ 	case MXT_SUSPEND_T9_CTRL:
+ 		mxt_soft_reset(data);
+ 
+@@ -2398,12 +3974,11 @@ static void mxt_start(struct mxt_data *data)
+ 		mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false);
+ 		break;
+ 	}
+-
+ }
+ 
+ static void mxt_stop(struct mxt_data *data)
+ {
+-	switch (data->pdata->suspend_mode) {
++	switch (data->suspend_mode) {
+ 	case MXT_SUSPEND_T9_CTRL:
+ 		/* Touch disable */
+ 		mxt_write_object(data,
+@@ -2433,131 +4008,75 @@ static void mxt_input_close(struct input_dev *dev)
+ 	mxt_stop(data);
+ }
+ 
+-#ifdef CONFIG_OF
+-static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
++static int mxt_parse_device_properties(struct mxt_data *data)
+ {
+-	struct mxt_platform_data *pdata;
+-	struct device_node *np = client->dev.of_node;
++	static const char keymap_property[] = "linux,gpio-keymap";
++	struct device *dev = &data->client->dev;
+ 	u32 *keymap;
+-	int proplen, ret;
+-
+-	if (!np)
+-		return ERR_PTR(-ENOENT);
+-
+-	pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
+-	if (!pdata)
+-		return ERR_PTR(-ENOMEM);
++	int n_keys;
++	int error;
+ 
+-	if (of_find_property(np, "linux,gpio-keymap", &proplen)) {
+-		pdata->t19_num_keys = proplen / sizeof(u32);
++	if (device_property_present(dev, keymap_property)) {
++		n_keys = device_property_read_u32_array(dev, keymap_property,
++							NULL, 0);
++		if (n_keys <= 0) {
++			error = n_keys < 0 ? n_keys : -EINVAL;
++			dev_err(dev, "invalid/malformed '%s' property: %d\n",
++				keymap_property, error);
++			return error;
++		}
+ 
+-		keymap = devm_kzalloc(&client->dev,
+-				pdata->t19_num_keys * sizeof(keymap[0]),
+-				GFP_KERNEL);
++		keymap = devm_kmalloc_array(dev, n_keys, sizeof(*keymap),
++					    GFP_KERNEL);
+ 		if (!keymap)
+-			return ERR_PTR(-ENOMEM);
++			return -ENOMEM;
+ 
+-		ret = of_property_read_u32_array(np, "linux,gpio-keymap",
+-						 keymap, pdata->t19_num_keys);
+-		if (ret)
+-			dev_warn(&client->dev,
+-				 "Couldn't read linux,gpio-keymap: %d\n", ret);
++		error = device_property_read_u32_array(dev, keymap_property,
++						       keymap, n_keys);
++		if (error) {
++			dev_err(dev, "failed to parse '%s' property: %d\n",
++				keymap_property, error);
++			return error;
++		}
+ 
+-		pdata->t19_keymap = keymap;
++		data->t19_keymap = keymap;
++		data->t19_num_keys = n_keys;
+ 	}
+ 
+-	pdata->suspend_mode = MXT_SUSPEND_DEEP_SLEEP;
+-
+-	return pdata;
+-}
+-#else
+-static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
+-{
+-	return ERR_PTR(-ENOENT);
++	return 0;
+ }
+-#endif
+-
+-#ifdef CONFIG_ACPI
+-
+-struct mxt_acpi_platform_data {
+-	const char *hid;
+-	struct mxt_platform_data pdata;
+-};
+-
+-static unsigned int samus_touchpad_buttons[] = {
+-	KEY_RESERVED,
+-	KEY_RESERVED,
+-	KEY_RESERVED,
+-	BTN_LEFT
+-};
+ 
+-static struct mxt_acpi_platform_data samus_platform_data[] = {
++static const struct dmi_system_id chromebook_T9_suspend_dmi[] = {
+ 	{
+-		/* Touchpad */
+-		.hid	= "ATML0000",
+-		.pdata	= {
+-			.t19_num_keys	= ARRAY_SIZE(samus_touchpad_buttons),
+-			.t19_keymap	= samus_touchpad_buttons,
+-		},
+-	},
+-	{
+-		/* Touchscreen */
+-		.hid	= "ATML0001",
+-	},
+-	{ }
+-};
+-
+-static unsigned int chromebook_tp_buttons[] = {
+-	KEY_RESERVED,
+-	KEY_RESERVED,
+-	KEY_RESERVED,
+-	KEY_RESERVED,
+-	KEY_RESERVED,
+-	BTN_LEFT
+-};
+-
+-static struct mxt_acpi_platform_data chromebook_platform_data[] = {
+-	{
+-		/* Touchpad */
+-		.hid	= "ATML0000",
+-		.pdata	= {
+-			.t19_num_keys	= ARRAY_SIZE(chromebook_tp_buttons),
+-			.t19_keymap	= chromebook_tp_buttons,
+-		},
+-	},
+-	{
+-		/* Touchscreen */
+-		.hid	= "ATML0001",
+-	},
+-	{ }
+-};
+-
+-static const struct dmi_system_id mxt_dmi_table[] = {
+-	{
+-		/* 2015 Google Pixel */
+-		.ident = "Chromebook Pixel 2",
+ 		.matches = {
+ 			DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
+-			DMI_MATCH(DMI_PRODUCT_NAME, "Samus"),
++			DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
+ 		},
+-		.driver_data = samus_platform_data,
+ 	},
+ 	{
+-		/* Other Google Chromebooks */
+-		.ident = "Chromebook",
+ 		.matches = {
+-			DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
++			DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
+ 		},
+-		.driver_data = chromebook_platform_data,
+ 	},
+ 	{ }
+ };
+ 
+-static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
++static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
+ {
+-	struct acpi_device *adev;
+-	const struct dmi_system_id *system_id;
+-	const struct mxt_acpi_platform_data *acpi_pdata;
++	struct mxt_data *data;
++	int error;
++
++	/*
++	 * Ignore devices that do not have device properties attached to
++	 * them, as we need help determining whether we are dealing with
++	 * touch screen or touchpad.
++	 *
++	 * So far on x86 the only users of Atmel touch controllers are
++	 * Chromebooks, and chromeos_laptop driver will ensure that
++	 * necessary properties are provided (if firmware does not do that).
++	 */
++	if (!device_property_present(&client->dev, "compatible"))
++		return -ENXIO;
+ 
+ 	/*
+ 	 * Ignore ACPI devices representing bootloader mode.
+@@ -2569,79 +4088,17 @@ static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
+ 	 * application mode addresses were all above 0x40, so we'll use it
+ 	 * as a threshold.
+ 	 */
+-	if (client->addr < 0x40)
+-		return ERR_PTR(-ENXIO);
+-
+-	adev = ACPI_COMPANION(&client->dev);
+-	if (!adev)
+-		return ERR_PTR(-ENOENT);
+-
+-	system_id = dmi_first_match(mxt_dmi_table);
+-	if (!system_id)
+-		return ERR_PTR(-ENOENT);
++	if (ACPI_COMPANION(&client->dev) && client->addr < 0x40)
++		return -ENXIO;
+ 
+-	acpi_pdata = system_id->driver_data;
+-	if (!acpi_pdata)
+-		return ERR_PTR(-ENOENT);
+-
+-	while (acpi_pdata->hid) {
+-		if (!strcmp(acpi_device_hid(adev), acpi_pdata->hid))
+-			return &acpi_pdata->pdata;
+-
+-		acpi_pdata++;
+-	}
+-
+-	return ERR_PTR(-ENOENT);
+-}
+-#else
+-static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
+-{
+-	return ERR_PTR(-ENOENT);
+-}
+-#endif
+-
+-static const struct mxt_platform_data *
+-mxt_get_platform_data(struct i2c_client *client)
+-{
+-	const struct mxt_platform_data *pdata;
+-
+-	pdata = dev_get_platdata(&client->dev);
+-	if (pdata)
+-		return pdata;
+-
+-	pdata = mxt_parse_dt(client);
+-	if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
+-		return pdata;
+-
+-	pdata = mxt_parse_acpi(client);
+-	if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
+-		return pdata;
+-
+-	dev_err(&client->dev, "No platform data specified\n");
+-	return ERR_PTR(-EINVAL);
+-}
+-
+-static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
+-{
+-	struct mxt_data *data;
+-	const struct mxt_platform_data *pdata;
+-	int error;
+-
+-	pdata = mxt_get_platform_data(client);
+-	if (IS_ERR(pdata))
+-		return PTR_ERR(pdata);
+-
+-	data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
+-	if (!data) {
+-		dev_err(&client->dev, "Failed to allocate memory\n");
++	data = devm_kzalloc(&client->dev, sizeof(struct mxt_data), GFP_KERNEL);
++	if (!data)
+ 		return -ENOMEM;
+-	}
+ 
+ 	snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
+ 		 client->adapter->nr, client->addr);
+ 
+ 	data->client = client;
+-	data->pdata = pdata;
+ 	data->irq = client->irq;
+ 	i2c_set_clientdata(client, data);
+ 
+@@ -2649,48 +4106,78 @@ static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
+ 	init_completion(&data->reset_completion);
+ 	init_completion(&data->crc_completion);
+ 
+-	error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
+-				     pdata->irqflags | IRQF_ONESHOT,
+-				     client->name, data);
++	data->suspend_mode = dmi_check_system(chromebook_T9_suspend_dmi) ?
++		MXT_SUSPEND_T9_CTRL : MXT_SUSPEND_DEEP_SLEEP;
++
++	error = mxt_parse_device_properties(data);
++	if (error)
++		return error;
++
++	data->reset_gpio = devm_gpiod_get_optional(&client->dev,
++						   "reset", GPIOD_OUT_LOW);
++	if (IS_ERR(data->reset_gpio)) {
++		error = PTR_ERR(data->reset_gpio);
++		dev_err(&client->dev, "Failed to get reset gpio: %d\n", error);
++		return error;
++	} else {
++		dev_dbg(&client->dev, "Got Reset GPIO\n");
++	  }
++
++	error = devm_request_threaded_irq(&client->dev, client->irq,
++					  NULL, mxt_interrupt, IRQF_ONESHOT,
++					  client->name, data);
+ 	if (error) {
+ 		dev_err(&client->dev, "Failed to register interrupt\n");
+-		goto err_free_mem;
++		return error;
+ 	}
+ 
+ 	disable_irq(client->irq);
+ 
++	if(!(IS_ERR(data->reset_gpio))) {
++		gpiod_direction_output(data->reset_gpio, 1);	/* GPIO in device tree is active-low */
++		dev_dbg(&client->dev, "Direction is ouput\n");
++	}
++	
++	if(!(IS_ERR(data->reset_gpio))) {
++		dev_info(&client->dev, "Resetting chip\n");
++		msleep(MXT_RESET_GPIO_TIME);
++		gpiod_set_value(data->reset_gpio, 1);
++		msleep(MXT_RESET_INVALID_CHG);
++		gpiod_set_value(data->reset_gpio, 0);
++	}
++
+ 	error = mxt_initialize(data);
+ 	if (error)
+-		goto err_free_irq;
++		return error;
+ 
+-	error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
+-	if (error) {
+-		dev_err(&client->dev, "Failure %d creating sysfs group\n",
+-			error);
+-		goto err_free_object;
+-	}
++	/* Removed the mxt_sys_init and mxt_debug_msg_init */
++	/* out of mxt_initialize to avoid duplicate inits */
++
++	error = mxt_sysfs_init(data);
++	if (error)
++		return error;
++
++	error = mxt_debug_msg_init(data);
++	if (error)
++		return error;
++
++	mutex_init(&data->debug_msg_lock);
+ 
+ 	return 0;
+ 
+-err_free_object:
+-	mxt_free_input_device(data);
+-	mxt_free_object_table(data);
+-err_free_irq:
+-	free_irq(client->irq, data);
+-err_free_mem:
+-	kfree(data);
+-	return error;
+ }
+ 
+ static int mxt_remove(struct i2c_client *client)
+ {
+ 	struct mxt_data *data = i2c_get_clientdata(client);
+ 
++	mxt_debug_msg_remove(data);	
++	mxt_sysfs_remove(data);
++
++	disable_irq(data->irq);
+ 	sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
+-	free_irq(data->irq, data);
+ 	mxt_free_input_device(data);
+ 	mxt_free_object_table(data);
+-	kfree(data);
+ 
+ 	return 0;
+ }
+@@ -2737,6 +4224,11 @@ static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
+ 
+ static const struct of_device_id mxt_of_match[] = {
+ 	{ .compatible = "atmel,maxtouch", },
++	/* Compatibles listed below are deprecated */
++	{ .compatible = "atmel,qt602240_ts", },
++	{ .compatible = "atmel,atmel_mxt_ts", },
++	{ .compatible = "atmel,atmel_mxt_tp", },
++	{ .compatible = "atmel,mXT224", },
+ 	{},
+ };
+ MODULE_DEVICE_TABLE(of, mxt_of_match);
+@@ -2763,7 +4255,7 @@ MODULE_DEVICE_TABLE(i2c, mxt_id);
+ static struct i2c_driver mxt_driver = {
+ 	.driver = {
+ 		.name	= "atmel_mxt_ts",
+-		.of_match_table = of_match_ptr(mxt_of_match),
++		.of_match_table = mxt_of_match,
+ 		.acpi_match_table = ACPI_PTR(mxt_acpi_id),
+ 		.pm	= &mxt_pm_ops,
+ 	},