atmel_mxt_ts.c - drivers/input/touchscreen/atmel_mxt_ts.c - Linux diff v6.2

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Atmel maXTouch Touchscreen driver
   4 *
   5 * Copyright (C) 2010 Samsung Electronics Co.Ltd
   6 * Copyright (C) 2011-2014 Atmel Corporation
   7 * Copyright (C) 2012 Google, Inc.
   8 * Copyright (C) 2016 Zodiac Inflight Innovations
   9 *
  10 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
 
 
 
 
 
 
  11 */
  12
  13#include <linux/acpi.h>
  14#include <linux/dmi.h>
  15#include <linux/module.h>
  16#include <linux/init.h>
  17#include <linux/completion.h>
  18#include <linux/delay.h>
  19#include <linux/firmware.h>
  20#include <linux/i2c.h>
 
  21#include <linux/input/mt.h>
  22#include <linux/interrupt.h>
  23#include <linux/irq.h>
  24#include <linux/of.h>
  25#include <linux/property.h>
  26#include <linux/slab.h>
  27#include <linux/regulator/consumer.h>
  28#include <linux/gpio/consumer.h>
  29#include <asm/unaligned.h>
  30#include <media/v4l2-device.h>
  31#include <media/v4l2-ioctl.h>
  32#include <media/videobuf2-v4l2.h>
  33#include <media/videobuf2-vmalloc.h>
  34#include <dt-bindings/input/atmel-maxtouch.h>
  35
  36/* Firmware files */
  37#define MXT_FW_NAME		"maxtouch.fw"
  38#define MXT_CFG_NAME		"maxtouch.cfg"
  39#define MXT_CFG_MAGIC		"OBP_RAW V1"
  40
  41/* Registers */
  42#define MXT_OBJECT_START	0x07
  43#define MXT_OBJECT_SIZE		6
  44#define MXT_INFO_CHECKSUM_SIZE	3
  45#define MXT_MAX_BLOCK_WRITE	256
  46
  47/* Object types */
  48#define MXT_DEBUG_DIAGNOSTIC_T37	37
  49#define MXT_GEN_MESSAGE_T5		5
  50#define MXT_GEN_COMMAND_T6		6
  51#define MXT_GEN_POWER_T7		7
  52#define MXT_GEN_ACQUIRE_T8		8
  53#define MXT_GEN_DATASOURCE_T53		53
  54#define MXT_TOUCH_MULTI_T9		9
  55#define MXT_TOUCH_KEYARRAY_T15		15
  56#define MXT_TOUCH_PROXIMITY_T23		23
  57#define MXT_TOUCH_PROXKEY_T52		52
  58#define MXT_PROCI_GRIPFACE_T20		20
  59#define MXT_PROCG_NOISE_T22		22
  60#define MXT_PROCI_ONETOUCH_T24		24
  61#define MXT_PROCI_TWOTOUCH_T27		27
  62#define MXT_PROCI_GRIP_T40		40
  63#define MXT_PROCI_PALM_T41		41
  64#define MXT_PROCI_TOUCHSUPPRESSION_T42	42
  65#define MXT_PROCI_STYLUS_T47		47
  66#define MXT_PROCG_NOISESUPPRESSION_T48	48
  67#define MXT_SPT_COMMSCONFIG_T18		18
  68#define MXT_SPT_GPIOPWM_T19		19
  69#define MXT_SPT_SELFTEST_T25		25
  70#define MXT_SPT_CTECONFIG_T28		28
  71#define MXT_SPT_USERDATA_T38		38
  72#define MXT_SPT_DIGITIZER_T43		43
  73#define MXT_SPT_MESSAGECOUNT_T44	44
  74#define MXT_SPT_CTECONFIG_T46		46
  75#define MXT_SPT_DYNAMICCONFIGURATIONCONTAINER_T71 71
  76#define MXT_TOUCH_MULTITOUCHSCREEN_T100 100
  77
  78/* MXT_GEN_MESSAGE_T5 object */
  79#define MXT_RPTID_NOMSG		0xff
  80
  81/* MXT_GEN_COMMAND_T6 field */
  82#define MXT_COMMAND_RESET	0
  83#define MXT_COMMAND_BACKUPNV	1
  84#define MXT_COMMAND_CALIBRATE	2
  85#define MXT_COMMAND_REPORTALL	3
  86#define MXT_COMMAND_DIAGNOSTIC	5
  87
  88/* Define for T6 status byte */
  89#define MXT_T6_STATUS_RESET	BIT(7)
  90#define MXT_T6_STATUS_OFL	BIT(6)
  91#define MXT_T6_STATUS_SIGERR	BIT(5)
  92#define MXT_T6_STATUS_CAL	BIT(4)
  93#define MXT_T6_STATUS_CFGERR	BIT(3)
  94#define MXT_T6_STATUS_COMSERR	BIT(2)
  95
  96/* MXT_GEN_POWER_T7 field */
  97struct t7_config {
  98	u8 idle;
  99	u8 active;
 100} __packed;
 101
 102#define MXT_POWER_CFG_RUN		0
 103#define MXT_POWER_CFG_DEEPSLEEP		1
 104
 105/* MXT_TOUCH_MULTI_T9 field */
 106#define MXT_T9_CTRL		0
 107#define MXT_T9_XSIZE		3
 108#define MXT_T9_YSIZE		4
 109#define MXT_T9_ORIENT		9
 110#define MXT_T9_RANGE		18
 111
 112/* MXT_TOUCH_MULTI_T9 status */
 113#define MXT_T9_UNGRIP		BIT(0)
 114#define MXT_T9_SUPPRESS		BIT(1)
 115#define MXT_T9_AMP		BIT(2)
 116#define MXT_T9_VECTOR		BIT(3)
 117#define MXT_T9_MOVE		BIT(4)
 118#define MXT_T9_RELEASE		BIT(5)
 119#define MXT_T9_PRESS		BIT(6)
 120#define MXT_T9_DETECT		BIT(7)
 121
 122struct t9_range {
 123	__le16 x;
 124	__le16 y;
 125} __packed;
 126
 127/* MXT_TOUCH_MULTI_T9 orient */
 128#define MXT_T9_ORIENT_SWITCH	BIT(0)
 129#define MXT_T9_ORIENT_INVERTX	BIT(1)
 130#define MXT_T9_ORIENT_INVERTY	BIT(2)
 131
 132/* MXT_SPT_COMMSCONFIG_T18 */
 133#define MXT_COMMS_CTRL		0
 134#define MXT_COMMS_CMD		1
 135#define MXT_COMMS_RETRIGEN	BIT(6)
 136
 137/* MXT_DEBUG_DIAGNOSTIC_T37 */
 138#define MXT_DIAGNOSTIC_PAGEUP	0x01
 139#define MXT_DIAGNOSTIC_DELTAS	0x10
 140#define MXT_DIAGNOSTIC_REFS	0x11
 141#define MXT_DIAGNOSTIC_SIZE	128
 142
 143#define MXT_FAMILY_1386			160
 144#define MXT1386_COLUMNS			3
 145#define MXT1386_PAGES_PER_COLUMN	8
 146
 147struct t37_debug {
 148#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
 149	u8 mode;
 150	u8 page;
 151	u8 data[MXT_DIAGNOSTIC_SIZE];
 152#endif
 153};
 154
 155/* Define for MXT_GEN_COMMAND_T6 */
 156#define MXT_BOOT_VALUE		0xa5
 157#define MXT_RESET_VALUE		0x01
 158#define MXT_BACKUP_VALUE	0x55
 159
 160/* T100 Multiple Touch Touchscreen */
 161#define MXT_T100_CTRL		0
 162#define MXT_T100_CFG1		1
 163#define MXT_T100_TCHAUX		3
 164#define MXT_T100_XSIZE		9
 165#define MXT_T100_XRANGE		13
 166#define MXT_T100_YSIZE		20
 167#define MXT_T100_YRANGE		24
 168
 169#define MXT_T100_CFG_SWITCHXY	BIT(5)
 170#define MXT_T100_CFG_INVERTY	BIT(6)
 171#define MXT_T100_CFG_INVERTX	BIT(7)
 172
 173#define MXT_T100_TCHAUX_VECT	BIT(0)
 174#define MXT_T100_TCHAUX_AMPL	BIT(1)
 175#define MXT_T100_TCHAUX_AREA	BIT(2)
 176
 177#define MXT_T100_DETECT		BIT(7)
 178#define MXT_T100_TYPE_MASK	0x70
 179
 180enum t100_type {
 181	MXT_T100_TYPE_FINGER		= 1,
 182	MXT_T100_TYPE_PASSIVE_STYLUS	= 2,
 183	MXT_T100_TYPE_HOVERING_FINGER	= 4,
 184	MXT_T100_TYPE_GLOVE		= 5,
 185	MXT_T100_TYPE_LARGE_TOUCH	= 6,
 186};
 187
 188#define MXT_DISTANCE_ACTIVE_TOUCH	0
 189#define MXT_DISTANCE_HOVERING		1
 190
 191#define MXT_TOUCH_MAJOR_DEFAULT		1
 192#define MXT_PRESSURE_DEFAULT		1
 193
 194/* Delay times */
 195#define MXT_BACKUP_TIME		50	/* msec */
 196#define MXT_RESET_GPIO_TIME	20	/* msec */
 197#define MXT_RESET_INVALID_CHG	100	/* msec */
 198#define MXT_RESET_TIME		200	/* msec */
 199#define MXT_RESET_TIMEOUT	3000	/* msec */
 200#define MXT_CRC_TIMEOUT		1000	/* msec */
 201#define MXT_FW_RESET_TIME	3000	/* msec */
 202#define MXT_FW_CHG_TIMEOUT	300	/* msec */
 203#define MXT_WAKEUP_TIME		25	/* msec */
 204
 205/* Command to unlock bootloader */
 206#define MXT_UNLOCK_CMD_MSB	0xaa
 207#define MXT_UNLOCK_CMD_LSB	0xdc
 208
 209/* Bootloader mode status */
 210#define MXT_WAITING_BOOTLOAD_CMD	0xc0	/* valid 7 6 bit only */
 211#define MXT_WAITING_FRAME_DATA	0x80	/* valid 7 6 bit only */
 212#define MXT_FRAME_CRC_CHECK	0x02
 213#define MXT_FRAME_CRC_FAIL	0x03
 214#define MXT_FRAME_CRC_PASS	0x04
 215#define MXT_APP_CRC_FAIL	0x40	/* valid 7 8 bit only */
 216#define MXT_BOOT_STATUS_MASK	0x3f
 217#define MXT_BOOT_EXTENDED_ID	BIT(5)
 218#define MXT_BOOT_ID_MASK	0x1f
 219
 220/* Touchscreen absolute values */
 221#define MXT_MAX_AREA		0xff
 222
 223#define MXT_PIXELS_PER_MM	20
 224
 225struct mxt_info {
 226	u8 family_id;
 227	u8 variant_id;
 228	u8 version;
 229	u8 build;
 230	u8 matrix_xsize;
 231	u8 matrix_ysize;
 232	u8 object_num;
 233};
 234
 235struct mxt_object {
 236	u8 type;
 237	u16 start_address;
 238	u8 size_minus_one;
 239	u8 instances_minus_one;
 240	u8 num_report_ids;
 241} __packed;
 242
 243struct mxt_dbg {
 244	u16 t37_address;
 245	u16 diag_cmd_address;
 246	struct t37_debug *t37_buf;
 247	unsigned int t37_pages;
 248	unsigned int t37_nodes;
 249
 250	struct v4l2_device v4l2;
 251	struct v4l2_pix_format format;
 252	struct video_device vdev;
 253	struct vb2_queue queue;
 254	struct mutex lock;
 255	int input;
 256};
 257
 258enum v4l_dbg_inputs {
 259	MXT_V4L_INPUT_DELTAS,
 260	MXT_V4L_INPUT_REFS,
 261	MXT_V4L_INPUT_MAX,
 262};
 263
 264enum mxt_suspend_mode {
 265	MXT_SUSPEND_DEEP_SLEEP	= 0,
 266	MXT_SUSPEND_T9_CTRL	= 1,
 267};
 268
 269/* Config update context */
 270struct mxt_cfg {
 271	u8 *raw;
 272	size_t raw_size;
 273	off_t raw_pos;
 274
 275	u8 *mem;
 276	size_t mem_size;
 277	int start_ofs;
 278
 279	struct mxt_info info;
 280};
 281
 282/* Each client has this additional data */
 283struct mxt_data {
 284	struct i2c_client *client;
 285	struct input_dev *input_dev;
 286	char phys[64];		/* device physical location */
 
 287	struct mxt_object *object_table;
 288	struct mxt_info *info;
 289	void *raw_info_block;
 290	unsigned int irq;
 291	unsigned int max_x;
 292	unsigned int max_y;
 293	bool invertx;
 294	bool inverty;
 295	bool xy_switch;
 296	u8 xsize;
 297	u8 ysize;
 298	bool in_bootloader;
 299	u16 mem_size;
 300	u8 t100_aux_ampl;
 301	u8 t100_aux_area;
 302	u8 t100_aux_vect;
 303	u8 max_reportid;
 304	u32 config_crc;
 305	u32 info_crc;
 306	u8 bootloader_addr;
 307	u8 *msg_buf;
 308	u8 t6_status;
 309	bool update_input;
 310	u8 last_message_count;
 311	u8 num_touchids;
 312	u8 multitouch;
 313	struct t7_config t7_cfg;
 314	struct mxt_dbg dbg;
 315	struct regulator_bulk_data regulators[2];
 316	struct gpio_desc *reset_gpio;
 317	struct gpio_desc *wake_gpio;
 318	bool use_retrigen_workaround;
 319
 320	/* Cached parameters from object table */
 321	u16 T5_address;
 322	u8 T5_msg_size;
 323	u8 T6_reportid;
 324	u16 T6_address;
 325	u16 T7_address;
 326	u16 T71_address;
 327	u8 T9_reportid_min;
 328	u8 T9_reportid_max;
 329	u16 T18_address;
 330	u8 T19_reportid;
 331	u16 T44_address;
 332	u8 T100_reportid_min;
 333	u8 T100_reportid_max;
 334
 335	/* for fw update in bootloader */
 336	struct completion bl_completion;
 337
 338	/* for reset handling */
 339	struct completion reset_completion;
 340
 341	/* for config update handling */
 342	struct completion crc_completion;
 343
 344	u32 *t19_keymap;
 345	unsigned int t19_num_keys;
 346
 347	enum mxt_suspend_mode suspend_mode;
 348
 349	u32 wakeup_method;
 350};
 351
 352struct mxt_vb2_buffer {
 353	struct vb2_buffer	vb;
 354	struct list_head	list;
 355};
 356
 357static size_t mxt_obj_size(const struct mxt_object *obj)
 358{
 359	return obj->size_minus_one + 1;
 360}
 361
 362static size_t mxt_obj_instances(const struct mxt_object *obj)
 363{
 364	return obj->instances_minus_one + 1;
 365}
 366
 367static bool mxt_object_readable(unsigned int type)
 368{
 369	switch (type) {
 370	case MXT_GEN_COMMAND_T6:
 371	case MXT_GEN_POWER_T7:
 372	case MXT_GEN_ACQUIRE_T8:
 373	case MXT_GEN_DATASOURCE_T53:
 374	case MXT_TOUCH_MULTI_T9:
 375	case MXT_TOUCH_KEYARRAY_T15:
 376	case MXT_TOUCH_PROXIMITY_T23:
 377	case MXT_TOUCH_PROXKEY_T52:
 378	case MXT_TOUCH_MULTITOUCHSCREEN_T100:
 379	case MXT_PROCI_GRIPFACE_T20:
 380	case MXT_PROCG_NOISE_T22:
 381	case MXT_PROCI_ONETOUCH_T24:
 382	case MXT_PROCI_TWOTOUCH_T27:
 383	case MXT_PROCI_GRIP_T40:
 384	case MXT_PROCI_PALM_T41:
 385	case MXT_PROCI_TOUCHSUPPRESSION_T42:
 386	case MXT_PROCI_STYLUS_T47:
 387	case MXT_PROCG_NOISESUPPRESSION_T48:
 388	case MXT_SPT_COMMSCONFIG_T18:
 389	case MXT_SPT_GPIOPWM_T19:
 390	case MXT_SPT_SELFTEST_T25:
 391	case MXT_SPT_CTECONFIG_T28:
 392	case MXT_SPT_USERDATA_T38:
 393	case MXT_SPT_DIGITIZER_T43:
 394	case MXT_SPT_CTECONFIG_T46:
 395	case MXT_SPT_DYNAMICCONFIGURATIONCONTAINER_T71:
 396		return true;
 397	default:
 398		return false;
 399	}
 400}
 401
 402static void mxt_dump_message(struct mxt_data *data, u8 *message)
 403{
 404	dev_dbg(&data->client->dev, "message: %*ph\n",
 405		data->T5_msg_size, message);
 406}
 407
 408static int mxt_wait_for_completion(struct mxt_data *data,
 409				   struct completion *comp,
 410				   unsigned int timeout_ms)
 411{
 412	struct device *dev = &data->client->dev;
 413	unsigned long timeout = msecs_to_jiffies(timeout_ms);
 414	long ret;
 415
 416	ret = wait_for_completion_interruptible_timeout(comp, timeout);
 417	if (ret < 0) {
 418		return ret;
 419	} else if (ret == 0) {
 420		dev_err(dev, "Wait for completion timed out.\n");
 421		return -ETIMEDOUT;
 422	}
 423	return 0;
 424}
 425
 426static int mxt_bootloader_read(struct mxt_data *data,
 427			       u8 *val, unsigned int count)
 428{
 429	int ret;
 430	struct i2c_msg msg;
 431
 432	msg.addr = data->bootloader_addr;
 433	msg.flags = data->client->flags & I2C_M_TEN;
 434	msg.flags |= I2C_M_RD;
 435	msg.len = count;
 436	msg.buf = val;
 437
 438	ret = i2c_transfer(data->client->adapter, &msg, 1);
 439	if (ret == 1) {
 440		ret = 0;
 441	} else {
 442		ret = ret < 0 ? ret : -EIO;
 443		dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n",
 444			__func__, ret);
 445	}
 446
 447	return ret;
 448}
 449
 450static int mxt_bootloader_write(struct mxt_data *data,
 451				const u8 * const val, unsigned int count)
 452{
 453	int ret;
 454	struct i2c_msg msg;
 455
 456	msg.addr = data->bootloader_addr;
 457	msg.flags = data->client->flags & I2C_M_TEN;
 458	msg.len = count;
 459	msg.buf = (u8 *)val;
 460
 461	ret = i2c_transfer(data->client->adapter, &msg, 1);
 462	if (ret == 1) {
 463		ret = 0;
 464	} else {
 465		ret = ret < 0 ? ret : -EIO;
 466		dev_err(&data->client->dev, "%s: i2c send failed (%d)\n",
 467			__func__, ret);
 468	}
 469
 470	return ret;
 471}
 472
 473static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
 474{
 475	u8 appmode = data->client->addr;
 476	u8 bootloader;
 477	u8 family_id = data->info ? data->info->family_id : 0;
 478
 479	switch (appmode) {
 480	case 0x4a:
 481	case 0x4b:
 482		/* Chips after 1664S use different scheme */
 483		if (retry || family_id >= 0xa2) {
 484			bootloader = appmode - 0x24;
 485			break;
 486		}
 487		fallthrough;	/* for normal case */
 488	case 0x4c:
 489	case 0x4d:
 490	case 0x5a:
 491	case 0x5b:
 492		bootloader = appmode - 0x26;
 493		break;
 494
 495	default:
 496		dev_err(&data->client->dev,
 497			"Appmode i2c address 0x%02x not found\n",
 498			appmode);
 499		return -EINVAL;
 500	}
 501
 502	data->bootloader_addr = bootloader;
 503	return 0;
 504}
 505
 506static int mxt_probe_bootloader(struct mxt_data *data, bool alt_address)
 507{
 508	struct device *dev = &data->client->dev;
 509	int error;
 510	u8 val;
 511	bool crc_failure;
 512
 513	error = mxt_lookup_bootloader_address(data, alt_address);
 514	if (error)
 515		return error;
 516
 517	error = mxt_bootloader_read(data, &val, 1);
 518	if (error)
 519		return error;
 520
 521	/* Check app crc fail mode */
 522	crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
 523
 524	dev_err(dev, "Detected bootloader, status:%02X%s\n",
 525			val, crc_failure ? ", APP_CRC_FAIL" : "");
 526
 527	return 0;
 528}
 529
 530static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
 531{
 532	struct device *dev = &data->client->dev;
 533	u8 buf[3];
 534
 535	if (val & MXT_BOOT_EXTENDED_ID) {
 536		if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
 537			dev_err(dev, "%s: i2c failure\n", __func__);
 538			return val;
 539		}
 540
 541		dev_dbg(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]);
 542
 543		return buf[0];
 544	} else {
 545		dev_dbg(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK);
 546
 547		return val;
 548	}
 549}
 550
 551static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
 552				bool wait)
 553{
 554	struct device *dev = &data->client->dev;
 555	u8 val;
 556	int ret;
 557
 558recheck:
 559	if (wait) {
 560		/*
 561		 * In application update mode, the interrupt
 562		 * line signals state transitions. We must wait for the
 563		 * CHG assertion before reading the status byte.
 564		 * Once the status byte has been read, the line is deasserted.
 565		 */
 566		ret = mxt_wait_for_completion(data, &data->bl_completion,
 567					      MXT_FW_CHG_TIMEOUT);
 568		if (ret) {
 569			/*
 570			 * TODO: handle -ERESTARTSYS better by terminating
 571			 * fw update process before returning to userspace
 572			 * by writing length 0x000 to device (iff we are in
 573			 * WAITING_FRAME_DATA state).
 574			 */
 575			dev_err(dev, "Update wait error %d\n", ret);
 576			return ret;
 577		}
 578	}
 579
 580	ret = mxt_bootloader_read(data, &val, 1);
 581	if (ret)
 582		return ret;
 583
 584	if (state == MXT_WAITING_BOOTLOAD_CMD)
 585		val = mxt_get_bootloader_version(data, val);
 586
 587	switch (state) {
 588	case MXT_WAITING_BOOTLOAD_CMD:
 589	case MXT_WAITING_FRAME_DATA:
 590	case MXT_APP_CRC_FAIL:
 591		val &= ~MXT_BOOT_STATUS_MASK;
 592		break;
 593	case MXT_FRAME_CRC_PASS:
 594		if (val == MXT_FRAME_CRC_CHECK) {
 595			goto recheck;
 596		} else if (val == MXT_FRAME_CRC_FAIL) {
 597			dev_err(dev, "Bootloader CRC fail\n");
 598			return -EINVAL;
 599		}
 600		break;
 601	default:
 602		return -EINVAL;
 603	}
 604
 605	if (val != state) {
 606		dev_err(dev, "Invalid bootloader state %02X != %02X\n",
 607			val, state);
 608		return -EINVAL;
 609	}
 610
 611	return 0;
 612}
 613
 614static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
 615{
 
 616	u8 buf[2];
 617
 618	if (unlock) {
 619		buf[0] = MXT_UNLOCK_CMD_LSB;
 620		buf[1] = MXT_UNLOCK_CMD_MSB;
 621	} else {
 622		buf[0] = 0x01;
 623		buf[1] = 0x01;
 624	}
 625
 626	return mxt_bootloader_write(data, buf, sizeof(buf));
 627}
 628
 629static bool mxt_wakeup_toggle(struct i2c_client *client,
 630			      bool wake_up, bool in_i2c)
 631{
 632	struct mxt_data *data = i2c_get_clientdata(client);
 633
 634	switch (data->wakeup_method) {
 635	case ATMEL_MXT_WAKEUP_I2C_SCL:
 636		if (!in_i2c)
 637			return false;
 638		break;
 639
 640	case ATMEL_MXT_WAKEUP_GPIO:
 641		if (in_i2c)
 642			return false;
 643
 644		gpiod_set_value(data->wake_gpio, wake_up);
 645		break;
 646
 647	default:
 648		return false;
 649	}
 650
 651	if (wake_up) {
 652		dev_dbg(&client->dev, "waking up controller\n");
 653
 654		msleep(MXT_WAKEUP_TIME);
 655	}
 656
 657	return true;
 658}
 659
 660static int __mxt_read_reg(struct i2c_client *client,
 661			       u16 reg, u16 len, void *val)
 662{
 663	struct i2c_msg xfer[2];
 664	bool retried = false;
 665	u8 buf[2];
 666	int ret;
 667
 668	buf[0] = reg & 0xff;
 669	buf[1] = (reg >> 8) & 0xff;
 670
 671	/* Write register */
 672	xfer[0].addr = client->addr;
 673	xfer[0].flags = 0;
 674	xfer[0].len = 2;
 675	xfer[0].buf = buf;
 676
 677	/* Read data */
 678	xfer[1].addr = client->addr;
 679	xfer[1].flags = I2C_M_RD;
 680	xfer[1].len = len;
 681	xfer[1].buf = val;
 682
 683retry:
 684	ret = i2c_transfer(client->adapter, xfer, 2);
 685	if (ret == 2) {
 686		ret = 0;
 687	} else if (!retried && mxt_wakeup_toggle(client, true, true)) {
 688		retried = true;
 689		goto retry;
 690	} else {
 691		if (ret >= 0)
 692			ret = -EIO;
 693		dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
 694			__func__, ret);
 695	}
 696
 697	return ret;
 698}
 699
 700static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
 701			   const void *val)
 702{
 703	bool retried = false;
 704	u8 *buf;
 705	size_t count;
 706	int ret;
 707
 708	count = len + 2;
 709	buf = kmalloc(count, GFP_KERNEL);
 710	if (!buf)
 711		return -ENOMEM;
 712
 713	buf[0] = reg & 0xff;
 714	buf[1] = (reg >> 8) & 0xff;
 715	memcpy(&buf[2], val, len);
 716
 717retry:
 718	ret = i2c_master_send(client, buf, count);
 719	if (ret == count) {
 720		ret = 0;
 721	} else if (!retried && mxt_wakeup_toggle(client, true, true)) {
 722		retried = true;
 723		goto retry;
 724	} else {
 725		if (ret >= 0)
 726			ret = -EIO;
 727		dev_err(&client->dev, "%s: i2c send failed (%d)\n",
 728			__func__, ret);
 729	}
 730
 731	kfree(buf);
 732	return ret;
 733}
 734
 735static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
 736{
 737	return __mxt_write_reg(client, reg, 1, &val);
 738}
 739
 740static struct mxt_object *
 741mxt_get_object(struct mxt_data *data, u8 type)
 742{
 743	struct mxt_object *object;
 744	int i;
 745
 746	for (i = 0; i < data->info->object_num; i++) {
 747		object = data->object_table + i;
 748		if (object->type == type)
 749			return object;
 750	}
 751
 752	dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
 753	return NULL;
 754}
 755
 756static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
 757{
 758	struct device *dev = &data->client->dev;
 759	u8 status = msg[1];
 760	u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16);
 761
 
 
 762	if (crc != data->config_crc) {
 763		data->config_crc = crc;
 764		dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc);
 765	}
 766
 767	complete(&data->crc_completion);
 768
 769	/* Detect reset */
 770	if (status & MXT_T6_STATUS_RESET)
 771		complete(&data->reset_completion);
 772
 773	/* Output debug if status has changed */
 774	if (status != data->t6_status)
 775		dev_dbg(dev, "T6 Status 0x%02X%s%s%s%s%s%s%s\n",
 776			status,
 777			status == 0 ? " OK" : "",
 778			status & MXT_T6_STATUS_RESET ? " RESET" : "",
 779			status & MXT_T6_STATUS_OFL ? " OFL" : "",
 780			status & MXT_T6_STATUS_SIGERR ? " SIGERR" : "",
 781			status & MXT_T6_STATUS_CAL ? " CAL" : "",
 782			status & MXT_T6_STATUS_CFGERR ? " CFGERR" : "",
 783			status & MXT_T6_STATUS_COMSERR ? " COMSERR" : "");
 784
 785	/* Save current status */
 786	data->t6_status = status;
 787}
 788
 789static int mxt_write_object(struct mxt_data *data,
 790				 u8 type, u8 offset, u8 val)
 791{
 792	struct mxt_object *object;
 793	u16 reg;
 794
 795	object = mxt_get_object(data, type);
 796	if (!object || offset >= mxt_obj_size(object))
 797		return -EINVAL;
 798
 799	reg = object->start_address;
 800	return mxt_write_reg(data->client, reg + offset, val);
 801}
 802
 803static void mxt_input_button(struct mxt_data *data, u8 *message)
 804{
 805	struct input_dev *input = data->input_dev;
 
 806	int i;
 807
 808	for (i = 0; i < data->t19_num_keys; i++) {
 809		if (data->t19_keymap[i] == KEY_RESERVED)
 810			continue;
 811
 812		/* Active-low switch */
 813		input_report_key(input, data->t19_keymap[i],
 814				 !(message[1] & BIT(i)));
 815	}
 816}
 817
 818static void mxt_input_sync(struct mxt_data *data)
 819{
 820	input_mt_report_pointer_emulation(data->input_dev,
 821					  data->t19_num_keys);
 822	input_sync(data->input_dev);
 823}
 824
 825static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
 826{
 827	struct device *dev = &data->client->dev;
 828	struct input_dev *input_dev = data->input_dev;
 829	int id;
 830	u8 status;
 831	int x;
 832	int y;
 833	int area;
 834	int amplitude;
 835
 836	id = message[0] - data->T9_reportid_min;
 837	status = message[1];
 838	x = (message[2] << 4) | ((message[4] >> 4) & 0xf);
 839	y = (message[3] << 4) | ((message[4] & 0xf));
 840
 841	/* Handle 10/12 bit switching */
 842	if (data->max_x < 1024)
 843		x >>= 2;
 844	if (data->max_y < 1024)
 845		y >>= 2;
 846
 847	area = message[5];
 848	amplitude = message[6];
 849
 850	dev_dbg(dev,
 851		"[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
 852		id,
 853		(status & MXT_T9_DETECT) ? 'D' : '.',
 854		(status & MXT_T9_PRESS) ? 'P' : '.',
 855		(status & MXT_T9_RELEASE) ? 'R' : '.',
 856		(status & MXT_T9_MOVE) ? 'M' : '.',
 857		(status & MXT_T9_VECTOR) ? 'V' : '.',
 858		(status & MXT_T9_AMP) ? 'A' : '.',
 859		(status & MXT_T9_SUPPRESS) ? 'S' : '.',
 860		(status & MXT_T9_UNGRIP) ? 'U' : '.',
 861		x, y, area, amplitude);
 862
 863	input_mt_slot(input_dev, id);
 864
 865	if (status & MXT_T9_DETECT) {
 866		/*
 867		 * Multiple bits may be set if the host is slow to read
 868		 * the status messages, indicating all the events that
 869		 * have happened.
 870		 */
 871		if (status & MXT_T9_RELEASE) {
 872			input_mt_report_slot_inactive(input_dev);
 
 873			mxt_input_sync(data);
 874		}
 875
 876		/* if active, pressure must be non-zero */
 877		if (!amplitude)
 878			amplitude = MXT_PRESSURE_DEFAULT;
 879
 880		/* Touch active */
 881		input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
 882		input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 883		input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 884		input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
 885		input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
 886	} else {
 887		/* Touch no longer active, close out slot */
 888		input_mt_report_slot_inactive(input_dev);
 889	}
 890
 891	data->update_input = true;
 892}
 893
 894static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
 895{
 896	struct device *dev = &data->client->dev;
 897	struct input_dev *input_dev = data->input_dev;
 898	int id;
 899	u8 status;
 900	u8 type = 0;
 901	u16 x;
 902	u16 y;
 903	int distance = 0;
 904	int tool = 0;
 905	u8 major = 0;
 906	u8 pressure = 0;
 907	u8 orientation = 0;
 908
 909	id = message[0] - data->T100_reportid_min - 2;
 910
 911	/* ignore SCRSTATUS events */
 912	if (id < 0)
 913		return;
 914
 915	status = message[1];
 916	x = get_unaligned_le16(&message[2]);
 917	y = get_unaligned_le16(&message[4]);
 918
 919	if (status & MXT_T100_DETECT) {
 920		type = (status & MXT_T100_TYPE_MASK) >> 4;
 921
 922		switch (type) {
 923		case MXT_T100_TYPE_HOVERING_FINGER:
 924			tool = MT_TOOL_FINGER;
 925			distance = MXT_DISTANCE_HOVERING;
 926
 927			if (data->t100_aux_vect)
 928				orientation = message[data->t100_aux_vect];
 929
 930			break;
 931
 932		case MXT_T100_TYPE_FINGER:
 933		case MXT_T100_TYPE_GLOVE:
 934			tool = MT_TOOL_FINGER;
 935			distance = MXT_DISTANCE_ACTIVE_TOUCH;
 936
 937			if (data->t100_aux_area)
 938				major = message[data->t100_aux_area];
 939
 940			if (data->t100_aux_ampl)
 941				pressure = message[data->t100_aux_ampl];
 942
 943			if (data->t100_aux_vect)
 944				orientation = message[data->t100_aux_vect];
 945
 946			break;
 947
 948		case MXT_T100_TYPE_PASSIVE_STYLUS:
 949			tool = MT_TOOL_PEN;
 950
 951			/*
 952			 * Passive stylus is reported with size zero so
 953			 * hardcode.
 954			 */
 955			major = MXT_TOUCH_MAJOR_DEFAULT;
 956
 957			if (data->t100_aux_ampl)
 958				pressure = message[data->t100_aux_ampl];
 959
 960			break;
 961
 962		case MXT_T100_TYPE_LARGE_TOUCH:
 963			/* Ignore suppressed touch */
 964			break;
 965
 966		default:
 967			dev_dbg(dev, "Unexpected T100 type\n");
 968			return;
 969		}
 970	}
 971
 972	/*
 973	 * Values reported should be non-zero if tool is touching the
 974	 * device
 975	 */
 976	if (!pressure && type != MXT_T100_TYPE_HOVERING_FINGER)
 977		pressure = MXT_PRESSURE_DEFAULT;
 978
 979	input_mt_slot(input_dev, id);
 980
 981	if (status & MXT_T100_DETECT) {
 982		dev_dbg(dev, "[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
 983			id, type, x, y, major, pressure, orientation);
 984
 985		input_mt_report_slot_state(input_dev, tool, 1);
 986		input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 987		input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 988		input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, major);
 989		input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
 990		input_report_abs(input_dev, ABS_MT_DISTANCE, distance);
 991		input_report_abs(input_dev, ABS_MT_ORIENTATION, orientation);
 992	} else {
 993		dev_dbg(dev, "[%u] release\n", id);
 994
 995		/* close out slot */
 996		input_mt_report_slot_inactive(input_dev);
 997	}
 998
 999	data->update_input = true;
