1/*
   2 * Cypress APA trackpad with I2C interface
   3 *
   4 * Author: Dudley Du <dudl@cypress.com>
   5 * Further cleanup and restructuring by:
   6 *   Daniel Kurtz <djkurtz@chromium.org>
   7 *   Benson Leung <bleung@chromium.org>
   8 *
   9 * Copyright (C) 2011-2015 Cypress Semiconductor, Inc.
  10 * Copyright (C) 2011-2012 Google, Inc.
  11 *
  12 * This file is subject to the terms and conditions of the GNU General Public
  13 * License.  See the file COPYING in the main directory of this archive for
  14 * more details.
  15 */
  16
  17#include <linux/delay.h>
  18#include <linux/i2c.h>
  19#include <linux/input.h>
  20#include <linux/input/mt.h>
  21#include <linux/interrupt.h>
  22#include <linux/module.h>
  23#include <linux/mutex.h>
  24#include <linux/regulator/consumer.h>
  25#include <linux/slab.h>
  26#include <linux/uaccess.h>
  27#include <linux/pm_runtime.h>
  28#include <linux/acpi.h>
  29#include <linux/of.h>
  30#include "cyapa.h"
  31
  32
  33#define CYAPA_ADAPTER_FUNC_NONE   0
  34#define CYAPA_ADAPTER_FUNC_I2C    1
  35#define CYAPA_ADAPTER_FUNC_SMBUS  2
  36#define CYAPA_ADAPTER_FUNC_BOTH   3
  37
  38#define CYAPA_FW_NAME		"cyapa.bin"
  39
  40const char product_id[] = "CYTRA";
  41
  42static int cyapa_reinitialize(struct cyapa *cyapa);
  43
  44bool cyapa_is_pip_bl_mode(struct cyapa *cyapa)
  45{
  46	if (cyapa->gen == CYAPA_GEN6 && cyapa->state == CYAPA_STATE_GEN6_BL)
  47		return true;
  48
  49	if (cyapa->gen == CYAPA_GEN5 && cyapa->state == CYAPA_STATE_GEN5_BL)
  50		return true;
  51
  52	return false;
  53}
  54
  55bool cyapa_is_pip_app_mode(struct cyapa *cyapa)
  56{
  57	if (cyapa->gen == CYAPA_GEN6 && cyapa->state == CYAPA_STATE_GEN6_APP)
  58		return true;
  59
  60	if (cyapa->gen == CYAPA_GEN5 && cyapa->state == CYAPA_STATE_GEN5_APP)
  61		return true;
  62
  63	return false;
  64}
  65
  66static bool cyapa_is_bootloader_mode(struct cyapa *cyapa)
  67{
  68	if (cyapa_is_pip_bl_mode(cyapa))
  69		return true;
  70
  71	if (cyapa->gen == CYAPA_GEN3 &&
  72		cyapa->state >= CYAPA_STATE_BL_BUSY &&
  73		cyapa->state <= CYAPA_STATE_BL_ACTIVE)
  74		return true;
  75
  76	return false;
  77}
  78
  79static inline bool cyapa_is_operational_mode(struct cyapa *cyapa)
  80{
  81	if (cyapa_is_pip_app_mode(cyapa))
  82		return true;
  83
  84	if (cyapa->gen == CYAPA_GEN3 && cyapa->state == CYAPA_STATE_OP)
  85		return true;
  86
  87	return false;
  88}
  89
  90/* Returns 0 on success, else negative errno on failure. */
  91static ssize_t cyapa_i2c_read(struct cyapa *cyapa, u8 reg, size_t len,
  92					u8 *values)
  93{
  94	struct i2c_client *client = cyapa->client;
  95	struct i2c_msg msgs[] = {
  96		{
  97			.addr = client->addr,
  98			.flags = 0,
  99			.len = 1,
 100			.buf = &reg,
 101		},
 102		{
 103			.addr = client->addr,
 104			.flags = I2C_M_RD,
 105			.len = len,
 106			.buf = values,
 107		},
 108	};
 109	int ret;
 110
 111	ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 112
 113	if (ret != ARRAY_SIZE(msgs))
 114		return ret < 0 ? ret : -EIO;
 115
 116	return 0;
 117}
 118
 119/**
 120 * cyapa_i2c_write - Execute i2c block data write operation
 121 * @cyapa: Handle to this driver
 122 * @reg: Offset of the data to written in the register map
 123 * @len: number of bytes to write
 124 * @values: Data to be written
 125 *
 126 * Return negative errno code on error; return zero when success.
 127 */
 128static int cyapa_i2c_write(struct cyapa *cyapa, u8 reg,
 129					 size_t len, const void *values)
 130{
 131	struct i2c_client *client = cyapa->client;
 132	char buf[32];
 133	int ret;
 134
 135	if (len > sizeof(buf) - 1)
 136		return -ENOMEM;
 137
 138	buf[0] = reg;
 139	memcpy(&buf[1], values, len);
 140
 141	ret = i2c_master_send(client, buf, len + 1);
 142	if (ret != len + 1)
 143		return ret < 0 ? ret : -EIO;
 144
 145	return 0;
 146}
 147
 148static u8 cyapa_check_adapter_functionality(struct i2c_client *client)
 149{
 150	u8 ret = CYAPA_ADAPTER_FUNC_NONE;
 151
 152	if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 153		ret |= CYAPA_ADAPTER_FUNC_I2C;
 154	if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
 155				     I2C_FUNC_SMBUS_BLOCK_DATA |
 156				     I2C_FUNC_SMBUS_I2C_BLOCK))
 157		ret |= CYAPA_ADAPTER_FUNC_SMBUS;
 158	return ret;
 159}
 160
 161/*
 162 * Query device for its current operating state.
 163 */
 164static int cyapa_get_state(struct cyapa *cyapa)
 165{
 166	u8 status[BL_STATUS_SIZE];
 167	u8 cmd[32];
 168	/* The i2c address of gen4 and gen5 trackpad device must be even. */
 169	bool even_addr = ((cyapa->client->addr & 0x0001) == 0);
 170	bool smbus = false;
 171	int retries = 2;
 172	int error;
 173
 174	cyapa->state = CYAPA_STATE_NO_DEVICE;
 175
 176	/*
 177	 * Get trackpad status by reading 3 registers starting from 0.
 178	 * If the device is in the bootloader, this will be BL_HEAD.
 179	 * If the device is in operation mode, this will be the DATA regs.
 180	 *
 181	 */
 182	error = cyapa_i2c_reg_read_block(cyapa, BL_HEAD_OFFSET, BL_STATUS_SIZE,
 183				       status);
 184
 185	/*
 186	 * On smbus systems in OP mode, the i2c_reg_read will fail with
 187	 * -ETIMEDOUT.  In this case, try again using the smbus equivalent
 188	 * command.  This should return a BL_HEAD indicating CYAPA_STATE_OP.
 189	 */
 190	if (cyapa->smbus && (error == -ETIMEDOUT || error == -ENXIO)) {
 191		if (!even_addr)
 192			error = cyapa_read_block(cyapa,
 193					CYAPA_CMD_BL_STATUS, status);
 194		smbus = true;
 195	}
 196
 197	if (error != BL_STATUS_SIZE)
 198		goto error;
 199
 200	/*
 201	 * Detect trackpad protocol based on characteristic registers and bits.
 202	 */
 203	do {
 204		cyapa->status[REG_OP_STATUS] = status[REG_OP_STATUS];
 205		cyapa->status[REG_BL_STATUS] = status[REG_BL_STATUS];
 206		cyapa->status[REG_BL_ERROR] = status[REG_BL_ERROR];
 207
 208		if (cyapa->gen == CYAPA_GEN_UNKNOWN ||
 209				cyapa->gen == CYAPA_GEN3) {
 210			error = cyapa_gen3_ops.state_parse(cyapa,
 211					status, BL_STATUS_SIZE);
 212			if (!error)
 213				goto out_detected;
 214		}
 215		if (cyapa->gen == CYAPA_GEN_UNKNOWN ||
 216				cyapa->gen == CYAPA_GEN6 ||
 217				cyapa->gen == CYAPA_GEN5) {
 218			error = cyapa_pip_state_parse(cyapa,
 219					status, BL_STATUS_SIZE);
 220			if (!error)
 221				goto out_detected;
 222		}
 223		/* For old Gen5 trackpads detecting. */
 224		if ((cyapa->gen == CYAPA_GEN_UNKNOWN ||
 225				cyapa->gen == CYAPA_GEN5) &&
 226			!smbus && even_addr) {
 227			error = cyapa_gen5_ops.state_parse(cyapa,
 228					status, BL_STATUS_SIZE);
 229			if (!error)
 230				goto out_detected;
 231		}
 232
 233		/*
 234		 * Write 0x00 0x00 to trackpad device to force update its
 235		 * status, then redo the detection again.
 236		 */
 237		if (!smbus) {
 238			cmd[0] = 0x00;
 239			cmd[1] = 0x00;
 240			error = cyapa_i2c_write(cyapa, 0, 2, cmd);
 241			if (error)
 242				goto error;
 243
 244			msleep(50);
 245
 246			error = cyapa_i2c_read(cyapa, BL_HEAD_OFFSET,
 247					BL_STATUS_SIZE, status);
 248			if (error)
 249				goto error;
 250		}
 251	} while (--retries > 0 && !smbus);
 252
 253	goto error;
 254
 255out_detected:
 256	if (cyapa->state <= CYAPA_STATE_BL_BUSY)
 257		return -EAGAIN;
 258	return 0;
 259
 260error:
 261	return (error < 0) ? error : -EAGAIN;
 262}
 263
 264/*
 265 * Poll device for its status in a loop, waiting up to timeout for a response.
 266 *
 267 * When the device switches state, it usually takes ~300 ms.
 268 * However, when running a new firmware image, the device must calibrate its
 269 * sensors, which can take as long as 2 seconds.
 270 *
 271 * Note: The timeout has granularity of the polling rate, which is 100 ms.
 272 *
 273 * Returns:
 274 *   0 when the device eventually responds with a valid non-busy state.
 275 *   -ETIMEDOUT if device never responds (too many -EAGAIN)
 276 *   -EAGAIN    if bootload is busy, or unknown state.
 277 *   < 0        other errors
 278 */
 279int cyapa_poll_state(struct cyapa *cyapa, unsigned int timeout)
 280{
 281	int error;
 282	int tries = timeout / 100;
 283
 284	do {
 285		error = cyapa_get_state(cyapa);
 286		if (!error && cyapa->state > CYAPA_STATE_BL_BUSY)
 287			return 0;
 288
 289		msleep(100);
 290	} while (tries--);
 291
 292	return (error == -EAGAIN || error == -ETIMEDOUT) ? -ETIMEDOUT : error;
 293}
 294
 295/*
 296 * Check if device is operational.
 297 *
 298 * An operational device is responding, has exited bootloader, and has
 299 * firmware supported by this driver.
 300 *
 301 * Returns:
 302 *   -ENODEV no device
 303 *   -EBUSY  no device or in bootloader
 304 *   -EIO    failure while reading from device
 305 *   -ETIMEDOUT timeout failure for bus idle or bus no response
 306 *   -EAGAIN device is still in bootloader
 307 *           if ->state = CYAPA_STATE_BL_IDLE, device has invalid firmware
 308 *   -EINVAL device is in operational mode, but not supported by this driver
 309 *   0       device is supported
 310 */
 311static int cyapa_check_is_operational(struct cyapa *cyapa)
 312{
 313	int error;
 314
 315	error = cyapa_poll_state(cyapa, 4000);
 316	if (error)
 317		return error;
 318
 319	switch (cyapa->gen) {
 320	case CYAPA_GEN6:
 321		cyapa->ops = &cyapa_gen6_ops;
 322		break;
 323	case CYAPA_GEN5:
 324		cyapa->ops = &cyapa_gen5_ops;
 325		break;
 326	case CYAPA_GEN3:
 327		cyapa->ops = &cyapa_gen3_ops;
 328		break;
 329	default:
 330		return -ENODEV;
 331	}
 332
 333	error = cyapa->ops->operational_check(cyapa);
 334	if (!error && cyapa_is_operational_mode(cyapa))
 335		cyapa->operational = true;
 336	else
 337		cyapa->operational = false;
 338
 339	return error;
 340}
 341
 342
 343/*
 344 * Returns 0 on device detected, negative errno on no device detected.
 345 * And when the device is detected and operational, it will be reset to
 346 * full power active mode automatically.
 347 */
 348static int cyapa_detect(struct cyapa *cyapa)
 349{
 350	struct device *dev = &cyapa->client->dev;
 351	int error;
 352
 353	error = cyapa_check_is_operational(cyapa);
 354	if (error) {
 355		if (error != -ETIMEDOUT && error != -ENODEV &&
 356			cyapa_is_bootloader_mode(cyapa)) {
 357			dev_warn(dev, "device detected but not operational\n");
 358			return 0;
 359		}
 360
 361		dev_err(dev, "no device detected: %d\n", error);
 362		return error;
 363	}
 364
 365	return 0;
 366}
 367
 368static int cyapa_open(struct input_dev *input)
 369{
 370	struct cyapa *cyapa = input_get_drvdata(input);
 371	struct i2c_client *client = cyapa->client;
 372	struct device *dev = &client->dev;
 373	int error;
 374
 375	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
 376	if (error)
 377		return error;
 378
 379	if (cyapa->operational) {
 380		/*
 381		 * though failed to set active power mode,
 382		 * but still may be able to work in lower scan rate
 383		 * when in operational mode.
 384		 */
 385		error = cyapa->ops->set_power_mode(cyapa,
 386				PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE);
 387		if (error) {
 388			dev_warn(dev, "set active power failed: %d\n", error);
 389			goto out;
 390		}
 391	} else {
 392		error = cyapa_reinitialize(cyapa);
 393		if (error || !cyapa->operational) {
 394			error = error ? error : -EAGAIN;
 395			goto out;
 396		}
 397	}
 398
 399	enable_irq(client->irq);
 400	if (!pm_runtime_enabled(dev)) {
 401		pm_runtime_set_active(dev);
 402		pm_runtime_enable(dev);
 403	}
 404
 405	pm_runtime_get_sync(dev);
 406	pm_runtime_mark_last_busy(dev);
 407	pm_runtime_put_sync_autosuspend(dev);
 408out:
 409	mutex_unlock(&cyapa->state_sync_lock);
 410	return error;
 411}
 412
 413static void cyapa_close(struct input_dev *input)
 414{
 415	struct cyapa *cyapa = input_get_drvdata(input);
 416	struct i2c_client *client = cyapa->client;
 417	struct device *dev = &cyapa->client->dev;
 418
 419	mutex_lock(&cyapa->state_sync_lock);
 420
 421	disable_irq(client->irq);
 422	if (pm_runtime_enabled(dev))
 423		pm_runtime_disable(dev);
 424	pm_runtime_set_suspended(dev);
 425
 426	if (cyapa->operational)
 427		cyapa->ops->set_power_mode(cyapa,
 428				PWR_MODE_OFF, 0, CYAPA_PM_DEACTIVE);
 429
 430	mutex_unlock(&cyapa->state_sync_lock);
 431}
 432
 433static int cyapa_create_input_dev(struct cyapa *cyapa)
 434{
 435	struct device *dev = &cyapa->client->dev;
 436	struct input_dev *input;
 437	int error;
 438
 439	if (!cyapa->physical_size_x || !cyapa->physical_size_y)
 440		return -EINVAL;
 441
 442	input = devm_input_allocate_device(dev);
 443	if (!input) {
 444		dev_err(dev, "failed to allocate memory for input device.\n");
 445		return -ENOMEM;
 446	}
 447
 448	input->name = CYAPA_NAME;
 449	input->phys = cyapa->phys;
 450	input->id.bustype = BUS_I2C;
 451	input->id.version = 1;
 452	input->id.product = 0;  /* Means any product in eventcomm. */
 453	input->dev.parent = &cyapa->client->dev;
 454
 455	input->open = cyapa_open;
 456	input->close = cyapa_close;
 457
 458	input_set_drvdata(input, cyapa);
 459
 460	__set_bit(EV_ABS, input->evbit);
 461
 462	/* Finger position */
 463	input_set_abs_params(input, ABS_MT_POSITION_X, 0, cyapa->max_abs_x, 0,
 464			     0);
 465	input_set_abs_params(input, ABS_MT_POSITION_Y, 0, cyapa->max_abs_y, 0,
 466			     0);
 467	input_set_abs_params(input, ABS_MT_PRESSURE, 0, cyapa->max_z, 0, 0);
 468	if (cyapa->gen > CYAPA_GEN3) {
 469		input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 470		input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
 471		/*
 472		 * Orientation is the angle between the vertical axis and
 473		 * the major axis of the contact ellipse.
 474		 * The range is -127 to 127.
 475		 * the positive direction is clockwise form the vertical axis.
 476		 * If the ellipse of contact degenerates into a circle,
 477		 * orientation is reported as 0.
 478		 *
 479		 * Also, for Gen5 trackpad the accurate of this orientation
 480		 * value is value + (-30 ~ 30).
 481		 */
 482		input_set_abs_params(input, ABS_MT_ORIENTATION,
 483				-127, 127, 0, 0);
 484	}
 485	if (cyapa->gen >= CYAPA_GEN5) {
 486		input_set_abs_params(input, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
 487		input_set_abs_params(input, ABS_MT_WIDTH_MINOR, 0, 255, 0, 0);
 488		input_set_abs_params(input, ABS_DISTANCE, 0, 1, 0, 0);
 489	}
 490
 491	input_abs_set_res(input, ABS_MT_POSITION_X,
 492			  cyapa->max_abs_x / cyapa->physical_size_x);
 493	input_abs_set_res(input, ABS_MT_POSITION_Y,
 494			  cyapa->max_abs_y / cyapa->physical_size_y);
 495
 496	if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK)
 497		__set_bit(BTN_LEFT, input->keybit);
 498	if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK)
 499		__set_bit(BTN_MIDDLE, input->keybit);
 500	if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK)
 501		__set_bit(BTN_RIGHT, input->keybit);
 502
 503	if (cyapa->btn_capability == CAPABILITY_LEFT_BTN_MASK)
 504		__set_bit(INPUT_PROP_BUTTONPAD, input->propbit);
 505
 506	/* Handle pointer emulation and unused slots in core */
 507	error = input_mt_init_slots(input, CYAPA_MAX_MT_SLOTS,
 508				    INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED);
 509	if (error) {
 510		dev_err(dev, "failed to initialize MT slots: %d\n", error);
 511		return error;
 512	}
 513
 514	/* Register the device in input subsystem */
 515	error = input_register_device(input);
 516	if (error) {
 517		dev_err(dev, "failed to register input device: %d\n", error);
 518		return error;
 519	}
 520
 521	cyapa->input = input;
 522	return 0;
 523}
 524
 525static void cyapa_enable_irq_for_cmd(struct cyapa *cyapa)
 526{
 527	struct input_dev *input = cyapa->input;
 528
 529	if (!input || !input_device_enabled(input)) {
 530		/*
 531		 * When input is NULL, TP must be in deep sleep mode.
 532		 * In this mode, later non-power I2C command will always failed
 533		 * if not bring it out of deep sleep mode firstly,
 534		 * so must command TP to active mode here.
 535		 */
 536		if (!input || cyapa->operational)
 537			cyapa->ops->set_power_mode(cyapa,
 538				PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE);
 539		/* Gen3 always using polling mode for command. */
 540		if (cyapa->gen >= CYAPA_GEN5)
 541			enable_irq(cyapa->client->irq);
 542	}
 543}
 544
 545static void cyapa_disable_irq_for_cmd(struct cyapa *cyapa)
 546{
 547	struct input_dev *input = cyapa->input;
 548
 549	if (!input || !input_device_enabled(input)) {
 550		if (cyapa->gen >= CYAPA_GEN5)
 551			disable_irq(cyapa->client->irq);
 552		if (!input || cyapa->operational)
 553			cyapa->ops->set_power_mode(cyapa,
 554					PWR_MODE_OFF, 0, CYAPA_PM_ACTIVE);
 555	}
 556}
 557
 558/*
 559 * cyapa_sleep_time_to_pwr_cmd and cyapa_pwr_cmd_to_sleep_time
 560 *
 561 * These are helper functions that convert to and from integer idle
 562 * times and register settings to write to the PowerMode register.
 563 * The trackpad supports between 20ms to 1000ms scan intervals.
 564 * The time will be increased in increments of 10ms from 20ms to 100ms.
 565 * From 100ms to 1000ms, time will be increased in increments of 20ms.
 566 *
 567 * When Idle_Time < 100, the format to convert Idle_Time to Idle_Command is:
 568 *   Idle_Command = Idle Time / 10;
 569 * When Idle_Time >= 100, the format to convert Idle_Time to Idle_Command is:
 570 *   Idle_Command = Idle Time / 20 + 5;
 571 */
 572u8 cyapa_sleep_time_to_pwr_cmd(u16 sleep_time)
 573{
 574	u16 encoded_time;
 575
 576	sleep_time = clamp_val(sleep_time, 20, 1000);
 577	encoded_time = sleep_time < 100 ? sleep_time / 10 : sleep_time / 20 + 5;
 578	return (encoded_time << 2) & PWR_MODE_MASK;
 579}
 580
 581u16 cyapa_pwr_cmd_to_sleep_time(u8 pwr_mode)
 582{
 583	u8 encoded_time = pwr_mode >> 2;
 584
 585	return (encoded_time < 10) ? encoded_time * 10
 586				   : (encoded_time - 5) * 20;
 587}
 588
 589/* 0 on driver initialize and detected successfully, negative on failure. */
 590static int cyapa_initialize(struct cyapa *cyapa)
 591{
 592	int error = 0;
 593
 594	cyapa->state = CYAPA_STATE_NO_DEVICE;
 595	cyapa->gen = CYAPA_GEN_UNKNOWN;
 596	mutex_init(&cyapa->state_sync_lock);
 597
 598	/*
 599	 * Set to hard code default, they will be updated with trackpad set
 600	 * default values after probe and initialized.
 601	 */
 602	cyapa->suspend_power_mode = PWR_MODE_SLEEP;
 603	cyapa->suspend_sleep_time =
 604		cyapa_pwr_cmd_to_sleep_time(cyapa->suspend_power_mode);
 605
 606	/* ops.initialize() is aimed to prepare for module communications. */
 607	error = cyapa_gen3_ops.initialize(cyapa);
 608	if (!error)
 609		error = cyapa_gen5_ops.initialize(cyapa);
 610	if (!error)
 611		error = cyapa_gen6_ops.initialize(cyapa);
 612	if (error)
 613		return error;
 614
 615	error = cyapa_detect(cyapa);
 616	if (error)
 617		return error;
 618
 619	/* Power down the device until we need it. */
 620	if (cyapa->operational)
 621		cyapa->ops->set_power_mode(cyapa,
 622				PWR_MODE_OFF, 0, CYAPA_PM_ACTIVE);
 623
 624	return 0;
 625}
 626
 627static int cyapa_reinitialize(struct cyapa *cyapa)
 628{
 629	struct device *dev = &cyapa->client->dev;
 630	struct input_dev *input = cyapa->input;
 631	int error;
 632
 633	if (pm_runtime_enabled(dev))
 634		pm_runtime_disable(dev);
 635
 636	/* Avoid command failures when TP was in OFF state. */
 637	if (cyapa->operational)
 638		cyapa->ops->set_power_mode(cyapa,
 639				PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_ACTIVE);
 640
 641	error = cyapa_detect(cyapa);
 642	if (error)
 643		goto out;
 644
 645	if (!input && cyapa->operational) {
 646		error = cyapa_create_input_dev(cyapa);
 647		if (error) {
 648			dev_err(dev, "create input_dev instance failed: %d\n",
 649					error);
 650			goto out;
 651		}
 652	}
 653
 654out:
 655	if (!input || !input_device_enabled(input)) {
 656		/* Reset to power OFF state to save power when no user open. */
 657		if (cyapa->operational)
 658			cyapa->ops->set_power_mode(cyapa,
 659					PWR_MODE_OFF, 0, CYAPA_PM_DEACTIVE);
 660	} else if (!error && cyapa->operational) {
 661		/*
 662		 * Make sure only enable runtime PM when device is
 663		 * in operational mode and input->users > 0.
 664		 */
 665		pm_runtime_set_active(dev);
 666		pm_runtime_enable(dev);
 667
 668		pm_runtime_get_sync(dev);
 669		pm_runtime_mark_last_busy(dev);
 670		pm_runtime_put_sync_autosuspend(dev);
 671	}
 672
 673	return error;
 674}
 675
 676static irqreturn_t cyapa_irq(int irq, void *dev_id)
 677{
 678	struct cyapa *cyapa = dev_id;
 679	struct device *dev = &cyapa->client->dev;
 680	int error;
 681
 682	if (device_may_wakeup(dev))
 683		pm_wakeup_event(dev, 0);
 684
 685	/* Interrupt event can be caused by host command to trackpad device. */
 686	if (cyapa->ops->irq_cmd_handler(cyapa)) {
 687		/*
 688		 * Interrupt event maybe from trackpad device input reporting.
 689		 */
 690		if (!cyapa->input) {
 691			/*
 692			 * Still in probing or in firmware image
 693			 * updating or reading.
 694			 */
 695			cyapa->ops->sort_empty_output_data(cyapa,
 696					NULL, NULL, NULL);
 697			goto out;
 698		}
 699
 700		if (cyapa->operational) {
 701			error = cyapa->ops->irq_handler(cyapa);
 702
 703			/*
 704			 * Apply runtime power management to touch report event
 705			 * except the events caused by the command responses.
 706			 * Note:
 707			 * It will introduce about 20~40 ms additional delay
 708			 * time in receiving for first valid touch report data.
 709			 * The time is used to execute device runtime resume
 710			 * process.
 711			 */
 712			pm_runtime_get_sync(dev);
 713			pm_runtime_mark_last_busy(dev);
 714			pm_runtime_put_sync_autosuspend(dev);
 715		}
 716
 717		if (!cyapa->operational || error) {
 718			if (!mutex_trylock(&cyapa->state_sync_lock)) {
 719				cyapa->ops->sort_empty_output_data(cyapa,
 720					NULL, NULL, NULL);
 721				goto out;
 722			}
 723			cyapa_reinitialize(cyapa);
 724			mutex_unlock(&cyapa->state_sync_lock);
 725		}
 726	}
 727
 728out:
 729	return IRQ_HANDLED;
 730}
 731
 732/*
 733 **************************************************************
 734 * sysfs interface
 735 **************************************************************
 736*/
 737#ifdef CONFIG_PM_SLEEP
 738static ssize_t cyapa_show_suspend_scanrate(struct device *dev,
 739					   struct device_attribute *attr,
 740					   char *buf)
 741{
 742	struct cyapa *cyapa = dev_get_drvdata(dev);
 743	u8 pwr_cmd;
 744	u16 sleep_time;
 745	int len;
 746	int error;
 747
 748	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
 749	if (error)
 750		return error;
 751
 752	pwr_cmd = cyapa->suspend_power_mode;
 753	sleep_time = cyapa->suspend_sleep_time;
 754
 755	mutex_unlock(&cyapa->state_sync_lock);
 756
 757	switch (pwr_cmd) {
 758	case PWR_MODE_BTN_ONLY:
 759		len = sysfs_emit(buf, "%s\n", BTN_ONLY_MODE_NAME);
 760		break;
 761
 762	case PWR_MODE_OFF:
 763		len = sysfs_emit(buf, "%s\n", OFF_MODE_NAME);
 764		break;
 765
 766	default:
 767		len = sysfs_emit(buf, "%u\n",
 768				 cyapa->gen == CYAPA_GEN3 ?
 769					cyapa_pwr_cmd_to_sleep_time(pwr_cmd) :
 770					sleep_time);
 771		break;
 772	}
 773
 774	return len;
 775}
 776
 777static ssize_t cyapa_update_suspend_scanrate(struct device *dev,
 778					     struct device_attribute *attr,
 779					     const char *buf, size_t count)
 780{
 781	struct cyapa *cyapa = dev_get_drvdata(dev);
 782	u16 sleep_time;
 783	int error;
 784
 785	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
 786	if (error)
 787		return error;
 788
 789	if (sysfs_streq(buf, BTN_ONLY_MODE_NAME)) {
 790		cyapa->suspend_power_mode = PWR_MODE_BTN_ONLY;
 791	} else if (sysfs_streq(buf, OFF_MODE_NAME)) {
 792		cyapa->suspend_power_mode = PWR_MODE_OFF;
 793	} else if (!kstrtou16(buf, 10, &sleep_time)) {
 794		cyapa->suspend_sleep_time = min_t(u16, sleep_time, 1000);
 795		cyapa->suspend_power_mode =
 796			cyapa_sleep_time_to_pwr_cmd(cyapa->suspend_sleep_time);
 797	} else {
 798		count = -EINVAL;
 799	}
 800
 801	mutex_unlock(&cyapa->state_sync_lock);
 802
 803	return count;
 804}
 805
 806static DEVICE_ATTR(suspend_scanrate_ms, S_IRUGO|S_IWUSR,
 807		   cyapa_show_suspend_scanrate,
 808		   cyapa_update_suspend_scanrate);
 809
 810static struct attribute *cyapa_power_wakeup_entries[] = {
 811	&dev_attr_suspend_scanrate_ms.attr,
 812	NULL,
 813};
 814
 815static const struct attribute_group cyapa_power_wakeup_group = {
 816	.name = power_group_name,
 817	.attrs = cyapa_power_wakeup_entries,
 818};
 819
 820static void cyapa_remove_power_wakeup_group(void *data)
 821{
 822	struct cyapa *cyapa = data;
 823
 824	sysfs_unmerge_group(&cyapa->client->dev.kobj,
 825				&cyapa_power_wakeup_group);
 826}
 827
 828static int cyapa_prepare_wakeup_controls(struct cyapa *cyapa)
 829{
 830	struct i2c_client *client = cyapa->client;
 831	struct device *dev = &client->dev;
 832	int error;
 833
 834	if (device_can_wakeup(dev)) {
 835		error = sysfs_merge_group(&dev->kobj,
 836					  &cyapa_power_wakeup_group);
 837		if (error) {
 838			dev_err(dev, "failed to add power wakeup group: %d\n",
 839				error);
 840			return error;
 841		}
 842
 843		error = devm_add_action_or_reset(dev,
 844				cyapa_remove_power_wakeup_group, cyapa);
 845		if (error) {
 
 846			dev_err(dev, "failed to add power cleanup action: %d\n",
 847				error);
 848			return error;
 849		}
 850	}
 851
 852	return 0;
 853}
 854#else
 855static inline int cyapa_prepare_wakeup_controls(struct cyapa *cyapa)
 856{
 857	return 0;
 858}
 859#endif /* CONFIG_PM_SLEEP */
 860
 861#ifdef CONFIG_PM
 862static ssize_t cyapa_show_rt_suspend_scanrate(struct device *dev,
 863					      struct device_attribute *attr,
 864					      char *buf)
 865{
 866	struct cyapa *cyapa = dev_get_drvdata(dev);
 867	u8 pwr_cmd;
 868	u16 sleep_time;
 869	int error;
 870
 871	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
 872	if (error)
 873		return error;
 874
 875	pwr_cmd = cyapa->runtime_suspend_power_mode;
 876	sleep_time = cyapa->runtime_suspend_sleep_time;
 877
 878	mutex_unlock(&cyapa->state_sync_lock);
 879
 880	return sysfs_emit(buf, "%u\n",
 881			  cyapa->gen == CYAPA_GEN3 ?
 882				cyapa_pwr_cmd_to_sleep_time(pwr_cmd) :
 883				sleep_time);
 884}
 885
 886static ssize_t cyapa_update_rt_suspend_scanrate(struct device *dev,
 887						struct device_attribute *attr,
 888						const char *buf, size_t count)
 889{
 890	struct cyapa *cyapa = dev_get_drvdata(dev);
 891	u16 time;
 892	int error;
 893
 894	if (buf == NULL || count == 0 || kstrtou16(buf, 10, &time)) {
 895		dev_err(dev, "invalid runtime suspend scanrate ms parameter\n");
 896		return -EINVAL;
 897	}
 898
 899	/*
 900	 * When the suspend scanrate is changed, pm_runtime_get to resume
 901	 * a potentially suspended device, update to the new pwr_cmd
 902	 * and then pm_runtime_put to suspend into the new power mode.
 903	 */
 904	pm_runtime_get_sync(dev);
 905
 906	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
 907	if (error)
 908		return error;
 909
 910	cyapa->runtime_suspend_sleep_time = min_t(u16, time, 1000);
 911	cyapa->runtime_suspend_power_mode =
 912		cyapa_sleep_time_to_pwr_cmd(cyapa->runtime_suspend_sleep_time);
 913
 914	mutex_unlock(&cyapa->state_sync_lock);
 915
 916	pm_runtime_put_sync_autosuspend(dev);
 917
 918	return count;
 919}
 920
 921static DEVICE_ATTR(runtime_suspend_scanrate_ms, S_IRUGO|S_IWUSR,
 922		   cyapa_show_rt_suspend_scanrate,
 923		   cyapa_update_rt_suspend_scanrate);
 924
 925static struct attribute *cyapa_power_runtime_entries[] = {
 926	&dev_attr_runtime_suspend_scanrate_ms.attr,
 927	NULL,
 928};
 929
 930static const struct attribute_group cyapa_power_runtime_group = {
 931	.name = power_group_name,
 932	.attrs = cyapa_power_runtime_entries,
 933};
 934
 935static void cyapa_remove_power_runtime_group(void *data)
 936{
 937	struct cyapa *cyapa = data;
 938
 939	sysfs_unmerge_group(&cyapa->client->dev.kobj,
 940				&cyapa_power_runtime_group);
 941}
 942
 943static int cyapa_start_runtime(struct cyapa *cyapa)
 944{
 945	struct device *dev = &cyapa->client->dev;
 946	int error;
 947
 948	cyapa->runtime_suspend_power_mode = PWR_MODE_IDLE;
 949	cyapa->runtime_suspend_sleep_time =
 950		cyapa_pwr_cmd_to_sleep_time(cyapa->runtime_suspend_power_mode);
 951
 952	error = sysfs_merge_group(&dev->kobj, &cyapa_power_runtime_group);
 953	if (error) {
 954		dev_err(dev,
 955			"failed to create power runtime group: %d\n", error);
 956		return error;
 957	}
 958
 959	error = devm_add_action_or_reset(dev, cyapa_remove_power_runtime_group,
 960					 cyapa);
 961	if (error) {
 
 962		dev_err(dev,
 963			"failed to add power runtime cleanup action: %d\n",
 964			error);
 965		return error;
 966	}
 967
 968	/* runtime is enabled until device is operational and opened. */
 969	pm_runtime_set_suspended(dev);
 970	pm_runtime_use_autosuspend(dev);
 971	pm_runtime_set_autosuspend_delay(dev, AUTOSUSPEND_DELAY);
 972
 973	return 0;
 974}
 975#else
 976static inline int cyapa_start_runtime(struct cyapa *cyapa)
 977{
 978	return 0;
 979}
 980#endif /* CONFIG_PM */
 981
 982static ssize_t cyapa_show_fm_ver(struct device *dev,
 983				 struct device_attribute *attr, char *buf)
 984{
 985	int error;
 986	struct cyapa *cyapa = dev_get_drvdata(dev);
 987
 988	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
 989	if (error)
 990		return error;
 991	error = sysfs_emit(buf, "%d.%d\n",
 992			   cyapa->fw_maj_ver, cyapa->fw_min_ver);
 993	mutex_unlock(&cyapa->state_sync_lock);
 994	return error;
 995}
 996
 997static ssize_t cyapa_show_product_id(struct device *dev,
 998				     struct device_attribute *attr, char *buf)
 999{
1000	struct cyapa *cyapa = dev_get_drvdata(dev);
1001	int size;
1002	int error;
1003
1004	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1005	if (error)
1006		return error;
1007	size = sysfs_emit(buf, "%s\n", cyapa->product_id);
1008	mutex_unlock(&cyapa->state_sync_lock);
1009	return size;
1010}
1011
1012static int cyapa_firmware(struct cyapa *cyapa, const char *fw_name)
1013{
1014	struct device *dev = &cyapa->client->dev;
1015	const struct firmware *fw;
1016	int error;
1017
1018	error = request_firmware(&fw, fw_name, dev);
1019	if (error) {
1020		dev_err(dev, "Could not load firmware from %s: %d\n",
1021			fw_name, error);
1022		return error;
1023	}
1024
1025	error = cyapa->ops->check_fw(cyapa, fw);
1026	if (error) {
1027		dev_err(dev, "Invalid CYAPA firmware image: %s\n",
1028				fw_name);
1029		goto done;
1030	}
1031
1032	/*
1033	 * Resume the potentially suspended device because doing FW
1034	 * update on a device not in the FULL mode has a chance to
1035	 * fail.
1036	 */
1037	pm_runtime_get_sync(dev);
1038
1039	/* Require IRQ support for firmware update commands. */
1040	cyapa_enable_irq_for_cmd(cyapa);
1041
1042	error = cyapa->ops->bl_enter(cyapa);
1043	if (error) {
1044		dev_err(dev, "bl_enter failed, %d\n", error);
1045		goto err_detect;
1046	}
1047
1048	error = cyapa->ops->bl_activate(cyapa);
1049	if (error) {
1050		dev_err(dev, "bl_activate failed, %d\n", error);
1051		goto err_detect;
1052	}
1053
1054	error = cyapa->ops->bl_initiate(cyapa, fw);
1055	if (error) {
1056		dev_err(dev, "bl_initiate failed, %d\n", error);
1057		goto err_detect;
1058	}
1059
1060	error = cyapa->ops->update_fw(cyapa, fw);
1061	if (error) {
1062		dev_err(dev, "update_fw failed, %d\n", error);
1063		goto err_detect;
1064	}
1065
1066err_detect:
1067	cyapa_disable_irq_for_cmd(cyapa);
1068	pm_runtime_put_noidle(dev);
1069
1070done:
1071	release_firmware(fw);
1072	return error;
1073}
1074
1075static ssize_t cyapa_update_fw_store(struct device *dev,
1076				     struct device_attribute *attr,
1077				     const char *buf, size_t count)
1078{
1079	struct cyapa *cyapa = dev_get_drvdata(dev);
1080	char fw_name[NAME_MAX];
1081	int ret, error;
1082
1083	if (count >= NAME_MAX) {
1084		dev_err(dev, "File name too long\n");
1085		return -EINVAL;
1086	}
1087
1088	memcpy(fw_name, buf, count);
1089	if (fw_name[count - 1] == '\n')
1090		fw_name[count - 1] = '\0';
1091	else
1092		fw_name[count] = '\0';
1093
1094	if (cyapa->input) {
1095		/*
1096		 * Force the input device to be registered after the firmware
1097		 * image is updated, so if the corresponding parameters updated
1098		 * in the new firmware image can taken effect immediately.
1099		 */
1100		input_unregister_device(cyapa->input);
1101		cyapa->input = NULL;
1102	}
1103
1104	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1105	if (error) {
1106		/*
1107		 * Whatever, do reinitialize to try to recover TP state to
1108		 * previous state just as it entered fw update entrance.
1109		 */
1110		cyapa_reinitialize(cyapa);
1111		return error;
1112	}
1113
1114	error = cyapa_firmware(cyapa, fw_name);
1115	if (error)
1116		dev_err(dev, "firmware update failed: %d\n", error);
1117	else
1118		dev_dbg(dev, "firmware update successfully done.\n");
1119
1120	/*
1121	 * Re-detect trackpad device states because firmware update process
1122	 * will reset trackpad device into bootloader mode.
1123	 */
1124	ret = cyapa_reinitialize(cyapa);
1125	if (ret) {
1126		dev_err(dev, "failed to re-detect after updated: %d\n", ret);
1127		error = error ? error : ret;
1128	}
1129
1130	mutex_unlock(&cyapa->state_sync_lock);
1131
1132	return error ? error : count;
1133}
1134
1135static ssize_t cyapa_calibrate_store(struct device *dev,
1136				     struct device_attribute *attr,
1137				     const char *buf, size_t count)
1138{
1139	struct cyapa *cyapa = dev_get_drvdata(dev);
1140	int error;
1141
1142	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1143	if (error)
1144		return error;
1145
1146	if (cyapa->operational) {
1147		cyapa_enable_irq_for_cmd(cyapa);
1148		error = cyapa->ops->calibrate_store(dev, attr, buf, count);
1149		cyapa_disable_irq_for_cmd(cyapa);
1150	} else {
1151		error = -EBUSY;  /* Still running in bootloader mode. */
1152	}
1153
1154	mutex_unlock(&cyapa->state_sync_lock);
1155	return error < 0 ? error : count;
1156}
1157
1158static ssize_t cyapa_show_baseline(struct device *dev,
1159				   struct device_attribute *attr, char *buf)
1160{
1161	struct cyapa *cyapa = dev_get_drvdata(dev);
1162	ssize_t error;
1163
1164	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1165	if (error)
1166		return error;
1167
1168	if (cyapa->operational) {
1169		cyapa_enable_irq_for_cmd(cyapa);
1170		error = cyapa->ops->show_baseline(dev, attr, buf);
1171		cyapa_disable_irq_for_cmd(cyapa);
1172	} else {
1173		error = -EBUSY;  /* Still running in bootloader mode. */
1174	}
1175
1176	mutex_unlock(&cyapa->state_sync_lock);
1177	return error;
1178}
1179
1180static char *cyapa_state_to_string(struct cyapa *cyapa)
1181{
1182	switch (cyapa->state) {
1183	case CYAPA_STATE_BL_BUSY:
1184		return "bootloader busy";
1185	case CYAPA_STATE_BL_IDLE:
1186		return "bootloader idle";
1187	case CYAPA_STATE_BL_ACTIVE:
1188		return "bootloader active";
1189	case CYAPA_STATE_GEN5_BL:
1190	case CYAPA_STATE_GEN6_BL:
1191		return "bootloader";
1192	case CYAPA_STATE_OP:
1193	case CYAPA_STATE_GEN5_APP:
1194	case CYAPA_STATE_GEN6_APP:
1195		return "operational";  /* Normal valid state. */
1196	default:
1197		return "invalid mode";
1198	}
1199}
1200
1201static ssize_t cyapa_show_mode(struct device *dev,
1202				   struct device_attribute *attr, char *buf)
1203{
1204	struct cyapa *cyapa = dev_get_drvdata(dev);
1205	int size;
1206	int error;
1207
1208	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1209	if (error)
1210		return error;
1211
1212	size = sysfs_emit(buf, "gen%d %s\n",
1213			  cyapa->gen, cyapa_state_to_string(cyapa));
1214
1215	mutex_unlock(&cyapa->state_sync_lock);
1216	return size;
1217}
1218
1219static DEVICE_ATTR(firmware_version, S_IRUGO, cyapa_show_fm_ver, NULL);
1220static DEVICE_ATTR(product_id, S_IRUGO, cyapa_show_product_id, NULL);
1221static DEVICE_ATTR(update_fw, S_IWUSR, NULL, cyapa_update_fw_store);
1222static DEVICE_ATTR(baseline, S_IRUGO, cyapa_show_baseline, NULL);
1223static DEVICE_ATTR(calibrate, S_IWUSR, NULL, cyapa_calibrate_store);
1224static DEVICE_ATTR(mode, S_IRUGO, cyapa_show_mode, NULL);
1225
1226static struct attribute *cyapa_attrs[] = {
1227	&dev_attr_firmware_version.attr,
1228	&dev_attr_product_id.attr,
1229	&dev_attr_update_fw.attr,
1230	&dev_attr_baseline.attr,
1231	&dev_attr_calibrate.attr,
1232	&dev_attr_mode.attr,
1233	NULL,
1234};
1235ATTRIBUTE_GROUPS(cyapa);
 
 
 
 
 
 
 
 
 
 
1236
1237static void cyapa_disable_regulator(void *data)
1238{
1239	struct cyapa *cyapa = data;
1240
1241	regulator_disable(cyapa->vcc);
1242}
1243
1244static int cyapa_probe(struct i2c_client *client)
 
