1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * AD714X CapTouch Programmable Controller driver supporting AD7142/3/7/8/7A
   4 *
   5 * Copyright 2009-2011 Analog Devices Inc.
   6 */
   7
   8#include <linux/device.h>
   9#include <linux/input.h>
  10#include <linux/interrupt.h>
  11#include <linux/slab.h>
  12#include <linux/input/ad714x.h>
  13#include <linux/module.h>
  14#include "ad714x.h"
  15
  16#define AD714X_PWR_CTRL           0x0
  17#define AD714X_STG_CAL_EN_REG     0x1
  18#define AD714X_AMB_COMP_CTRL0_REG 0x2
  19#define AD714X_PARTID_REG         0x17
  20#define AD7142_PARTID             0xE620
  21#define AD7143_PARTID             0xE630
  22#define AD7147_PARTID             0x1470
  23#define AD7148_PARTID             0x1480
  24#define AD714X_STAGECFG_REG       0x80
  25#define AD714X_SYSCFG_REG         0x0
  26
  27#define STG_LOW_INT_EN_REG     0x5
  28#define STG_HIGH_INT_EN_REG    0x6
  29#define STG_COM_INT_EN_REG     0x7
  30#define STG_LOW_INT_STA_REG    0x8
  31#define STG_HIGH_INT_STA_REG   0x9
  32#define STG_COM_INT_STA_REG    0xA
  33
  34#define CDC_RESULT_S0          0xB
  35#define CDC_RESULT_S1          0xC
  36#define CDC_RESULT_S2          0xD
  37#define CDC_RESULT_S3          0xE
  38#define CDC_RESULT_S4          0xF
  39#define CDC_RESULT_S5          0x10
  40#define CDC_RESULT_S6          0x11
  41#define CDC_RESULT_S7          0x12
  42#define CDC_RESULT_S8          0x13
  43#define CDC_RESULT_S9          0x14
  44#define CDC_RESULT_S10         0x15
  45#define CDC_RESULT_S11         0x16
  46
  47#define STAGE0_AMBIENT		0xF1
  48#define STAGE1_AMBIENT		0x115
  49#define STAGE2_AMBIENT		0x139
  50#define STAGE3_AMBIENT		0x15D
  51#define STAGE4_AMBIENT		0x181
  52#define STAGE5_AMBIENT		0x1A5
  53#define STAGE6_AMBIENT		0x1C9
  54#define STAGE7_AMBIENT		0x1ED
  55#define STAGE8_AMBIENT		0x211
  56#define STAGE9_AMBIENT		0x234
  57#define STAGE10_AMBIENT		0x259
  58#define STAGE11_AMBIENT		0x27D
  59
  60#define PER_STAGE_REG_NUM      36
  61#define STAGE_CFGREG_NUM       8
  62#define SYS_CFGREG_NUM         8
  63
  64/*
  65 * driver information which will be used to maintain the software flow
  66 */
  67enum ad714x_device_state { IDLE, JITTER, ACTIVE, SPACE };
  68
  69struct ad714x_slider_drv {
  70	int highest_stage;
  71	int abs_pos;
  72	int flt_pos;
  73	enum ad714x_device_state state;
  74	struct input_dev *input;
  75};
  76
  77struct ad714x_wheel_drv {
  78	int abs_pos;
  79	int flt_pos;
  80	int pre_highest_stage;
  81	int highest_stage;
  82	enum ad714x_device_state state;
  83	struct input_dev *input;
  84};
  85
  86struct ad714x_touchpad_drv {
  87	int x_highest_stage;
  88	int x_flt_pos;
  89	int x_abs_pos;
  90	int y_highest_stage;
  91	int y_flt_pos;
  92	int y_abs_pos;
  93	int left_ep;
  94	int left_ep_val;
  95	int right_ep;
  96	int right_ep_val;
  97	int top_ep;
  98	int top_ep_val;
  99	int bottom_ep;
 100	int bottom_ep_val;
 101	enum ad714x_device_state state;
 102	struct input_dev *input;
 103};
 104
 105struct ad714x_button_drv {
 106	enum ad714x_device_state state;
 107	/*
 108	 * Unlike slider/wheel/touchpad, all buttons point to
 109	 * same input_dev instance
 110	 */
 111	struct input_dev *input;
 112};
 113
 114struct ad714x_driver_data {
 115	struct ad714x_slider_drv *slider;
 116	struct ad714x_wheel_drv *wheel;
 117	struct ad714x_touchpad_drv *touchpad;
 118	struct ad714x_button_drv *button;
 119};
 120
 121/*
 122 * information to integrate all things which will be private data
 123 * of spi/i2c device
 124 */
 125
 126static void ad714x_use_com_int(struct ad714x_chip *ad714x,
 127				int start_stage, int end_stage)
 128{
 129	unsigned short data;
 130	unsigned short mask;
 131
 132	mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
 133
 134	ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
 135	data |= 1 << end_stage;
 136	ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
 137
 138	ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
 139	data &= ~mask;
 140	ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
 141}
 142
 143static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
 144				int start_stage, int end_stage)
 145{
 146	unsigned short data;
 147	unsigned short mask;
 148
 149	mask = ((1 << (end_stage + 1)) - 1) - ((1 << start_stage) - 1);
 150
 151	ad714x->read(ad714x, STG_COM_INT_EN_REG, &data, 1);
 152	data &= ~(1 << end_stage);
 153	ad714x->write(ad714x, STG_COM_INT_EN_REG, data);
 154
 155	ad714x->read(ad714x, STG_HIGH_INT_EN_REG, &data, 1);
 156	data |= mask;
 157	ad714x->write(ad714x, STG_HIGH_INT_EN_REG, data);
 158}
 159
 160static int ad714x_cal_highest_stage(struct ad714x_chip *ad714x,
 161					int start_stage, int end_stage)
 162{
 163	int max_res = 0;
 164	int max_idx = 0;
 165	int i;
 166
 167	for (i = start_stage; i <= end_stage; i++) {
 168		if (ad714x->sensor_val[i] > max_res) {
 169			max_res = ad714x->sensor_val[i];
 170			max_idx = i;
 171		}
 172	}
 173
 174	return max_idx;
 175}
 176
 177static int ad714x_cal_abs_pos(struct ad714x_chip *ad714x,
 178				int start_stage, int end_stage,
 179				int highest_stage, int max_coord)
 180{
 181	int a_param, b_param;
 182
 183	if (highest_stage == start_stage) {
 184		a_param = ad714x->sensor_val[start_stage + 1];
 185		b_param = ad714x->sensor_val[start_stage] +
 186			ad714x->sensor_val[start_stage + 1];
 187	} else if (highest_stage == end_stage) {
 188		a_param = ad714x->sensor_val[end_stage] *
 189			(end_stage - start_stage) +
 190			ad714x->sensor_val[end_stage - 1] *
 191			(end_stage - start_stage - 1);
 192		b_param = ad714x->sensor_val[end_stage] +
 193			ad714x->sensor_val[end_stage - 1];
 194	} else {
 195		a_param = ad714x->sensor_val[highest_stage] *
 196			(highest_stage - start_stage) +
 197			ad714x->sensor_val[highest_stage - 1] *
 198			(highest_stage - start_stage - 1) +
 199			ad714x->sensor_val[highest_stage + 1] *
 200			(highest_stage - start_stage + 1);
 201		b_param = ad714x->sensor_val[highest_stage] +
 202			ad714x->sensor_val[highest_stage - 1] +
 203			ad714x->sensor_val[highest_stage + 1];
 204	}
 205
 206	return (max_coord / (end_stage - start_stage)) * a_param / b_param;
 207}
 208
 209/*
 210 * One button can connect to multi positive and negative of CDCs
 211 * Multi-buttons can connect to same positive/negative of one CDC
 212 */
 213static void ad714x_button_state_machine(struct ad714x_chip *ad714x, int idx)
 214{
 215	struct ad714x_button_plat *hw = &ad714x->hw->button[idx];
 216	struct ad714x_button_drv *sw = &ad714x->sw->button[idx];
 217
 218	switch (sw->state) {
 219	case IDLE:
 220		if (((ad714x->h_state & hw->h_mask) == hw->h_mask) &&
 221		    ((ad714x->l_state & hw->l_mask) == hw->l_mask)) {
 222			dev_dbg(ad714x->dev, "button %d touched\n", idx);
 223			input_report_key(sw->input, hw->keycode, 1);
 224			input_sync(sw->input);
 225			sw->state = ACTIVE;
 226		}
 227		break;
 228
 229	case ACTIVE:
 230		if (((ad714x->h_state & hw->h_mask) != hw->h_mask) ||
 231		    ((ad714x->l_state & hw->l_mask) != hw->l_mask)) {
 232			dev_dbg(ad714x->dev, "button %d released\n", idx);
 233			input_report_key(sw->input, hw->keycode, 0);
 234			input_sync(sw->input);
 235			sw->state = IDLE;
 236		}
 237		break;
 238
 239	default:
 240		break;
 241	}
 242}
 243
 244/*
 245 * The response of a sensor is defined by the absolute number of codes
 246 * between the current CDC value and the ambient value.
 247 */
 248static void ad714x_slider_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
 249{
 250	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 251	int i;
 252
 253	ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
 254			&ad714x->adc_reg[hw->start_stage],
 255			hw->end_stage - hw->start_stage + 1);
 256
 257	for (i = hw->start_stage; i <= hw->end_stage; i++) {
 258		ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
 259				&ad714x->amb_reg[i], 1);
 260
 261		ad714x->sensor_val[i] =
 262			abs(ad714x->adc_reg[i] - ad714x->amb_reg[i]);
 263	}
 264}
 265
 266static void ad714x_slider_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
 267{
 268	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 269	struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
 270
 271	sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
 272			hw->end_stage);
 273
 274	dev_dbg(ad714x->dev, "slider %d highest_stage:%d\n", idx,
 275		sw->highest_stage);
 276}
 277
 278/*
 279 * The formulae are very straight forward. It uses the sensor with the
 280 * highest response and the 2 adjacent ones.
 281 * When Sensor 0 has the highest response, only sensor 0 and sensor 1
 282 * are used in the calculations. Similarly when the last sensor has the
 283 * highest response, only the last sensor and the second last sensors
 284 * are used in the calculations.
 285 *
 286 * For i= idx_of_peak_Sensor-1 to i= idx_of_peak_Sensor+1
 287 *         v += Sensor response(i)*i
 288 *         w += Sensor response(i)
 289 * POS=(Number_of_Positions_Wanted/(Number_of_Sensors_Used-1)) *(v/w)
 290 */
 291static void ad714x_slider_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
 292{
 293	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 294	struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
 295
 296	sw->abs_pos = ad714x_cal_abs_pos(ad714x, hw->start_stage, hw->end_stage,
 297		sw->highest_stage, hw->max_coord);
 298
 299	dev_dbg(ad714x->dev, "slider %d absolute position:%d\n", idx,
 300		sw->abs_pos);
 301}
 302
 303/*
 304 * To minimise the Impact of the noise on the algorithm, ADI developed a
 305 * routine that filters the CDC results after they have been read by the
 306 * host processor.
 307 * The filter used is an Infinite Input Response(IIR) filter implemented
 308 * in firmware and attenuates the noise on the CDC results after they've
 309 * been read by the host processor.
 310 * Filtered_CDC_result = (Filtered_CDC_result * (10 - Coefficient) +
 311 *				Latest_CDC_result * Coefficient)/10
 312 */
 313static void ad714x_slider_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
 314{
 315	struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
 316
 317	sw->flt_pos = (sw->flt_pos * (10 - 4) +
 318			sw->abs_pos * 4)/10;
 319
 320	dev_dbg(ad714x->dev, "slider %d filter position:%d\n", idx,
 321		sw->flt_pos);
 322}
 323
 324static void ad714x_slider_use_com_int(struct ad714x_chip *ad714x, int idx)
 325{
 326	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 327
 328	ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
 329}
 330
 331static void ad714x_slider_use_thr_int(struct ad714x_chip *ad714x, int idx)
 332{
 333	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 334
 335	ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
 336}
 337
 338static void ad714x_slider_state_machine(struct ad714x_chip *ad714x, int idx)
 339{
 340	struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 341	struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
 342	unsigned short h_state, c_state;
 343	unsigned short mask;
 344
 345	mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
 346
 347	h_state = ad714x->h_state & mask;
 348	c_state = ad714x->c_state & mask;
 349
 350	switch (sw->state) {
 351	case IDLE:
 352		if (h_state) {
 353			sw->state = JITTER;
 354			/* In End of Conversion interrupt mode, the AD714X
 355			 * continuously generates hardware interrupts.
 356			 */
 357			ad714x_slider_use_com_int(ad714x, idx);
 358			dev_dbg(ad714x->dev, "slider %d touched\n", idx);
 359		}
 360		break;
 361
 362	case JITTER:
 363		if (c_state == mask) {
 364			ad714x_slider_cal_sensor_val(ad714x, idx);
 365			ad714x_slider_cal_highest_stage(ad714x, idx);
 366			ad714x_slider_cal_abs_pos(ad714x, idx);
 367			sw->flt_pos = sw->abs_pos;
 368			sw->state = ACTIVE;
 369		}
 370		break;
 371
 372	case ACTIVE:
 373		if (c_state == mask) {
 374			if (h_state) {
 375				ad714x_slider_cal_sensor_val(ad714x, idx);
 376				ad714x_slider_cal_highest_stage(ad714x, idx);
 377				ad714x_slider_cal_abs_pos(ad714x, idx);
 378				ad714x_slider_cal_flt_pos(ad714x, idx);
 379				input_report_abs(sw->input, ABS_X, sw->flt_pos);
 380				input_report_key(sw->input, BTN_TOUCH, 1);
 381			} else {
 382				/* When the user lifts off the sensor, configure
 383				 * the AD714X back to threshold interrupt mode.
 384				 */
 385				ad714x_slider_use_thr_int(ad714x, idx);
 386				sw->state = IDLE;
 387				input_report_key(sw->input, BTN_TOUCH, 0);
 388				dev_dbg(ad714x->dev, "slider %d released\n",
 389					idx);
 390			}
 391			input_sync(sw->input);
 392		}
 393		break;
 394
 395	default:
 396		break;
 397	}
 398}
 399
 400/*
 401 * When the scroll wheel is activated, we compute the absolute position based
 402 * on the sensor values. To calculate the position, we first determine the
 403 * sensor that has the greatest response among the 8 sensors that constitutes
 404 * the scrollwheel. Then we determined the 2 sensors on either sides of the
 405 * sensor with the highest response and we apply weights to these sensors.
 406 */
 407static void ad714x_wheel_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
 408{
 409	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 410	struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
 411
 412	sw->pre_highest_stage = sw->highest_stage;
 413	sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
 414			hw->end_stage);
 415
 416	dev_dbg(ad714x->dev, "wheel %d highest_stage:%d\n", idx,
 417		sw->highest_stage);
 418}
 419
 420static void ad714x_wheel_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
 421{
 422	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 423	int i;
 424
 425	ad714x->read(ad714x, CDC_RESULT_S0 + hw->start_stage,
 426			&ad714x->adc_reg[hw->start_stage],
 427			hw->end_stage - hw->start_stage + 1);
 428
 429	for (i = hw->start_stage; i <= hw->end_stage; i++) {
 430		ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
 431				&ad714x->amb_reg[i], 1);
 432		if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
 433			ad714x->sensor_val[i] =
 434				ad714x->adc_reg[i] - ad714x->amb_reg[i];
 435		else
 436			ad714x->sensor_val[i] = 0;
 437	}
 438}
 439
 440/*
 441 * When the scroll wheel is activated, we compute the absolute position based
 442 * on the sensor values. To calculate the position, we first determine the
 443 * sensor that has the greatest response among the sensors that constitutes
 444 * the scrollwheel. Then we determined the sensors on either sides of the
 445 * sensor with the highest response and we apply weights to these sensors. The
 446 * result of this computation gives us the mean value.
 447 */
 448
 449static void ad714x_wheel_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
 450{
 451	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 452	struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
 453	int stage_num = hw->end_stage - hw->start_stage + 1;
 454	int first_before, highest, first_after;
 455	int a_param, b_param;
 456
 457	first_before = (sw->highest_stage + stage_num - 1) % stage_num;
 458	highest = sw->highest_stage;
 459	first_after = (sw->highest_stage + stage_num + 1) % stage_num;
 460
 461	a_param = ad714x->sensor_val[highest] *
 462		(highest - hw->start_stage) +
 463		ad714x->sensor_val[first_before] *
 464		(highest - hw->start_stage - 1) +
 465		ad714x->sensor_val[first_after] *
 466		(highest - hw->start_stage + 1);
 467	b_param = ad714x->sensor_val[highest] +
 468		ad714x->sensor_val[first_before] +
 469		ad714x->sensor_val[first_after];
 470
 471	sw->abs_pos = ((hw->max_coord / (hw->end_stage - hw->start_stage)) *
 472			a_param) / b_param;
 473
 474	if (sw->abs_pos > hw->max_coord)
 475		sw->abs_pos = hw->max_coord;
 476	else if (sw->abs_pos < 0)
 477		sw->abs_pos = 0;
 478}
 479
 480static void ad714x_wheel_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
 481{
 482	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 483	struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
 484	if (((sw->pre_highest_stage == hw->end_stage) &&
 485			(sw->highest_stage == hw->start_stage)) ||
 486	    ((sw->pre_highest_stage == hw->start_stage) &&
 487			(sw->highest_stage == hw->end_stage)))
 488		sw->flt_pos = sw->abs_pos;
 489	else
 490		sw->flt_pos = ((sw->flt_pos * 30) + (sw->abs_pos * 71)) / 100;
 491
 492	if (sw->flt_pos > hw->max_coord)
 493		sw->flt_pos = hw->max_coord;
 494}
 495
 496static void ad714x_wheel_use_com_int(struct ad714x_chip *ad714x, int idx)
 497{
 498	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 499
 500	ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
 501}
 502
 503static void ad714x_wheel_use_thr_int(struct ad714x_chip *ad714x, int idx)
 504{
 505	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 506
 507	ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
 508}
 509
 510static void ad714x_wheel_state_machine(struct ad714x_chip *ad714x, int idx)
 511{
 512	struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 513	struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
 514	unsigned short h_state, c_state;
 515	unsigned short mask;
 516
 517	mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
 518
 519	h_state = ad714x->h_state & mask;
 520	c_state = ad714x->c_state & mask;
 521
 522	switch (sw->state) {
 523	case IDLE:
 524		if (h_state) {
 525			sw->state = JITTER;
 526			/* In End of Conversion interrupt mode, the AD714X
 527			 * continuously generates hardware interrupts.
 528			 */
 529			ad714x_wheel_use_com_int(ad714x, idx);
 530			dev_dbg(ad714x->dev, "wheel %d touched\n", idx);
 531		}
 532		break;
 533
 534	case JITTER:
 535		if (c_state == mask)	{
 536			ad714x_wheel_cal_sensor_val(ad714x, idx);
 537			ad714x_wheel_cal_highest_stage(ad714x, idx);
 538			ad714x_wheel_cal_abs_pos(ad714x, idx);
 539			sw->flt_pos = sw->abs_pos;
 540			sw->state = ACTIVE;
 541		}
 542		break;
 543
 544	case ACTIVE:
 545		if (c_state == mask) {
 546			if (h_state) {
 547				ad714x_wheel_cal_sensor_val(ad714x, idx);
 548				ad714x_wheel_cal_highest_stage(ad714x, idx);
 549				ad714x_wheel_cal_abs_pos(ad714x, idx);
 550				ad714x_wheel_cal_flt_pos(ad714x, idx);
 551				input_report_abs(sw->input, ABS_WHEEL,
 552					sw->flt_pos);
 553				input_report_key(sw->input, BTN_TOUCH, 1);
 554			} else {
 555				/* When the user lifts off the sensor, configure
 556				 * the AD714X back to threshold interrupt mode.
 557				 */
 558				ad714x_wheel_use_thr_int(ad714x, idx);
 559				sw->state = IDLE;
 560				input_report_key(sw->input, BTN_TOUCH, 0);
 561
 562				dev_dbg(ad714x->dev, "wheel %d released\n",
 563					idx);
 564			}
 565			input_sync(sw->input);
 566		}
 567		break;
 568
 569	default:
 570		break;
 571	}
 572}
 573
 574static void touchpad_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
 575{
 576	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 577	int i;
 578
 579	ad714x->read(ad714x, CDC_RESULT_S0 + hw->x_start_stage,
 580			&ad714x->adc_reg[hw->x_start_stage],
 581			hw->x_end_stage - hw->x_start_stage + 1);
 582
 583	for (i = hw->x_start_stage; i <= hw->x_end_stage; i++) {
 584		ad714x->read(ad714x, STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
 585				&ad714x->amb_reg[i], 1);
 586		if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
 587			ad714x->sensor_val[i] =
 588				ad714x->adc_reg[i] - ad714x->amb_reg[i];
 589		else
 590			ad714x->sensor_val[i] = 0;
 591	}
 592}
 593
 594static void touchpad_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
 595{
 596	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 597	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 598
 599	sw->x_highest_stage = ad714x_cal_highest_stage(ad714x,
 600		hw->x_start_stage, hw->x_end_stage);
 601	sw->y_highest_stage = ad714x_cal_highest_stage(ad714x,
 602		hw->y_start_stage, hw->y_end_stage);
 603
 604	dev_dbg(ad714x->dev,
 605		"touchpad %d x_highest_stage:%d, y_highest_stage:%d\n",
 606		idx, sw->x_highest_stage, sw->y_highest_stage);
 607}
 608
 609/*
 610 * If 2 fingers are touching the sensor then 2 peaks can be observed in the
 611 * distribution.
 612 * The arithmetic doesn't support to get absolute coordinates for multi-touch
 613 * yet.
 614 */
 615static int touchpad_check_second_peak(struct ad714x_chip *ad714x, int idx)
 616{
 617	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 618	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 619	int i;
 620
 621	for (i = hw->x_start_stage; i < sw->x_highest_stage; i++) {
 622		if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
 623			> (ad714x->sensor_val[i + 1] / 10))
 624			return 1;
 625	}
 626
 627	for (i = sw->x_highest_stage; i < hw->x_end_stage; i++) {
 628		if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
 629			> (ad714x->sensor_val[i] / 10))
 630			return 1;
 631	}
 632
 633	for (i = hw->y_start_stage; i < sw->y_highest_stage; i++) {
 634		if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
 635			> (ad714x->sensor_val[i + 1] / 10))
 636			return 1;
 637	}
 638
 639	for (i = sw->y_highest_stage; i < hw->y_end_stage; i++) {
 640		if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
 641			> (ad714x->sensor_val[i] / 10))
 642			return 1;
 643	}
 644
 645	return 0;
 646}
 647
 648/*
 649 * If only one finger is used to activate the touch pad then only 1 peak will be
 650 * registered in the distribution. This peak and the 2 adjacent sensors will be
 651 * used in the calculation of the absolute position. This will prevent hand
 652 * shadows to affect the absolute position calculation.
 653 */
 654static void touchpad_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
 655{
 656	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 657	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 658
 659	sw->x_abs_pos = ad714x_cal_abs_pos(ad714x, hw->x_start_stage,
 660			hw->x_end_stage, sw->x_highest_stage, hw->x_max_coord);
 661	sw->y_abs_pos = ad714x_cal_abs_pos(ad714x, hw->y_start_stage,
 662			hw->y_end_stage, sw->y_highest_stage, hw->y_max_coord);
 663
 664	dev_dbg(ad714x->dev, "touchpad %d absolute position:(%d, %d)\n", idx,
 665			sw->x_abs_pos, sw->y_abs_pos);
 666}
 667
 668static void touchpad_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
 669{
 670	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 671
 672	sw->x_flt_pos = (sw->x_flt_pos * (10 - 4) +
 673			sw->x_abs_pos * 4)/10;
 674	sw->y_flt_pos = (sw->y_flt_pos * (10 - 4) +
 675			sw->y_abs_pos * 4)/10;
 676
 677	dev_dbg(ad714x->dev, "touchpad %d filter position:(%d, %d)\n",
 678			idx, sw->x_flt_pos, sw->y_flt_pos);
 679}
 680
 681/*
 682 * To prevent distortion from showing in the absolute position, it is
 683 * necessary to detect the end points. When endpoints are detected, the
 684 * driver stops updating the status variables with absolute positions.
 685 * End points are detected on the 4 edges of the touchpad sensor. The
 686 * method to detect them is the same for all 4.
 687 * To detect the end points, the firmware computes the difference in
 688 * percent between the sensor on the edge and the adjacent one. The
 689 * difference is calculated in percent in order to make the end point
 690 * detection independent of the pressure.
 691 */
 692
 693#define LEFT_END_POINT_DETECTION_LEVEL                  550
 694#define RIGHT_END_POINT_DETECTION_LEVEL                 750
 695#define LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL         850
 696#define TOP_END_POINT_DETECTION_LEVEL                   550
 697#define BOTTOM_END_POINT_DETECTION_LEVEL                950
 698#define TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL         700
 699static int touchpad_check_endpoint(struct ad714x_chip *ad714x, int idx)
 700{
 701	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 702	struct ad714x_touchpad_drv *sw  = &ad714x->sw->touchpad[idx];
 703	int percent_sensor_diff;
 704
 705	/* left endpoint detect */
 706	percent_sensor_diff = (ad714x->sensor_val[hw->x_start_stage] -
 707			ad714x->sensor_val[hw->x_start_stage + 1]) * 100 /
 708			ad714x->sensor_val[hw->x_start_stage + 1];
 709	if (!sw->left_ep) {
 710		if (percent_sensor_diff >= LEFT_END_POINT_DETECTION_LEVEL)  {
 711			sw->left_ep = 1;
 712			sw->left_ep_val =
 713				ad714x->sensor_val[hw->x_start_stage + 1];
 714		}
 715	} else {
 716		if ((percent_sensor_diff < LEFT_END_POINT_DETECTION_LEVEL) &&
 717		    (ad714x->sensor_val[hw->x_start_stage + 1] >
 718		     LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->left_ep_val))
 719			sw->left_ep = 0;
 720	}
 721
 722	/* right endpoint detect */
 723	percent_sensor_diff = (ad714x->sensor_val[hw->x_end_stage] -
 724			ad714x->sensor_val[hw->x_end_stage - 1]) * 100 /
 725			ad714x->sensor_val[hw->x_end_stage - 1];
 726	if (!sw->right_ep) {
 727		if (percent_sensor_diff >= RIGHT_END_POINT_DETECTION_LEVEL)  {
 728			sw->right_ep = 1;
 729			sw->right_ep_val =
 730				ad714x->sensor_val[hw->x_end_stage - 1];
 731		}
 732	} else {
 733		if ((percent_sensor_diff < RIGHT_END_POINT_DETECTION_LEVEL) &&
 734		(ad714x->sensor_val[hw->x_end_stage - 1] >
 735		LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->right_ep_val))
 736			sw->right_ep = 0;
 737	}
 738
 739	/* top endpoint detect */
 740	percent_sensor_diff = (ad714x->sensor_val[hw->y_start_stage] -
 741			ad714x->sensor_val[hw->y_start_stage + 1]) * 100 /
 742			ad714x->sensor_val[hw->y_start_stage + 1];
 743	if (!sw->top_ep) {
 744		if (percent_sensor_diff >= TOP_END_POINT_DETECTION_LEVEL)  {
 745			sw->top_ep = 1;
 746			sw->top_ep_val =
 747				ad714x->sensor_val[hw->y_start_stage + 1];
 748		}
 749	} else {
 750		if ((percent_sensor_diff < TOP_END_POINT_DETECTION_LEVEL) &&
 751		(ad714x->sensor_val[hw->y_start_stage + 1] >
 752		TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->top_ep_val))
 753			sw->top_ep = 0;
 754	}
 755
 756	/* bottom endpoint detect */
 757	percent_sensor_diff = (ad714x->sensor_val[hw->y_end_stage] -
 758		ad714x->sensor_val[hw->y_end_stage - 1]) * 100 /
 759		ad714x->sensor_val[hw->y_end_stage - 1];
 760	if (!sw->bottom_ep) {
 761		if (percent_sensor_diff >= BOTTOM_END_POINT_DETECTION_LEVEL)  {
 762			sw->bottom_ep = 1;
 763			sw->bottom_ep_val =
 764				ad714x->sensor_val[hw->y_end_stage - 1];
 765		}
 766	} else {
 767		if ((percent_sensor_diff < BOTTOM_END_POINT_DETECTION_LEVEL) &&
 768		(ad714x->sensor_val[hw->y_end_stage - 1] >
 769		 TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->bottom_ep_val))
 770			sw->bottom_ep = 0;
 771	}
 772
 773	return sw->left_ep || sw->right_ep || sw->top_ep || sw->bottom_ep;
 774}
 775
 776static void touchpad_use_com_int(struct ad714x_chip *ad714x, int idx)
 777{
 778	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 779
 780	ad714x_use_com_int(ad714x, hw->x_start_stage, hw->x_end_stage);
 781}
 782
 783static void touchpad_use_thr_int(struct ad714x_chip *ad714x, int idx)
 784{
 785	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 786
 787	ad714x_use_thr_int(ad714x, hw->x_start_stage, hw->x_end_stage);
 788	ad714x_use_thr_int(ad714x, hw->y_start_stage, hw->y_end_stage);
 789}
 790
 791static void ad714x_touchpad_state_machine(struct ad714x_chip *ad714x, int idx)
 792{
 793	struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 794	struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 795	unsigned short h_state, c_state;
 796	unsigned short mask;
 797
 798	mask = (((1 << (hw->x_end_stage + 1)) - 1) -
 799		((1 << hw->x_start_stage) - 1)) +
 800		(((1 << (hw->y_end_stage + 1)) - 1) -
 801		((1 << hw->y_start_stage) - 1));
 802
 803	h_state = ad714x->h_state & mask;
 804	c_state = ad714x->c_state & mask;
 805
 806	switch (sw->state) {
 807	case IDLE:
 808		if (h_state) {
 809			sw->state = JITTER;
 810			/* In End of Conversion interrupt mode, the AD714X
 811			 * continuously generates hardware interrupts.
 812			 */
 813			touchpad_use_com_int(ad714x, idx);
 814			dev_dbg(ad714x->dev, "touchpad %d touched\n", idx);
 815		}
 816		break;
 817
 818	case JITTER:
 819		if (c_state == mask) {
 820			touchpad_cal_sensor_val(ad714x, idx);
 821			touchpad_cal_highest_stage(ad714x, idx);
 822			if ((!touchpad_check_second_peak(ad714x, idx)) &&
 823				(!touchpad_check_endpoint(ad714x, idx))) {
 824				dev_dbg(ad714x->dev,
 825					"touchpad%d, 2 fingers or endpoint\n",
 826					idx);
 827				touchpad_cal_abs_pos(ad714x, idx);
 828				sw->x_flt_pos = sw->x_abs_pos;
 829				sw->y_flt_pos = sw->y_abs_pos;
 830				sw->state = ACTIVE;
 831			}
 832		}
 833		break;
 834
 835	case ACTIVE:
 836		if (c_state == mask) {
 837			if (h_state) {
 838				touchpad_cal_sensor_val(ad714x, idx);
 839				touchpad_cal_highest_stage(ad714x, idx);
 840				if ((!touchpad_check_second_peak(ad714x, idx))
 841				  && (!touchpad_check_endpoint(ad714x, idx))) {
 842					touchpad_cal_abs_pos(ad714x, idx);
 843					touchpad_cal_flt_pos(ad714x, idx);
 844					input_report_abs(sw->input, ABS_X,
 845						sw->x_flt_pos);
 846					input_report_abs(sw->input, ABS_Y,
 847						sw->y_flt_pos);
 848					input_report_key(sw->input, BTN_TOUCH,
 849						1);
 850				}
 851			} else {
 852				/* When the user lifts off the sensor, configure
 853				 * the AD714X back to threshold interrupt mode.
 854				 */
 855				touchpad_use_thr_int(ad714x, idx);
 856				sw->state = IDLE;
 857				input_report_key(sw->input, BTN_TOUCH, 0);
 858				dev_dbg(ad714x->dev, "touchpad %d released\n",
 859					idx);
 860			}
 861			input_sync(sw->input);
 862		}
 863		break;
 864
 865	default:
 866		break;
 867	}
 868}
 869
 870static int ad714x_hw_detect(struct ad714x_chip *ad714x)
 871{
 872	unsigned short data;
 873
 874	ad714x->read(ad714x, AD714X_PARTID_REG, &data, 1);
 875	switch (data & 0xFFF0) {
 876	case AD7142_PARTID:
 877		ad714x->product = 0x7142;
 878		ad714x->version = data & 0xF;
 879		dev_info(ad714x->dev, "found AD7142 captouch, rev:%d\n",
 880				ad714x->version);
 881		return 0;
 882
 883	case AD7143_PARTID:
 884		ad714x->product = 0x7143;
 885		ad714x->version = data & 0xF;
 886		dev_info(ad714x->dev, "found AD7143 captouch, rev:%d\n",
 887				ad714x->version);
 888		return 0;
 889
 890	case AD7147_PARTID:
 891		ad714x->product = 0x7147;
 892		ad714x->version = data & 0xF;
 893		dev_info(ad714x->dev, "found AD7147(A) captouch, rev:%d\n",
 894				ad714x->version);
 895		return 0;
 896
 897	case AD7148_PARTID:
 898		ad714x->product = 0x7148;
 899		ad714x->version = data & 0xF;
 900		dev_info(ad714x->dev, "found AD7148 captouch, rev:%d\n",
 901				ad714x->version);
 902		return 0;
 903
 904	default:
 905		dev_err(ad714x->dev,
 906			"fail to detect AD714X captouch, read ID is %04x\n",
 907			data);
 908		return -ENODEV;
 909	}
 910}
 911
 912static void ad714x_hw_init(struct ad714x_chip *ad714x)
 913{
 914	int i, j;
 915	unsigned short reg_base;
 916	unsigned short data;
 917
 918	/* configuration CDC and interrupts */
 919
 920	for (i = 0; i < STAGE_NUM; i++) {
 921		reg_base = AD714X_STAGECFG_REG + i * STAGE_CFGREG_NUM;
 922		for (j = 0; j < STAGE_CFGREG_NUM; j++)
 923			ad714x->write(ad714x, reg_base + j,
 924					ad714x->hw->stage_cfg_reg[i][j]);
 925	}
 926
 927	for (i = 0; i < SYS_CFGREG_NUM; i++)
 928		ad714x->write(ad714x, AD714X_SYSCFG_REG + i,
 929			ad714x->hw->sys_cfg_reg[i]);
 930	for (i = 0; i < SYS_CFGREG_NUM; i++)
 931		ad714x->read(ad714x, AD714X_SYSCFG_REG + i, &data, 1);
 932
 933	ad714x->write(ad714x, AD714X_STG_CAL_EN_REG, 0xFFF);
 934
 935	/* clear all interrupts */
 936	ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
 937}
 938
 939static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
 940{
 941	struct ad714x_chip *ad714x = data;
 942	int i;
 943
 944	mutex_lock(&ad714x->mutex);
 945
 946	ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
 947
 948	for (i = 0; i < ad714x->hw->button_num; i++)
 949		ad714x_button_state_machine(ad714x, i);
 950	for (i = 0; i < ad714x->hw->slider_num; i++)
 951		ad714x_slider_state_machine(ad714x, i);
 952	for (i = 0; i < ad714x->hw->wheel_num; i++)
 953		ad714x_wheel_state_machine(ad714x, i);
 954	for (i = 0; i < ad714x->hw->touchpad_num; i++)
 955		ad714x_touchpad_state_machine(ad714x, i);
 956
 957	mutex_unlock(&ad714x->mutex);
 958
 959	return IRQ_HANDLED;
 960}
 961
 962struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
 963				 ad714x_read_t read, ad714x_write_t write)
 964{
 965	int i;
 966	int error;
 967	struct input_dev *input;
 968
 969	struct ad714x_platform_data *plat_data = dev_get_platdata(dev);
 970	struct ad714x_chip *ad714x;
 971	void *drv_mem;
 972	unsigned long irqflags;
 973
 974	struct ad714x_button_drv *bt_drv;
 975	struct ad714x_slider_drv *sd_drv;
 976	struct ad714x_wheel_drv *wl_drv;
 977	struct ad714x_touchpad_drv *tp_drv;
 978
 979
 980	if (irq <= 0) {
 981		dev_err(dev, "IRQ not configured!\n");
 982		error = -EINVAL;
 983		return ERR_PTR(error);
 984	}
 985
 986	if (dev_get_platdata(dev) == NULL) {
 987		dev_err(dev, "platform data for ad714x doesn't exist\n");
 988		error = -EINVAL;
 989		return ERR_PTR(error);
 990	}
 991
 992	ad714x = devm_kzalloc(dev, sizeof(*ad714x) + sizeof(*ad714x->sw) +
 993				   sizeof(*sd_drv) * plat_data->slider_num +
 994				   sizeof(*wl_drv) * plat_data->wheel_num +
 995				   sizeof(*tp_drv) * plat_data->touchpad_num +
 996				   sizeof(*bt_drv) * plat_data->button_num,
 997			      GFP_KERNEL);
 998	if (!ad714x) {
 999		error = -ENOMEM;
1000		return ERR_PTR(error);
1001	}
1002	ad714x->hw = plat_data;
1003
1004	drv_mem = ad714x + 1;
1005	ad714x->sw = drv_mem;
1006	drv_mem += sizeof(*ad714x->sw);
1007	ad714x->sw->slider = sd_drv = drv_mem;
1008	drv_mem += sizeof(*sd_drv) * ad714x->hw->slider_num;
1009	ad714x->sw->wheel = wl_drv = drv_mem;
1010	drv_mem += sizeof(*wl_drv) * ad714x->hw->wheel_num;
1011	ad714x->sw->touchpad = tp_drv = drv_mem;
1012	drv_mem += sizeof(*tp_drv) * ad714x->hw->touchpad_num;
1013	ad714x->sw->button = bt_drv = drv_mem;
1014	drv_mem += sizeof(*bt_drv) * ad714x->hw->button_num;
1015
1016	ad714x->read = read;
1017	ad714x->write = write;
1018	ad714x->irq = irq;
1019	ad714x->dev = dev;
1020
1021	error = ad714x_hw_detect(ad714x);
1022	if (error)
1023		return ERR_PTR(error);
1024
1025	/* initialize and request sw/hw resources */
1026
1027	ad714x_hw_init(ad714x);
1028	mutex_init(&ad714x->mutex);
1029
1030	/* a slider uses one input_dev instance */
1031	if (ad714x->hw->slider_num > 0) {
1032		struct ad714x_slider_plat *sd_plat = ad714x->hw->slider;
1033
1034		for (i = 0; i < ad714x->hw->slider_num; i++) {
1035			input = devm_input_allocate_device(dev);
1036			if (!input)
1037				return ERR_PTR(-ENOMEM);
1038
1039			__set_bit(EV_ABS, input->evbit);
1040			__set_bit(EV_KEY, input->evbit);
1041			__set_bit(ABS_X, input->absbit);
1042			__set_bit(BTN_TOUCH, input->keybit);
1043			input_set_abs_params(input,
1044				ABS_X, 0, sd_plat->max_coord, 0, 0);
1045
1046			input->id.bustype = bus_type;
1047			input->id.product = ad714x->product;
1048			input->id.version = ad714x->version;
1049			input->name = "ad714x_captouch_slider";
1050			input->dev.parent = dev;
1051
1052			error = input_register_device(input);
1053			if (error)
1054				return ERR_PTR(error);
1055
1056			sd_drv[i].input = input;
1057		}
1058	}
1059
1060	/* a wheel uses one input_dev instance */
1061	if (ad714x->hw->wheel_num > 0) {
1062		struct ad714x_wheel_plat *wl_plat = ad714x->hw->wheel;
1063
1064		for (i = 0; i < ad714x->hw->wheel_num; i++) {
1065			input = devm_input_allocate_device(dev);
1066			if (!input)
1067				return ERR_PTR(-ENOMEM);
1068
1069			__set_bit(EV_KEY, input->evbit);
1070			__set_bit(EV_ABS, input->evbit);
1071			__set_bit(ABS_WHEEL, input->absbit);
1072			__set_bit(BTN_TOUCH, input->keybit);
1073			input_set_abs_params(input,
1074				ABS_WHEEL, 0, wl_plat->max_coord, 0, 0);
1075
1076			input->id.bustype = bus_type;
1077			input->id.product = ad714x->product;
1078			input->id.version = ad714x->version;
1079			input->name = "ad714x_captouch_wheel";
1080			input->dev.parent = dev;
1081
1082			error = input_register_device(input);
1083			if (error)
1084				return ERR_PTR(error);
1085
1086			wl_drv[i].input = input;
1087		}
1088	}
1089
1090	/* a touchpad uses one input_dev instance */
1091	if (ad714x->hw->touchpad_num > 0) {
1092		struct ad714x_touchpad_plat *tp_plat = ad714x->hw->touchpad;
1093
1094		for (i = 0; i < ad714x->hw->touchpad_num; i++) {
1095			input = devm_input_allocate_device(dev);
1096			if (!input)
1097				return ERR_PTR(-ENOMEM);
1098
1099			__set_bit(EV_ABS, input->evbit);
1100			__set_bit(EV_KEY, input->evbit);
1101			__set_bit(ABS_X, input->absbit);
1102			__set_bit(ABS_Y, input->absbit);
1103			__set_bit(BTN_TOUCH, input->keybit);
1104			input_set_abs_params(input,
1105				ABS_X, 0, tp_plat->x_max_coord, 0, 0);
1106			input_set_abs_params(input,
1107				ABS_Y, 0, tp_plat->y_max_coord, 0, 0);
1108
1109			input->id.bustype = bus_type;
1110			input->id.product = ad714x->product;
1111			input->id.version = ad714x->version;
1112			input->name = "ad714x_captouch_pad";
1113			input->dev.parent = dev;
1114
1115			error = input_register_device(input);
1116			if (error)
1117				return ERR_PTR(error);
1118
1119			tp_drv[i].input = input;
1120		}
1121	}
1122
1123	/* all buttons use one input node */
1124	if (ad714x->hw->button_num > 0) {
1125		struct ad714x_button_plat *bt_plat = ad714x->hw->button;
1126
1127		input = devm_input_allocate_device(dev);
1128		if (!input) {
1129			error = -ENOMEM;
1130			return ERR_PTR(error);
1131		}
1132
1133		__set_bit(EV_KEY, input->evbit);
1134		for (i = 0; i < ad714x->hw->button_num; i++) {
1135			bt_drv[i].input = input;
1136			__set_bit(bt_plat[i].keycode, input->keybit);
1137		}
1138
1139		input->id.bustype = bus_type;
1140		input->id.product = ad714x->product;
1141		input->id.version = ad714x->version;
1142		input->name = "ad714x_captouch_button";
1143		input->dev.parent = dev;
1144
1145		error = input_register_device(input);
1146		if (error)
1147			return ERR_PTR(error);
1148	}
1149
1150	irqflags = plat_data->irqflags ?: IRQF_TRIGGER_FALLING;
1151	irqflags |= IRQF_ONESHOT;
1152
1153	error = devm_request_threaded_irq(dev, ad714x->irq, NULL,
1154					  ad714x_interrupt_thread,
1155					  irqflags, "ad714x_captouch", ad714x);
1156	if (error) {
1157		dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
1158		return ERR_PTR(error);
1159	}
1160
1161	return ad714x;
1162}
1163EXPORT_SYMBOL(ad714x_probe);
1164
1165static int ad714x_suspend(struct device *dev)
 