1000}
1001
1002static int mxt_proc_message(struct mxt_data *data, u8 *message)
1003{
1004	u8 report_id = message[0];
1005
1006	if (report_id == MXT_RPTID_NOMSG)
1007		return 0;
1008
1009	if (report_id == data->T6_reportid) {
1010		mxt_proc_t6_messages(data, message);
1011	} else if (!data->input_dev) {
1012		/*
1013		 * Do not report events if input device
1014		 * is not yet registered.
1015		 */
1016		mxt_dump_message(data, message);
1017	} else if (report_id >= data->T9_reportid_min &&
1018		   report_id <= data->T9_reportid_max) {
1019		mxt_proc_t9_message(data, message);
1020	} else if (report_id >= data->T100_reportid_min &&
1021		   report_id <= data->T100_reportid_max) {
1022		mxt_proc_t100_message(data, message);
1023	} else if (report_id == data->T19_reportid) {
1024		mxt_input_button(data, message);
1025		data->update_input = true;
1026	} else {
1027		mxt_dump_message(data, message);
1028	}
1029
1030	return 1;
1031}
1032
1033static int mxt_read_and_process_messages(struct mxt_data *data, u8 count)
1034{
1035	struct device *dev = &data->client->dev;
1036	int ret;
1037	int i;
1038	u8 num_valid = 0;
1039
1040	/* Safety check for msg_buf */
1041	if (count > data->max_reportid)
1042		return -EINVAL;
1043
1044	/* Process remaining messages if necessary */
1045	ret = __mxt_read_reg(data->client, data->T5_address,
1046				data->T5_msg_size * count, data->msg_buf);
1047	if (ret) {
1048		dev_err(dev, "Failed to read %u messages (%d)\n", count, ret);
1049		return ret;
1050	}
1051
1052	for (i = 0;  i < count; i++) {
1053		ret = mxt_proc_message(data,
1054			data->msg_buf + data->T5_msg_size * i);
1055
1056		if (ret == 1)
1057			num_valid++;
1058	}
1059
1060	/* return number of messages read */
1061	return num_valid;
1062}
1063
1064static irqreturn_t mxt_process_messages_t44(struct mxt_data *data)
1065{
1066	struct device *dev = &data->client->dev;
1067	int ret;
1068	u8 count, num_left;
1069
1070	/* Read T44 and T5 together */
1071	ret = __mxt_read_reg(data->client, data->T44_address,
1072		data->T5_msg_size + 1, data->msg_buf);
1073	if (ret) {
1074		dev_err(dev, "Failed to read T44 and T5 (%d)\n", ret);
1075		return IRQ_NONE;
1076	}
1077
1078	count = data->msg_buf[0];
1079
1080	/*
1081	 * This condition may be caused by the CHG line being configured in
1082	 * Mode 0. It results in unnecessary I2C operations but it is benign.
1083	 */
1084	if (count == 0)
1085		return IRQ_NONE;
1086
1087	if (count > data->max_reportid) {
1088		dev_warn(dev, "T44 count %d exceeded max report id\n", count);
1089		count = data->max_reportid;
1090	}
1091
1092	/* Process first message */
1093	ret = mxt_proc_message(data, data->msg_buf + 1);
1094	if (ret < 0) {
1095		dev_warn(dev, "Unexpected invalid message\n");
1096		return IRQ_NONE;
1097	}
1098
1099	num_left = count - 1;
1100
1101	/* Process remaining messages if necessary */
1102	if (num_left) {
1103		ret = mxt_read_and_process_messages(data, num_left);
1104		if (ret < 0)
1105			goto end;
1106		else if (ret != num_left)
1107			dev_warn(dev, "Unexpected invalid message\n");
1108	}
1109
1110end:
1111	if (data->update_input) {
1112		mxt_input_sync(data);
1113		data->update_input = false;
1114	}
1115
1116	return IRQ_HANDLED;
1117}
1118
1119static int mxt_process_messages_until_invalid(struct mxt_data *data)
1120{
1121	struct device *dev = &data->client->dev;
1122	int count, read;
1123	u8 tries = 2;
1124
1125	count = data->max_reportid;
1126
1127	/* Read messages until we force an invalid */
1128	do {
1129		read = mxt_read_and_process_messages(data, count);
1130		if (read < count)
1131			return 0;
1132	} while (--tries);
1133
1134	if (data->update_input) {
1135		mxt_input_sync(data);
1136		data->update_input = false;
1137	}
1138
1139	dev_err(dev, "CHG pin isn't cleared\n");
1140	return -EBUSY;
1141}
1142
1143static irqreturn_t mxt_process_messages(struct mxt_data *data)
1144{
1145	int total_handled, num_handled;
1146	u8 count = data->last_message_count;
1147
1148	if (count < 1 || count > data->max_reportid)
1149		count = 1;
1150
1151	/* include final invalid message */
1152	total_handled = mxt_read_and_process_messages(data, count + 1);
1153	if (total_handled < 0)
1154		return IRQ_NONE;
1155	/* if there were invalid messages, then we are done */
1156	else if (total_handled <= count)
1157		goto update_count;
1158
1159	/* keep reading two msgs until one is invalid or reportid limit */
1160	do {
1161		num_handled = mxt_read_and_process_messages(data, 2);
1162		if (num_handled < 0)
1163			return IRQ_NONE;
1164
1165		total_handled += num_handled;
1166
1167		if (num_handled < 2)
1168			break;
1169	} while (total_handled < data->num_touchids);
1170
1171update_count:
1172	data->last_message_count = total_handled;
1173
1174	if (data->update_input) {
1175		mxt_input_sync(data);
1176		data->update_input = false;
1177	}
1178
1179	return IRQ_HANDLED;
1180}
1181
1182static irqreturn_t mxt_interrupt(int irq, void *dev_id)
1183{
1184	struct mxt_data *data = dev_id;
1185
1186	if (data->in_bootloader) {
1187		/* bootloader state transition completion */
1188		complete(&data->bl_completion);
1189		return IRQ_HANDLED;
1190	}
1191
1192	if (!data->object_table)
1193		return IRQ_HANDLED;
1194
1195	if (data->T44_address) {
1196		return mxt_process_messages_t44(data);
1197	} else {
1198		return mxt_process_messages(data);
1199	}
1200}
1201
1202static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
1203			  u8 value, bool wait)
1204{
1205	u16 reg;
1206	u8 command_register;
1207	int timeout_counter = 0;
1208	int ret;
1209
1210	reg = data->T6_address + cmd_offset;
1211
1212	ret = mxt_write_reg(data->client, reg, value);
1213	if (ret)
1214		return ret;
1215
1216	if (!wait)
1217		return 0;
1218
1219	do {
1220		msleep(20);
1221		ret = __mxt_read_reg(data->client, reg, 1, &command_register);
1222		if (ret)
1223			return ret;
1224	} while (command_register != 0 && timeout_counter++ <= 100);
1225
1226	if (timeout_counter > 100) {
1227		dev_err(&data->client->dev, "Command failed!\n");
1228		return -EIO;
1229	}
1230
1231	return 0;
1232}
1233
1234static int mxt_acquire_irq(struct mxt_data *data)
1235{
1236	int error;
1237
1238	enable_irq(data->irq);
1239
1240	if (data->use_retrigen_workaround) {
1241		error = mxt_process_messages_until_invalid(data);
1242		if (error)
1243			return error;
1244	}
1245
1246	return 0;
1247}
1248
1249static int mxt_soft_reset(struct mxt_data *data)
1250{
1251	struct device *dev = &data->client->dev;
1252	int ret = 0;
1253
1254	dev_info(dev, "Resetting device\n");
1255
1256	disable_irq(data->irq);
1257
1258	reinit_completion(&data->reset_completion);
1259
1260	ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false);
1261	if (ret)
1262		return ret;
1263
1264	/* Ignore CHG line for 100ms after reset */
1265	msleep(MXT_RESET_INVALID_CHG);
1266
1267	mxt_acquire_irq(data);
1268
1269	ret = mxt_wait_for_completion(data, &data->reset_completion,
1270				      MXT_RESET_TIMEOUT);
1271	if (ret)
1272		return ret;
1273
1274	return 0;
1275}
1276
1277static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
1278{
1279	/*
1280	 * On failure, CRC is set to 0 and config will always be
1281	 * downloaded.
1282	 */
1283	data->config_crc = 0;
1284	reinit_completion(&data->crc_completion);
1285
1286	mxt_t6_command(data, cmd, value, true);
1287
1288	/*
1289	 * Wait for crc message. On failure, CRC is set to 0 and config will
1290	 * always be downloaded.
1291	 */
1292	mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
1293}
1294
1295static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte)
1296{
1297	static const unsigned int crcpoly = 0x80001B;
1298	u32 result;
1299	u32 data_word;
1300
1301	data_word = (secondbyte << 8) | firstbyte;
1302	result = ((*crc << 1) ^ data_word);
1303
1304	if (result & 0x1000000)
1305		result ^= crcpoly;
1306
1307	*crc = result;
1308}
1309
1310static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off)
1311{
1312	u32 crc = 0;
1313	u8 *ptr = base + start_off;
1314	u8 *last_val = base + end_off - 1;
1315
1316	if (end_off < start_off)
1317		return -EINVAL;
1318
1319	while (ptr < last_val) {
1320		mxt_calc_crc24(&crc, *ptr, *(ptr + 1));
1321		ptr += 2;
1322	}
1323
1324	/* if len is odd, fill the last byte with 0 */
1325	if (ptr == last_val)
1326		mxt_calc_crc24(&crc, *ptr, 0);
1327
1328	/* Mask to 24-bit */
1329	crc &= 0x00FFFFFF;
1330
1331	return crc;
1332}
1333
1334static int mxt_check_retrigen(struct mxt_data *data)
1335{
1336	struct i2c_client *client = data->client;
1337	int error;
1338	int val;
1339	struct irq_data *irqd;
1340
1341	data->use_retrigen_workaround = false;
1342
1343	irqd = irq_get_irq_data(data->irq);
1344	if (!irqd)
1345		return -EINVAL;
1346
1347	if (irqd_is_level_type(irqd))
1348		return 0;
1349
1350	if (data->T18_address) {
1351		error = __mxt_read_reg(client,
1352				       data->T18_address + MXT_COMMS_CTRL,
1353				       1, &val);
1354		if (error)
1355			return error;
1356
1357		if (val & MXT_COMMS_RETRIGEN)
1358			return 0;
1359	}
1360
1361	dev_warn(&client->dev, "Enabling RETRIGEN workaround\n");
1362	data->use_retrigen_workaround = true;
1363	return 0;
1364}
1365
1366static int mxt_prepare_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg)
1367{
1368	struct device *dev = &data->client->dev;
1369	struct mxt_object *object;
1370	unsigned int type, instance, size, byte_offset;
1371	int offset;
1372	int ret;
1373	int i;
1374	u16 reg;
1375	u8 val;
1376
1377	while (cfg->raw_pos < cfg->raw_size) {
1378		/* Read type, instance, length */
1379		ret = sscanf(cfg->raw + cfg->raw_pos, "%x %x %x%n",
1380			     &type, &instance, &size, &offset);
1381		if (ret == 0) {
1382			/* EOF */
1383			break;
1384		} else if (ret != 3) {
1385			dev_err(dev, "Bad format: failed to parse object\n");
1386			return -EINVAL;
1387		}
1388		cfg->raw_pos += offset;
1389
1390		object = mxt_get_object(data, type);
1391		if (!object) {
1392			/* Skip object */
1393			for (i = 0; i < size; i++) {
1394				ret = sscanf(cfg->raw + cfg->raw_pos, "%hhx%n",
1395					     &val, &offset);
1396				if (ret != 1) {
1397					dev_err(dev, "Bad format in T%d at %d\n",
1398						type, i);
1399					return -EINVAL;
1400				}
1401				cfg->raw_pos += offset;
1402			}
1403			continue;
1404		}
1405
1406		if (size > mxt_obj_size(object)) {
1407			/*
1408			 * Either we are in fallback mode due to wrong
1409			 * config or config from a later fw version,
1410			 * or the file is corrupt or hand-edited.
1411			 */
1412			dev_warn(dev, "Discarding %zu byte(s) in T%u\n",
1413				 size - mxt_obj_size(object), type);
1414		} else if (mxt_obj_size(object) > size) {
1415			/*
1416			 * If firmware is upgraded, new bytes may be added to
1417			 * end of objects. It is generally forward compatible
1418			 * to zero these bytes - previous behaviour will be
1419			 * retained. However this does invalidate the CRC and
1420			 * will force fallback mode until the configuration is
1421			 * updated. We warn here but do nothing else - the
1422			 * malloc has zeroed the entire configuration.
1423			 */
1424			dev_warn(dev, "Zeroing %zu byte(s) in T%d\n",
1425				 mxt_obj_size(object) - size, type);
1426		}
1427
1428		if (instance >= mxt_obj_instances(object)) {
1429			dev_err(dev, "Object instances exceeded!\n");
1430			return -EINVAL;
1431		}
1432
1433		reg = object->start_address + mxt_obj_size(object) * instance;
1434
1435		for (i = 0; i < size; i++) {
1436			ret = sscanf(cfg->raw + cfg->raw_pos, "%hhx%n",
1437				     &val,
1438				     &offset);
1439			if (ret != 1) {
1440				dev_err(dev, "Bad format in T%d at %d\n",
1441					type, i);
1442				return -EINVAL;
1443			}
1444			cfg->raw_pos += offset;
1445
1446			if (i > mxt_obj_size(object))
1447				continue;
1448
1449			byte_offset = reg + i - cfg->start_ofs;
1450
1451			if (byte_offset >= 0 && byte_offset < cfg->mem_size) {
1452				*(cfg->mem + byte_offset) = val;
1453			} else {
1454				dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
1455					reg, object->type, byte_offset);
1456				return -EINVAL;
1457			}
1458		}
1459	}
1460
1461	return 0;
1462}
1463
1464static int mxt_upload_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg)
 