1245{
1246	struct device *dev = &client->dev;
1247	struct cyapa *cyapa;
1248	u8 adapter_func;
1249	union i2c_smbus_data dummy;
1250	int error;
1251
1252	adapter_func = cyapa_check_adapter_functionality(client);
1253	if (adapter_func == CYAPA_ADAPTER_FUNC_NONE) {
1254		dev_err(dev, "not a supported I2C/SMBus adapter\n");
1255		return -EIO;
1256	}
1257
1258	/* Make sure there is something at this address */
1259	if (i2c_smbus_xfer(client->adapter, client->addr, 0,
1260			I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0)
1261		return -ENODEV;
1262
1263	cyapa = devm_kzalloc(dev, sizeof(struct cyapa), GFP_KERNEL);
1264	if (!cyapa)
1265		return -ENOMEM;
1266
1267	/* i2c isn't supported, use smbus */
1268	if (adapter_func == CYAPA_ADAPTER_FUNC_SMBUS)
1269		cyapa->smbus = true;
1270
1271	cyapa->client = client;
1272	i2c_set_clientdata(client, cyapa);
1273	sprintf(cyapa->phys, "i2c-%d-%04x/input0", client->adapter->nr,
1274		client->addr);
1275
1276	cyapa->vcc = devm_regulator_get(dev, "vcc");
1277	if (IS_ERR(cyapa->vcc)) {
1278		error = PTR_ERR(cyapa->vcc);
1279		dev_err(dev, "failed to get vcc regulator: %d\n", error);
1280		return error;
1281	}
1282
1283	error = regulator_enable(cyapa->vcc);
1284	if (error) {
1285		dev_err(dev, "failed to enable regulator: %d\n", error);
1286		return error;
1287	}
1288
1289	error = devm_add_action_or_reset(dev, cyapa_disable_regulator, cyapa);
1290	if (error) {
 
1291		dev_err(dev, "failed to add disable regulator action: %d\n",
1292			error);
1293		return error;
1294	}
1295
1296	error = cyapa_initialize(cyapa);
1297	if (error) {
1298		dev_err(dev, "failed to detect and initialize tp device.\n");
1299		return error;
1300	}
1301
 
 
 
 
 
 
 
 
 
 
 
 
 
1302	error = cyapa_prepare_wakeup_controls(cyapa);
1303	if (error) {
1304		dev_err(dev, "failed to prepare wakeup controls: %d\n", error);
1305		return error;
1306	}
1307
1308	error = cyapa_start_runtime(cyapa);
1309	if (error) {
1310		dev_err(dev, "failed to start pm_runtime: %d\n", error);
1311		return error;
1312	}
1313
1314	error = devm_request_threaded_irq(dev, client->irq,
1315					  NULL, cyapa_irq,
1316					  IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1317					  "cyapa", cyapa);
1318	if (error) {
1319		dev_err(dev, "failed to request threaded irq: %d\n", error);
1320		return error;
1321	}
1322
1323	/* Disable IRQ until the device is opened */
1324	disable_irq(client->irq);
1325
1326	/*
1327	 * Register the device in the input subsystem when it's operational.
1328	 * Otherwise, keep in this driver, so it can be be recovered or updated
1329	 * through the sysfs mode and update_fw interfaces by user or apps.
1330	 */
1331	if (cyapa->operational) {
1332		error = cyapa_create_input_dev(cyapa);
1333		if (error) {
1334			dev_err(dev, "create input_dev instance failed: %d\n",
1335					error);
1336			return error;
1337		}
1338	}
1339
1340	return 0;
1341}
1342
1343static int cyapa_suspend(struct device *dev)
1344{
1345	struct i2c_client *client = to_i2c_client(dev);
1346	struct cyapa *cyapa = i2c_get_clientdata(client);
1347	u8 power_mode;
1348	int error;
1349
1350	error = mutex_lock_interruptible(&cyapa->state_sync_lock);
1351	if (error)
1352		return error;
1353
1354	/*
1355	 * Runtime PM is enable only when device is in operational mode and
1356	 * users in use, so need check it before disable it to
1357	 * avoid unbalance warning.
1358	 */
1359	if (pm_runtime_enabled(dev))
1360		pm_runtime_disable(dev);
1361	disable_irq(client->irq);
1362
1363	/*
1364	 * Set trackpad device to idle mode if wakeup is allowed,
1365	 * otherwise turn off.
1366	 */
1367	if (cyapa->operational) {
1368		power_mode = device_may_wakeup(dev) ? cyapa->suspend_power_mode
1369						    : PWR_MODE_OFF;
1370		error = cyapa->ops->set_power_mode(cyapa, power_mode,
1371				cyapa->suspend_sleep_time, CYAPA_PM_SUSPEND);
1372		if (error)
1373			dev_err(dev, "suspend set power mode failed: %d\n",
1374					error);
1375	}
1376
1377	/*
1378	 * Disable proximity interrupt when system idle, want true touch to
1379	 * wake the system.
1380	 */
1381	if (cyapa->dev_pwr_mode != PWR_MODE_OFF)
1382		cyapa->ops->set_proximity(cyapa, false);
1383
1384	if (device_may_wakeup(dev))
1385		cyapa->irq_wake = (enable_irq_wake(client->irq) == 0);
1386
1387	mutex_unlock(&cyapa->state_sync_lock);
1388	return 0;
1389}
1390
1391static int cyapa_resume(struct device *dev)
1392{
1393	struct i2c_client *client = to_i2c_client(dev);
1394	struct cyapa *cyapa = i2c_get_clientdata(client);
1395	int error;
1396
1397	mutex_lock(&cyapa->state_sync_lock);
1398
1399	if (device_may_wakeup(dev) && cyapa->irq_wake) {
1400		disable_irq_wake(client->irq);
1401		cyapa->irq_wake = false;
1402	}
1403
1404	/*
1405	 * Update device states and runtime PM states.
1406	 * Re-Enable proximity interrupt after enter operational mode.
1407	 */
1408	error = cyapa_reinitialize(cyapa);
1409	if (error)
1410		dev_warn(dev, "failed to reinitialize TP device: %d\n", error);
1411
1412	enable_irq(client->irq);
1413
1414	mutex_unlock(&cyapa->state_sync_lock);
1415	return 0;
1416}
1417
1418static int cyapa_runtime_suspend(struct device *dev)
1419{
1420	struct cyapa *cyapa = dev_get_drvdata(dev);
1421	int error;
1422
1423	error = cyapa->ops->set_power_mode(cyapa,
1424			cyapa->runtime_suspend_power_mode,
1425			cyapa->runtime_suspend_sleep_time,
1426			CYAPA_PM_RUNTIME_SUSPEND);
1427	if (error)
1428		dev_warn(dev, "runtime suspend failed: %d\n", error);
1429
1430	return 0;
1431}
1432
1433static int cyapa_runtime_resume(struct device *dev)
1434{
1435	struct cyapa *cyapa = dev_get_drvdata(dev);
1436	int error;
1437
1438	error = cyapa->ops->set_power_mode(cyapa,
1439			PWR_MODE_FULL_ACTIVE, 0, CYAPA_PM_RUNTIME_RESUME);
1440	if (error)
1441		dev_warn(dev, "runtime resume failed: %d\n", error);
1442
1443	return 0;
1444}
1445
1446static const struct dev_pm_ops cyapa_pm_ops = {
1447	SYSTEM_SLEEP_PM_OPS(cyapa_suspend, cyapa_resume)
1448	RUNTIME_PM_OPS(cyapa_runtime_suspend, cyapa_runtime_resume, NULL)
1449};
1450
1451static const struct i2c_device_id cyapa_id_table[] = {
1452	{ "cyapa", 0 },
1453	{ },
1454};
1455MODULE_DEVICE_TABLE(i2c, cyapa_id_table);
1456
1457#ifdef CONFIG_ACPI
1458static const struct acpi_device_id cyapa_acpi_id[] = {
1459	{ "CYAP0000", 0 },  /* Gen3 trackpad with 0x67 I2C address. */
1460	{ "CYAP0001", 0 },  /* Gen5 trackpad with 0x24 I2C address. */
1461	{ "CYAP0002", 0 },  /* Gen6 trackpad with 0x24 I2C address. */
1462	{ }
1463};
1464MODULE_DEVICE_TABLE(acpi, cyapa_acpi_id);
1465#endif
1466
1467#ifdef CONFIG_OF
1468static const struct of_device_id cyapa_of_match[] = {
1469	{ .compatible = "cypress,cyapa" },
1470	{ /* sentinel */ }
1471};
1472MODULE_DEVICE_TABLE(of, cyapa_of_match);
1473#endif
1474
1475static struct i2c_driver cyapa_driver = {
1476	.driver = {
1477		.name = "cyapa",
1478		.dev_groups = cyapa_groups,
1479		.pm = pm_ptr(&cyapa_pm_ops),
1480		.acpi_match_table = ACPI_PTR(cyapa_acpi_id),
1481		.of_match_table = of_match_ptr(cyapa_of_match),
1482	},
1483
1484	.probe = cyapa_probe,
1485	.id_table = cyapa_id_table,
1486};
1487
1488module_i2c_driver(cyapa_driver);
1489
1490MODULE_DESCRIPTION("Cypress APA I2C Trackpad Driver");
1491MODULE_AUTHOR("Dudley Du <dudl@cypress.com>");
1492MODULE_LICENSE("GPL");