1166{
1167	struct ad714x_chip *ad714x = dev_get_drvdata(dev);
1168	unsigned short data;
1169
1170	dev_dbg(ad714x->dev, "%s enter\n", __func__);
1171
1172	mutex_lock(&ad714x->mutex);
1173
1174	data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3;
1175	ad714x->write(ad714x, AD714X_PWR_CTRL, data);
1176
1177	mutex_unlock(&ad714x->mutex);
1178
1179	return 0;
1180}
 
1181
1182static int ad714x_resume(struct device *dev)
1183{
1184	struct ad714x_chip *ad714x = dev_get_drvdata(dev);
1185	dev_dbg(ad714x->dev, "%s enter\n", __func__);
1186
1187	mutex_lock(&ad714x->mutex);
1188
1189	/* resume to non-shutdown mode */
1190
1191	ad714x->write(ad714x, AD714X_PWR_CTRL,
1192			ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL]);
1193
1194	/* make sure the interrupt output line is not low level after resume,
1195	 * otherwise we will get no chance to enter falling-edge irq again
1196	 */
1197
1198	ad714x->read(ad714x, STG_LOW_INT_STA_REG, &ad714x->l_state, 3);
1199
1200	mutex_unlock(&ad714x->mutex);
1201
1202	return 0;
1203}
1204
1205EXPORT_SIMPLE_DEV_PM_OPS(ad714x_pm, ad714x_suspend, ad714x_resume);
1206
1207MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor Driver");
1208MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
1209MODULE_LICENSE("GPL");