1465{
1466	unsigned int byte_offset = 0;
1467	int error;
1468
1469	/* Write configuration as blocks */
1470	while (byte_offset < cfg->mem_size) {
1471		unsigned int size = cfg->mem_size - byte_offset;
1472
1473		if (size > MXT_MAX_BLOCK_WRITE)
1474			size = MXT_MAX_BLOCK_WRITE;
1475
1476		error = __mxt_write_reg(data->client,
1477					cfg->start_ofs + byte_offset,
1478					size, cfg->mem + byte_offset);
1479		if (error) {
1480			dev_err(&data->client->dev,
1481				"Config write error, ret=%d\n", error);
1482			return error;
1483		}
1484
1485		byte_offset += size;
1486	}
1487
1488	return 0;
1489}
1490
1491static int mxt_init_t7_power_cfg(struct mxt_data *data);
1492
1493/*
1494 * mxt_update_cfg - download configuration to chip
1495 *
1496 * Atmel Raw Config File Format
1497 *
1498 * The first four lines of the raw config file contain:
1499 *  1) Version
1500 *  2) Chip ID Information (first 7 bytes of device memory)
1501 *  3) Chip Information Block 24-bit CRC Checksum
1502 *  4) Chip Configuration 24-bit CRC Checksum
1503 *
1504 * The rest of the file consists of one line per object instance:
1505 *   <TYPE> <INSTANCE> <SIZE> <CONTENTS>
1506 *
1507 *   <TYPE> - 2-byte object type as hex
1508 *   <INSTANCE> - 2-byte object instance number as hex
1509 *   <SIZE> - 2-byte object size as hex
1510 *   <CONTENTS> - array of <SIZE> 1-byte hex values
1511 */
1512static int mxt_update_cfg(struct mxt_data *data, const struct firmware *fw)
1513{
1514	struct device *dev = &data->client->dev;
1515	struct mxt_cfg cfg;
1516	int ret;
1517	int offset;
 
1518	int i;
 
1519	u32 info_crc, config_crc, calculated_crc;
1520	u16 crc_start = 0;
1521
1522	/* Make zero terminated copy of the OBP_RAW file */
1523	cfg.raw = kmemdup_nul(fw->data, fw->size, GFP_KERNEL);
1524	if (!cfg.raw)
1525		return -ENOMEM;
1526
1527	cfg.raw_size = fw->size;
1528
1529	mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
1530
1531	if (strncmp(cfg.raw, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
1532		dev_err(dev, "Unrecognised config file\n");
1533		ret = -EINVAL;
1534		goto release_raw;
1535	}
1536
1537	cfg.raw_pos = strlen(MXT_CFG_MAGIC);
1538
1539	/* Load information block and check */
1540	for (i = 0; i < sizeof(struct mxt_info); i++) {
1541		ret = sscanf(cfg.raw + cfg.raw_pos, "%hhx%n",
1542			     (unsigned char *)&cfg.info + i,
1543			     &offset);
1544		if (ret != 1) {
1545			dev_err(dev, "Bad format\n");
1546			ret = -EINVAL;
1547			goto release_raw;
1548		}
1549
1550		cfg.raw_pos += offset;
1551	}
1552
1553	if (cfg.info.family_id != data->info->family_id) {
1554		dev_err(dev, "Family ID mismatch!\n");
1555		ret = -EINVAL;
1556		goto release_raw;
1557	}
1558
1559	if (cfg.info.variant_id != data->info->variant_id) {
1560		dev_err(dev, "Variant ID mismatch!\n");
1561		ret = -EINVAL;
1562		goto release_raw;
1563	}
1564
1565	/* Read CRCs */
1566	ret = sscanf(cfg.raw + cfg.raw_pos, "%x%n", &info_crc, &offset);
1567	if (ret != 1) {
1568		dev_err(dev, "Bad format: failed to parse Info CRC\n");
1569		ret = -EINVAL;
1570		goto release_raw;
1571	}
1572	cfg.raw_pos += offset;
1573
1574	ret = sscanf(cfg.raw + cfg.raw_pos, "%x%n", &config_crc, &offset);
1575	if (ret != 1) {
1576		dev_err(dev, "Bad format: failed to parse Config CRC\n");
1577		ret = -EINVAL;
1578		goto release_raw;
1579	}
1580	cfg.raw_pos += offset;
1581
1582	/*
1583	 * The Info Block CRC is calculated over mxt_info and the object
1584	 * table. If it does not match then we are trying to load the
1585	 * configuration from a different chip or firmware version, so
1586	 * the configuration CRC is invalid anyway.
1587	 */
1588	if (info_crc == data->info_crc) {
1589		if (config_crc == 0 || data->config_crc == 0) {
1590			dev_info(dev, "CRC zero, attempting to apply config\n");
1591		} else if (config_crc == data->config_crc) {
1592			dev_dbg(dev, "Config CRC 0x%06X: OK\n",
1593				 data->config_crc);
1594			ret = 0;
1595			goto release_raw;
1596		} else {
1597			dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
1598				 data->config_crc, config_crc);
1599		}
1600	} else {
1601		dev_warn(dev,
1602			 "Warning: Info CRC error - device=0x%06X file=0x%06X\n",
1603			 data->info_crc, info_crc);
1604	}
1605
1606	/* Malloc memory to store configuration */
1607	cfg.start_ofs = MXT_OBJECT_START +
1608			data->info->object_num * sizeof(struct mxt_object) +
1609			MXT_INFO_CHECKSUM_SIZE;
1610	cfg.mem_size = data->mem_size - cfg.start_ofs;
1611	cfg.mem = kzalloc(cfg.mem_size, GFP_KERNEL);
1612	if (!cfg.mem) {
1613		ret = -ENOMEM;
1614		goto release_raw;
1615	}
1616
1617	ret = mxt_prepare_cfg_mem(data, &cfg);
 
1618	if (ret)
1619		goto release_mem;
1620
1621	/* Calculate crc of the received configs (not the raw config file) */
1622	if (data->T71_address)
1623		crc_start = data->T71_address;
1624	else if (data->T7_address)
1625		crc_start = data->T7_address;
1626	else
1627		dev_warn(dev, "Could not find CRC start\n");
1628
1629	if (crc_start > cfg.start_ofs) {
1630		calculated_crc = mxt_calculate_crc(cfg.mem,
1631						   crc_start - cfg.start_ofs,
1632						   cfg.mem_size);
1633
1634		if (config_crc > 0 && config_crc != calculated_crc)
1635			dev_warn(dev, "Config CRC in file inconsistent, calculated=%06X, file=%06X\n",
1636				 calculated_crc, config_crc);
1637	}
1638
1639	ret = mxt_upload_cfg_mem(data, &cfg);
 
 
 
 
 
 
 
 
 
1640	if (ret)
1641		goto release_mem;
1642
1643	mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1644
1645	ret = mxt_check_retrigen(data);
1646	if (ret)
1647		goto release_mem;
1648
1649	ret = mxt_soft_reset(data);
1650	if (ret)
1651		goto release_mem;
1652
1653	dev_info(dev, "Config successfully updated\n");
1654
1655	/* T7 config may have changed */
1656	mxt_init_t7_power_cfg(data);
1657
1658release_mem:
1659	kfree(cfg.mem);
1660release_raw:
1661	kfree(cfg.raw);
1662	return ret;
1663}
1664
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1665static void mxt_free_input_device(struct mxt_data *data)
1666{
1667	if (data->input_dev) {
1668		input_unregister_device(data->input_dev);
1669		data->input_dev = NULL;
1670	}
1671}
1672
1673static void mxt_free_object_table(struct mxt_data *data)
1674{
1675#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
1676	video_unregister_device(&data->dbg.vdev);
1677	v4l2_device_unregister(&data->dbg.v4l2);
1678#endif
 
 
1679	data->object_table = NULL;
1680	data->info = NULL;
1681	kfree(data->raw_info_block);
1682	data->raw_info_block = NULL;
1683	kfree(data->msg_buf);
1684	data->msg_buf = NULL;
1685	data->T5_address = 0;
1686	data->T5_msg_size = 0;
1687	data->T6_reportid = 0;
1688	data->T7_address = 0;
1689	data->T71_address = 0;
1690	data->T9_reportid_min = 0;
1691	data->T9_reportid_max = 0;
1692	data->T18_address = 0;
1693	data->T19_reportid = 0;
1694	data->T44_address = 0;
1695	data->T100_reportid_min = 0;
1696	data->T100_reportid_max = 0;
1697	data->max_reportid = 0;
1698}
1699
1700static int mxt_parse_object_table(struct mxt_data *data,
1701				  struct mxt_object *object_table)
1702{
1703	struct i2c_client *client = data->client;
 
 
 
1704	int i;
1705	u8 reportid;
1706	u16 end_address;
1707
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1708	/* Valid Report IDs start counting from 1 */
1709	reportid = 1;
1710	data->mem_size = 0;
1711	for (i = 0; i < data->info->object_num; i++) {
1712		struct mxt_object *object = object_table + i;
1713		u8 min_id, max_id;
1714
1715		le16_to_cpus(&object->start_address);
1716
1717		if (object->num_report_ids) {
1718			min_id = reportid;
1719			reportid += object->num_report_ids *
1720					mxt_obj_instances(object);
1721			max_id = reportid - 1;
1722		} else {
1723			min_id = 0;
1724			max_id = 0;
1725		}
1726
1727		dev_dbg(&data->client->dev,
1728			"T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n",
1729			object->type, object->start_address,
1730			mxt_obj_size(object), mxt_obj_instances(object),
1731			min_id, max_id);
1732
1733		switch (object->type) {
1734		case MXT_GEN_MESSAGE_T5:
1735			if (data->info->family_id == 0x80 &&
1736			    data->info->version < 0x20) {
1737				/*
1738				 * On mXT224 firmware versions prior to V2.0
1739				 * read and discard unused CRC byte otherwise
1740				 * DMA reads are misaligned.
1741				 */
1742				data->T5_msg_size = mxt_obj_size(object);
1743			} else {
1744				/* CRC not enabled, so skip last byte */
1745				data->T5_msg_size = mxt_obj_size(object) - 1;
1746			}
1747			data->T5_address = object->start_address;
1748			break;
1749		case MXT_GEN_COMMAND_T6:
1750			data->T6_reportid = min_id;
1751			data->T6_address = object->start_address;
1752			break;
1753		case MXT_GEN_POWER_T7:
1754			data->T7_address = object->start_address;
1755			break;
1756		case MXT_SPT_DYNAMICCONFIGURATIONCONTAINER_T71:
1757			data->T71_address = object->start_address;
1758			break;
1759		case MXT_TOUCH_MULTI_T9:
1760			data->multitouch = MXT_TOUCH_MULTI_T9;
1761			/* Only handle messages from first T9 instance */
1762			data->T9_reportid_min = min_id;
1763			data->T9_reportid_max = min_id +
1764						object->num_report_ids - 1;
1765			data->num_touchids = object->num_report_ids;
1766			break;
1767		case MXT_SPT_COMMSCONFIG_T18:
1768			data->T18_address = object->start_address;
1769			break;
1770		case MXT_SPT_MESSAGECOUNT_T44:
1771			data->T44_address = object->start_address;
1772			break;
1773		case MXT_SPT_GPIOPWM_T19:
1774			data->T19_reportid = min_id;
1775			break;
1776		case MXT_TOUCH_MULTITOUCHSCREEN_T100:
1777			data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100;
1778			data->T100_reportid_min = min_id;
1779			data->T100_reportid_max = max_id;
1780			/* first two report IDs reserved */
1781			data->num_touchids = object->num_report_ids - 2;
1782			break;
1783		}
1784
1785		end_address = object->start_address
1786			+ mxt_obj_size(object) * mxt_obj_instances(object) - 1;
1787
1788		if (end_address >= data->mem_size)
1789			data->mem_size = end_address + 1;
1790	}
1791
1792	/* Store maximum reportid */
1793	data->max_reportid = reportid;
1794
1795	/* If T44 exists, T5 position has to be directly after */
1796	if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
1797		dev_err(&client->dev, "Invalid T44 position\n");
1798		return -EINVAL;
 
1799	}
1800
1801	data->msg_buf = kcalloc(data->max_reportid,
1802				data->T5_msg_size, GFP_KERNEL);
1803	if (!data->msg_buf)
1804		return -ENOMEM;
1805
1806	return 0;
1807}
1808
1809static int mxt_read_info_block(struct mxt_data *data)
1810{
1811	struct i2c_client *client = data->client;
1812	int error;
1813	size_t size;
1814	void *id_buf, *buf;
1815	uint8_t num_objects;
1816	u32 calculated_crc;
1817	u8 *crc_ptr;
1818
1819	/* If info block already allocated, free it */
1820	if (data->raw_info_block)
1821		mxt_free_object_table(data);
1822
1823	/* Read 7-byte ID information block starting at address 0 */
1824	size = sizeof(struct mxt_info);
1825	id_buf = kzalloc(size, GFP_KERNEL);
1826	if (!id_buf)
1827		return -ENOMEM;
1828
1829	error = __mxt_read_reg(client, 0, size, id_buf);
1830	if (error)
1831		goto err_free_mem;
1832
1833	/* Resize buffer to give space for rest of info block */
1834	num_objects = ((struct mxt_info *)id_buf)->object_num;
1835	size += (num_objects * sizeof(struct mxt_object))
1836		+ MXT_INFO_CHECKSUM_SIZE;
1837
1838	buf = krealloc(id_buf, size, GFP_KERNEL);
1839	if (!buf) {
1840		error = -ENOMEM;
1841		goto err_free_mem;
1842	}
1843	id_buf = buf;
1844
1845	/* Read rest of info block */
1846	error = __mxt_read_reg(client, MXT_OBJECT_START,
1847			       size - MXT_OBJECT_START,
1848			       id_buf + MXT_OBJECT_START);
1849	if (error)
1850		goto err_free_mem;
1851
1852	/* Extract & calculate checksum */
1853	crc_ptr = id_buf + size - MXT_INFO_CHECKSUM_SIZE;
1854	data->info_crc = crc_ptr[0] | (crc_ptr[1] << 8) | (crc_ptr[2] << 16);
1855
1856	calculated_crc = mxt_calculate_crc(id_buf, 0,
1857					   size - MXT_INFO_CHECKSUM_SIZE);
1858
1859	/*
1860	 * CRC mismatch can be caused by data corruption due to I2C comms
1861	 * issue or else device is not using Object Based Protocol (eg i2c-hid)
1862	 */
1863	if ((data->info_crc == 0) || (data->info_crc != calculated_crc)) {
1864		dev_err(&client->dev,
1865			"Info Block CRC error calculated=0x%06X read=0x%06X\n",
1866			calculated_crc, data->info_crc);
1867		error = -EIO;
1868		goto err_free_mem;
1869	}
1870
1871	data->raw_info_block = id_buf;
1872	data->info = (struct mxt_info *)id_buf;
1873
1874	dev_info(&client->dev,
1875		 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
1876		 data->info->family_id, data->info->variant_id,
1877		 data->info->version >> 4, data->info->version & 0xf,
1878		 data->info->build, data->info->object_num);
1879
1880	/* Parse object table information */
1881	error = mxt_parse_object_table(data, id_buf + MXT_OBJECT_START);
1882	if (error) {
1883		dev_err(&client->dev, "Error %d parsing object table\n", error);
1884		mxt_free_object_table(data);
1885		return error;
1886	}
1887
1888	data->object_table = (struct mxt_object *)(id_buf + MXT_OBJECT_START);
1889
1890	return 0;
1891
1892err_free_mem:
1893	kfree(id_buf);
1894	return error;
1895}
1896
1897static int mxt_read_t9_resolution(struct mxt_data *data)
1898{
1899	struct i2c_client *client = data->client;
1900	int error;
1901	struct t9_range range;
1902	unsigned char orient;
1903	struct mxt_object *object;
1904
1905	object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
1906	if (!object)
1907		return -EINVAL;
1908
1909	error = __mxt_read_reg(client,
1910			       object->start_address + MXT_T9_XSIZE,
1911			       sizeof(data->xsize), &data->xsize);
1912	if (error)
1913		return error;
1914
1915	error = __mxt_read_reg(client,
1916			       object->start_address + MXT_T9_YSIZE,
1917			       sizeof(data->ysize), &data->ysize);
1918	if (error)
1919		return error;
1920
1921	error = __mxt_read_reg(client,
1922			       object->start_address + MXT_T9_RANGE,
1923			       sizeof(range), &range);
1924	if (error)
1925		return error;
1926
1927	data->max_x = get_unaligned_le16(&range.x);
1928	data->max_y = get_unaligned_le16(&range.y);
1929
1930	error =  __mxt_read_reg(client,
1931				object->start_address + MXT_T9_ORIENT,
1932				1, &orient);
1933	if (error)
1934		return error;
1935
1936	data->xy_switch = orient & MXT_T9_ORIENT_SWITCH;
1937	data->invertx = orient & MXT_T9_ORIENT_INVERTX;
1938	data->inverty = orient & MXT_T9_ORIENT_INVERTY;
1939
1940	return 0;
1941}
1942
1943static int mxt_read_t100_config(struct mxt_data *data)
1944{
1945	struct i2c_client *client = data->client;
1946	int error;
1947	struct mxt_object *object;
1948	u16 range_x, range_y;
1949	u8 cfg, tchaux;
1950	u8 aux;
1951
1952	object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100);
1953	if (!object)
1954		return -EINVAL;
1955
1956	/* read touchscreen dimensions */
1957	error = __mxt_read_reg(client,
1958			       object->start_address + MXT_T100_XRANGE,
1959			       sizeof(range_x), &range_x);
1960	if (error)
1961		return error;
1962
1963	data->max_x = get_unaligned_le16(&range_x);
1964
1965	error = __mxt_read_reg(client,
1966			       object->start_address + MXT_T100_YRANGE,
1967			       sizeof(range_y), &range_y);
1968	if (error)
1969		return error;
1970
1971	data->max_y = get_unaligned_le16(&range_y);
1972
1973	error = __mxt_read_reg(client,
1974			       object->start_address + MXT_T100_XSIZE,
1975			       sizeof(data->xsize), &data->xsize);
1976	if (error)
1977		return error;
1978
1979	error = __mxt_read_reg(client,
1980			       object->start_address + MXT_T100_YSIZE,
1981			       sizeof(data->ysize), &data->ysize);
1982	if (error)
1983		return error;
1984
1985	/* read orientation config */
1986	error =  __mxt_read_reg(client,
1987				object->start_address + MXT_T100_CFG1,
1988				1, &cfg);
1989	if (error)
1990		return error;
1991
1992	data->xy_switch = cfg & MXT_T100_CFG_SWITCHXY;
1993	data->invertx = cfg & MXT_T100_CFG_INVERTX;
1994	data->inverty = cfg & MXT_T100_CFG_INVERTY;
1995
1996	/* allocate aux bytes */
1997	error =  __mxt_read_reg(client,
1998				object->start_address + MXT_T100_TCHAUX,
1999				1, &tchaux);
2000	if (error)
2001		return error;
2002
2003	aux = 6;
2004
2005	if (tchaux & MXT_T100_TCHAUX_VECT)
2006		data->t100_aux_vect = aux++;
2007
2008	if (tchaux & MXT_T100_TCHAUX_AMPL)
2009		data->t100_aux_ampl = aux++;
2010
2011	if (tchaux & MXT_T100_TCHAUX_AREA)
2012		data->t100_aux_area = aux++;
2013
2014	dev_dbg(&client->dev,
2015		"T100 aux mappings vect:%u ampl:%u area:%u\n",
2016		data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area);
2017
2018	return 0;
2019}
2020
2021static int mxt_input_open(struct input_dev *dev);
2022static void mxt_input_close(struct input_dev *dev);
2023
2024static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
2025				   struct mxt_data *data)
2026{
 
2027	int i;
2028
2029	input_dev->name = "Atmel maXTouch Touchpad";
2030
2031	__set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
2032
2033	input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
2034	input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
2035	input_abs_set_res(input_dev, ABS_MT_POSITION_X,
2036			  MXT_PIXELS_PER_MM);
2037	input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
2038			  MXT_PIXELS_PER_MM);
2039
2040	for (i = 0; i < data->t19_num_keys; i++)
2041		if (data->t19_keymap[i] != KEY_RESERVED)
2042			input_set_capability(input_dev, EV_KEY,
2043					     data->t19_keymap[i]);
2044}
2045
2046static int mxt_initialize_input_device(struct mxt_data *data)
2047{
 
2048	struct device *dev = &data->client->dev;
2049	struct input_dev *input_dev;
2050	int error;
2051	unsigned int num_mt_slots;
2052	unsigned int mt_flags = 0;
2053
2054	switch (data->multitouch) {
2055	case MXT_TOUCH_MULTI_T9:
2056		num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
2057		error = mxt_read_t9_resolution(data);
2058		if (error)
2059			dev_warn(dev, "Failed to initialize T9 resolution\n");
2060		break;
2061
2062	case MXT_TOUCH_MULTITOUCHSCREEN_T100:
2063		num_mt_slots = data->num_touchids;
2064		error = mxt_read_t100_config(data);
2065		if (error)
2066			dev_warn(dev, "Failed to read T100 config\n");
2067		break;
2068
2069	default:
2070		dev_err(dev, "Invalid multitouch object\n");
2071		return -EINVAL;
2072	}
2073
2074	/* Handle default values and orientation switch */
2075	if (data->max_x == 0)
2076		data->max_x = 1023;
2077
2078	if (data->max_y == 0)
2079		data->max_y = 1023;
2080
2081	if (data->xy_switch)
2082		swap(data->max_x, data->max_y);
2083
2084	dev_info(dev, "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
2085
2086	/* Register input device */
2087	input_dev = input_allocate_device();
2088	if (!input_dev)
 
2089		return -ENOMEM;
 
2090
2091	input_dev->name = "Atmel maXTouch Touchscreen";
2092	input_dev->phys = data->phys;
2093	input_dev->id.bustype = BUS_I2C;
2094	input_dev->dev.parent = dev;
2095	input_dev->open = mxt_input_open;
2096	input_dev->close = mxt_input_close;
2097
2098	input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
2099
2100	/* For single touch */
2101	input_set_abs_params(input_dev, ABS_X, 0, data->max_x, 0, 0);
2102	input_set_abs_params(input_dev, ABS_Y, 0, data->max_y, 0, 0);
2103
2104	if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
2105	    (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2106	     data->t100_aux_ampl)) {
2107		input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0);
2108	}
2109
2110	/* If device has buttons we assume it is a touchpad */
2111	if (data->t19_num_keys) {
2112		mxt_set_up_as_touchpad(input_dev, data);
2113		mt_flags |= INPUT_MT_POINTER;
2114	} else {
2115		mt_flags |= INPUT_MT_DIRECT;
2116	}
2117
2118	/* For multi touch */
2119	error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
2120	if (error) {
2121		dev_err(dev, "Error %d initialising slots\n", error);
2122		goto err_free_mem;
2123	}
2124
2125	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) {
2126		input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
2127				     0, MT_TOOL_MAX, 0, 0);
2128		input_set_abs_params(input_dev, ABS_MT_DISTANCE,
2129				     MXT_DISTANCE_ACTIVE_TOUCH,
2130				     MXT_DISTANCE_HOVERING,
2131				     0, 0);
2132	}
2133
2134	input_set_abs_params(input_dev, ABS_MT_POSITION_X,
2135			     0, data->max_x, 0, 0);
2136	input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
2137			     0, data->max_y, 0, 0);
2138
2139	if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
2140	    (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2141	     data->t100_aux_area)) {
2142		input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
2143				     0, MXT_MAX_AREA, 0, 0);
2144	}
2145
2146	if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
2147	    (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2148	     data->t100_aux_ampl)) {
2149		input_set_abs_params(input_dev, ABS_MT_PRESSURE,
2150				     0, 255, 0, 0);
2151	}
2152
2153	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2154	    data->t100_aux_vect) {
2155		input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
2156				     0, 255, 0, 0);
2157	}
2158
2159	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
 
 
 
 
 
 
2160	    data->t100_aux_vect) {
2161		input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
2162				     0, 255, 0, 0);
2163	}
2164
2165	input_set_drvdata(input_dev, data);
2166
2167	error = input_register_device(input_dev);
2168	if (error) {
2169		dev_err(dev, "Error %d registering input device\n", error);
2170		goto err_free_mem;
2171	}
2172
2173	data->input_dev = input_dev;
2174
2175	return 0;
2176
2177err_free_mem:
2178	input_free_device(input_dev);
2179	return error;
2180}
2181
2182static int mxt_configure_objects(struct mxt_data *data,
2183				 const struct firmware *cfg);
2184
2185static void mxt_config_cb(const struct firmware *cfg, void *ctx)
2186{
2187	mxt_configure_objects(ctx, cfg);
2188	release_firmware(cfg);
2189}
2190
2191static int mxt_initialize(struct mxt_data *data)
2192{
2193	struct i2c_client *client = data->client;
2194	int recovery_attempts = 0;
2195	int error;
2196
2197	while (1) {
2198		error = mxt_read_info_block(data);
2199		if (!error)
2200			break;
2201
2202		/* Check bootloader state */
2203		error = mxt_probe_bootloader(data, false);
2204		if (error) {
2205			dev_info(&client->dev, "Trying alternate bootloader address\n");
2206			error = mxt_probe_bootloader(data, true);
2207			if (error) {
2208				/* Chip is not in appmode or bootloader mode */
2209				return error;
2210			}
2211		}
2212
2213		/* OK, we are in bootloader, see if we can recover */
2214		if (++recovery_attempts > 1) {
2215			dev_err(&client->dev, "Could not recover from bootloader mode\n");
2216			/*
2217			 * We can reflash from this state, so do not
2218			 * abort initialization.
2219			 */
2220			data->in_bootloader = true;
2221			return 0;
2222		}
2223
2224		/* Attempt to exit bootloader into app mode */
2225		mxt_send_bootloader_cmd(data, false);
2226		msleep(MXT_FW_RESET_TIME);
2227	}
2228
2229	error = mxt_check_retrigen(data);
2230	if (error)
 
 
2231		return error;
 
2232
2233	error = mxt_acquire_irq(data);
2234	if (error)
2235		return error;
2236
2237	error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
2238					&client->dev, GFP_KERNEL, data,
2239					mxt_config_cb);
2240	if (error) {
2241		dev_err(&client->dev, "Failed to invoke firmware loader: %d\n",
2242			error);
2243		return error;
2244	}
2245
2246	return 0;
 
 
 
 
2247}
2248
2249static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep)
2250{
2251	struct device *dev = &data->client->dev;
2252	int error;
2253	struct t7_config *new_config;
2254	struct t7_config deepsleep = { .active = 0, .idle = 0 };
2255
2256	if (sleep == MXT_POWER_CFG_DEEPSLEEP)
2257		new_config = &deepsleep;
2258	else
2259		new_config = &data->t7_cfg;
2260
2261	error = __mxt_write_reg(data->client, data->T7_address,
2262				sizeof(data->t7_cfg), new_config);
2263	if (error)
2264		return error;
2265
2266	dev_dbg(dev, "Set T7 ACTV:%d IDLE:%d\n",
2267		new_config->active, new_config->idle);
2268
2269	return 0;
2270}
2271
2272static int mxt_init_t7_power_cfg(struct mxt_data *data)
2273{
2274	struct device *dev = &data->client->dev;
2275	int error;
2276	bool retry = false;
2277
2278recheck:
2279	error = __mxt_read_reg(data->client, data->T7_address,
2280				sizeof(data->t7_cfg), &data->t7_cfg);
2281	if (error)
2282		return error;
2283
2284	if (data->t7_cfg.active == 0 || data->t7_cfg.idle == 0) {
2285		if (!retry) {
2286			dev_dbg(dev, "T7 cfg zero, resetting\n");
2287			mxt_soft_reset(data);
2288			retry = true;
2289			goto recheck;
2290		} else {
2291			dev_dbg(dev, "T7 cfg zero after reset, overriding\n");
2292			data->t7_cfg.active = 20;
2293			data->t7_cfg.idle = 100;
2294			return mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
2295		}
2296	}
2297
2298	dev_dbg(dev, "Initialized power cfg: ACTV %d, IDLE %d\n",
2299		data->t7_cfg.active, data->t7_cfg.idle);
2300	return 0;
2301}
2302
2303#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
2304static const struct v4l2_file_operations mxt_video_fops = {
2305	.owner = THIS_MODULE,
2306	.open = v4l2_fh_open,
2307	.release = vb2_fop_release,
2308	.unlocked_ioctl = video_ioctl2,
2309	.read = vb2_fop_read,
2310	.mmap = vb2_fop_mmap,
2311	.poll = vb2_fop_poll,
2312};
2313
2314static u16 mxt_get_debug_value(struct mxt_data *data, unsigned int x,
2315			       unsigned int y)
2316{
2317	struct mxt_info *info = data->info;
2318	struct mxt_dbg *dbg = &data->dbg;
2319	unsigned int ofs, page;
2320	unsigned int col = 0;
2321	unsigned int col_width;
2322
2323	if (info->family_id == MXT_FAMILY_1386) {
2324		col_width = info->matrix_ysize / MXT1386_COLUMNS;
2325		col = y / col_width;
2326		y = y % col_width;
2327	} else {
2328		col_width = info->matrix_ysize;
2329	}
2330
2331	ofs = (y + (x * col_width)) * sizeof(u16);
2332	page = ofs / MXT_DIAGNOSTIC_SIZE;
2333	ofs %= MXT_DIAGNOSTIC_SIZE;
2334
2335	if (info->family_id == MXT_FAMILY_1386)
2336		page += col * MXT1386_PAGES_PER_COLUMN;
2337
2338	return get_unaligned_le16(&dbg->t37_buf[page].data[ofs]);
2339}
2340
2341static int mxt_convert_debug_pages(struct mxt_data *data, u16 *outbuf)
2342{
2343	struct mxt_dbg *dbg = &data->dbg;
2344	unsigned int x = 0;
2345	unsigned int y = 0;
2346	unsigned int i, rx, ry;
2347
2348	for (i = 0; i < dbg->t37_nodes; i++) {
2349		/* Handle orientation */
2350		rx = data->xy_switch ? y : x;
2351		ry = data->xy_switch ? x : y;
2352		rx = data->invertx ? (data->xsize - 1 - rx) : rx;
2353		ry = data->inverty ? (data->ysize - 1 - ry) : ry;
2354
2355		outbuf[i] = mxt_get_debug_value(data, rx, ry);
2356
2357		/* Next value */
2358		if (++x >= (data->xy_switch ? data->ysize : data->xsize)) {
2359			x = 0;
2360			y++;
2361		}
2362	}
2363
2364	return 0;
2365}
2366
2367static int mxt_read_diagnostic_debug(struct mxt_data *data, u8 mode,
2368				     u16 *outbuf)
2369{
2370	struct mxt_dbg *dbg = &data->dbg;
2371	int retries = 0;
2372	int page;
2373	int ret;
2374	u8 cmd = mode;
2375	struct t37_debug *p;
2376	u8 cmd_poll;
2377
2378	for (page = 0; page < dbg->t37_pages; page++) {
2379		p = dbg->t37_buf + page;
2380
2381		ret = mxt_write_reg(data->client, dbg->diag_cmd_address,
2382				    cmd);
2383		if (ret)
2384			return ret;
2385
2386		retries = 0;
2387		msleep(20);
2388wait_cmd:
2389		/* Read back command byte */
2390		ret = __mxt_read_reg(data->client, dbg->diag_cmd_address,
2391				     sizeof(cmd_poll), &cmd_poll);
2392		if (ret)
2393			return ret;
2394
2395		/* Field is cleared once the command has been processed */
2396		if (cmd_poll) {
2397			if (retries++ > 100)
2398				return -EINVAL;
2399
2400			msleep(20);
2401			goto wait_cmd;
2402		}
2403
2404		/* Read T37 page */
2405		ret = __mxt_read_reg(data->client, dbg->t37_address,
2406				     sizeof(struct t37_debug), p);
2407		if (ret)
2408			return ret;
2409
2410		if (p->mode != mode || p->page != page) {
2411			dev_err(&data->client->dev, "T37 page mismatch\n");
2412			return -EINVAL;
2413		}
2414
2415		dev_dbg(&data->client->dev, "%s page:%d retries:%d\n",
2416			__func__, page, retries);
2417
2418		/* For remaining pages, write PAGEUP rather than mode */
2419		cmd = MXT_DIAGNOSTIC_PAGEUP;
2420	}
2421
2422	return mxt_convert_debug_pages(data, outbuf);
2423}
2424
2425static int mxt_queue_setup(struct vb2_queue *q,
2426		       unsigned int *nbuffers, unsigned int *nplanes,
2427		       unsigned int sizes[], struct device *alloc_devs[])
2428{
2429	struct mxt_data *data = q->drv_priv;
2430	size_t size = data->dbg.t37_nodes * sizeof(u16);
2431
2432	if (*nplanes)
2433		return sizes[0] < size ? -EINVAL : 0;
2434
2435	*nplanes = 1;
2436	sizes[0] = size;
2437
2438	return 0;
2439}
2440
2441static void mxt_buffer_queue(struct vb2_buffer *vb)
2442{
2443	struct mxt_data *data = vb2_get_drv_priv(vb->vb2_queue);
2444	u16 *ptr;
2445	int ret;
2446	u8 mode;
2447
2448	ptr = vb2_plane_vaddr(vb, 0);
2449	if (!ptr) {
2450		dev_err(&data->client->dev, "Error acquiring frame ptr\n");
2451		goto fault;
2452	}
2453
2454	switch (data->dbg.input) {
2455	case MXT_V4L_INPUT_DELTAS:
2456	default:
2457		mode = MXT_DIAGNOSTIC_DELTAS;
2458		break;
2459
2460	case MXT_V4L_INPUT_REFS:
2461		mode = MXT_DIAGNOSTIC_REFS;
2462		break;
2463	}
2464
2465	ret = mxt_read_diagnostic_debug(data, mode, ptr);
2466	if (ret)
2467		goto fault;
2468
2469	vb2_set_plane_payload(vb, 0, data->dbg.t37_nodes * sizeof(u16));
2470	vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
2471	return;
2472
2473fault:
2474	vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2475}
2476
2477/* V4L2 structures */
2478static const struct vb2_ops mxt_queue_ops = {
2479	.queue_setup		= mxt_queue_setup,
2480	.buf_queue		= mxt_buffer_queue,
2481	.wait_prepare		= vb2_ops_wait_prepare,
2482	.wait_finish		= vb2_ops_wait_finish,
2483};
2484
2485static const struct vb2_queue mxt_queue = {
2486	.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
2487	.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ,
2488	.buf_struct_size = sizeof(struct mxt_vb2_buffer),
2489	.ops = &mxt_queue_ops,
2490	.mem_ops = &vb2_vmalloc_memops,
2491	.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC,
2492	.min_buffers_needed = 1,
2493};
2494
2495static int mxt_vidioc_querycap(struct file *file, void *priv,
2496				 struct v4l2_capability *cap)
2497{
2498	struct mxt_data *data = video_drvdata(file);
2499
2500	strscpy(cap->driver, "atmel_mxt_ts", sizeof(cap->driver));
2501	strscpy(cap->card, "atmel_mxt_ts touch", sizeof(cap->card));
2502	snprintf(cap->bus_info, sizeof(cap->bus_info),
2503		 "I2C:%s", dev_name(&data->client->dev));
2504	return 0;
2505}
2506
2507static int mxt_vidioc_enum_input(struct file *file, void *priv,
2508				   struct v4l2_input *i)
2509{
2510	if (i->index >= MXT_V4L_INPUT_MAX)
2511		return -EINVAL;
2512
2513	i->type = V4L2_INPUT_TYPE_TOUCH;
2514
2515	switch (i->index) {
2516	case MXT_V4L_INPUT_REFS:
2517		strscpy(i->name, "Mutual Capacitance References",
2518			sizeof(i->name));
2519		break;
2520	case MXT_V4L_INPUT_DELTAS:
2521		strscpy(i->name, "Mutual Capacitance Deltas", sizeof(i->name));
2522		break;
2523	}
2524
2525	return 0;
2526}
2527
2528static int mxt_set_input(struct mxt_data *data, unsigned int i)
2529{
2530	struct v4l2_pix_format *f = &data->dbg.format;
2531
2532	if (i >= MXT_V4L_INPUT_MAX)
2533		return -EINVAL;
2534
2535	if (i == MXT_V4L_INPUT_DELTAS)
2536		f->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
2537	else
2538		f->pixelformat = V4L2_TCH_FMT_TU16;
2539
2540	f->width = data->xy_switch ? data->ysize : data->xsize;
2541	f->height = data->xy_switch ? data->xsize : data->ysize;
2542	f->field = V4L2_FIELD_NONE;
2543	f->colorspace = V4L2_COLORSPACE_RAW;
2544	f->bytesperline = f->width * sizeof(u16);
2545	f->sizeimage = f->width * f->height * sizeof(u16);
2546
2547	data->dbg.input = i;
2548
2549	return 0;
2550}
2551
2552static int mxt_vidioc_s_input(struct file *file, void *priv, unsigned int i)
2553{
2554	return mxt_set_input(video_drvdata(file), i);
2555}
2556
2557static int mxt_vidioc_g_input(struct file *file, void *priv, unsigned int *i)
2558{
2559	struct mxt_data *data = video_drvdata(file);
2560
2561	*i = data->dbg.input;
2562
2563	return 0;
2564}
2565
2566static int mxt_vidioc_fmt(struct file *file, void *priv, struct v4l2_format *f)
2567{
2568	struct mxt_data *data = video_drvdata(file);
2569
2570	f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2571	f->fmt.pix = data->dbg.format;
2572
2573	return 0;
2574}
2575
2576static int mxt_vidioc_enum_fmt(struct file *file, void *priv,
2577				 struct v4l2_fmtdesc *fmt)
2578{
2579	if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2580		return -EINVAL;
2581
2582	switch (fmt->index) {
2583	case 0:
2584		fmt->pixelformat = V4L2_TCH_FMT_TU16;
2585		break;
2586
2587	case 1:
2588		fmt->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
2589		break;
2590
2591	default:
2592		return -EINVAL;
2593	}
2594
2595	return 0;
2596}
2597
2598static int mxt_vidioc_g_parm(struct file *file, void *fh,
2599			     struct v4l2_streamparm *a)
2600{
2601	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2602		return -EINVAL;
2603
2604	a->parm.capture.readbuffers = 1;
2605	a->parm.capture.timeperframe.numerator = 1;
2606	a->parm.capture.timeperframe.denominator = 10;
2607	return 0;
2608}
2609
2610static const struct v4l2_ioctl_ops mxt_video_ioctl_ops = {
2611	.vidioc_querycap        = mxt_vidioc_querycap,
2612
2613	.vidioc_enum_fmt_vid_cap = mxt_vidioc_enum_fmt,
2614	.vidioc_s_fmt_vid_cap   = mxt_vidioc_fmt,
2615	.vidioc_g_fmt_vid_cap   = mxt_vidioc_fmt,
2616	.vidioc_try_fmt_vid_cap	= mxt_vidioc_fmt,
2617	.vidioc_g_parm		= mxt_vidioc_g_parm,
2618
2619	.vidioc_enum_input      = mxt_vidioc_enum_input,
2620	.vidioc_g_input         = mxt_vidioc_g_input,
2621	.vidioc_s_input         = mxt_vidioc_s_input,
2622
2623	.vidioc_reqbufs         = vb2_ioctl_reqbufs,
2624	.vidioc_create_bufs     = vb2_ioctl_create_bufs,
2625	.vidioc_querybuf        = vb2_ioctl_querybuf,
2626	.vidioc_qbuf            = vb2_ioctl_qbuf,
2627	.vidioc_dqbuf           = vb2_ioctl_dqbuf,
2628	.vidioc_expbuf          = vb2_ioctl_expbuf,
2629
2630	.vidioc_streamon        = vb2_ioctl_streamon,
2631	.vidioc_streamoff       = vb2_ioctl_streamoff,
2632};
2633
2634static const struct video_device mxt_video_device = {
2635	.name = "Atmel maxTouch",
2636	.fops = &mxt_video_fops,
2637	.ioctl_ops = &mxt_video_ioctl_ops,
2638	.release = video_device_release_empty,
2639	.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TOUCH |
2640		       V4L2_CAP_READWRITE | V4L2_CAP_STREAMING,
2641};
2642
2643static void mxt_debug_init(struct mxt_data *data)
2644{
2645	struct mxt_info *info = data->info;
2646	struct mxt_dbg *dbg = &data->dbg;
2647	struct mxt_object *object;
2648	int error;
2649
2650	object = mxt_get_object(data, MXT_GEN_COMMAND_T6);
2651	if (!object)
2652		goto error;
2653
2654	dbg->diag_cmd_address = object->start_address + MXT_COMMAND_DIAGNOSTIC;
2655
2656	object = mxt_get_object(data, MXT_DEBUG_DIAGNOSTIC_T37);
2657	if (!object)
2658		goto error;
2659
2660	if (mxt_obj_size(object) != sizeof(struct t37_debug)) {
2661		dev_warn(&data->client->dev, "Bad T37 size");
2662		goto error;
2663	}
2664
2665	dbg->t37_address = object->start_address;
2666
2667	/* Calculate size of data and allocate buffer */
2668	dbg->t37_nodes = data->xsize * data->ysize;
2669
2670	if (info->family_id == MXT_FAMILY_1386)
2671		dbg->t37_pages = MXT1386_COLUMNS * MXT1386_PAGES_PER_COLUMN;
2672	else
2673		dbg->t37_pages = DIV_ROUND_UP(data->xsize *
2674					      info->matrix_ysize *
2675					      sizeof(u16),
2676					      sizeof(dbg->t37_buf->data));
2677
2678	dbg->t37_buf = devm_kmalloc_array(&data->client->dev, dbg->t37_pages,
2679					  sizeof(struct t37_debug), GFP_KERNEL);
2680	if (!dbg->t37_buf)
2681		goto error;
2682
2683	/* init channel to zero */
2684	mxt_set_input(data, 0);
2685
2686	/* register video device */
2687	snprintf(dbg->v4l2.name, sizeof(dbg->v4l2.name), "%s", "atmel_mxt_ts");
2688	error = v4l2_device_register(&data->client->dev, &dbg->v4l2);
2689	if (error)
2690		goto error;
2691
2692	/* initialize the queue */
2693	mutex_init(&dbg->lock);
2694	dbg->queue = mxt_queue;
2695	dbg->queue.drv_priv = data;
2696	dbg->queue.lock = &dbg->lock;
2697	dbg->queue.dev = &data->client->dev;
2698
2699	error = vb2_queue_init(&dbg->queue);
2700	if (error)
2701		goto error_unreg_v4l2;
2702
2703	dbg->vdev = mxt_video_device;
2704	dbg->vdev.v4l2_dev = &dbg->v4l2;
2705	dbg->vdev.lock = &dbg->lock;
2706	dbg->vdev.vfl_dir = VFL_DIR_RX;
2707	dbg->vdev.queue = &dbg->queue;
2708	video_set_drvdata(&dbg->vdev, data);
2709
2710	error = video_register_device(&dbg->vdev, VFL_TYPE_TOUCH, -1);
2711	if (error)
2712		goto error_unreg_v4l2;
2713
2714	return;
2715
2716error_unreg_v4l2:
2717	v4l2_device_unregister(&dbg->v4l2);
2718error:
2719	dev_warn(&data->client->dev, "Error initializing T37\n");
2720}
2721#else
2722static void mxt_debug_init(struct mxt_data *data)
2723{
2724}
2725#endif
2726
2727static int mxt_configure_objects(struct mxt_data *data,
2728				 const struct firmware *cfg)
2729{
2730	struct device *dev = &data->client->dev;
 
2731	int error;
2732
2733	error = mxt_init_t7_power_cfg(data);
2734	if (error) {
2735		dev_err(dev, "Failed to initialize power cfg\n");
2736		return error;
2737	}
2738
2739	if (cfg) {
2740		error = mxt_update_cfg(data, cfg);
2741		if (error)
2742			dev_warn(dev, "Error %d updating config\n", error);
2743	}
2744
2745	if (data->multitouch) {
2746		error = mxt_initialize_input_device(data);
2747		if (error)
2748			return error;
2749	} else {
2750		dev_warn(dev, "No touch object detected\n");
2751	}
2752
2753	mxt_debug_init(data);
2754
 
 
 
 
 
2755	return 0;
2756}
2757
2758/* Firmware Version is returned as Major.Minor.Build */
2759static ssize_t mxt_fw_version_show(struct device *dev,
2760				   struct device_attribute *attr, char *buf)
2761{
2762	struct mxt_data *data = dev_get_drvdata(dev);
2763	struct mxt_info *info = data->info;
2764	return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
2765			 info->version >> 4, info->version & 0xf, info->build);
2766}
2767
2768/* Hardware Version is returned as FamilyID.VariantID */
2769static ssize_t mxt_hw_version_show(struct device *dev,
2770				   struct device_attribute *attr, char *buf)
2771{
2772	struct mxt_data *data = dev_get_drvdata(dev);
2773	struct mxt_info *info = data->info;
2774	return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
2775			 info->family_id, info->variant_id);
2776}
2777
2778static ssize_t mxt_show_instance(char *buf, int count,
2779				 struct mxt_object *object, int instance,
2780				 const u8 *val)
2781{
2782	int i;
2783
2784	if (mxt_obj_instances(object) > 1)
2785		count += scnprintf(buf + count, PAGE_SIZE - count,
2786				   "Instance %u\n", instance);
2787
2788	for (i = 0; i < mxt_obj_size(object); i++)
2789		count += scnprintf(buf + count, PAGE_SIZE - count,
2790				"\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
2791	count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
2792
2793	return count;
2794}
2795
2796static ssize_t mxt_object_show(struct device *dev,
2797				    struct device_attribute *attr, char *buf)
2798{
2799	struct mxt_data *data = dev_get_drvdata(dev);
2800	struct mxt_object *object;
2801	int count = 0;
2802	int i, j;
2803	int error;
2804	u8 *obuf;
2805
2806	/* Pre-allocate buffer large enough to hold max sized object. */
2807	obuf = kmalloc(256, GFP_KERNEL);
2808	if (!obuf)
2809		return -ENOMEM;
2810
2811	error = 0;
2812	for (i = 0; i < data->info->object_num; i++) {
2813		object = data->object_table + i;
2814
2815		if (!mxt_object_readable(object->type))
2816			continue;
2817
2818		count += scnprintf(buf + count, PAGE_SIZE - count,
2819				"T%u:\n", object->type);
2820
2821		for (j = 0; j < mxt_obj_instances(object); j++) {
2822			u16 size = mxt_obj_size(object);
2823			u16 addr = object->start_address + j * size;
2824
2825			error = __mxt_read_reg(data->client, addr, size, obuf);
2826			if (error)
2827				goto done;
2828
2829			count = mxt_show_instance(buf, count, object, j, obuf);
2830		}
2831	}
2832
2833done:
2834	kfree(obuf);
2835	return error ?: count;
2836}
2837
2838static int mxt_check_firmware_format(struct device *dev,
2839				     const struct firmware *fw)
2840{
2841	unsigned int pos = 0;
2842	char c;
2843
2844	while (pos < fw->size) {
2845		c = *(fw->data + pos);
2846
2847		if (c < '0' || (c > '9' && c < 'A') || c > 'F')
2848			return 0;
2849
2850		pos++;
2851	}
2852
2853	/*
2854	 * To convert file try:
2855	 * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw
2856	 */
2857	dev_err(dev, "Aborting: firmware file must be in binary format\n");
2858
2859	return -EINVAL;
2860}
2861
2862static int mxt_load_fw(struct device *dev, const char *fn)
2863{
2864	struct mxt_data *data = dev_get_drvdata(dev);
2865	const struct firmware *fw = NULL;
2866	unsigned int frame_size;
2867	unsigned int pos = 0;
2868	unsigned int retry = 0;
2869	unsigned int frame = 0;
2870	int ret;
2871
2872	ret = request_firmware(&fw, fn, dev);
2873	if (ret) {
2874		dev_err(dev, "Unable to open firmware %s\n", fn);
2875		return ret;
2876	}
2877
2878	/* Check for incorrect enc file */
2879	ret = mxt_check_firmware_format(dev, fw);
2880	if (ret)
2881		goto release_firmware;
2882
2883	if (!data->in_bootloader) {
2884		/* Change to the bootloader mode */
2885		data->in_bootloader = true;
2886
2887		ret = mxt_t6_command(data, MXT_COMMAND_RESET,
2888				     MXT_BOOT_VALUE, false);
2889		if (ret)
2890			goto release_firmware;
2891
2892		msleep(MXT_RESET_TIME);
2893
2894		/* Do not need to scan since we know family ID */
2895		ret = mxt_lookup_bootloader_address(data, 0);
2896		if (ret)
2897			goto release_firmware;
2898
2899		mxt_free_input_device(data);
2900		mxt_free_object_table(data);
2901	} else {
2902		enable_irq(data->irq);
2903	}
2904
2905	reinit_completion(&data->bl_completion);
2906
2907	ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
2908	if (ret) {
2909		/* Bootloader may still be unlocked from previous attempt */
2910		ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false);
2911		if (ret)
2912			goto disable_irq;
2913	} else {
2914		dev_info(dev, "Unlocking bootloader\n");
2915
2916		/* Unlock bootloader */
2917		ret = mxt_send_bootloader_cmd(data, true);
2918		if (ret)
2919			goto disable_irq;
2920	}
2921
2922	while (pos < fw->size) {
2923		ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true);
2924		if (ret)
2925			goto disable_irq;
2926
2927		frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
2928
2929		/* Take account of CRC bytes */
2930		frame_size += 2;
2931
2932		/* Write one frame to device */
2933		ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
2934		if (ret)
2935			goto disable_irq;
2936
2937		ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
2938		if (ret) {
2939			retry++;
2940
2941			/* Back off by 20ms per retry */
2942			msleep(retry * 20);
2943
2944			if (retry > 20) {
2945				dev_err(dev, "Retry count exceeded\n");
2946				goto disable_irq;
2947			}
2948		} else {
2949			retry = 0;
2950			pos += frame_size;
2951			frame++;
2952		}
2953
2954		if (frame % 50 == 0)
2955			dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n",
2956				frame, pos, fw->size);
2957	}
2958
2959	/* Wait for flash. */
2960	ret = mxt_wait_for_completion(data, &data->bl_completion,
2961				      MXT_FW_RESET_TIME);
2962	if (ret)
2963		goto disable_irq;
2964
2965	dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos);
2966
2967	/*
2968	 * Wait for device to reset. Some bootloader versions do not assert
2969	 * the CHG line after bootloading has finished, so ignore potential
2970	 * errors.
2971	 */
2972	mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
2973
2974	data->in_bootloader = false;
2975
2976disable_irq:
2977	disable_irq(data->irq);
2978release_firmware:
2979	release_firmware(fw);
2980	return ret;
2981}
2982
2983static ssize_t mxt_update_fw_store(struct device *dev,
2984					struct device_attribute *attr,
2985					const char *buf, size_t count)
2986{
2987	struct mxt_data *data = dev_get_drvdata(dev);
2988	int error;
2989
2990	error = mxt_load_fw(dev, MXT_FW_NAME);
2991	if (error) {
2992		dev_err(dev, "The firmware update failed(%d)\n", error);
2993		count = error;
2994	} else {
2995		dev_info(dev, "The firmware update succeeded\n");
2996
2997		error = mxt_initialize(data);
2998		if (error)
2999			return error;
3000	}
3001
3002	return count;
3003}
3004
3005static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
3006static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
3007static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
3008static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
3009
3010static struct attribute *mxt_attrs[] = {
3011	&dev_attr_fw_version.attr,
3012	&dev_attr_hw_version.attr,
3013	&dev_attr_object.attr,
3014	&dev_attr_update_fw.attr,
3015	NULL
3016};
3017
3018static const struct attribute_group mxt_attr_group = {
3019	.attrs = mxt_attrs,
3020};
3021
3022static void mxt_start(struct mxt_data *data)
3023{
3024	mxt_wakeup_toggle(data->client, true, false);
3025
3026	switch (data->suspend_mode) {
3027	case MXT_SUSPEND_T9_CTRL:
3028		mxt_soft_reset(data);
3029
3030		/* Touch enable */
3031		/* 0x83 = SCANEN | RPTEN | ENABLE */
3032		mxt_write_object(data,
3033				MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0x83);
3034		break;
3035
3036	case MXT_SUSPEND_DEEP_SLEEP:
3037	default:
3038		mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
3039
3040		/* Recalibrate since chip has been in deep sleep */
3041		mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false);
3042		break;
3043	}
 
3044}
3045
3046static void mxt_stop(struct mxt_data *data)
3047{
3048	switch (data->suspend_mode) {
3049	case MXT_SUSPEND_T9_CTRL:
3050		/* Touch disable */
3051		mxt_write_object(data,
3052				MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0);
3053		break;
3054
3055	case MXT_SUSPEND_DEEP_SLEEP:
3056	default:
3057		mxt_set_t7_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP);
3058		break;
3059	}
3060
3061	mxt_wakeup_toggle(data->client, false, false);
3062}
3063
3064static int mxt_input_open(struct input_dev *dev)
3065{
3066	struct mxt_data *data = input_get_drvdata(dev);
3067
3068	mxt_start(data);
3069
3070	return 0;
3071}
3072
3073static void mxt_input_close(struct input_dev *dev)
3074{
3075	struct mxt_data *data = input_get_drvdata(dev);
3076
3077	mxt_stop(data);
3078}
3079
3080static int mxt_parse_device_properties(struct mxt_data *data)
 
3081{
3082	static const char keymap_property[] = "linux,gpio-keymap";
3083	struct device *dev = &data->client->dev;
3084	u32 *keymap;
3085	int n_keys;
3086	int error;
3087
3088	if (device_property_present(dev, keymap_property)) {
3089		n_keys = device_property_count_u32(dev, keymap_property);
3090		if (n_keys <= 0) {
3091			error = n_keys < 0 ? n_keys : -EINVAL;
3092			dev_err(dev, "invalid/malformed '%s' property: %d\n",
3093				keymap_property, error);
3094			return error;
3095		}
 
3096
3097		keymap = devm_kmalloc_array(dev, n_keys, sizeof(*keymap),
3098					    GFP_KERNEL);
 
3099		if (!keymap)
3100			return -ENOMEM;
3101
3102		error = device_property_read_u32_array(dev, keymap_property,
3103						       keymap, n_keys);
3104		if (error) {
3105			dev_err(dev, "failed to parse '%s' property: %d\n",
3106				keymap_property, error);
3107			return error;
3108		}
3109
3110		data->t19_keymap = keymap;
3111		data->t19_num_keys = n_keys;
3112	}
3113
3114	return 0;
 
 
3115}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3116
3117static const struct dmi_system_id chromebook_T9_suspend_dmi[] = {
3118	{
 
 
3119		.matches = {
3120			DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
3121			DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
3122		},
 
3123	},
3124	{
 
 
3125		.matches = {
3126			DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
3127		},
 
3128	},
3129	{ }
3130};
3131
3132static int mxt_probe(struct i2c_client *client)
3133{
3134	struct mxt_data *data;
3135	int error;
3136
3137	/*
3138	 * Ignore devices that do not have device properties attached to
3139	 * them, as we need help determining whether we are dealing with
3140	 * touch screen or touchpad.
3141	 *
3142	 * So far on x86 the only users of Atmel touch controllers are
3143	 * Chromebooks, and chromeos_laptop driver will ensure that
3144	 * necessary properties are provided (if firmware does not do that).
3145	 */
3146	if (!device_property_present(&client->dev, "compatible"))
3147		return -ENXIO;
3148
3149	/*
3150	 * Ignore ACPI devices representing bootloader mode.
3151	 *
3152	 * This is a bit of a hack: Google Chromebook BIOS creates ACPI
3153	 * devices for both application and bootloader modes, but we are
3154	 * interested in application mode only (if device is in bootloader
3155	 * mode we'll end up switching into application anyway). So far
3156	 * application mode addresses were all above 0x40, so we'll use it
3157	 * as a threshold.
3158	 */
3159	if (ACPI_COMPANION(&client->dev) && client->addr < 0x40)
3160		return -ENXIO;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3161
3162	data = devm_kzalloc(&client->dev, sizeof(struct mxt_data), GFP_KERNEL);
3163	if (!data)
 
 
 
 
 
 
 
 
 
 
 
3164		return -ENOMEM;
 
3165
3166	snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
3167		 client->adapter->nr, client->addr);
3168
3169	data->client = client;
 
3170	data->irq = client->irq;
3171	i2c_set_clientdata(client, data);
3172
3173	init_completion(&data->bl_completion);
3174	init_completion(&data->reset_completion);
3175	init_completion(&data->crc_completion);
3176
3177	data->suspend_mode = dmi_check_system(chromebook_T9_suspend_dmi) ?
3178		MXT_SUSPEND_T9_CTRL : MXT_SUSPEND_DEEP_SLEEP;
3179
3180	error = mxt_parse_device_properties(data);
3181	if (error)
3182		return error;
3183
3184	/*
3185	 * VDDA is the analog voltage supply 2.57..3.47 V
3186	 * VDD  is the digital voltage supply 1.71..3.47 V
3187	 */
3188	data->regulators[0].supply = "vdda";
3189	data->regulators[1].supply = "vdd";
3190	error = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(data->regulators),
3191					data->regulators);
3192	if (error) {
3193		if (error != -EPROBE_DEFER)
3194			dev_err(&client->dev, "Failed to get regulators %d\n",
3195				error);
3196		return error;
3197	}
3198
3199	/* Request the RESET line as asserted so we go into reset */
3200	data->reset_gpio = devm_gpiod_get_optional(&client->dev,
3201						   "reset", GPIOD_OUT_HIGH);
3202	if (IS_ERR(data->reset_gpio)) {
3203		error = PTR_ERR(data->reset_gpio);
3204		dev_err(&client->dev, "Failed to get reset gpio: %d\n", error);
3205		return error;
3206	}
3207
3208	/* Request the WAKE line as asserted so we go out of sleep */
3209	data->wake_gpio = devm_gpiod_get_optional(&client->dev,
3210						  "wake", GPIOD_OUT_HIGH);
3211	if (IS_ERR(data->wake_gpio)) {
3212		error = PTR_ERR(data->wake_gpio);
3213		dev_err(&client->dev, "Failed to get wake gpio: %d\n", error);
3214		return error;
3215	}
3216
3217	error = devm_request_threaded_irq(&client->dev, client->irq,
3218					  NULL, mxt_interrupt,
3219					  IRQF_ONESHOT | IRQF_NO_AUTOEN,
3220					  client->name, data);
3221	if (error) {
3222		dev_err(&client->dev, "Failed to register interrupt\n");
3223		return error;
3224	}
3225
3226	error = regulator_bulk_enable(ARRAY_SIZE(data->regulators),
3227				      data->regulators);
3228	if (error) {
3229		dev_err(&client->dev, "failed to enable regulators: %d\n",
3230			error);
3231		return error;
3232	}
3233	/*
3234	 * The device takes 40ms to come up after power-on according
3235	 * to the mXT224 datasheet, page 13.
3236	 */
3237	msleep(MXT_BACKUP_TIME);
3238
3239	if (data->reset_gpio) {
3240		/* Wait a while and then de-assert the RESET GPIO line */
3241		msleep(MXT_RESET_GPIO_TIME);
3242		gpiod_set_value(data->reset_gpio, 0);
3243		msleep(MXT_RESET_INVALID_CHG);
3244	}
3245
3246	/*
3247	 * Controllers like mXT1386 have a dedicated WAKE line that could be
3248	 * connected to a GPIO or to I2C SCL pin, or permanently asserted low.
3249	 *
3250	 * This WAKE line is used for waking controller from a deep-sleep and
3251	 * it needs to be asserted low for 25 milliseconds before I2C transfers
3252	 * could be accepted by controller if it was in a deep-sleep mode.
3253	 * Controller will go into sleep automatically after 2 seconds of
3254	 * inactivity if WAKE line is deasserted and deep sleep is activated.
3255	 *
3256	 * If WAKE line is connected to I2C SCL pin, then the first I2C transfer
3257	 * will get an instant NAK and transfer needs to be retried after 25ms.
3258	 *
3259	 * If WAKE line is connected to a GPIO line, the line must be asserted
3260	 * 25ms before the host attempts to communicate with the controller.
3261	 */
3262	device_property_read_u32(&client->dev, "atmel,wakeup-method",
3263				 &data->wakeup_method);
3264
3265	error = mxt_initialize(data);
3266	if (error)
3267		goto err_disable_regulators;
3268
3269	error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
3270	if (error) {
3271		dev_err(&client->dev, "Failure %d creating sysfs group\n",
3272			error);
3273		goto err_free_object;
3274	}
3275
3276	return 0;
3277
3278err_free_object:
3279	mxt_free_input_device(data);
3280	mxt_free_object_table(data);
3281err_disable_regulators:
3282	regulator_bulk_disable(ARRAY_SIZE(data->regulators),
3283			       data->regulators);
 
3284	return error;
3285}
3286
3287static void mxt_remove(struct i2c_client *client)
3288{
3289	struct mxt_data *data = i2c_get_clientdata(client);
3290
3291	disable_irq(data->irq);
3292	sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
 
3293	mxt_free_input_device(data);
3294	mxt_free_object_table(data);
3295	regulator_bulk_disable(ARRAY_SIZE(data->regulators),
3296			       data->regulators);
 
3297}
3298
3299static int __maybe_unused mxt_suspend(struct device *dev)
3300{
3301	struct i2c_client *client = to_i2c_client(dev);
3302	struct mxt_data *data = i2c_get_clientdata(client);
3303	struct input_dev *input_dev = data->input_dev;
3304
3305	if (!input_dev)
3306		return 0;
3307
3308	mutex_lock(&input_dev->mutex);
3309
3310	if (input_device_enabled(input_dev))
3311		mxt_stop(data);
3312
3313	mutex_unlock(&input_dev->mutex);
3314
3315	disable_irq(data->irq);
3316
3317	return 0;
3318}
3319
3320static int __maybe_unused mxt_resume(struct device *dev)
3321{
3322	struct i2c_client *client = to_i2c_client(dev);
3323	struct mxt_data *data = i2c_get_clientdata(client);
3324	struct input_dev *input_dev = data->input_dev;
3325
3326	if (!input_dev)
3327		return 0;
3328
3329	enable_irq(data->irq);
3330
3331	mutex_lock(&input_dev->mutex);
3332
3333	if (input_device_enabled(input_dev))
3334		mxt_start(data);
3335
3336	mutex_unlock(&input_dev->mutex);
3337
3338	return 0;
3339}
3340
3341static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
3342
3343static const struct of_device_id mxt_of_match[] = {
3344	{ .compatible = "atmel,maxtouch", },
3345	/* Compatibles listed below are deprecated */
3346	{ .compatible = "atmel,qt602240_ts", },
3347	{ .compatible = "atmel,atmel_mxt_ts", },
3348	{ .compatible = "atmel,atmel_mxt_tp", },
3349	{ .compatible = "atmel,mXT224", },
3350	{},
3351};
3352MODULE_DEVICE_TABLE(of, mxt_of_match);
3353
3354#ifdef CONFIG_ACPI
3355static const struct acpi_device_id mxt_acpi_id[] = {
3356	{ "ATML0000", 0 },	/* Touchpad */
3357	{ "ATML0001", 0 },	/* Touchscreen */
3358	{ }
3359};
3360MODULE_DEVICE_TABLE(acpi, mxt_acpi_id);
3361#endif
3362
3363static const struct i2c_device_id mxt_id[] = {
3364	{ "qt602240_ts", 0 },
3365	{ "atmel_mxt_ts", 0 },
3366	{ "atmel_mxt_tp", 0 },
3367	{ "maxtouch", 0 },
3368	{ "mXT224", 0 },
3369	{ }
3370};
3371MODULE_DEVICE_TABLE(i2c, mxt_id);
3372
3373static struct i2c_driver mxt_driver = {
3374	.driver = {
3375		.name	= "atmel_mxt_ts",
3376		.of_match_table = mxt_of_match,
3377		.acpi_match_table = ACPI_PTR(mxt_acpi_id),
3378		.pm	= &mxt_pm_ops,
3379	},
3380	.probe_new	= mxt_probe,
3381	.remove		= mxt_remove,
3382	.id_table	= mxt_id,
3383};
3384
3385module_i2c_driver(mxt_driver);
3386
3387/* Module information */
3388MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
3389MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
3390MODULE_LICENSE("GPL");

 
   1/*
   2 * Atmel maXTouch Touchscreen driver
   3 *
   4 * Copyright (C) 2010 Samsung Electronics Co.Ltd
   5 * Copyright (C) 2011-2014 Atmel Corporation
   6 * Copyright (C) 2012 Google, Inc.
   7 * Copyright (C) 2016 Zodiac Inflight Innovations
   8 *
   9 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
  10 *
  11 * This program is free software; you can redistribute  it and/or modify it
  12 * under  the terms of  the GNU General  Public License as published by the
  13 * Free Software Foundation;  either version 2 of the  License, or (at your
  14 * option) any later version.
  15 *
  16 */
  17
  18#include <linux/acpi.h>
  19#include <linux/dmi.h>
  20#include <linux/module.h>
  21#include <linux/init.h>
  22#include <linux/completion.h>
  23#include <linux/delay.h>
  24#include <linux/firmware.h>
  25#include <linux/i2c.h>
  26#include <linux/platform_data/atmel_mxt_ts.h>
  27#include <linux/input/mt.h>
  28#include <linux/interrupt.h>
 
  29#include <linux/of.h>
 
  30#include <linux/slab.h>
 
 
  31#include <asm/unaligned.h>
  32#include <media/v4l2-device.h>
  33#include <media/v4l2-ioctl.h>
  34#include <media/videobuf2-v4l2.h>
  35#include <media/videobuf2-vmalloc.h>
 
  36
  37/* Firmware files */
  38#define MXT_FW_NAME		"maxtouch.fw"
  39#define MXT_CFG_NAME		"maxtouch.cfg"
  40#define MXT_CFG_MAGIC		"OBP_RAW V1"
  41
  42/* Registers */
  43#define MXT_OBJECT_START	0x07
  44#define MXT_OBJECT_SIZE		6
  45#define MXT_INFO_CHECKSUM_SIZE	3
  46#define MXT_MAX_BLOCK_WRITE	256
  47
  48/* Object types */
  49#define MXT_DEBUG_DIAGNOSTIC_T37	37
  50#define MXT_GEN_MESSAGE_T5		5
  51#define MXT_GEN_COMMAND_T6		6
  52#define MXT_GEN_POWER_T7		7
  53#define MXT_GEN_ACQUIRE_T8		8
  54#define MXT_GEN_DATASOURCE_T53		53
  55#define MXT_TOUCH_MULTI_T9		9
  56#define MXT_TOUCH_KEYARRAY_T15		15
  57#define MXT_TOUCH_PROXIMITY_T23		23
  58#define MXT_TOUCH_PROXKEY_T52		52
  59#define MXT_PROCI_GRIPFACE_T20		20
  60#define MXT_PROCG_NOISE_T22		22
  61#define MXT_PROCI_ONETOUCH_T24		24
  62#define MXT_PROCI_TWOTOUCH_T27		27
  63#define MXT_PROCI_GRIP_T40		40
  64#define MXT_PROCI_PALM_T41		41
  65#define MXT_PROCI_TOUCHSUPPRESSION_T42	42
  66#define MXT_PROCI_STYLUS_T47		47
  67#define MXT_PROCG_NOISESUPPRESSION_T48	48
  68#define MXT_SPT_COMMSCONFIG_T18		18
  69#define MXT_SPT_GPIOPWM_T19		19
  70#define MXT_SPT_SELFTEST_T25		25
  71#define MXT_SPT_CTECONFIG_T28		28
  72#define MXT_SPT_USERDATA_T38		38
  73#define MXT_SPT_DIGITIZER_T43		43
  74#define MXT_SPT_MESSAGECOUNT_T44	44
  75#define MXT_SPT_CTECONFIG_T46		46
 
  76#define MXT_TOUCH_MULTITOUCHSCREEN_T100 100
  77
  78/* MXT_GEN_MESSAGE_T5 object */
  79#define MXT_RPTID_NOMSG		0xff
  80
  81/* MXT_GEN_COMMAND_T6 field */
  82#define MXT_COMMAND_RESET	0
  83#define MXT_COMMAND_BACKUPNV	1
  84#define MXT_COMMAND_CALIBRATE	2
  85#define MXT_COMMAND_REPORTALL	3
  86#define MXT_COMMAND_DIAGNOSTIC	5
  87
  88/* Define for T6 status byte */
  89#define MXT_T6_STATUS_RESET	(1 << 7)
  90#define MXT_T6_STATUS_OFL	(1 << 6)
  91#define MXT_T6_STATUS_SIGERR	(1 << 5)
  92#define MXT_T6_STATUS_CAL	(1 << 4)
  93#define MXT_T6_STATUS_CFGERR	(1 << 3)
  94#define MXT_T6_STATUS_COMSERR	(1 << 2)
  95
  96/* MXT_GEN_POWER_T7 field */
  97struct t7_config {
  98	u8 idle;
  99	u8 active;
 100} __packed;
 101
 102#define MXT_POWER_CFG_RUN		0
 103#define MXT_POWER_CFG_DEEPSLEEP		1
 104
 105/* MXT_TOUCH_MULTI_T9 field */
 106#define MXT_T9_CTRL		0
 107#define MXT_T9_XSIZE		3
 108#define MXT_T9_YSIZE		4
 109#define MXT_T9_ORIENT		9
 110#define MXT_T9_RANGE		18
 111
 112/* MXT_TOUCH_MULTI_T9 status */
 113#define MXT_T9_UNGRIP		(1 << 0)
 114#define MXT_T9_SUPPRESS		(1 << 1)
 115#define MXT_T9_AMP		(1 << 2)
 116#define MXT_T9_VECTOR		(1 << 3)
 117#define MXT_T9_MOVE		(1 << 4)
 118#define MXT_T9_RELEASE		(1 << 5)
 119#define MXT_T9_PRESS		(1 << 6)
 120#define MXT_T9_DETECT		(1 << 7)
 121
 122struct t9_range {
 123	__le16 x;
 124	__le16 y;
 125} __packed;
 126
 127/* MXT_TOUCH_MULTI_T9 orient */
 128#define MXT_T9_ORIENT_SWITCH	(1 << 0)
 129#define MXT_T9_ORIENT_INVERTX	(1 << 1)
 130#define MXT_T9_ORIENT_INVERTY	(1 << 2)
 131
 132/* MXT_SPT_COMMSCONFIG_T18 */
 133#define MXT_COMMS_CTRL		0
 134#define MXT_COMMS_CMD		1
 
 135
 136/* MXT_DEBUG_DIAGNOSTIC_T37 */
 137#define MXT_DIAGNOSTIC_PAGEUP	0x01
 138#define MXT_DIAGNOSTIC_DELTAS	0x10
 139#define MXT_DIAGNOSTIC_REFS	0x11
 140#define MXT_DIAGNOSTIC_SIZE	128
 141
 142#define MXT_FAMILY_1386			160
 143#define MXT1386_COLUMNS			3
 144#define MXT1386_PAGES_PER_COLUMN	8
 145
 146struct t37_debug {
 147#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
 148	u8 mode;
 149	u8 page;
 150	u8 data[MXT_DIAGNOSTIC_SIZE];
 151#endif
 152};
 153
 154/* Define for MXT_GEN_COMMAND_T6 */
 155#define MXT_BOOT_VALUE		0xa5
 156#define MXT_RESET_VALUE		0x01
 157#define MXT_BACKUP_VALUE	0x55
 158
 159/* T100 Multiple Touch Touchscreen */
 160#define MXT_T100_CTRL		0
 161#define MXT_T100_CFG1		1
 162#define MXT_T100_TCHAUX		3
 163#define MXT_T100_XSIZE		9
 164#define MXT_T100_XRANGE		13
 165#define MXT_T100_YSIZE		20
 166#define MXT_T100_YRANGE		24
 167
 168#define MXT_T100_CFG_SWITCHXY	BIT(5)
 169#define MXT_T100_CFG_INVERTY	BIT(6)
 170#define MXT_T100_CFG_INVERTX	BIT(7)
 171
 172#define MXT_T100_TCHAUX_VECT	BIT(0)
 173#define MXT_T100_TCHAUX_AMPL	BIT(1)
 174#define MXT_T100_TCHAUX_AREA	BIT(2)
 175
 176#define MXT_T100_DETECT		BIT(7)
 177#define MXT_T100_TYPE_MASK	0x70
 178
 179enum t100_type {
 180	MXT_T100_TYPE_FINGER		= 1,
 181	MXT_T100_TYPE_PASSIVE_STYLUS	= 2,
 182	MXT_T100_TYPE_HOVERING_FINGER	= 4,
 183	MXT_T100_TYPE_GLOVE		= 5,
 184	MXT_T100_TYPE_LARGE_TOUCH	= 6,
 185};
 186
 187#define MXT_DISTANCE_ACTIVE_TOUCH	0
 188#define MXT_DISTANCE_HOVERING		1
 189
 190#define MXT_TOUCH_MAJOR_DEFAULT		1
 191#define MXT_PRESSURE_DEFAULT		1
 192
 193/* Delay times */
 194#define MXT_BACKUP_TIME		50	/* msec */
 
 
 195#define MXT_RESET_TIME		200	/* msec */
 196#define MXT_RESET_TIMEOUT	3000	/* msec */
 197#define MXT_CRC_TIMEOUT		1000	/* msec */
 198#define MXT_FW_RESET_TIME	3000	/* msec */
 199#define MXT_FW_CHG_TIMEOUT	300	/* msec */
 
 200
 201/* Command to unlock bootloader */
 202#define MXT_UNLOCK_CMD_MSB	0xaa
 203#define MXT_UNLOCK_CMD_LSB	0xdc
 204
 205/* Bootloader mode status */
 206#define MXT_WAITING_BOOTLOAD_CMD	0xc0	/* valid 7 6 bit only */
 207#define MXT_WAITING_FRAME_DATA	0x80	/* valid 7 6 bit only */
 208#define MXT_FRAME_CRC_CHECK	0x02
 209#define MXT_FRAME_CRC_FAIL	0x03
 210#define MXT_FRAME_CRC_PASS	0x04
 211#define MXT_APP_CRC_FAIL	0x40	/* valid 7 8 bit only */
 212#define MXT_BOOT_STATUS_MASK	0x3f
 213#define MXT_BOOT_EXTENDED_ID	(1 << 5)
 214#define MXT_BOOT_ID_MASK	0x1f
 215
 216/* Touchscreen absolute values */
 217#define MXT_MAX_AREA		0xff
 218
 219#define MXT_PIXELS_PER_MM	20
 220
 221struct mxt_info {
 222	u8 family_id;
 223	u8 variant_id;
 224	u8 version;
 225	u8 build;
 226	u8 matrix_xsize;
 227	u8 matrix_ysize;
 228	u8 object_num;
 229};
 230
 231struct mxt_object {
 232	u8 type;
 233	u16 start_address;
 234	u8 size_minus_one;
 235	u8 instances_minus_one;
 236	u8 num_report_ids;
 237} __packed;
 238
 239struct mxt_dbg {
 240	u16 t37_address;
 241	u16 diag_cmd_address;
 242	struct t37_debug *t37_buf;
 243	unsigned int t37_pages;
 244	unsigned int t37_nodes;
 245
 246	struct v4l2_device v4l2;
 247	struct v4l2_pix_format format;
 248	struct video_device vdev;
 249	struct vb2_queue queue;
 250	struct mutex lock;
 251	int input;
 252};
 253
 254enum v4l_dbg_inputs {
 255	MXT_V4L_INPUT_DELTAS,
 256	MXT_V4L_INPUT_REFS,
 257	MXT_V4L_INPUT_MAX,
 258};
 259
 260static const struct v4l2_file_operations mxt_video_fops = {
 261	.owner = THIS_MODULE,
 262	.open = v4l2_fh_open,
 263	.release = vb2_fop_release,
 264	.unlocked_ioctl = video_ioctl2,
 265	.read = vb2_fop_read,
 266	.mmap = vb2_fop_mmap,
 267	.poll = vb2_fop_poll,
 
 
 
 
 
 
 
 
 268};
 269
 270/* Each client has this additional data */
 271struct mxt_data {
 272	struct i2c_client *client;
 273	struct input_dev *input_dev;
 274	char phys[64];		/* device physical location */
 275	const struct mxt_platform_data *pdata;
 276	struct mxt_object *object_table;
 277	struct mxt_info info;
 
 278	unsigned int irq;
 279	unsigned int max_x;
 280	unsigned int max_y;
 281	bool invertx;
 282	bool inverty;
 283	bool xy_switch;
 284	u8 xsize;
 285	u8 ysize;
 286	bool in_bootloader;
 287	u16 mem_size;
 288	u8 t100_aux_ampl;
 289	u8 t100_aux_area;
 290	u8 t100_aux_vect;
 291	u8 max_reportid;
 292	u32 config_crc;
 293	u32 info_crc;
 294	u8 bootloader_addr;
 295	u8 *msg_buf;
 296	u8 t6_status;
 297	bool update_input;
 298	u8 last_message_count;
 299	u8 num_touchids;
 300	u8 multitouch;
 301	struct t7_config t7_cfg;
 302	struct mxt_dbg dbg;
 
 
 
 
 303
 304	/* Cached parameters from object table */
 305	u16 T5_address;
 306	u8 T5_msg_size;
 307	u8 T6_reportid;
 308	u16 T6_address;
 309	u16 T7_address;
 
 310	u8 T9_reportid_min;
 311	u8 T9_reportid_max;
 
 312	u8 T19_reportid;
 313	u16 T44_address;
 314	u8 T100_reportid_min;
 315	u8 T100_reportid_max;
 316
 317	/* for fw update in bootloader */
 318	struct completion bl_completion;
 319
 320	/* for reset handling */
 321	struct completion reset_completion;
 322
 323	/* for config update handling */
 324	struct completion crc_completion;
 
 
 
 
 
 
 
 325};
 326
 327struct mxt_vb2_buffer {
 328	struct vb2_buffer	vb;
 329	struct list_head	list;
 330};
 331
 332static size_t mxt_obj_size(const struct mxt_object *obj)
 333{
 334	return obj->size_minus_one + 1;
 335}
 336
 337static size_t mxt_obj_instances(const struct mxt_object *obj)
 338{
 339	return obj->instances_minus_one + 1;
 340}
 341
 342static bool mxt_object_readable(unsigned int type)
 343{
 344	switch (type) {
 345	case MXT_GEN_COMMAND_T6:
 346	case MXT_GEN_POWER_T7:
 347	case MXT_GEN_ACQUIRE_T8:
 348	case MXT_GEN_DATASOURCE_T53:
 349	case MXT_TOUCH_MULTI_T9:
 350	case MXT_TOUCH_KEYARRAY_T15:
 351	case MXT_TOUCH_PROXIMITY_T23:
 352	case MXT_TOUCH_PROXKEY_T52:
 
 353	case MXT_PROCI_GRIPFACE_T20:
 354	case MXT_PROCG_NOISE_T22:
 355	case MXT_PROCI_ONETOUCH_T24:
 356	case MXT_PROCI_TWOTOUCH_T27:
 357	case MXT_PROCI_GRIP_T40:
 358	case MXT_PROCI_PALM_T41:
 359	case MXT_PROCI_TOUCHSUPPRESSION_T42:
 360	case MXT_PROCI_STYLUS_T47:
 361	case MXT_PROCG_NOISESUPPRESSION_T48:
 362	case MXT_SPT_COMMSCONFIG_T18:
 363	case MXT_SPT_GPIOPWM_T19:
 364	case MXT_SPT_SELFTEST_T25:
 365	case MXT_SPT_CTECONFIG_T28:
 366	case MXT_SPT_USERDATA_T38:
 367	case MXT_SPT_DIGITIZER_T43:
 368	case MXT_SPT_CTECONFIG_T46:
 
 369		return true;
 370	default:
 371		return false;
 372	}
 373}
 374
 375static void mxt_dump_message(struct mxt_data *data, u8 *message)
 376{
 377	dev_dbg(&data->client->dev, "message: %*ph\n",
 378		data->T5_msg_size, message);
 379}
 380
 381static int mxt_wait_for_completion(struct mxt_data *data,
 382				   struct completion *comp,
 383				   unsigned int timeout_ms)
 384{
 385	struct device *dev = &data->client->dev;
 386	unsigned long timeout = msecs_to_jiffies(timeout_ms);
 387	long ret;
 388
 389	ret = wait_for_completion_interruptible_timeout(comp, timeout);
 390	if (ret < 0) {
 391		return ret;
 392	} else if (ret == 0) {
 393		dev_err(dev, "Wait for completion timed out.\n");
 394		return -ETIMEDOUT;
 395	}
 396	return 0;
 397}
 398
 399static int mxt_bootloader_read(struct mxt_data *data,
 400			       u8 *val, unsigned int count)
 401{
 402	int ret;
 403	struct i2c_msg msg;
 404
 405	msg.addr = data->bootloader_addr;
 406	msg.flags = data->client->flags & I2C_M_TEN;
 407	msg.flags |= I2C_M_RD;
 408	msg.len = count;
 409	msg.buf = val;
 410
 411	ret = i2c_transfer(data->client->adapter, &msg, 1);
 412	if (ret == 1) {
 413		ret = 0;
 414	} else {
 415		ret = ret < 0 ? ret : -EIO;
 416		dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n",
 417			__func__, ret);
 418	}
 419
 420	return ret;
 421}
 422
 423static int mxt_bootloader_write(struct mxt_data *data,
 424				const u8 * const val, unsigned int count)
 425{
 426	int ret;
 427	struct i2c_msg msg;
 428
 429	msg.addr = data->bootloader_addr;
 430	msg.flags = data->client->flags & I2C_M_TEN;
 431	msg.len = count;
 432	msg.buf = (u8 *)val;
 433
 434	ret = i2c_transfer(data->client->adapter, &msg, 1);
 435	if (ret == 1) {
 436		ret = 0;
 437	} else {
 438		ret = ret < 0 ? ret : -EIO;
 439		dev_err(&data->client->dev, "%s: i2c send failed (%d)\n",
 440			__func__, ret);
 441	}
 442
 443	return ret;
 444}
 445
 446static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry)
 447{
 448	u8 appmode = data->client->addr;
 449	u8 bootloader;
 
 450
 451	switch (appmode) {
 452	case 0x4a:
 453	case 0x4b:
 454		/* Chips after 1664S use different scheme */
 455		if (retry || data->info.family_id >= 0xa2) {
 456			bootloader = appmode - 0x24;
 457			break;
 458		}
 459		/* Fall through for normal case */
 460	case 0x4c:
 461	case 0x4d:
 462	case 0x5a:
 463	case 0x5b:
 464		bootloader = appmode - 0x26;
 465		break;
 466
 467	default:
 468		dev_err(&data->client->dev,
 469			"Appmode i2c address 0x%02x not found\n",
 470			appmode);
 471		return -EINVAL;
 472	}
 473
 474	data->bootloader_addr = bootloader;
 475	return 0;
 476}
 477
 478static int mxt_probe_bootloader(struct mxt_data *data, bool alt_address)
 479{
 480	struct device *dev = &data->client->dev;
 481	int error;
 482	u8 val;
 483	bool crc_failure;
 484
 485	error = mxt_lookup_bootloader_address(data, alt_address);
 486	if (error)
 487		return error;
 488
 489	error = mxt_bootloader_read(data, &val, 1);
 490	if (error)
 491		return error;
 492
 493	/* Check app crc fail mode */
 494	crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL;
 495
 496	dev_err(dev, "Detected bootloader, status:%02X%s\n",
 497			val, crc_failure ? ", APP_CRC_FAIL" : "");
 498
 499	return 0;
 500}
 501
 502static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val)
 503{
 504	struct device *dev = &data->client->dev;
 505	u8 buf[3];
 506
 507	if (val & MXT_BOOT_EXTENDED_ID) {
 508		if (mxt_bootloader_read(data, &buf[0], 3) != 0) {
 509			dev_err(dev, "%s: i2c failure\n", __func__);
 510			return val;
 511		}
 512
 513		dev_dbg(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]);
 514
 515		return buf[0];
 516	} else {
 517		dev_dbg(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK);
 518
 519		return val;
 520	}
 521}
 522
 523static int mxt_check_bootloader(struct mxt_data *data, unsigned int state,
 524				bool wait)
 525{
 526	struct device *dev = &data->client->dev;
 527	u8 val;
 528	int ret;
 529
 530recheck:
 531	if (wait) {
 532		/*
 533		 * In application update mode, the interrupt
 534		 * line signals state transitions. We must wait for the
 535		 * CHG assertion before reading the status byte.
 536		 * Once the status byte has been read, the line is deasserted.
 537		 */
 538		ret = mxt_wait_for_completion(data, &data->bl_completion,
 539					      MXT_FW_CHG_TIMEOUT);
 540		if (ret) {
 541			/*
 542			 * TODO: handle -ERESTARTSYS better by terminating
 543			 * fw update process before returning to userspace
 544			 * by writing length 0x000 to device (iff we are in
 545			 * WAITING_FRAME_DATA state).
 546			 */
 547			dev_err(dev, "Update wait error %d\n", ret);
 548			return ret;
 549		}
 550	}
 551
 552	ret = mxt_bootloader_read(data, &val, 1);
 553	if (ret)
 554		return ret;
 555
 556	if (state == MXT_WAITING_BOOTLOAD_CMD)
 557		val = mxt_get_bootloader_version(data, val);
 558
 559	switch (state) {
 560	case MXT_WAITING_BOOTLOAD_CMD:
 561	case MXT_WAITING_FRAME_DATA:
 562	case MXT_APP_CRC_FAIL:
 563		val &= ~MXT_BOOT_STATUS_MASK;
 564		break;
 565	case MXT_FRAME_CRC_PASS:
 566		if (val == MXT_FRAME_CRC_CHECK) {
 567			goto recheck;
 568		} else if (val == MXT_FRAME_CRC_FAIL) {
 569			dev_err(dev, "Bootloader CRC fail\n");
 570			return -EINVAL;
 571		}
 572		break;
 573	default:
 574		return -EINVAL;
 575	}
 576
 577	if (val != state) {
 578		dev_err(dev, "Invalid bootloader state %02X != %02X\n",
 579			val, state);
 580		return -EINVAL;
 581	}
 582
 583	return 0;
 584}
 585
 586static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock)
 587{
 588	int ret;
 589	u8 buf[2];
 590
 591	if (unlock) {
 592		buf[0] = MXT_UNLOCK_CMD_LSB;
 593		buf[1] = MXT_UNLOCK_CMD_MSB;
 594	} else {
 595		buf[0] = 0x01;
 596		buf[1] = 0x01;
 597	}
 598
 599	ret = mxt_bootloader_write(data, buf, 2);
 600	if (ret)
 601		return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 602
 603	return 0;
 604}
 605
 606static int __mxt_read_reg(struct i2c_client *client,
 607			       u16 reg, u16 len, void *val)
 608{
 609	struct i2c_msg xfer[2];
 
 610	u8 buf[2];
 611	int ret;
 612
 613	buf[0] = reg & 0xff;
 614	buf[1] = (reg >> 8) & 0xff;
 615
 616	/* Write register */
 617	xfer[0].addr = client->addr;
 618	xfer[0].flags = 0;
 619	xfer[0].len = 2;
 620	xfer[0].buf = buf;
 621
 622	/* Read data */
 623	xfer[1].addr = client->addr;
 624	xfer[1].flags = I2C_M_RD;
 625	xfer[1].len = len;
 626	xfer[1].buf = val;
 627
 
 628	ret = i2c_transfer(client->adapter, xfer, 2);
 629	if (ret == 2) {
 630		ret = 0;
 
 
 
 631	} else {
 632		if (ret >= 0)
 633			ret = -EIO;
 634		dev_err(&client->dev, "%s: i2c transfer failed (%d)\n",
 635			__func__, ret);
 636	}
 637
 638	return ret;
 639}
 640
 641static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len,
 642			   const void *val)
 643{
 
 644	u8 *buf;
 645	size_t count;
 646	int ret;
 647
 648	count = len + 2;
 649	buf = kmalloc(count, GFP_KERNEL);
 650	if (!buf)
 651		return -ENOMEM;
 652
 653	buf[0] = reg & 0xff;
 654	buf[1] = (reg >> 8) & 0xff;
 655	memcpy(&buf[2], val, len);
 656
 
 657	ret = i2c_master_send(client, buf, count);
 658	if (ret == count) {
 659		ret = 0;
 
 
 
 660	} else {
 661		if (ret >= 0)
 662			ret = -EIO;
 663		dev_err(&client->dev, "%s: i2c send failed (%d)\n",
 664			__func__, ret);
 665	}
 666
 667	kfree(buf);
 668	return ret;
 669}
 670
 671static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val)
 672{
 673	return __mxt_write_reg(client, reg, 1, &val);
 674}
 675
 676static struct mxt_object *
 677mxt_get_object(struct mxt_data *data, u8 type)
 678{
 679	struct mxt_object *object;
 680	int i;
 681
 682	for (i = 0; i < data->info.object_num; i++) {
 683		object = data->object_table + i;
 684		if (object->type == type)
 685			return object;
 686	}
 687
 688	dev_warn(&data->client->dev, "Invalid object type T%u\n", type);
 689	return NULL;
 690}
 691
 692static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg)
 693{
 694	struct device *dev = &data->client->dev;
 695	u8 status = msg[1];
 696	u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16);
 697
 698	complete(&data->crc_completion);
 699
 700	if (crc != data->config_crc) {
 701		data->config_crc = crc;
 702		dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc);
 703	}
 704
 
 
 705	/* Detect reset */
 706	if (status & MXT_T6_STATUS_RESET)
 707		complete(&data->reset_completion);
 708
 709	/* Output debug if status has changed */
 710	if (status != data->t6_status)
 711		dev_dbg(dev, "T6 Status 0x%02X%s%s%s%s%s%s%s\n",
 712			status,
 713			status == 0 ? " OK" : "",
 714			status & MXT_T6_STATUS_RESET ? " RESET" : "",
 715			status & MXT_T6_STATUS_OFL ? " OFL" : "",
 716			status & MXT_T6_STATUS_SIGERR ? " SIGERR" : "",
 717			status & MXT_T6_STATUS_CAL ? " CAL" : "",
 718			status & MXT_T6_STATUS_CFGERR ? " CFGERR" : "",
 719			status & MXT_T6_STATUS_COMSERR ? " COMSERR" : "");
 720
 721	/* Save current status */
 722	data->t6_status = status;
 723}
 724
 725static int mxt_write_object(struct mxt_data *data,
 726				 u8 type, u8 offset, u8 val)
 727{
 728	struct mxt_object *object;
 729	u16 reg;
 730
 731	object = mxt_get_object(data, type);
 732	if (!object || offset >= mxt_obj_size(object))
 733		return -EINVAL;
 734
 735	reg = object->start_address;
 736	return mxt_write_reg(data->client, reg + offset, val);
 737}
 738
 739static void mxt_input_button(struct mxt_data *data, u8 *message)
 740{
 741	struct input_dev *input = data->input_dev;
 742	const struct mxt_platform_data *pdata = data->pdata;
 743	int i;
 744
 745	for (i = 0; i < pdata->t19_num_keys; i++) {
 746		if (pdata->t19_keymap[i] == KEY_RESERVED)
 747			continue;
 748
 749		/* Active-low switch */
 750		input_report_key(input, pdata->t19_keymap[i],
 751				 !(message[1] & BIT(i)));
 752	}
 753}
 754
 755static void mxt_input_sync(struct mxt_data *data)
 756{
 757	input_mt_report_pointer_emulation(data->input_dev,
 758					  data->pdata->t19_num_keys);
 759	input_sync(data->input_dev);
 760}
 761
 762static void mxt_proc_t9_message(struct mxt_data *data, u8 *message)
 763{
 764	struct device *dev = &data->client->dev;
 765	struct input_dev *input_dev = data->input_dev;
 766	int id;
 767	u8 status;
 768	int x;
 769	int y;
 770	int area;
 771	int amplitude;
 772
 773	id = message[0] - data->T9_reportid_min;
 774	status = message[1];
 775	x = (message[2] << 4) | ((message[4] >> 4) & 0xf);
 776	y = (message[3] << 4) | ((message[4] & 0xf));
 777
 778	/* Handle 10/12 bit switching */
 779	if (data->max_x < 1024)
 780		x >>= 2;
 781	if (data->max_y < 1024)
 782		y >>= 2;
 783
 784	area = message[5];
 785	amplitude = message[6];
 786
 787	dev_dbg(dev,
 788		"[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n",
 789		id,
 790		(status & MXT_T9_DETECT) ? 'D' : '.',
 791		(status & MXT_T9_PRESS) ? 'P' : '.',
 792		(status & MXT_T9_RELEASE) ? 'R' : '.',
 793		(status & MXT_T9_MOVE) ? 'M' : '.',
 794		(status & MXT_T9_VECTOR) ? 'V' : '.',
 795		(status & MXT_T9_AMP) ? 'A' : '.',
 796		(status & MXT_T9_SUPPRESS) ? 'S' : '.',
 797		(status & MXT_T9_UNGRIP) ? 'U' : '.',
 798		x, y, area, amplitude);
 799
 800	input_mt_slot(input_dev, id);
 801
 802	if (status & MXT_T9_DETECT) {
 803		/*
 804		 * Multiple bits may be set if the host is slow to read
 805		 * the status messages, indicating all the events that
 806		 * have happened.
 807		 */
 808		if (status & MXT_T9_RELEASE) {
 809			input_mt_report_slot_state(input_dev,
 810						   MT_TOOL_FINGER, 0);
 811			mxt_input_sync(data);
 812		}
 813
 
 
 
 
 814		/* Touch active */
 815		input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1);
 816		input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 817		input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 818		input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude);
 819		input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area);
 820	} else {
 821		/* Touch no longer active, close out slot */
 822		input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0);
 823	}
 824
 825	data->update_input = true;
 826}
 827
 828static void mxt_proc_t100_message(struct mxt_data *data, u8 *message)
 829{
 830	struct device *dev = &data->client->dev;
 831	struct input_dev *input_dev = data->input_dev;
 832	int id;
 833	u8 status;
 834	u8 type = 0;
 835	u16 x;
 836	u16 y;
 837	int distance = 0;
 838	int tool = 0;
 839	u8 major = 0;
 840	u8 pressure = 0;
 841	u8 orientation = 0;
 842
 843	id = message[0] - data->T100_reportid_min - 2;
 844
 845	/* ignore SCRSTATUS events */
 846	if (id < 0)
 847		return;
 848
 849	status = message[1];
 850	x = get_unaligned_le16(&message[2]);
 851	y = get_unaligned_le16(&message[4]);
 852
 853	if (status & MXT_T100_DETECT) {
 854		type = (status & MXT_T100_TYPE_MASK) >> 4;
 855
 856		switch (type) {
 857		case MXT_T100_TYPE_HOVERING_FINGER:
 858			tool = MT_TOOL_FINGER;
 859			distance = MXT_DISTANCE_HOVERING;
 860
 861			if (data->t100_aux_vect)
 862				orientation = message[data->t100_aux_vect];
 863
 864			break;
 865
 866		case MXT_T100_TYPE_FINGER:
 867		case MXT_T100_TYPE_GLOVE:
 868			tool = MT_TOOL_FINGER;
 869			distance = MXT_DISTANCE_ACTIVE_TOUCH;
 870
 871			if (data->t100_aux_area)
 872				major = message[data->t100_aux_area];
 873
 874			if (data->t100_aux_ampl)
 875				pressure = message[data->t100_aux_ampl];
 876
 877			if (data->t100_aux_vect)
 878				orientation = message[data->t100_aux_vect];
 879
 880			break;
 881
 882		case MXT_T100_TYPE_PASSIVE_STYLUS:
 883			tool = MT_TOOL_PEN;
 884
 885			/*
 886			 * Passive stylus is reported with size zero so
 887			 * hardcode.
 888			 */
 889			major = MXT_TOUCH_MAJOR_DEFAULT;
 890
 891			if (data->t100_aux_ampl)
 892				pressure = message[data->t100_aux_ampl];
 893
 894			break;
 895
 896		case MXT_T100_TYPE_LARGE_TOUCH:
 897			/* Ignore suppressed touch */
 898			break;
 899
 900		default:
 901			dev_dbg(dev, "Unexpected T100 type\n");
 902			return;
 903		}
 904	}
 905
 906	/*
 907	 * Values reported should be non-zero if tool is touching the
 908	 * device
 909	 */
 910	if (!pressure && type != MXT_T100_TYPE_HOVERING_FINGER)
 911		pressure = MXT_PRESSURE_DEFAULT;
 912
 913	input_mt_slot(input_dev, id);
 914
 915	if (status & MXT_T100_DETECT) {
 916		dev_dbg(dev, "[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n",
 917			id, type, x, y, major, pressure, orientation);
 918
 919		input_mt_report_slot_state(input_dev, tool, 1);
 920		input_report_abs(input_dev, ABS_MT_POSITION_X, x);
 921		input_report_abs(input_dev, ABS_MT_POSITION_Y, y);
 922		input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, major);
 923		input_report_abs(input_dev, ABS_MT_PRESSURE, pressure);
 924		input_report_abs(input_dev, ABS_MT_DISTANCE, distance);
 925		input_report_abs(input_dev, ABS_MT_ORIENTATION, orientation);
 926	} else {
 927		dev_dbg(dev, "[%u] release\n", id);
 928
 929		/* close out slot */
 930		input_mt_report_slot_state(input_dev, 0, 0);
 931	}
 932
 933	data->update_input = true;
 934}
 935
 936static int mxt_proc_message(struct mxt_data *data, u8 *message)
 937{
 938	u8 report_id = message[0];
 939
 940	if (report_id == MXT_RPTID_NOMSG)
 941		return 0;
 942
 943	if (report_id == data->T6_reportid) {
 944		mxt_proc_t6_messages(data, message);
 945	} else if (!data->input_dev) {
 946		/*
 947		 * Do not report events if input device
 948		 * is not yet registered.
 949		 */
 950		mxt_dump_message(data, message);
 951	} else if (report_id >= data->T9_reportid_min &&
 952		   report_id <= data->T9_reportid_max) {
 953		mxt_proc_t9_message(data, message);
 954	} else if (report_id >= data->T100_reportid_min &&
 955		   report_id <= data->T100_reportid_max) {
 956		mxt_proc_t100_message(data, message);
 957	} else if (report_id == data->T19_reportid) {
 958		mxt_input_button(data, message);
 959		data->update_input = true;
 960	} else {
 961		mxt_dump_message(data, message);
 962	}
 963
 964	return 1;
 965}
 966
 967static int mxt_read_and_process_messages(struct mxt_data *data, u8 count)
 968{
 969	struct device *dev = &data->client->dev;
 970	int ret;
 971	int i;
 972	u8 num_valid = 0;
 973
 974	/* Safety check for msg_buf */
 975	if (count > data->max_reportid)
 976		return -EINVAL;
 977
 978	/* Process remaining messages if necessary */
 979	ret = __mxt_read_reg(data->client, data->T5_address,
 980				data->T5_msg_size * count, data->msg_buf);
 981	if (ret) {
 982		dev_err(dev, "Failed to read %u messages (%d)\n", count, ret);
 983		return ret;
 984	}
 985
 986	for (i = 0;  i < count; i++) {
 987		ret = mxt_proc_message(data,
 988			data->msg_buf + data->T5_msg_size * i);
 989
 990		if (ret == 1)
 991			num_valid++;
 992	}
 993
 994	/* return number of messages read */
 995	return num_valid;
 996}
 997
 998static irqreturn_t mxt_process_messages_t44(struct mxt_data *data)
 999{
1000	struct device *dev = &data->client->dev;
1001	int ret;
1002	u8 count, num_left;
1003
1004	/* Read T44 and T5 together */
1005	ret = __mxt_read_reg(data->client, data->T44_address,
1006		data->T5_msg_size + 1, data->msg_buf);
1007	if (ret) {
1008		dev_err(dev, "Failed to read T44 and T5 (%d)\n", ret);
1009		return IRQ_NONE;
1010	}
1011
1012	count = data->msg_buf[0];
1013
1014	/*
1015	 * This condition may be caused by the CHG line being configured in
1016	 * Mode 0. It results in unnecessary I2C operations but it is benign.
1017	 */
1018	if (count == 0)
1019		return IRQ_NONE;
1020
1021	if (count > data->max_reportid) {
1022		dev_warn(dev, "T44 count %d exceeded max report id\n", count);
1023		count = data->max_reportid;
1024	}
1025
1026	/* Process first message */
1027	ret = mxt_proc_message(data, data->msg_buf + 1);
1028	if (ret < 0) {
1029		dev_warn(dev, "Unexpected invalid message\n");
1030		return IRQ_NONE;
1031	}
1032
1033	num_left = count - 1;
1034
1035	/* Process remaining messages if necessary */
1036	if (num_left) {
1037		ret = mxt_read_and_process_messages(data, num_left);
1038		if (ret < 0)
1039			goto end;
1040		else if (ret != num_left)
1041			dev_warn(dev, "Unexpected invalid message\n");
1042	}
1043
1044end:
1045	if (data->update_input) {
1046		mxt_input_sync(data);
1047		data->update_input = false;
1048	}
1049
1050	return IRQ_HANDLED;
1051}
1052
1053static int mxt_process_messages_until_invalid(struct mxt_data *data)
1054{
1055	struct device *dev = &data->client->dev;
1056	int count, read;
1057	u8 tries = 2;
1058
1059	count = data->max_reportid;
1060
1061	/* Read messages until we force an invalid */
1062	do {
1063		read = mxt_read_and_process_messages(data, count);
1064		if (read < count)
1065			return 0;
1066	} while (--tries);
1067
1068	if (data->update_input) {
1069		mxt_input_sync(data);
1070		data->update_input = false;
1071	}
1072
1073	dev_err(dev, "CHG pin isn't cleared\n");
1074	return -EBUSY;
1075}
1076
1077static irqreturn_t mxt_process_messages(struct mxt_data *data)
1078{
1079	int total_handled, num_handled;
1080	u8 count = data->last_message_count;
1081
1082	if (count < 1 || count > data->max_reportid)
1083		count = 1;
1084
1085	/* include final invalid message */
1086	total_handled = mxt_read_and_process_messages(data, count + 1);
1087	if (total_handled < 0)
1088		return IRQ_NONE;
1089	/* if there were invalid messages, then we are done */
1090	else if (total_handled <= count)
1091		goto update_count;
1092
1093	/* keep reading two msgs until one is invalid or reportid limit */
1094	do {
1095		num_handled = mxt_read_and_process_messages(data, 2);
1096		if (num_handled < 0)
1097			return IRQ_NONE;
1098
1099		total_handled += num_handled;
1100
1101		if (num_handled < 2)
1102			break;
1103	} while (total_handled < data->num_touchids);
1104
1105update_count:
1106	data->last_message_count = total_handled;
1107
1108	if (data->update_input) {
1109		mxt_input_sync(data);
1110		data->update_input = false;
1111	}
1112
1113	return IRQ_HANDLED;
1114}
1115
1116static irqreturn_t mxt_interrupt(int irq, void *dev_id)
1117{
1118	struct mxt_data *data = dev_id;
1119
1120	if (data->in_bootloader) {
1121		/* bootloader state transition completion */
1122		complete(&data->bl_completion);
1123		return IRQ_HANDLED;
1124	}
1125
1126	if (!data->object_table)
1127		return IRQ_HANDLED;
1128
1129	if (data->T44_address) {
1130		return mxt_process_messages_t44(data);
1131	} else {
1132		return mxt_process_messages(data);
1133	}
1134}
1135
1136static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
1137			  u8 value, bool wait)
1138{
1139	u16 reg;
1140	u8 command_register;
1141	int timeout_counter = 0;
1142	int ret;
1143
1144	reg = data->T6_address + cmd_offset;
1145
1146	ret = mxt_write_reg(data->client, reg, value);
1147	if (ret)
1148		return ret;
1149
1150	if (!wait)
1151		return 0;
1152
1153	do {
1154		msleep(20);
1155		ret = __mxt_read_reg(data->client, reg, 1, &command_register);
1156		if (ret)
1157			return ret;
1158	} while (command_register != 0 && timeout_counter++ <= 100);
1159
1160	if (timeout_counter > 100) {
1161		dev_err(&data->client->dev, "Command failed!\n");
1162		return -EIO;
1163	}
1164
1165	return 0;
1166}
1167
1168static int mxt_acquire_irq(struct mxt_data *data)
1169{
1170	int error;
1171
1172	enable_irq(data->irq);
1173
1174	error = mxt_process_messages_until_invalid(data);
1175	if (error)
1176		return error;
 
 
1177
1178	return 0;
1179}
1180
1181static int mxt_soft_reset(struct mxt_data *data)
1182{
1183	struct device *dev = &data->client->dev;
1184	int ret = 0;
1185
1186	dev_info(dev, "Resetting device\n");
1187
1188	disable_irq(data->irq);
1189
1190	reinit_completion(&data->reset_completion);
1191
1192	ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false);
1193	if (ret)
1194		return ret;
1195
1196	/* Ignore CHG line for 100ms after reset */
1197	msleep(100);
1198
1199	mxt_acquire_irq(data);
1200
1201	ret = mxt_wait_for_completion(data, &data->reset_completion,
1202				      MXT_RESET_TIMEOUT);
1203	if (ret)
1204		return ret;
1205
1206	return 0;
1207}
1208
1209static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value)
1210{
1211	/*
1212	 * On failure, CRC is set to 0 and config will always be
1213	 * downloaded.
1214	 */
1215	data->config_crc = 0;
1216	reinit_completion(&data->crc_completion);
1217
1218	mxt_t6_command(data, cmd, value, true);
1219
1220	/*
1221	 * Wait for crc message. On failure, CRC is set to 0 and config will
1222	 * always be downloaded.
1223	 */
1224	mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT);
1225}
1226
1227static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte)
1228{
1229	static const unsigned int crcpoly = 0x80001B;
1230	u32 result;
1231	u32 data_word;
1232
1233	data_word = (secondbyte << 8) | firstbyte;
1234	result = ((*crc << 1) ^ data_word);
1235
1236	if (result & 0x1000000)
1237		result ^= crcpoly;
1238
1239	*crc = result;
1240}
1241
1242static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off)
1243{
1244	u32 crc = 0;
1245	u8 *ptr = base + start_off;
1246	u8 *last_val = base + end_off - 1;
1247
1248	if (end_off < start_off)
1249		return -EINVAL;
1250
1251	while (ptr < last_val) {
1252		mxt_calc_crc24(&crc, *ptr, *(ptr + 1));
1253		ptr += 2;
1254	}
1255
1256	/* if len is odd, fill the last byte with 0 */
1257	if (ptr == last_val)
1258		mxt_calc_crc24(&crc, *ptr, 0);
1259
1260	/* Mask to 24-bit */
1261	crc &= 0x00FFFFFF;
1262
1263	return crc;
1264}
1265
1266static int mxt_prepare_cfg_mem(struct mxt_data *data,
1267			       const struct firmware *cfg,
1268			       unsigned int data_pos,
1269			       unsigned int cfg_start_ofs,
1270			       u8 *config_mem,
1271			       size_t config_mem_size)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1272{
1273	struct device *dev = &data->client->dev;
1274	struct mxt_object *object;
1275	unsigned int type, instance, size, byte_offset;
1276	int offset;
1277	int ret;
1278	int i;
1279	u16 reg;
1280	u8 val;
1281
1282	while (data_pos < cfg->size) {
1283		/* Read type, instance, length */
1284		ret = sscanf(cfg->data + data_pos, "%x %x %x%n",
1285			     &type, &instance, &size, &offset);
1286		if (ret == 0) {
1287			/* EOF */
1288			break;
1289		} else if (ret != 3) {
1290			dev_err(dev, "Bad format: failed to parse object\n");
1291			return -EINVAL;
1292		}
1293		data_pos += offset;
1294
1295		object = mxt_get_object(data, type);
1296		if (!object) {
1297			/* Skip object */
1298			for (i = 0; i < size; i++) {
1299				ret = sscanf(cfg->data + data_pos, "%hhx%n",
1300					     &val, &offset);
1301				if (ret != 1) {
1302					dev_err(dev, "Bad format in T%d at %d\n",
1303						type, i);
1304					return -EINVAL;
1305				}
1306				data_pos += offset;
1307			}
1308			continue;
1309		}
1310
1311		if (size > mxt_obj_size(object)) {
1312			/*
1313			 * Either we are in fallback mode due to wrong
1314			 * config or config from a later fw version,
1315			 * or the file is corrupt or hand-edited.
1316			 */
1317			dev_warn(dev, "Discarding %zu byte(s) in T%u\n",
1318				 size - mxt_obj_size(object), type);
1319		} else if (mxt_obj_size(object) > size) {
1320			/*
1321			 * If firmware is upgraded, new bytes may be added to
1322			 * end of objects. It is generally forward compatible
1323			 * to zero these bytes - previous behaviour will be
1324			 * retained. However this does invalidate the CRC and
1325			 * will force fallback mode until the configuration is
1326			 * updated. We warn here but do nothing else - the
1327			 * malloc has zeroed the entire configuration.
1328			 */
1329			dev_warn(dev, "Zeroing %zu byte(s) in T%d\n",
1330				 mxt_obj_size(object) - size, type);
1331		}
1332
1333		if (instance >= mxt_obj_instances(object)) {
1334			dev_err(dev, "Object instances exceeded!\n");
1335			return -EINVAL;
1336		}
1337
1338		reg = object->start_address + mxt_obj_size(object) * instance;
1339
1340		for (i = 0; i < size; i++) {
1341			ret = sscanf(cfg->data + data_pos, "%hhx%n",
1342				     &val,
1343				     &offset);
1344			if (ret != 1) {
1345				dev_err(dev, "Bad format in T%d at %d\n",
1346					type, i);
1347				return -EINVAL;
1348			}
1349			data_pos += offset;
1350
1351			if (i > mxt_obj_size(object))
1352				continue;
1353
1354			byte_offset = reg + i - cfg_start_ofs;
1355
1356			if (byte_offset >= 0 && byte_offset < config_mem_size) {
1357				*(config_mem + byte_offset) = val;
1358			} else {
1359				dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n",
1360					reg, object->type, byte_offset);
1361				return -EINVAL;
1362			}
1363		}
1364	}
1365
1366	return 0;
1367}
1368
1369static int mxt_upload_cfg_mem(struct mxt_data *data, unsigned int cfg_start,
1370			      u8 *config_mem, size_t config_mem_size)
1371{
1372	unsigned int byte_offset = 0;
1373	int error;
1374
1375	/* Write configuration as blocks */
1376	while (byte_offset < config_mem_size) {
1377		unsigned int size = config_mem_size - byte_offset;
1378
1379		if (size > MXT_MAX_BLOCK_WRITE)
1380			size = MXT_MAX_BLOCK_WRITE;
1381
1382		error = __mxt_write_reg(data->client,
1383					cfg_start + byte_offset,
1384					size, config_mem + byte_offset);
1385		if (error) {
1386			dev_err(&data->client->dev,
1387				"Config write error, ret=%d\n", error);
1388			return error;
1389		}
1390
1391		byte_offset += size;
1392	}
1393
1394	return 0;
1395}
1396
1397static int mxt_init_t7_power_cfg(struct mxt_data *data);
1398
1399/*
1400 * mxt_update_cfg - download configuration to chip
1401 *
1402 * Atmel Raw Config File Format
1403 *
1404 * The first four lines of the raw config file contain:
1405 *  1) Version
1406 *  2) Chip ID Information (first 7 bytes of device memory)
1407 *  3) Chip Information Block 24-bit CRC Checksum
1408 *  4) Chip Configuration 24-bit CRC Checksum
1409 *
1410 * The rest of the file consists of one line per object instance:
1411 *   <TYPE> <INSTANCE> <SIZE> <CONTENTS>
1412 *
1413 *   <TYPE> - 2-byte object type as hex
1414 *   <INSTANCE> - 2-byte object instance number as hex
1415 *   <SIZE> - 2-byte object size as hex
1416 *   <CONTENTS> - array of <SIZE> 1-byte hex values
1417 */
1418static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg)
1419{
1420	struct device *dev = &data->client->dev;
1421	struct mxt_info cfg_info;
1422	int ret;
1423	int offset;
1424	int data_pos;
1425	int i;
1426	int cfg_start_ofs;
1427	u32 info_crc, config_crc, calculated_crc;
1428	u8 *config_mem;
1429	size_t config_mem_size;
 
 
 
 
 
 
1430
1431	mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1);
1432
1433	if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) {
1434		dev_err(dev, "Unrecognised config file\n");
1435		return -EINVAL;
 
1436	}
1437
1438	data_pos = strlen(MXT_CFG_MAGIC);
1439
1440	/* Load information block and check */
1441	for (i = 0; i < sizeof(struct mxt_info); i++) {
1442		ret = sscanf(cfg->data + data_pos, "%hhx%n",
1443			     (unsigned char *)&cfg_info + i,
1444			     &offset);
1445		if (ret != 1) {
1446			dev_err(dev, "Bad format\n");
1447			return -EINVAL;
 
1448		}
1449
1450		data_pos += offset;
1451	}
1452
1453	if (cfg_info.family_id != data->info.family_id) {
1454		dev_err(dev, "Family ID mismatch!\n");
1455		return -EINVAL;
 
1456	}
1457
1458	if (cfg_info.variant_id != data->info.variant_id) {
1459		dev_err(dev, "Variant ID mismatch!\n");
1460		return -EINVAL;
 
1461	}
1462
1463	/* Read CRCs */
1464	ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset);
1465	if (ret != 1) {
1466		dev_err(dev, "Bad format: failed to parse Info CRC\n");
1467		return -EINVAL;
 
1468	}
1469	data_pos += offset;
1470
1471	ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset);
1472	if (ret != 1) {
1473		dev_err(dev, "Bad format: failed to parse Config CRC\n");
1474		return -EINVAL;
 
1475	}
1476	data_pos += offset;
1477
1478	/*
1479	 * The Info Block CRC is calculated over mxt_info and the object
1480	 * table. If it does not match then we are trying to load the
1481	 * configuration from a different chip or firmware version, so
1482	 * the configuration CRC is invalid anyway.
1483	 */
1484	if (info_crc == data->info_crc) {
1485		if (config_crc == 0 || data->config_crc == 0) {
1486			dev_info(dev, "CRC zero, attempting to apply config\n");
1487		} else if (config_crc == data->config_crc) {
1488			dev_dbg(dev, "Config CRC 0x%06X: OK\n",
1489				 data->config_crc);
1490			return 0;
 
1491		} else {
1492			dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n",
1493				 data->config_crc, config_crc);
1494		}
1495	} else {
1496		dev_warn(dev,
1497			 "Warning: Info CRC error - device=0x%06X file=0x%06X\n",
1498			 data->info_crc, info_crc);
1499	}
1500
1501	/* Malloc memory to store configuration */
1502	cfg_start_ofs = MXT_OBJECT_START +
1503			data->info.object_num * sizeof(struct mxt_object) +
1504			MXT_INFO_CHECKSUM_SIZE;
1505	config_mem_size = data->mem_size - cfg_start_ofs;
1506	config_mem = kzalloc(config_mem_size, GFP_KERNEL);
1507	if (!config_mem) {
1508		dev_err(dev, "Failed to allocate memory\n");
1509		return -ENOMEM;
1510	}
1511
1512	ret = mxt_prepare_cfg_mem(data, cfg, data_pos, cfg_start_ofs,
1513				  config_mem, config_mem_size);
1514	if (ret)
1515		goto release_mem;
1516
1517	/* Calculate crc of the received configs (not the raw config file) */
1518	if (data->T7_address < cfg_start_ofs) {
1519		dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n",
1520			data->T7_address, cfg_start_ofs);
1521		ret = 0;
1522		goto release_mem;
 
 
 
 
 
 
 
 
 
 
1523	}
1524
1525	calculated_crc = mxt_calculate_crc(config_mem,
1526					   data->T7_address - cfg_start_ofs,
1527					   config_mem_size);
1528
1529	if (config_crc > 0 && config_crc != calculated_crc)
1530		dev_warn(dev, "Config CRC error, calculated=%06X, file=%06X\n",
1531			 calculated_crc, config_crc);
1532
1533	ret = mxt_upload_cfg_mem(data, cfg_start_ofs,
1534				 config_mem, config_mem_size);
1535	if (ret)
1536		goto release_mem;
1537
1538	mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE);
1539
 
 
 
 
1540	ret = mxt_soft_reset(data);
1541	if (ret)
1542		goto release_mem;
1543
1544	dev_info(dev, "Config successfully updated\n");
1545
1546	/* T7 config may have changed */
1547	mxt_init_t7_power_cfg(data);
1548
1549release_mem:
1550	kfree(config_mem);
 
 
1551	return ret;
1552}
1553
1554static int mxt_get_info(struct mxt_data *data)
1555{
1556	struct i2c_client *client = data->client;
1557	struct mxt_info *info = &data->info;
1558	int error;
1559
1560	/* Read 7-byte info block starting at address 0 */
1561	error = __mxt_read_reg(client, 0, sizeof(*info), info);
1562	if (error)
1563		return error;
1564
1565	return 0;
1566}
1567
1568static void mxt_free_input_device(struct mxt_data *data)
1569{
1570	if (data->input_dev) {
1571		input_unregister_device(data->input_dev);
1572		data->input_dev = NULL;
1573	}
1574}
1575
1576static void mxt_free_object_table(struct mxt_data *data)
1577{
1578#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
1579	video_unregister_device(&data->dbg.vdev);
1580	v4l2_device_unregister(&data->dbg.v4l2);
1581#endif
1582
1583	kfree(data->object_table);
1584	data->object_table = NULL;
 
 
 
1585	kfree(data->msg_buf);
1586	data->msg_buf = NULL;
1587	data->T5_address = 0;
1588	data->T5_msg_size = 0;
1589	data->T6_reportid = 0;
1590	data->T7_address = 0;
 
1591	data->T9_reportid_min = 0;
1592	data->T9_reportid_max = 0;
 
1593	data->T19_reportid = 0;
1594	data->T44_address = 0;
1595	data->T100_reportid_min = 0;
1596	data->T100_reportid_max = 0;
1597	data->max_reportid = 0;
1598}
1599
1600static int mxt_get_object_table(struct mxt_data *data)
 
1601{
1602	struct i2c_client *client = data->client;
1603	size_t table_size;
1604	struct mxt_object *object_table;
1605	int error;
1606	int i;
1607	u8 reportid;
1608	u16 end_address;
1609
1610	table_size = data->info.object_num * sizeof(struct mxt_object);
1611	object_table = kzalloc(table_size, GFP_KERNEL);
1612	if (!object_table) {
1613		dev_err(&data->client->dev, "Failed to allocate memory\n");
1614		return -ENOMEM;
1615	}
1616
1617	error = __mxt_read_reg(client, MXT_OBJECT_START, table_size,
1618			object_table);
1619	if (error) {
1620		kfree(object_table);
1621		return error;
1622	}
1623
1624	/* Valid Report IDs start counting from 1 */
1625	reportid = 1;
1626	data->mem_size = 0;
1627	for (i = 0; i < data->info.object_num; i++) {
1628		struct mxt_object *object = object_table + i;
1629		u8 min_id, max_id;
1630
1631		le16_to_cpus(&object->start_address);
1632
1633		if (object->num_report_ids) {
1634			min_id = reportid;
1635			reportid += object->num_report_ids *
1636					mxt_obj_instances(object);
1637			max_id = reportid - 1;
1638		} else {
1639			min_id = 0;
1640			max_id = 0;
1641		}
1642
1643		dev_dbg(&data->client->dev,
1644			"T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n",
1645			object->type, object->start_address,
1646			mxt_obj_size(object), mxt_obj_instances(object),
1647			min_id, max_id);
1648
1649		switch (object->type) {
1650		case MXT_GEN_MESSAGE_T5:
1651			if (data->info.family_id == 0x80 &&
1652			    data->info.version < 0x20) {
1653				/*
1654				 * On mXT224 firmware versions prior to V2.0
1655				 * read and discard unused CRC byte otherwise
1656				 * DMA reads are misaligned.
1657				 */
1658				data->T5_msg_size = mxt_obj_size(object);
1659			} else {
1660				/* CRC not enabled, so skip last byte */
1661				data->T5_msg_size = mxt_obj_size(object) - 1;
1662			}
1663			data->T5_address = object->start_address;
1664			break;
1665		case MXT_GEN_COMMAND_T6:
1666			data->T6_reportid = min_id;
1667			data->T6_address = object->start_address;
1668			break;
1669		case MXT_GEN_POWER_T7:
1670			data->T7_address = object->start_address;
1671			break;
 
 
 
1672		case MXT_TOUCH_MULTI_T9:
1673			data->multitouch = MXT_TOUCH_MULTI_T9;
 
1674			data->T9_reportid_min = min_id;
1675			data->T9_reportid_max = max_id;
1676			data->num_touchids = object->num_report_ids
1677						* mxt_obj_instances(object);
 
 
 
1678			break;
1679		case MXT_SPT_MESSAGECOUNT_T44:
1680			data->T44_address = object->start_address;
1681			break;
1682		case MXT_SPT_GPIOPWM_T19:
1683			data->T19_reportid = min_id;
1684			break;
1685		case MXT_TOUCH_MULTITOUCHSCREEN_T100:
1686			data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100;
1687			data->T100_reportid_min = min_id;
1688			data->T100_reportid_max = max_id;
1689			/* first two report IDs reserved */
1690			data->num_touchids = object->num_report_ids - 2;
1691			break;
1692		}
1693
1694		end_address = object->start_address
1695			+ mxt_obj_size(object) * mxt_obj_instances(object) - 1;
1696
1697		if (end_address >= data->mem_size)
1698			data->mem_size = end_address + 1;
1699	}
1700
1701	/* Store maximum reportid */
1702	data->max_reportid = reportid;
1703
1704	/* If T44 exists, T5 position has to be directly after */
1705	if (data->T44_address && (data->T5_address != data->T44_address + 1)) {
1706		dev_err(&client->dev, "Invalid T44 position\n");
1707		error = -EINVAL;
1708		goto free_object_table;
1709	}
1710
1711	data->msg_buf = kcalloc(data->max_reportid,
1712				data->T5_msg_size, GFP_KERNEL);
1713	if (!data->msg_buf) {
1714		dev_err(&client->dev, "Failed to allocate message buffer\n");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1715		error = -ENOMEM;
1716		goto free_object_table;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1717	}
1718
1719	data->object_table = object_table;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1720
1721	return 0;
1722
1723free_object_table:
1724	mxt_free_object_table(data);
1725	return error;
1726}
1727
1728static int mxt_read_t9_resolution(struct mxt_data *data)
1729{
1730	struct i2c_client *client = data->client;
1731	int error;
1732	struct t9_range range;
1733	unsigned char orient;
1734	struct mxt_object *object;
1735
1736	object = mxt_get_object(data, MXT_TOUCH_MULTI_T9);
1737	if (!object)
1738		return -EINVAL;
1739
1740	error = __mxt_read_reg(client,
1741			       object->start_address + MXT_T9_XSIZE,
1742			       sizeof(data->xsize), &data->xsize);
1743	if (error)
1744		return error;
1745
1746	error = __mxt_read_reg(client,
1747			       object->start_address + MXT_T9_YSIZE,
1748			       sizeof(data->ysize), &data->ysize);
1749	if (error)
1750		return error;
1751
1752	error = __mxt_read_reg(client,
1753			       object->start_address + MXT_T9_RANGE,
1754			       sizeof(range), &range);
1755	if (error)
1756		return error;
1757
1758	data->max_x = get_unaligned_le16(&range.x);
1759	data->max_y = get_unaligned_le16(&range.y);
1760
1761	error =  __mxt_read_reg(client,
1762				object->start_address + MXT_T9_ORIENT,
1763				1, &orient);
1764	if (error)
1765		return error;
1766
1767	data->xy_switch = orient & MXT_T9_ORIENT_SWITCH;
1768	data->invertx = orient & MXT_T9_ORIENT_INVERTX;
1769	data->inverty = orient & MXT_T9_ORIENT_INVERTY;
1770
1771	return 0;
1772}
1773
1774static int mxt_read_t100_config(struct mxt_data *data)
1775{
1776	struct i2c_client *client = data->client;
1777	int error;
1778	struct mxt_object *object;
1779	u16 range_x, range_y;
1780	u8 cfg, tchaux;
1781	u8 aux;
1782
1783	object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100);
1784	if (!object)
1785		return -EINVAL;
1786
1787	/* read touchscreen dimensions */
1788	error = __mxt_read_reg(client,
1789			       object->start_address + MXT_T100_XRANGE,
1790			       sizeof(range_x), &range_x);
1791	if (error)
1792		return error;
1793
1794	data->max_x = get_unaligned_le16(&range_x);
1795
1796	error = __mxt_read_reg(client,
1797			       object->start_address + MXT_T100_YRANGE,
1798			       sizeof(range_y), &range_y);
1799	if (error)
1800		return error;
1801
1802	data->max_y = get_unaligned_le16(&range_y);
1803
1804	error = __mxt_read_reg(client,
1805			       object->start_address + MXT_T100_XSIZE,
1806			       sizeof(data->xsize), &data->xsize);
1807	if (error)
1808		return error;
1809
1810	error = __mxt_read_reg(client,
1811			       object->start_address + MXT_T100_YSIZE,
1812			       sizeof(data->ysize), &data->ysize);
1813	if (error)
1814		return error;
1815
1816	/* read orientation config */
1817	error =  __mxt_read_reg(client,
1818				object->start_address + MXT_T100_CFG1,
1819				1, &cfg);
1820	if (error)
1821		return error;
1822
1823	data->xy_switch = cfg & MXT_T100_CFG_SWITCHXY;
1824	data->invertx = cfg & MXT_T100_CFG_INVERTX;
1825	data->inverty = cfg & MXT_T100_CFG_INVERTY;
1826
1827	/* allocate aux bytes */
1828	error =  __mxt_read_reg(client,
1829				object->start_address + MXT_T100_TCHAUX,
1830				1, &tchaux);
1831	if (error)
1832		return error;
1833
1834	aux = 6;
1835
1836	if (tchaux & MXT_T100_TCHAUX_VECT)
1837		data->t100_aux_vect = aux++;
1838
1839	if (tchaux & MXT_T100_TCHAUX_AMPL)
1840		data->t100_aux_ampl = aux++;
1841
1842	if (tchaux & MXT_T100_TCHAUX_AREA)
1843		data->t100_aux_area = aux++;
1844
1845	dev_dbg(&client->dev,
1846		"T100 aux mappings vect:%u ampl:%u area:%u\n",
1847		data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area);
1848
1849	return 0;
1850}
1851
1852static int mxt_input_open(struct input_dev *dev);
1853static void mxt_input_close(struct input_dev *dev);
1854
1855static void mxt_set_up_as_touchpad(struct input_dev *input_dev,
1856				   struct mxt_data *data)
1857{
1858	const struct mxt_platform_data *pdata = data->pdata;
1859	int i;
1860
1861	input_dev->name = "Atmel maXTouch Touchpad";
1862
1863	__set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit);
1864
1865	input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM);
1866	input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM);
1867	input_abs_set_res(input_dev, ABS_MT_POSITION_X,
1868			  MXT_PIXELS_PER_MM);
1869	input_abs_set_res(input_dev, ABS_MT_POSITION_Y,
1870			  MXT_PIXELS_PER_MM);
1871
1872	for (i = 0; i < pdata->t19_num_keys; i++)
1873		if (pdata->t19_keymap[i] != KEY_RESERVED)
1874			input_set_capability(input_dev, EV_KEY,
1875					     pdata->t19_keymap[i]);
1876}
1877
1878static int mxt_initialize_input_device(struct mxt_data *data)
1879{
1880	const struct mxt_platform_data *pdata = data->pdata;
1881	struct device *dev = &data->client->dev;
1882	struct input_dev *input_dev;
1883	int error;
1884	unsigned int num_mt_slots;
1885	unsigned int mt_flags = 0;
1886
1887	switch (data->multitouch) {
1888	case MXT_TOUCH_MULTI_T9:
1889		num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1;
1890		error = mxt_read_t9_resolution(data);
1891		if (error)
1892			dev_warn(dev, "Failed to initialize T9 resolution\n");
1893		break;
1894
1895	case MXT_TOUCH_MULTITOUCHSCREEN_T100:
1896		num_mt_slots = data->num_touchids;
1897		error = mxt_read_t100_config(data);
1898		if (error)
1899			dev_warn(dev, "Failed to read T100 config\n");
1900		break;
1901
1902	default:
1903		dev_err(dev, "Invalid multitouch object\n");
1904		return -EINVAL;
1905	}
1906
1907	/* Handle default values and orientation switch */
1908	if (data->max_x == 0)
1909		data->max_x = 1023;
1910
1911	if (data->max_y == 0)
1912		data->max_y = 1023;
1913
1914	if (data->xy_switch)
1915		swap(data->max_x, data->max_y);
1916
1917	dev_info(dev, "Touchscreen size X%uY%u\n", data->max_x, data->max_y);
1918
1919	/* Register input device */
1920	input_dev = input_allocate_device();
1921	if (!input_dev) {
1922		dev_err(dev, "Failed to allocate memory\n");
1923		return -ENOMEM;
1924	}
1925
1926	input_dev->name = "Atmel maXTouch Touchscreen";
1927	input_dev->phys = data->phys;
1928	input_dev->id.bustype = BUS_I2C;
1929	input_dev->dev.parent = dev;
1930	input_dev->open = mxt_input_open;
1931	input_dev->close = mxt_input_close;
1932
1933	input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
1934
1935	/* For single touch */
1936	input_set_abs_params(input_dev, ABS_X, 0, data->max_x, 0, 0);
1937	input_set_abs_params(input_dev, ABS_Y, 0, data->max_y, 0, 0);
1938
1939	if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1940	    (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1941	     data->t100_aux_ampl)) {
1942		input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0);
1943	}
1944
1945	/* If device has buttons we assume it is a touchpad */
1946	if (pdata->t19_num_keys) {
1947		mxt_set_up_as_touchpad(input_dev, data);
1948		mt_flags |= INPUT_MT_POINTER;
1949	} else {
1950		mt_flags |= INPUT_MT_DIRECT;
1951	}
1952
1953	/* For multi touch */
1954	error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags);
1955	if (error) {
1956		dev_err(dev, "Error %d initialising slots\n", error);
1957		goto err_free_mem;
1958	}
1959
1960	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) {
1961		input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE,
1962				     0, MT_TOOL_MAX, 0, 0);
1963		input_set_abs_params(input_dev, ABS_MT_DISTANCE,
1964				     MXT_DISTANCE_ACTIVE_TOUCH,
1965				     MXT_DISTANCE_HOVERING,
1966				     0, 0);
1967	}
1968
1969	input_set_abs_params(input_dev, ABS_MT_POSITION_X,
1970			     0, data->max_x, 0, 0);
1971	input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1972			     0, data->max_y, 0, 0);
1973
1974	if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1975	    (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1976	     data->t100_aux_area)) {
1977		input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
1978				     0, MXT_MAX_AREA, 0, 0);
1979	}
1980
1981	if (data->multitouch == MXT_TOUCH_MULTI_T9 ||
1982	    (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1983	     data->t100_aux_ampl)) {
1984		input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1985				     0, 255, 0, 0);
1986	}
1987
1988	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1989	    data->t100_aux_vect) {
1990		input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
1991				     0, 255, 0, 0);
1992	}
1993
1994	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
1995	    data->t100_aux_ampl) {
1996		input_set_abs_params(input_dev, ABS_MT_PRESSURE,
1997				     0, 255, 0, 0);
1998	}
1999
2000	if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 &&
2001	    data->t100_aux_vect) {
2002		input_set_abs_params(input_dev, ABS_MT_ORIENTATION,
2003				     0, 255, 0, 0);
2004	}
2005
2006	input_set_drvdata(input_dev, data);
2007
2008	error = input_register_device(input_dev);
2009	if (error) {
2010		dev_err(dev, "Error %d registering input device\n", error);
2011		goto err_free_mem;
2012	}
2013
2014	data->input_dev = input_dev;
2015
2016	return 0;
2017
2018err_free_mem:
2019	input_free_device(input_dev);
2020	return error;
2021}
2022
2023static int mxt_configure_objects(struct mxt_data *data,
2024				 const struct firmware *cfg);
2025
2026static void mxt_config_cb(const struct firmware *cfg, void *ctx)
2027{
2028	mxt_configure_objects(ctx, cfg);
2029	release_firmware(cfg);
2030}
2031
2032static int mxt_initialize(struct mxt_data *data)
2033{
2034	struct i2c_client *client = data->client;
2035	int recovery_attempts = 0;
2036	int error;
2037
2038	while (1) {
2039		error = mxt_get_info(data);
2040		if (!error)
2041			break;
2042
2043		/* Check bootloader state */
2044		error = mxt_probe_bootloader(data, false);
2045		if (error) {
2046			dev_info(&client->dev, "Trying alternate bootloader address\n");
2047			error = mxt_probe_bootloader(data, true);
2048			if (error) {
2049				/* Chip is not in appmode or bootloader mode */
2050				return error;
2051			}
2052		}
2053
2054		/* OK, we are in bootloader, see if we can recover */
2055		if (++recovery_attempts > 1) {
2056			dev_err(&client->dev, "Could not recover from bootloader mode\n");
2057			/*
2058			 * We can reflash from this state, so do not
2059			 * abort initialization.
2060			 */
2061			data->in_bootloader = true;
2062			return 0;
2063		}
2064
2065		/* Attempt to exit bootloader into app mode */
2066		mxt_send_bootloader_cmd(data, false);
2067		msleep(MXT_FW_RESET_TIME);
2068	}
2069
2070	/* Get object table information */
2071	error = mxt_get_object_table(data);
2072	if (error) {
2073		dev_err(&client->dev, "Error %d reading object table\n", error);
2074		return error;
2075	}
2076
2077	error = mxt_acquire_irq(data);
2078	if (error)
2079		goto err_free_object_table;
2080
2081	error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME,
2082					&client->dev, GFP_KERNEL, data,
2083					mxt_config_cb);
2084	if (error) {
2085		dev_err(&client->dev, "Failed to invoke firmware loader: %d\n",
2086			error);
2087		goto err_free_object_table;
2088	}
2089
2090	return 0;
2091
2092err_free_object_table:
2093	mxt_free_object_table(data);
2094	return error;
2095}
2096
2097static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep)
2098{
2099	struct device *dev = &data->client->dev;
2100	int error;
2101	struct t7_config *new_config;
2102	struct t7_config deepsleep = { .active = 0, .idle = 0 };
2103
2104	if (sleep == MXT_POWER_CFG_DEEPSLEEP)
2105		new_config = &deepsleep;
2106	else
2107		new_config = &data->t7_cfg;
2108
2109	error = __mxt_write_reg(data->client, data->T7_address,
2110				sizeof(data->t7_cfg), new_config);
2111	if (error)
2112		return error;
2113
2114	dev_dbg(dev, "Set T7 ACTV:%d IDLE:%d\n",
2115		new_config->active, new_config->idle);
2116
2117	return 0;
2118}
2119
2120static int mxt_init_t7_power_cfg(struct mxt_data *data)
2121{
2122	struct device *dev = &data->client->dev;
2123	int error;
2124	bool retry = false;
2125
2126recheck:
2127	error = __mxt_read_reg(data->client, data->T7_address,
2128				sizeof(data->t7_cfg), &data->t7_cfg);
2129	if (error)
2130		return error;
2131
2132	if (data->t7_cfg.active == 0 || data->t7_cfg.idle == 0) {
2133		if (!retry) {
2134			dev_dbg(dev, "T7 cfg zero, resetting\n");
2135			mxt_soft_reset(data);
2136			retry = true;
2137			goto recheck;
2138		} else {
2139			dev_dbg(dev, "T7 cfg zero after reset, overriding\n");
2140			data->t7_cfg.active = 20;
2141			data->t7_cfg.idle = 100;
2142			return mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
2143		}
2144	}
2145
2146	dev_dbg(dev, "Initialized power cfg: ACTV %d, IDLE %d\n",
2147		data->t7_cfg.active, data->t7_cfg.idle);
2148	return 0;
2149}
2150
2151#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37
 
 
 
 
 
 
 
 
 
 
2152static u16 mxt_get_debug_value(struct mxt_data *data, unsigned int x,
2153			       unsigned int y)
2154{
2155	struct mxt_info *info = &data->info;
2156	struct mxt_dbg *dbg = &data->dbg;
2157	unsigned int ofs, page;
2158	unsigned int col = 0;
2159	unsigned int col_width;
2160
2161	if (info->family_id == MXT_FAMILY_1386) {
2162		col_width = info->matrix_ysize / MXT1386_COLUMNS;
2163		col = y / col_width;
2164		y = y % col_width;
2165	} else {
2166		col_width = info->matrix_ysize;
2167	}
2168
2169	ofs = (y + (x * col_width)) * sizeof(u16);
2170	page = ofs / MXT_DIAGNOSTIC_SIZE;
2171	ofs %= MXT_DIAGNOSTIC_SIZE;
2172
2173	if (info->family_id == MXT_FAMILY_1386)
2174		page += col * MXT1386_PAGES_PER_COLUMN;
2175
2176	return get_unaligned_le16(&dbg->t37_buf[page].data[ofs]);
2177}
2178
2179static int mxt_convert_debug_pages(struct mxt_data *data, u16 *outbuf)
2180{
2181	struct mxt_dbg *dbg = &data->dbg;
2182	unsigned int x = 0;
2183	unsigned int y = 0;
2184	unsigned int i, rx, ry;
2185
2186	for (i = 0; i < dbg->t37_nodes; i++) {
2187		/* Handle orientation */
2188		rx = data->xy_switch ? y : x;
2189		ry = data->xy_switch ? x : y;
2190		rx = data->invertx ? (data->xsize - 1 - rx) : rx;
2191		ry = data->inverty ? (data->ysize - 1 - ry) : ry;
2192
2193		outbuf[i] = mxt_get_debug_value(data, rx, ry);
2194
2195		/* Next value */
2196		if (++x >= (data->xy_switch ? data->ysize : data->xsize)) {
2197			x = 0;
2198			y++;
2199		}
2200	}
2201
2202	return 0;
2203}
2204
2205static int mxt_read_diagnostic_debug(struct mxt_data *data, u8 mode,
2206				     u16 *outbuf)
2207{
2208	struct mxt_dbg *dbg = &data->dbg;
2209	int retries = 0;
2210	int page;
2211	int ret;
2212	u8 cmd = mode;
2213	struct t37_debug *p;
2214	u8 cmd_poll;
2215
2216	for (page = 0; page < dbg->t37_pages; page++) {
2217		p = dbg->t37_buf + page;
2218
2219		ret = mxt_write_reg(data->client, dbg->diag_cmd_address,
2220				    cmd);
2221		if (ret)
2222			return ret;
2223
2224		retries = 0;
2225		msleep(20);
2226wait_cmd:
2227		/* Read back command byte */
2228		ret = __mxt_read_reg(data->client, dbg->diag_cmd_address,
2229				     sizeof(cmd_poll), &cmd_poll);
2230		if (ret)
2231			return ret;
2232
2233		/* Field is cleared once the command has been processed */
2234		if (cmd_poll) {
2235			if (retries++ > 100)
2236				return -EINVAL;
2237
2238			msleep(20);
2239			goto wait_cmd;
2240		}
2241
2242		/* Read T37 page */
2243		ret = __mxt_read_reg(data->client, dbg->t37_address,
2244				     sizeof(struct t37_debug), p);
2245		if (ret)
2246			return ret;
2247
2248		if (p->mode != mode || p->page != page) {
2249			dev_err(&data->client->dev, "T37 page mismatch\n");
2250			return -EINVAL;
2251		}
2252
2253		dev_dbg(&data->client->dev, "%s page:%d retries:%d\n",
2254			__func__, page, retries);
2255
2256		/* For remaining pages, write PAGEUP rather than mode */
2257		cmd = MXT_DIAGNOSTIC_PAGEUP;
2258	}
2259
2260	return mxt_convert_debug_pages(data, outbuf);
2261}
2262
2263static int mxt_queue_setup(struct vb2_queue *q,
2264		       unsigned int *nbuffers, unsigned int *nplanes,
2265		       unsigned int sizes[], struct device *alloc_devs[])
2266{
2267	struct mxt_data *data = q->drv_priv;
2268	size_t size = data->dbg.t37_nodes * sizeof(u16);
2269
2270	if (*nplanes)
2271		return sizes[0] < size ? -EINVAL : 0;
2272
2273	*nplanes = 1;
2274	sizes[0] = size;
2275
2276	return 0;
2277}
2278
2279static void mxt_buffer_queue(struct vb2_buffer *vb)
2280{
2281	struct mxt_data *data = vb2_get_drv_priv(vb->vb2_queue);
2282	u16 *ptr;
2283	int ret;
2284	u8 mode;
2285
2286	ptr = vb2_plane_vaddr(vb, 0);
2287	if (!ptr) {
2288		dev_err(&data->client->dev, "Error acquiring frame ptr\n");
2289		goto fault;
2290	}
2291
2292	switch (data->dbg.input) {
2293	case MXT_V4L_INPUT_DELTAS:
2294	default:
2295		mode = MXT_DIAGNOSTIC_DELTAS;
2296		break;
2297
2298	case MXT_V4L_INPUT_REFS:
2299		mode = MXT_DIAGNOSTIC_REFS;
2300		break;
2301	}
2302
2303	ret = mxt_read_diagnostic_debug(data, mode, ptr);
2304	if (ret)
2305		goto fault;
2306
2307	vb2_set_plane_payload(vb, 0, data->dbg.t37_nodes * sizeof(u16));
2308	vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
2309	return;
2310
2311fault:
2312	vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2313}
2314
2315/* V4L2 structures */
2316static const struct vb2_ops mxt_queue_ops = {
2317	.queue_setup		= mxt_queue_setup,
2318	.buf_queue		= mxt_buffer_queue,
2319	.wait_prepare		= vb2_ops_wait_prepare,
2320	.wait_finish		= vb2_ops_wait_finish,
2321};
2322
2323static const struct vb2_queue mxt_queue = {
2324	.type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
2325	.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ,
2326	.buf_struct_size = sizeof(struct mxt_vb2_buffer),
2327	.ops = &mxt_queue_ops,
2328	.mem_ops = &vb2_vmalloc_memops,
2329	.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC,
2330	.min_buffers_needed = 1,
2331};
2332
2333static int mxt_vidioc_querycap(struct file *file, void *priv,
2334				 struct v4l2_capability *cap)
2335{
2336	struct mxt_data *data = video_drvdata(file);
2337
2338	strlcpy(cap->driver, "atmel_mxt_ts", sizeof(cap->driver));
2339	strlcpy(cap->card, "atmel_mxt_ts touch", sizeof(cap->card));
2340	snprintf(cap->bus_info, sizeof(cap->bus_info),
2341		 "I2C:%s", dev_name(&data->client->dev));
2342	return 0;
2343}
2344
2345static int mxt_vidioc_enum_input(struct file *file, void *priv,
2346				   struct v4l2_input *i)
2347{
2348	if (i->index >= MXT_V4L_INPUT_MAX)
2349		return -EINVAL;
2350
2351	i->type = V4L2_INPUT_TYPE_TOUCH;
2352
2353	switch (i->index) {
2354	case MXT_V4L_INPUT_REFS:
2355		strlcpy(i->name, "Mutual Capacitance References",
2356			sizeof(i->name));
2357		break;
2358	case MXT_V4L_INPUT_DELTAS:
2359		strlcpy(i->name, "Mutual Capacitance Deltas", sizeof(i->name));
2360		break;
2361	}
2362
2363	return 0;
2364}
2365
2366static int mxt_set_input(struct mxt_data *data, unsigned int i)
2367{
2368	struct v4l2_pix_format *f = &data->dbg.format;
2369
2370	if (i >= MXT_V4L_INPUT_MAX)
2371		return -EINVAL;
2372
2373	if (i == MXT_V4L_INPUT_DELTAS)
2374		f->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
2375	else
2376		f->pixelformat = V4L2_TCH_FMT_TU16;
2377
2378	f->width = data->xy_switch ? data->ysize : data->xsize;
2379	f->height = data->xy_switch ? data->xsize : data->ysize;
2380	f->field = V4L2_FIELD_NONE;
2381	f->colorspace = V4L2_COLORSPACE_RAW;
2382	f->bytesperline = f->width * sizeof(u16);
2383	f->sizeimage = f->width * f->height * sizeof(u16);
2384
2385	data->dbg.input = i;
2386
2387	return 0;
2388}
2389
2390static int mxt_vidioc_s_input(struct file *file, void *priv, unsigned int i)
2391{
2392	return mxt_set_input(video_drvdata(file), i);
2393}
2394
2395static int mxt_vidioc_g_input(struct file *file, void *priv, unsigned int *i)
2396{
2397	struct mxt_data *data = video_drvdata(file);
2398
2399	*i = data->dbg.input;
2400
2401	return 0;
2402}
2403
2404static int mxt_vidioc_fmt(struct file *file, void *priv, struct v4l2_format *f)
2405{
2406	struct mxt_data *data = video_drvdata(file);
2407
2408	f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2409	f->fmt.pix = data->dbg.format;
2410
2411	return 0;
2412}
2413
2414static int mxt_vidioc_enum_fmt(struct file *file, void *priv,
2415				 struct v4l2_fmtdesc *fmt)
2416{
2417	if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2418		return -EINVAL;
2419
2420	switch (fmt->index) {
2421	case 0:
2422		fmt->pixelformat = V4L2_TCH_FMT_TU16;
2423		break;
2424
2425	case 1:
2426		fmt->pixelformat = V4L2_TCH_FMT_DELTA_TD16;
2427		break;
2428
2429	default:
2430		return -EINVAL;
2431	}
2432
2433	return 0;
2434}
2435
2436static int mxt_vidioc_g_parm(struct file *file, void *fh,
2437			     struct v4l2_streamparm *a)
2438{
2439	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2440		return -EINVAL;
2441
2442	a->parm.capture.readbuffers = 1;
2443	a->parm.capture.timeperframe.numerator = 1;
2444	a->parm.capture.timeperframe.denominator = 10;
2445	return 0;
2446}
2447
2448static const struct v4l2_ioctl_ops mxt_video_ioctl_ops = {
2449	.vidioc_querycap        = mxt_vidioc_querycap,
2450
2451	.vidioc_enum_fmt_vid_cap = mxt_vidioc_enum_fmt,
2452	.vidioc_s_fmt_vid_cap   = mxt_vidioc_fmt,
2453	.vidioc_g_fmt_vid_cap   = mxt_vidioc_fmt,
2454	.vidioc_try_fmt_vid_cap	= mxt_vidioc_fmt,
2455	.vidioc_g_parm		= mxt_vidioc_g_parm,
2456
2457	.vidioc_enum_input      = mxt_vidioc_enum_input,
2458	.vidioc_g_input         = mxt_vidioc_g_input,
2459	.vidioc_s_input         = mxt_vidioc_s_input,
2460
2461	.vidioc_reqbufs         = vb2_ioctl_reqbufs,
2462	.vidioc_create_bufs     = vb2_ioctl_create_bufs,
2463	.vidioc_querybuf        = vb2_ioctl_querybuf,
2464	.vidioc_qbuf            = vb2_ioctl_qbuf,
2465	.vidioc_dqbuf           = vb2_ioctl_dqbuf,
2466	.vidioc_expbuf          = vb2_ioctl_expbuf,
2467
2468	.vidioc_streamon        = vb2_ioctl_streamon,
2469	.vidioc_streamoff       = vb2_ioctl_streamoff,
2470};
2471
2472static const struct video_device mxt_video_device = {
2473	.name = "Atmel maxTouch",
2474	.fops = &mxt_video_fops,
2475	.ioctl_ops = &mxt_video_ioctl_ops,
2476	.release = video_device_release_empty,
2477	.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TOUCH |
2478		       V4L2_CAP_READWRITE | V4L2_CAP_STREAMING,
2479};
2480
2481static void mxt_debug_init(struct mxt_data *data)
2482{
2483	struct mxt_info *info = &data->info;
2484	struct mxt_dbg *dbg = &data->dbg;
2485	struct mxt_object *object;
2486	int error;
2487
2488	object = mxt_get_object(data, MXT_GEN_COMMAND_T6);
2489	if (!object)
2490		goto error;
2491
2492	dbg->diag_cmd_address = object->start_address + MXT_COMMAND_DIAGNOSTIC;
2493
2494	object = mxt_get_object(data, MXT_DEBUG_DIAGNOSTIC_T37);
2495	if (!object)
2496		goto error;
2497
2498	if (mxt_obj_size(object) != sizeof(struct t37_debug)) {
2499		dev_warn(&data->client->dev, "Bad T37 size");
2500		goto error;
2501	}
2502
2503	dbg->t37_address = object->start_address;
2504
2505	/* Calculate size of data and allocate buffer */
2506	dbg->t37_nodes = data->xsize * data->ysize;
2507
2508	if (info->family_id == MXT_FAMILY_1386)
2509		dbg->t37_pages = MXT1386_COLUMNS * MXT1386_PAGES_PER_COLUMN;
2510	else
2511		dbg->t37_pages = DIV_ROUND_UP(data->xsize *
2512					      data->info.matrix_ysize *
2513					      sizeof(u16),
2514					      sizeof(dbg->t37_buf->data));
2515
2516	dbg->t37_buf = devm_kmalloc_array(&data->client->dev, dbg->t37_pages,
2517					  sizeof(struct t37_debug), GFP_KERNEL);
2518	if (!dbg->t37_buf)
2519		goto error;
2520
2521	/* init channel to zero */
2522	mxt_set_input(data, 0);
2523
2524	/* register video device */
2525	snprintf(dbg->v4l2.name, sizeof(dbg->v4l2.name), "%s", "atmel_mxt_ts");
2526	error = v4l2_device_register(&data->client->dev, &dbg->v4l2);
2527	if (error)
2528		goto error;
2529
2530	/* initialize the queue */
2531	mutex_init(&dbg->lock);
2532	dbg->queue = mxt_queue;
2533	dbg->queue.drv_priv = data;
2534	dbg->queue.lock = &dbg->lock;
2535	dbg->queue.dev = &data->client->dev;
2536
2537	error = vb2_queue_init(&dbg->queue);
2538	if (error)
2539		goto error_unreg_v4l2;
2540
2541	dbg->vdev = mxt_video_device;
2542	dbg->vdev.v4l2_dev = &dbg->v4l2;
2543	dbg->vdev.lock = &dbg->lock;
2544	dbg->vdev.vfl_dir = VFL_DIR_RX;
2545	dbg->vdev.queue = &dbg->queue;
2546	video_set_drvdata(&dbg->vdev, data);
2547
2548	error = video_register_device(&dbg->vdev, VFL_TYPE_TOUCH, -1);
2549	if (error)
2550		goto error_unreg_v4l2;
2551
2552	return;
2553
2554error_unreg_v4l2:
2555	v4l2_device_unregister(&dbg->v4l2);
2556error:
2557	dev_warn(&data->client->dev, "Error initializing T37\n");
2558}
2559#else
2560static void mxt_debug_init(struct mxt_data *data)
2561{
2562}
2563#endif
2564
2565static int mxt_configure_objects(struct mxt_data *data,
2566				 const struct firmware *cfg)
2567{
2568	struct device *dev = &data->client->dev;
2569	struct mxt_info *info = &data->info;
2570	int error;
2571
2572	error = mxt_init_t7_power_cfg(data);
2573	if (error) {
2574		dev_err(dev, "Failed to initialize power cfg\n");
2575		return error;
2576	}
2577
2578	if (cfg) {
2579		error = mxt_update_cfg(data, cfg);
2580		if (error)
2581			dev_warn(dev, "Error %d updating config\n", error);
2582	}
2583
2584	if (data->multitouch) {
2585		error = mxt_initialize_input_device(data);
2586		if (error)
2587			return error;
2588	} else {
2589		dev_warn(dev, "No touch object detected\n");
2590	}
2591
2592	mxt_debug_init(data);
2593
2594	dev_info(dev,
2595		 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n",
2596		 info->family_id, info->variant_id, info->version >> 4,
2597		 info->version & 0xf, info->build, info->object_num);
2598
2599	return 0;
2600}
2601
2602/* Firmware Version is returned as Major.Minor.Build */
2603static ssize_t mxt_fw_version_show(struct device *dev,
2604				   struct device_attribute *attr, char *buf)
2605{
2606	struct mxt_data *data = dev_get_drvdata(dev);
2607	struct mxt_info *info = &data->info;
2608	return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n",
2609			 info->version >> 4, info->version & 0xf, info->build);
2610}
2611
2612/* Hardware Version is returned as FamilyID.VariantID */
2613static ssize_t mxt_hw_version_show(struct device *dev,
2614				   struct device_attribute *attr, char *buf)
2615{
2616	struct mxt_data *data = dev_get_drvdata(dev);
2617	struct mxt_info *info = &data->info;
2618	return scnprintf(buf, PAGE_SIZE, "%u.%u\n",
2619			 info->family_id, info->variant_id);
2620}
2621
2622static ssize_t mxt_show_instance(char *buf, int count,
2623				 struct mxt_object *object, int instance,
2624				 const u8 *val)
2625{
2626	int i;
2627
2628	if (mxt_obj_instances(object) > 1)
2629		count += scnprintf(buf + count, PAGE_SIZE - count,
2630				   "Instance %u\n", instance);
2631
2632	for (i = 0; i < mxt_obj_size(object); i++)
2633		count += scnprintf(buf + count, PAGE_SIZE - count,
2634				"\t[%2u]: %02x (%d)\n", i, val[i], val[i]);
2635	count += scnprintf(buf + count, PAGE_SIZE - count, "\n");
2636
2637	return count;
2638}
2639
2640static ssize_t mxt_object_show(struct device *dev,
2641				    struct device_attribute *attr, char *buf)
2642{
2643	struct mxt_data *data = dev_get_drvdata(dev);
2644	struct mxt_object *object;
2645	int count = 0;
2646	int i, j;
2647	int error;
2648	u8 *obuf;
2649
2650	/* Pre-allocate buffer large enough to hold max sized object. */
2651	obuf = kmalloc(256, GFP_KERNEL);
2652	if (!obuf)
2653		return -ENOMEM;
2654
2655	error = 0;
2656	for (i = 0; i < data->info.object_num; i++) {
2657		object = data->object_table + i;
2658
2659		if (!mxt_object_readable(object->type))
2660			continue;
2661
2662		count += scnprintf(buf + count, PAGE_SIZE - count,
2663				"T%u:\n", object->type);
2664
2665		for (j = 0; j < mxt_obj_instances(object); j++) {
2666			u16 size = mxt_obj_size(object);
2667			u16 addr = object->start_address + j * size;
2668
2669			error = __mxt_read_reg(data->client, addr, size, obuf);
2670			if (error)
2671				goto done;
2672
2673			count = mxt_show_instance(buf, count, object, j, obuf);
2674		}
2675	}
2676
2677done:
2678	kfree(obuf);
2679	return error ?: count;
2680}
2681
2682static int mxt_check_firmware_format(struct device *dev,
2683				     const struct firmware *fw)
2684{
2685	unsigned int pos = 0;
2686	char c;
2687
2688	while (pos < fw->size) {
2689		c = *(fw->data + pos);
2690
2691		if (c < '0' || (c > '9' && c < 'A') || c > 'F')
2692			return 0;
2693
2694		pos++;
2695	}
2696
2697	/*
2698	 * To convert file try:
2699	 * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw
2700	 */
2701	dev_err(dev, "Aborting: firmware file must be in binary format\n");
2702
2703	return -EINVAL;
2704}
2705
2706static int mxt_load_fw(struct device *dev, const char *fn)
2707{
2708	struct mxt_data *data = dev_get_drvdata(dev);
2709	const struct firmware *fw = NULL;
2710	unsigned int frame_size;
2711	unsigned int pos = 0;
2712	unsigned int retry = 0;
2713	unsigned int frame = 0;
2714	int ret;
2715
2716	ret = request_firmware(&fw, fn, dev);
2717	if (ret) {
2718		dev_err(dev, "Unable to open firmware %s\n", fn);
2719		return ret;
2720	}
2721
2722	/* Check for incorrect enc file */
2723	ret = mxt_check_firmware_format(dev, fw);
2724	if (ret)
2725		goto release_firmware;
2726
2727	if (!data->in_bootloader) {
2728		/* Change to the bootloader mode */
2729		data->in_bootloader = true;
2730
2731		ret = mxt_t6_command(data, MXT_COMMAND_RESET,
2732				     MXT_BOOT_VALUE, false);
2733		if (ret)
2734			goto release_firmware;
2735
2736		msleep(MXT_RESET_TIME);
2737
2738		/* Do not need to scan since we know family ID */
2739		ret = mxt_lookup_bootloader_address(data, 0);
2740		if (ret)
2741			goto release_firmware;
2742
2743		mxt_free_input_device(data);
2744		mxt_free_object_table(data);
2745	} else {
2746		enable_irq(data->irq);
2747	}
2748
2749	reinit_completion(&data->bl_completion);
2750
2751	ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false);
2752	if (ret) {
2753		/* Bootloader may still be unlocked from previous attempt */
2754		ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false);
2755		if (ret)
2756			goto disable_irq;
2757	} else {
2758		dev_info(dev, "Unlocking bootloader\n");
2759
2760		/* Unlock bootloader */
2761		ret = mxt_send_bootloader_cmd(data, true);
2762		if (ret)
2763			goto disable_irq;
2764	}
2765
2766	while (pos < fw->size) {
2767		ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true);
2768		if (ret)
2769			goto disable_irq;
2770
2771		frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1));
2772
2773		/* Take account of CRC bytes */
2774		frame_size += 2;
2775
2776		/* Write one frame to device */
2777		ret = mxt_bootloader_write(data, fw->data + pos, frame_size);
2778		if (ret)
2779			goto disable_irq;
2780
2781		ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true);
2782		if (ret) {
2783			retry++;
2784
2785			/* Back off by 20ms per retry */
2786			msleep(retry * 20);
2787
2788			if (retry > 20) {
2789				dev_err(dev, "Retry count exceeded\n");
2790				goto disable_irq;
2791			}
2792		} else {
2793			retry = 0;
2794			pos += frame_size;
2795			frame++;
2796		}
2797
2798		if (frame % 50 == 0)
2799			dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n",
2800				frame, pos, fw->size);
2801	}
2802
2803	/* Wait for flash. */
2804	ret = mxt_wait_for_completion(data, &data->bl_completion,
2805				      MXT_FW_RESET_TIME);
2806	if (ret)
2807		goto disable_irq;
2808
2809	dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos);
2810
2811	/*
2812	 * Wait for device to reset. Some bootloader versions do not assert
2813	 * the CHG line after bootloading has finished, so ignore potential
2814	 * errors.
2815	 */
2816	mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME);
2817
2818	data->in_bootloader = false;
2819
2820disable_irq:
2821	disable_irq(data->irq);
2822release_firmware:
2823	release_firmware(fw);
2824	return ret;
2825}
2826
2827static ssize_t mxt_update_fw_store(struct device *dev,
2828					struct device_attribute *attr,
2829					const char *buf, size_t count)
2830{
2831	struct mxt_data *data = dev_get_drvdata(dev);
2832	int error;
2833
2834	error = mxt_load_fw(dev, MXT_FW_NAME);
2835	if (error) {
2836		dev_err(dev, "The firmware update failed(%d)\n", error);
2837		count = error;
2838	} else {
2839		dev_info(dev, "The firmware update succeeded\n");
2840
2841		error = mxt_initialize(data);
2842		if (error)
2843			return error;
2844	}
2845
2846	return count;
2847}
2848
2849static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL);
2850static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL);
2851static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL);
2852static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store);
2853
2854static struct attribute *mxt_attrs[] = {
2855	&dev_attr_fw_version.attr,
2856	&dev_attr_hw_version.attr,
2857	&dev_attr_object.attr,
2858	&dev_attr_update_fw.attr,
2859	NULL
2860};
2861
2862static const struct attribute_group mxt_attr_group = {
2863	.attrs = mxt_attrs,
2864};
2865
2866static void mxt_start(struct mxt_data *data)
2867{
2868	switch (data->pdata->suspend_mode) {
 
 
2869	case MXT_SUSPEND_T9_CTRL:
2870		mxt_soft_reset(data);
2871
2872		/* Touch enable */
2873		/* 0x83 = SCANEN | RPTEN | ENABLE */
2874		mxt_write_object(data,
2875				MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0x83);
2876		break;
2877
2878	case MXT_SUSPEND_DEEP_SLEEP:
2879	default:
2880		mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN);
2881
2882		/* Recalibrate since chip has been in deep sleep */
2883		mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false);
2884		break;
2885	}
2886
2887}
2888
2889static void mxt_stop(struct mxt_data *data)
2890{
2891	switch (data->pdata->suspend_mode) {
2892	case MXT_SUSPEND_T9_CTRL:
2893		/* Touch disable */
2894		mxt_write_object(data,
2895				MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0);
2896		break;
2897
2898	case MXT_SUSPEND_DEEP_SLEEP:
2899	default:
2900		mxt_set_t7_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP);
2901		break;
2902	}
 
 
2903}
2904
2905static int mxt_input_open(struct input_dev *dev)
2906{
2907	struct mxt_data *data = input_get_drvdata(dev);
2908
2909	mxt_start(data);
2910
2911	return 0;
2912}
2913
2914static void mxt_input_close(struct input_dev *dev)
2915{
2916	struct mxt_data *data = input_get_drvdata(dev);
2917
2918	mxt_stop(data);
2919}
2920
2921#ifdef CONFIG_OF
2922static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
2923{
2924	struct mxt_platform_data *pdata;
2925	struct device_node *np = client->dev.of_node;
2926	u32 *keymap;
2927	int proplen, ret;
 
2928
2929	if (!np)
2930		return ERR_PTR(-ENOENT);
2931
2932	pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
2933	if (!pdata)
2934		return ERR_PTR(-ENOMEM);
2935
2936	if (of_find_property(np, "linux,gpio-keymap", &proplen)) {
2937		pdata->t19_num_keys = proplen / sizeof(u32);
2938
2939		keymap = devm_kzalloc(&client->dev,
2940				pdata->t19_num_keys * sizeof(keymap[0]),
2941				GFP_KERNEL);
2942		if (!keymap)
2943			return ERR_PTR(-ENOMEM);
2944
2945		ret = of_property_read_u32_array(np, "linux,gpio-keymap",
2946						 keymap, pdata->t19_num_keys);
2947		if (ret)
2948			dev_warn(&client->dev,
2949				 "Couldn't read linux,gpio-keymap: %d\n", ret);
 
 
2950
2951		pdata->t19_keymap = keymap;
 
2952	}
2953
2954	pdata->suspend_mode = MXT_SUSPEND_DEEP_SLEEP;
2955
2956	return pdata;
2957}
2958#else
2959static const struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client)
2960{
2961	return ERR_PTR(-ENOENT);
2962}
2963#endif
2964
2965#ifdef CONFIG_ACPI
2966
2967struct mxt_acpi_platform_data {
2968	const char *hid;
2969	struct mxt_platform_data pdata;
2970};
2971
2972static unsigned int samus_touchpad_buttons[] = {
2973	KEY_RESERVED,
2974	KEY_RESERVED,
2975	KEY_RESERVED,
2976	BTN_LEFT
2977};
2978
2979static struct mxt_acpi_platform_data samus_platform_data[] = {
2980	{
2981		/* Touchpad */
2982		.hid	= "ATML0000",
2983		.pdata	= {
2984			.t19_num_keys	= ARRAY_SIZE(samus_touchpad_buttons),
2985			.t19_keymap	= samus_touchpad_buttons,
2986		},
2987	},
2988	{
2989		/* Touchscreen */
2990		.hid	= "ATML0001",
2991	},
2992	{ }
2993};
2994
2995static unsigned int chromebook_tp_buttons[] = {
2996	KEY_RESERVED,
2997	KEY_RESERVED,
2998	KEY_RESERVED,
2999	KEY_RESERVED,
3000	KEY_RESERVED,
3001	BTN_LEFT
3002};
3003
3004static struct mxt_acpi_platform_data chromebook_platform_data[] = {
3005	{
3006		/* Touchpad */
3007		.hid	= "ATML0000",
3008		.pdata	= {
3009			.t19_num_keys	= ARRAY_SIZE(chromebook_tp_buttons),
3010			.t19_keymap	= chromebook_tp_buttons,
3011		},
3012	},
3013	{
3014		/* Touchscreen */
3015		.hid	= "ATML0001",
3016	},
3017	{ }
3018};
3019
3020static const struct dmi_system_id mxt_dmi_table[] = {
3021	{
3022		/* 2015 Google Pixel */
3023		.ident = "Chromebook Pixel 2",
3024		.matches = {
3025			DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
3026			DMI_MATCH(DMI_PRODUCT_NAME, "Samus"),
3027		},
3028		.driver_data = samus_platform_data,
3029	},
3030	{
3031		/* Other Google Chromebooks */
3032		.ident = "Chromebook",
3033		.matches = {
3034			DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
3035		},
3036		.driver_data = chromebook_platform_data,
3037	},
3038	{ }
3039};
3040
3041static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
3042{
3043	struct acpi_device *adev;
3044	const struct dmi_system_id *system_id;
3045	const struct mxt_acpi_platform_data *acpi_pdata;
 
 
 
 
 
 
 
 
 
 
 
3046
3047	/*
3048	 * Ignore ACPI devices representing bootloader mode.
3049	 *
3050	 * This is a bit of a hack: Google Chromebook BIOS creates ACPI
3051	 * devices for both application and bootloader modes, but we are
3052	 * interested in application mode only (if device is in bootloader
3053	 * mode we'll end up switching into application anyway). So far
3054	 * application mode addresses were all above 0x40, so we'll use it
3055	 * as a threshold.
3056	 */
3057	if (client->addr < 0x40)
3058		return ERR_PTR(-ENXIO);
3059
3060	adev = ACPI_COMPANION(&client->dev);
3061	if (!adev)
3062		return ERR_PTR(-ENOENT);
3063
3064	system_id = dmi_first_match(mxt_dmi_table);
3065	if (!system_id)
3066		return ERR_PTR(-ENOENT);
3067
3068	acpi_pdata = system_id->driver_data;
3069	if (!acpi_pdata)
3070		return ERR_PTR(-ENOENT);
3071
3072	while (acpi_pdata->hid) {
3073		if (!strcmp(acpi_device_hid(adev), acpi_pdata->hid))
3074			return &acpi_pdata->pdata;
3075
3076		acpi_pdata++;
3077	}
3078
3079	return ERR_PTR(-ENOENT);
3080}
3081#else
3082static const struct mxt_platform_data *mxt_parse_acpi(struct i2c_client *client)
3083{
3084	return ERR_PTR(-ENOENT);
3085}
3086#endif
3087
3088static const struct mxt_platform_data *
3089mxt_get_platform_data(struct i2c_client *client)
3090{
3091	const struct mxt_platform_data *pdata;
3092
3093	pdata = dev_get_platdata(&client->dev);
3094	if (pdata)
3095		return pdata;
3096
3097	pdata = mxt_parse_dt(client);
3098	if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
3099		return pdata;
3100
3101	pdata = mxt_parse_acpi(client);
3102	if (!IS_ERR(pdata) || PTR_ERR(pdata) != -ENOENT)
3103		return pdata;
3104
3105	dev_err(&client->dev, "No platform data specified\n");
3106	return ERR_PTR(-EINVAL);
3107}
3108
3109static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id)
3110{
3111	struct mxt_data *data;
3112	const struct mxt_platform_data *pdata;
3113	int error;
3114
3115	pdata = mxt_get_platform_data(client);
3116	if (IS_ERR(pdata))
3117		return PTR_ERR(pdata);
3118
3119	data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL);
3120	if (!data) {
3121		dev_err(&client->dev, "Failed to allocate memory\n");
3122		return -ENOMEM;
3123	}
3124
3125	snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0",
3126		 client->adapter->nr, client->addr);
3127
3128	data->client = client;
3129	data->pdata = pdata;
3130	data->irq = client->irq;
3131	i2c_set_clientdata(client, data);
3132
3133	init_completion(&data->bl_completion);
3134	init_completion(&data->reset_completion);
3135	init_completion(&data->crc_completion);
3136
3137	error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
3138				     pdata->irqflags | IRQF_ONESHOT,
3139				     client->name, data);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3140	if (error) {
3141		dev_err(&client->dev, "Failed to register interrupt\n");
3142		goto err_free_mem;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3143	}
3144
3145	disable_irq(client->irq);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3146
3147	error = mxt_initialize(data);
3148	if (error)
3149		goto err_free_irq;
3150
3151	error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group);
3152	if (error) {
3153		dev_err(&client->dev, "Failure %d creating sysfs group\n",
3154			error);
3155		goto err_free_object;
3156	}
3157
3158	return 0;
3159
3160err_free_object:
3161	mxt_free_input_device(data);
3162	mxt_free_object_table(data);
3163err_free_irq:
3164	free_irq(client->irq, data);
3165err_free_mem:
3166	kfree(data);
3167	return error;
3168}
3169
3170static int mxt_remove(struct i2c_client *client)
3171{
3172	struct mxt_data *data = i2c_get_clientdata(client);
3173
 
3174	sysfs_remove_group(&client->dev.kobj, &mxt_attr_group);
3175	free_irq(data->irq, data);
3176	mxt_free_input_device(data);
3177	mxt_free_object_table(data);
3178	kfree(data);
3179
3180	return 0;
3181}
3182
3183static int __maybe_unused mxt_suspend(struct device *dev)
3184{
3185	struct i2c_client *client = to_i2c_client(dev);
3186	struct mxt_data *data = i2c_get_clientdata(client);
3187	struct input_dev *input_dev = data->input_dev;
3188
3189	if (!input_dev)
3190		return 0;
3191
3192	mutex_lock(&input_dev->mutex);
3193
3194	if (input_dev->users)
3195		mxt_stop(data);
3196
3197	mutex_unlock(&input_dev->mutex);
3198
 
 
3199	return 0;
3200}
3201
3202static int __maybe_unused mxt_resume(struct device *dev)
3203{
3204	struct i2c_client *client = to_i2c_client(dev);
3205	struct mxt_data *data = i2c_get_clientdata(client);
3206	struct input_dev *input_dev = data->input_dev;
3207
3208	if (!input_dev)
3209		return 0;
3210
 
 
3211	mutex_lock(&input_dev->mutex);
3212
3213	if (input_dev->users)
3214		mxt_start(data);
3215
3216	mutex_unlock(&input_dev->mutex);
3217
3218	return 0;
3219}
3220
3221static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume);
3222
3223static const struct of_device_id mxt_of_match[] = {
3224	{ .compatible = "atmel,maxtouch", },
 
 
 
 
 
3225	{},
3226};
3227MODULE_DEVICE_TABLE(of, mxt_of_match);
3228
3229#ifdef CONFIG_ACPI
3230static const struct acpi_device_id mxt_acpi_id[] = {
3231	{ "ATML0000", 0 },	/* Touchpad */
3232	{ "ATML0001", 0 },	/* Touchscreen */
3233	{ }
3234};
3235MODULE_DEVICE_TABLE(acpi, mxt_acpi_id);
3236#endif
3237
3238static const struct i2c_device_id mxt_id[] = {
3239	{ "qt602240_ts", 0 },
3240	{ "atmel_mxt_ts", 0 },
3241	{ "atmel_mxt_tp", 0 },
3242	{ "maxtouch", 0 },
3243	{ "mXT224", 0 },
3244	{ }
3245};
3246MODULE_DEVICE_TABLE(i2c, mxt_id);
3247
3248static struct i2c_driver mxt_driver = {
3249	.driver = {
3250		.name	= "atmel_mxt_ts",
3251		.of_match_table = of_match_ptr(mxt_of_match),
3252		.acpi_match_table = ACPI_PTR(mxt_acpi_id),
3253		.pm	= &mxt_pm_ops,
3254	},
3255	.probe		= mxt_probe,
3256	.remove		= mxt_remove,
3257	.id_table	= mxt_id,
3258};
3259
3260module_i2c_driver(mxt_driver);
3261
3262/* Module information */
3263MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
3264MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver");
3265MODULE_LICENSE("GPL");