sx9500.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright (c) 2014 Intel Corporation
   4 *
   5 * Driver for Semtech's SX9500 capacitive proximity/button solution.
   6 * Datasheet available at
   7 * <http://www.semtech.com/images/datasheet/sx9500.pdf>.
   8 */
   9
  10#include <linux/kernel.h>
  11#include <linux/slab.h>
  12#include <linux/module.h>
  13#include <linux/i2c.h>
  14#include <linux/irq.h>
  15#include <linux/acpi.h>
  16#include <linux/gpio/consumer.h>
  17#include <linux/regmap.h>
  18#include <linux/pm.h>
  19#include <linux/delay.h>
  20
  21#include <linux/iio/iio.h>
  22#include <linux/iio/buffer.h>
  23#include <linux/iio/sysfs.h>
  24#include <linux/iio/events.h>
  25#include <linux/iio/trigger.h>
  26#include <linux/iio/triggered_buffer.h>
  27#include <linux/iio/trigger_consumer.h>
  28
  29#define SX9500_DRIVER_NAME		"sx9500"
  30
  31/* Register definitions. */
  32#define SX9500_REG_IRQ_SRC		0x00
  33#define SX9500_REG_STAT			0x01
  34#define SX9500_REG_IRQ_MSK		0x03
  35
  36#define SX9500_REG_PROX_CTRL0		0x06
  37#define SX9500_REG_PROX_CTRL1		0x07
  38#define SX9500_REG_PROX_CTRL2		0x08
  39#define SX9500_REG_PROX_CTRL3		0x09
  40#define SX9500_REG_PROX_CTRL4		0x0a
  41#define SX9500_REG_PROX_CTRL5		0x0b
  42#define SX9500_REG_PROX_CTRL6		0x0c
  43#define SX9500_REG_PROX_CTRL7		0x0d
  44#define SX9500_REG_PROX_CTRL8		0x0e
  45
  46#define SX9500_REG_SENSOR_SEL		0x20
  47#define SX9500_REG_USE_MSB		0x21
  48#define SX9500_REG_USE_LSB		0x22
  49#define SX9500_REG_AVG_MSB		0x23
  50#define SX9500_REG_AVG_LSB		0x24
  51#define SX9500_REG_DIFF_MSB		0x25
  52#define SX9500_REG_DIFF_LSB		0x26
  53#define SX9500_REG_OFFSET_MSB		0x27
  54#define SX9500_REG_OFFSET_LSB		0x28
  55
  56#define SX9500_REG_RESET		0x7f
  57
  58/* Write this to REG_RESET to do a soft reset. */
  59#define SX9500_SOFT_RESET		0xde
  60
  61#define SX9500_SCAN_PERIOD_MASK		GENMASK(6, 4)
  62#define SX9500_SCAN_PERIOD_SHIFT	4
  63
  64/*
  65 * These serve for identifying IRQ source in the IRQ_SRC register, and
  66 * also for masking the IRQs in the IRQ_MSK register.
  67 */
  68#define SX9500_CLOSE_IRQ		BIT(6)
  69#define SX9500_FAR_IRQ			BIT(5)
  70#define SX9500_CONVDONE_IRQ		BIT(3)
  71
  72#define SX9500_PROXSTAT_SHIFT		4
  73#define SX9500_COMPSTAT_MASK		GENMASK(3, 0)
  74
  75#define SX9500_NUM_CHANNELS		4
  76#define SX9500_CHAN_MASK		GENMASK(SX9500_NUM_CHANNELS - 1, 0)
  77
  78struct sx9500_data {
  79	struct mutex mutex;
  80	struct i2c_client *client;
  81	struct iio_trigger *trig;
  82	struct regmap *regmap;
  83	struct gpio_desc *gpiod_rst;
  84	/*
  85	 * Last reading of the proximity status for each channel.  We
  86	 * only send an event to user space when this changes.
  87	 */
  88	bool prox_stat[SX9500_NUM_CHANNELS];
  89	bool event_enabled[SX9500_NUM_CHANNELS];
  90	bool trigger_enabled;
  91	/* Remember enabled channels and sample rate during suspend. */
  92	unsigned int suspend_ctrl0;
  93	struct completion completion;
  94	int data_rdy_users, close_far_users;
  95	int channel_users[SX9500_NUM_CHANNELS];
  96};
  97
  98static const struct iio_event_spec sx9500_events[] = {
  99	{
 100		.type = IIO_EV_TYPE_THRESH,
 101		.dir = IIO_EV_DIR_EITHER,
 102		.mask_separate = BIT(IIO_EV_INFO_ENABLE),
 103	},
 104};
 105
 106#define SX9500_CHANNEL(idx)					\
 107	{							\
 108		.type = IIO_PROXIMITY,				\
 109		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),	\
 110		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 111		.indexed = 1,					\
 112		.channel = idx,					\
 113		.event_spec = sx9500_events,			\
 114		.num_event_specs = ARRAY_SIZE(sx9500_events),	\
 115		.scan_index = idx,				\
 116		.scan_type = {					\
 117			.sign = 'u',				\
 118			.realbits = 16,				\
 119			.storagebits = 16,			\
 120			.shift = 0,				\
 121		},						\
 122	}
 123
 124static const struct iio_chan_spec sx9500_channels[] = {
 125	SX9500_CHANNEL(0),
 126	SX9500_CHANNEL(1),
 127	SX9500_CHANNEL(2),
 128	SX9500_CHANNEL(3),
 129	IIO_CHAN_SOFT_TIMESTAMP(4),
 130};
 131
 132static const struct {
 133	int val;
 134	int val2;
 135} sx9500_samp_freq_table[] = {
 136	{33, 333333},
 137	{16, 666666},
 138	{11, 111111},
 139	{8, 333333},
 140	{6, 666666},
 141	{5, 0},
 142	{3, 333333},
 143	{2, 500000},
 144};
 145
 146static const unsigned int sx9500_scan_period_table[] = {
 147	30, 60, 90, 120, 150, 200, 300, 400,
 148};
 149
 150static const struct regmap_range sx9500_writable_reg_ranges[] = {
 151	regmap_reg_range(SX9500_REG_IRQ_MSK, SX9500_REG_IRQ_MSK),
 152	regmap_reg_range(SX9500_REG_PROX_CTRL0, SX9500_REG_PROX_CTRL8),
 153	regmap_reg_range(SX9500_REG_SENSOR_SEL, SX9500_REG_SENSOR_SEL),
 154	regmap_reg_range(SX9500_REG_OFFSET_MSB, SX9500_REG_OFFSET_LSB),
 155	regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
 156};
 157
 158static const struct regmap_access_table sx9500_writeable_regs = {
 159	.yes_ranges = sx9500_writable_reg_ranges,
 160	.n_yes_ranges = ARRAY_SIZE(sx9500_writable_reg_ranges),
 161};
 162
 163/*
 164 * All allocated registers are readable, so we just list unallocated
 165 * ones.
 166 */
 167static const struct regmap_range sx9500_non_readable_reg_ranges[] = {
 168	regmap_reg_range(SX9500_REG_STAT + 1, SX9500_REG_STAT + 1),
 169	regmap_reg_range(SX9500_REG_IRQ_MSK + 1, SX9500_REG_PROX_CTRL0 - 1),
 170	regmap_reg_range(SX9500_REG_PROX_CTRL8 + 1, SX9500_REG_SENSOR_SEL - 1),
 171	regmap_reg_range(SX9500_REG_OFFSET_LSB + 1, SX9500_REG_RESET - 1),
 172};
 173
 174static const struct regmap_access_table sx9500_readable_regs = {
 175	.no_ranges = sx9500_non_readable_reg_ranges,
 176	.n_no_ranges = ARRAY_SIZE(sx9500_non_readable_reg_ranges),
 177};
 178
 179static const struct regmap_range sx9500_volatile_reg_ranges[] = {
 180	regmap_reg_range(SX9500_REG_IRQ_SRC, SX9500_REG_STAT),
 181	regmap_reg_range(SX9500_REG_USE_MSB, SX9500_REG_OFFSET_LSB),
 182	regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
 183};
 184
 185static const struct regmap_access_table sx9500_volatile_regs = {
 186	.yes_ranges = sx9500_volatile_reg_ranges,
 187	.n_yes_ranges = ARRAY_SIZE(sx9500_volatile_reg_ranges),
 188};
 189
 190static const struct regmap_config sx9500_regmap_config = {
 191	.reg_bits = 8,
 192	.val_bits = 8,
 193
 194	.max_register = SX9500_REG_RESET,
 195	.cache_type = REGCACHE_RBTREE,
 196
 197	.wr_table = &sx9500_writeable_regs,
 198	.rd_table = &sx9500_readable_regs,
 199	.volatile_table = &sx9500_volatile_regs,
 200};
 201
 202static int sx9500_inc_users(struct sx9500_data *data, int *counter,
 203			    unsigned int reg, unsigned int bitmask)
 204{
 205	(*counter)++;
 206	if (*counter != 1)
 207		/* Bit is already active, nothing to do. */
 208		return 0;
 209
 210	return regmap_set_bits(data->regmap, reg, bitmask);
 211}
 212
 213static int sx9500_dec_users(struct sx9500_data *data, int *counter,
 214			    unsigned int reg, unsigned int bitmask)
 215{
 216	(*counter)--;
 217	if (*counter != 0)
 218		/* There are more users, do not deactivate. */
 219		return 0;
 220
 221	return regmap_clear_bits(data->regmap, reg, bitmask);
 222}
 223
 224static int sx9500_inc_chan_users(struct sx9500_data *data, int chan)
 225{
 226	return sx9500_inc_users(data, &data->channel_users[chan],
 227				SX9500_REG_PROX_CTRL0, BIT(chan));
 228}
 229
 230static int sx9500_dec_chan_users(struct sx9500_data *data, int chan)
 231{
 232	return sx9500_dec_users(data, &data->channel_users[chan],
 233				SX9500_REG_PROX_CTRL0, BIT(chan));
 234}
 235
 236static int sx9500_inc_data_rdy_users(struct sx9500_data *data)
 237{
 238	return sx9500_inc_users(data, &data->data_rdy_users,
 239				SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ);
 240}
 241
 242static int sx9500_dec_data_rdy_users(struct sx9500_data *data)
 243{
 244	return sx9500_dec_users(data, &data->data_rdy_users,
 245				SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ);
 246}
 247
 248static int sx9500_inc_close_far_users(struct sx9500_data *data)
 249{
 250	return sx9500_inc_users(data, &data->close_far_users,
 251				SX9500_REG_IRQ_MSK,
 252				SX9500_CLOSE_IRQ | SX9500_FAR_IRQ);
 253}
 254
 255static int sx9500_dec_close_far_users(struct sx9500_data *data)
 256{
 257	return sx9500_dec_users(data, &data->close_far_users,
 258				SX9500_REG_IRQ_MSK,
 259				SX9500_CLOSE_IRQ | SX9500_FAR_IRQ);
 260}
 261
 262static int sx9500_read_prox_data(struct sx9500_data *data,
 263				 const struct iio_chan_spec *chan,
 264				 int *val)
 265{
 266	int ret;
 267	__be16 regval;
 268
 269	ret = regmap_write(data->regmap, SX9500_REG_SENSOR_SEL, chan->channel);
 270	if (ret < 0)
 271		return ret;
 272
 273	ret = regmap_bulk_read(data->regmap, SX9500_REG_USE_MSB, &regval, 2);
 274	if (ret < 0)
 275		return ret;
 276
 277	*val = be16_to_cpu(regval);
 278
 279	return IIO_VAL_INT;
 280}
 281
 282/*
 283 * If we have no interrupt support, we have to wait for a scan period
 284 * after enabling a channel to get a result.
 285 */
 286static int sx9500_wait_for_sample(struct sx9500_data *data)
 287{
 288	int ret;
 289	unsigned int val;
 290
 291	ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, &val);
 292	if (ret < 0)
 293		return ret;
 294
 295	val = (val & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT;
 296
 297	msleep(sx9500_scan_period_table[val]);
 298
 299	return 0;
 300}
 301
 302static int sx9500_read_proximity(struct sx9500_data *data,
 303				 const struct iio_chan_spec *chan,
 304				 int *val)
 305{
 306	int ret;
 307
 308	mutex_lock(&data->mutex);
 309
 310	ret = sx9500_inc_chan_users(data, chan->channel);
 311	if (ret < 0)
 312		goto out;
 313
 314	ret = sx9500_inc_data_rdy_users(data);
 315	if (ret < 0)
 316		goto out_dec_chan;
 317
 318	mutex_unlock(&data->mutex);
 319
 320	if (data->client->irq > 0)
 321		ret = wait_for_completion_interruptible(&data->completion);
 322	else
 323		ret = sx9500_wait_for_sample(data);
 324
 325	mutex_lock(&data->mutex);
 326
 327	if (ret < 0)
 328		goto out_dec_data_rdy;
 329
 330	ret = sx9500_read_prox_data(data, chan, val);
 331	if (ret < 0)
 332		goto out_dec_data_rdy;
 333
 334	ret = sx9500_dec_data_rdy_users(data);
 335	if (ret < 0)
 336		goto out_dec_chan;
 337
 338	ret = sx9500_dec_chan_users(data, chan->channel);
 339	if (ret < 0)
 340		goto out;
 341
 342	ret = IIO_VAL_INT;
 343
 344	goto out;
 345
 346out_dec_data_rdy:
 347	sx9500_dec_data_rdy_users(data);
 348out_dec_chan:
 349	sx9500_dec_chan_users(data, chan->channel);
 350out:
 351	mutex_unlock(&data->mutex);
 352	reinit_completion(&data->completion);
 353
 354	return ret;
 355}
 356
 357static int sx9500_read_samp_freq(struct sx9500_data *data,
 358				 int *val, int *val2)
 359{
 360	int ret;
 361	unsigned int regval;
 362
 363	mutex_lock(&data->mutex);
 364	ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, &regval);
 365	mutex_unlock(&data->mutex);
 366
 367	if (ret < 0)
 368		return ret;
 369
 370	regval = (regval & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT;
 371	*val = sx9500_samp_freq_table[regval].val;
 372	*val2 = sx9500_samp_freq_table[regval].val2;
 373
 374	return IIO_VAL_INT_PLUS_MICRO;
 375}
 376
 377static int sx9500_read_raw(struct iio_dev *indio_dev,
 378			   const struct iio_chan_spec *chan,
 379			   int *val, int *val2, long mask)
 380{
 381	struct sx9500_data *data = iio_priv(indio_dev);
 382	int ret;
 383
 384	switch (chan->type) {
 385	case IIO_PROXIMITY:
 386		switch (mask) {
 387		case IIO_CHAN_INFO_RAW:
 388			if (!iio_device_claim_direct(indio_dev))
 389				return -EBUSY;
 390			ret = sx9500_read_proximity(data, chan, val);
 391			iio_device_release_direct(indio_dev);
 392			return ret;
 393		case IIO_CHAN_INFO_SAMP_FREQ:
 394			return sx9500_read_samp_freq(data, val, val2);
 395		default:
 396			return -EINVAL;
 397		}
 398	default:
 399		return -EINVAL;
 400	}
 401}
 402
 403static int sx9500_set_samp_freq(struct sx9500_data *data,
 404				int val, int val2)
 405{
 406	int i, ret;
 407
 408	for (i = 0; i < ARRAY_SIZE(sx9500_samp_freq_table); i++)
 409		if (val == sx9500_samp_freq_table[i].val &&
 410		    val2 == sx9500_samp_freq_table[i].val2)
 411			break;
 412
 413	if (i == ARRAY_SIZE(sx9500_samp_freq_table))
 414		return -EINVAL;
 415
 416	mutex_lock(&data->mutex);
 417
 418	ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
 419				 SX9500_SCAN_PERIOD_MASK,
 420				 i << SX9500_SCAN_PERIOD_SHIFT);
 421
 422	mutex_unlock(&data->mutex);
 423
 424	return ret;
 425}
 426
 427static int sx9500_write_raw(struct iio_dev *indio_dev,
 428			    const struct iio_chan_spec *chan,
 429			    int val, int val2, long mask)
 430{
 431	struct sx9500_data *data = iio_priv(indio_dev);
 432
 433	switch (chan->type) {
 434	case IIO_PROXIMITY:
 435		switch (mask) {
 436		case IIO_CHAN_INFO_SAMP_FREQ:
 437			return sx9500_set_samp_freq(data, val, val2);
 438		default:
 439			return -EINVAL;
 440		}
 441	default:
 442		return -EINVAL;
 443	}
 444}
 445
 446static irqreturn_t sx9500_irq_handler(int irq, void *private)
 447{
 448	struct iio_dev *indio_dev = private;
 449	struct sx9500_data *data = iio_priv(indio_dev);
 450
 451	if (data->trigger_enabled)
 452		iio_trigger_poll(data->trig);
 453
 454	/*
 455	 * Even if no event is enabled, we need to wake the thread to
 456	 * clear the interrupt state by reading SX9500_REG_IRQ_SRC.  It
 457	 * is not possible to do that here because regmap_read takes a
 458	 * mutex.
 459	 */
 460	return IRQ_WAKE_THREAD;
 461}
 462
 463static void sx9500_push_events(struct iio_dev *indio_dev)
 464{
 465	int ret;
 466	unsigned int val, chan;
 467	struct sx9500_data *data = iio_priv(indio_dev);
 468
 469	ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
 470	if (ret < 0) {
 471		dev_err(&data->client->dev, "i2c transfer error in irq\n");
 472		return;
 473	}
 474
 475	val >>= SX9500_PROXSTAT_SHIFT;
 476	for (chan = 0; chan < SX9500_NUM_CHANNELS; chan++) {
 477		int dir;
 478		u64 ev;
 479		bool new_prox = val & BIT(chan);
 480
 481		if (!data->event_enabled[chan])
 482			continue;
 483		if (new_prox == data->prox_stat[chan])
 484			/* No change on this channel. */
 485			continue;
 486
 487		dir = new_prox ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
 488		ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan,
 489					  IIO_EV_TYPE_THRESH, dir);
 490		iio_push_event(indio_dev, ev, iio_get_time_ns(indio_dev));
 491		data->prox_stat[chan] = new_prox;
 492	}
 493}
 494
 495static irqreturn_t sx9500_irq_thread_handler(int irq, void *private)
 496{
 497	struct iio_dev *indio_dev = private;
 498	struct sx9500_data *data = iio_priv(indio_dev);
 499	int ret;
 500	unsigned int val;
 501
 502	mutex_lock(&data->mutex);
 503
 504	ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
 505	if (ret < 0) {
 506		dev_err(&data->client->dev, "i2c transfer error in irq\n");
 507		goto out;
 508	}
 509
 510	if (val & (SX9500_CLOSE_IRQ | SX9500_FAR_IRQ))
 511		sx9500_push_events(indio_dev);
 512
 513	if (val & SX9500_CONVDONE_IRQ)
 514		complete(&data->completion);
 515
 516out:
 517	mutex_unlock(&data->mutex);
 518
 519	return IRQ_HANDLED;
 520}
 521
 522static int sx9500_read_event_config(struct iio_dev *indio_dev,
 523				    const struct iio_chan_spec *chan,
 524				    enum iio_event_type type,
 525				    enum iio_event_direction dir)
 526{
 527	struct sx9500_data *data = iio_priv(indio_dev);
 528
 529	if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
 530	    dir != IIO_EV_DIR_EITHER)
 531		return -EINVAL;
 532
 533	return data->event_enabled[chan->channel];
 534}
 535
 536static int sx9500_write_event_config(struct iio_dev *indio_dev,
 537				     const struct iio_chan_spec *chan,
 538				     enum iio_event_type type,
 539				     enum iio_event_direction dir,
 540				     bool state)
 541{
 542	struct sx9500_data *data = iio_priv(indio_dev);
 543	int ret;
 544
 545	if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
 546	    dir != IIO_EV_DIR_EITHER)
 547		return -EINVAL;
 548
 549	mutex_lock(&data->mutex);
 550
 551	if (state) {
 552		ret = sx9500_inc_chan_users(data, chan->channel);
 553		if (ret < 0)
 554			goto out_unlock;
 555		ret = sx9500_inc_close_far_users(data);
 556		if (ret < 0)
 557			goto out_undo_chan;
 558	} else {
 559		ret = sx9500_dec_chan_users(data, chan->channel);
 560		if (ret < 0)
 561			goto out_unlock;
 562		ret = sx9500_dec_close_far_users(data);
 563		if (ret < 0)
 564			goto out_undo_chan;
 565	}
 566
 567	data->event_enabled[chan->channel] = state;
 568	goto out_unlock;
 569
 570out_undo_chan:
 571	if (state)
 572		sx9500_dec_chan_users(data, chan->channel);
 573	else
 574		sx9500_inc_chan_users(data, chan->channel);
 575out_unlock:
 576	mutex_unlock(&data->mutex);
 577	return ret;
 578}
 579
 580static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
 581	"2.500000 3.333333 5 6.666666 8.333333 11.111111 16.666666 33.333333");
 582
 583static struct attribute *sx9500_attributes[] = {
 584	&iio_const_attr_sampling_frequency_available.dev_attr.attr,
 585	NULL,
 586};
 587
 588static const struct attribute_group sx9500_attribute_group = {
 589	.attrs = sx9500_attributes,
 590};
 591
 592static const struct iio_info sx9500_info = {
 593	.attrs = &sx9500_attribute_group,
 594	.read_raw = &sx9500_read_raw,
 595	.write_raw = &sx9500_write_raw,
 596	.read_event_config = &sx9500_read_event_config,
 597	.write_event_config = &sx9500_write_event_config,
 598};
 599
 600static int sx9500_set_trigger_state(struct iio_trigger *trig,
 601				    bool state)
 602{
 603	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 604	struct sx9500_data *data = iio_priv(indio_dev);
 605	int ret;
 606
 607	mutex_lock(&data->mutex);
 608
 609	if (state)
 610		ret = sx9500_inc_data_rdy_users(data);
 611	else
 612		ret = sx9500_dec_data_rdy_users(data);
 613	if (ret < 0)
 614		goto out;
 615
 616	data->trigger_enabled = state;
 617
 618out:
 619	mutex_unlock(&data->mutex);
 620
 621	return ret;
 622}
 623
 624static const struct iio_trigger_ops sx9500_trigger_ops = {
 625	.set_trigger_state = sx9500_set_trigger_state,
 626};
 627
 628static irqreturn_t sx9500_trigger_handler(int irq, void *private)
 629{
 630	struct iio_poll_func *pf = private;
 631	struct iio_dev *indio_dev = pf->indio_dev;
 632	struct sx9500_data *data = iio_priv(indio_dev);
 633	int val, bit, ret, i = 0;
 634	struct {
 635		u16 chan[SX9500_NUM_CHANNELS];
 636		aligned_s64 timestamp;
 637	} scan = { };
 638
 639	mutex_lock(&data->mutex);
 640
 641	iio_for_each_active_channel(indio_dev, bit) {
 642		ret = sx9500_read_prox_data(data, &indio_dev->channels[bit],
 643					    &val);
 644		if (ret < 0)
 645			goto out;
 646
 647		scan.chan[i++] = val;
 648	}
 649
 650	iio_push_to_buffers_with_timestamp(indio_dev, &scan,
 651					   iio_get_time_ns(indio_dev));
 652
 653out:
 654	mutex_unlock(&data->mutex);
 655
 656	iio_trigger_notify_done(indio_dev->trig);
 657
 658	return IRQ_HANDLED;
 659}
 660
 661static int sx9500_buffer_postenable(struct iio_dev *indio_dev)
 662{
 663	struct sx9500_data *data = iio_priv(indio_dev);
 664	int ret = 0, i;
 665
 666	mutex_lock(&data->mutex);
 667
 668	for (i = 0; i < SX9500_NUM_CHANNELS; i++)
 669		if (test_bit(i, indio_dev->active_scan_mask)) {
 670			ret = sx9500_inc_chan_users(data, i);
 671			if (ret)
 672				break;
 673		}
 674
 675	if (ret)
 676		for (i = i - 1; i >= 0; i--)
 677			if (test_bit(i, indio_dev->active_scan_mask))
 678				sx9500_dec_chan_users(data, i);
 679
 680	mutex_unlock(&data->mutex);
 681
 682	return ret;
 683}
 684
 685static int sx9500_buffer_predisable(struct iio_dev *indio_dev)
 686{
 687	struct sx9500_data *data = iio_priv(indio_dev);
 688	int ret = 0, i;
 689
 690	mutex_lock(&data->mutex);
 691
 692	for (i = 0; i < SX9500_NUM_CHANNELS; i++)
 693		if (test_bit(i, indio_dev->active_scan_mask)) {
 694			ret = sx9500_dec_chan_users(data, i);
 695			if (ret)
 696				break;
 697		}
 698
 699	if (ret)
 700		for (i = i - 1; i >= 0; i--)
 701			if (test_bit(i, indio_dev->active_scan_mask))
 702				sx9500_inc_chan_users(data, i);
 703
 704	mutex_unlock(&data->mutex);
 705
 706	return ret;
 707}
 708
 709static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = {
 710	.postenable = sx9500_buffer_postenable,
 711	.predisable = sx9500_buffer_predisable,
 712};
 713
 714struct sx9500_reg_default {
 715	u8 reg;
 716	u8 def;
 717};
 718
 719static const struct sx9500_reg_default sx9500_default_regs[] = {
 720	{
 721		.reg = SX9500_REG_PROX_CTRL1,
 722		/* Shield enabled, small range. */
 723		.def = 0x43,
 724	},
 725	{
 726		.reg = SX9500_REG_PROX_CTRL2,
 727		/* x8 gain, 167kHz frequency, finest resolution. */
 728		.def = 0x77,
 729	},
 730	{
 731		.reg = SX9500_REG_PROX_CTRL3,
 732		/* Doze enabled, 2x scan period doze, no raw filter. */
 733		.def = 0x40,
 734	},
 735	{
 736		.reg = SX9500_REG_PROX_CTRL4,
 737		/* Average threshold. */
 738		.def = 0x30,
 739	},
 740	{
 741		.reg = SX9500_REG_PROX_CTRL5,
 742		/*
 743		 * Debouncer off, lowest average negative filter,
 744		 * highest average positive filter.
 745		 */
 746		.def = 0x0f,
 747	},
 748	{
 749		.reg = SX9500_REG_PROX_CTRL6,
 750		/* Proximity detection threshold: 280 */
 751		.def = 0x0e,
 752	},
 753	{
 754		.reg = SX9500_REG_PROX_CTRL7,
 755		/*
 756		 * No automatic compensation, compensate each pin
 757		 * independently, proximity hysteresis: 32, close
 758		 * debouncer off, far debouncer off.
 759		 */
 760		.def = 0x00,
 761	},
 762	{
 763		.reg = SX9500_REG_PROX_CTRL8,
 764		/* No stuck timeout, no periodic compensation. */
 765		.def = 0x00,
 766	},
 767	{
 768		.reg = SX9500_REG_PROX_CTRL0,
 769		/* Scan period: 30ms, all sensors disabled. */
 770		.def = 0x00,
 771	},
 772};
 773
 774/* Activate all channels and perform an initial compensation. */
 775static int sx9500_init_compensation(struct iio_dev *indio_dev)
 776{
 777	struct sx9500_data *data = iio_priv(indio_dev);
 778	int i, ret;
 779	unsigned int val;
 780
 781	ret = regmap_set_bits(data->regmap, SX9500_REG_PROX_CTRL0,
 782			      SX9500_CHAN_MASK);
 783	if (ret < 0)
 784		return ret;
 785
 786	for (i = 10; i >= 0; i--) {
 787		usleep_range(10000, 20000);
 788		ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
 789		if (ret < 0)
 790			goto out;
 791		if (!(val & SX9500_COMPSTAT_MASK))
 792			break;
 793	}
 794
 795	if (i < 0) {
 796		dev_err(&data->client->dev, "initial compensation timed out");
 797		ret = -ETIMEDOUT;
 798	}
 799
 800out:
 801	regmap_clear_bits(data->regmap, SX9500_REG_PROX_CTRL0,
 802			  SX9500_CHAN_MASK);
 803	return ret;
 804}
 805
 806static int sx9500_init_device(struct iio_dev *indio_dev)
 807{
 808	struct sx9500_data *data = iio_priv(indio_dev);
 809	int ret, i;
 810	unsigned int val;
 811
 812	if (data->gpiod_rst) {
 813		gpiod_set_value_cansleep(data->gpiod_rst, 0);
 814		usleep_range(1000, 2000);
 815		gpiod_set_value_cansleep(data->gpiod_rst, 1);
 816		usleep_range(1000, 2000);
 817	}
 818
 819	ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0);
 820	if (ret < 0)
 821		return ret;
 822
 823	ret = regmap_write(data->regmap, SX9500_REG_RESET,
 824			   SX9500_SOFT_RESET);
 825	if (ret < 0)
 826		return ret;
 827
 828	ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
 829	if (ret < 0)
 830		return ret;
 831
 832	for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) {
 833		ret = regmap_write(data->regmap,
 834				   sx9500_default_regs[i].reg,
 835				   sx9500_default_regs[i].def);
 836		if (ret < 0)
 837			return ret;
 838	}
 839
 840	return sx9500_init_compensation(indio_dev);
 841}
 842
 843static const struct acpi_gpio_params reset_gpios = { 0, 0, false };
 844static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false };
 845
 846static const struct acpi_gpio_mapping acpi_sx9500_gpios[] = {
 847	{ "reset-gpios", &reset_gpios, 1 },
 848	/*
 849	 * Some platforms have a bug in ACPI GPIO description making IRQ
 850	 * GPIO to be output only. Ask the GPIO core to ignore this limit.
 851	 */
 852	{ "interrupt-gpios", &interrupt_gpios, 1, ACPI_GPIO_QUIRK_NO_IO_RESTRICTION },
 853	{ }
 854};
 855
 856static void sx9500_gpio_probe(struct i2c_client *client,
 857			      struct sx9500_data *data)
 858{
 859	struct gpio_desc *gpiod_int;
 860	struct device *dev;
 861	int ret;
 862
 863	if (!client)
 864		return;
 865
 866	dev = &client->dev;
 867
 868	ret = devm_acpi_dev_add_driver_gpios(dev, acpi_sx9500_gpios);
 869	if (ret)
 870		dev_dbg(dev, "Unable to add GPIO mapping table\n");
 871
 872	if (client->irq <= 0) {
 873		gpiod_int = devm_gpiod_get(dev, "interrupt", GPIOD_IN);
 874		if (IS_ERR(gpiod_int))
 875			dev_err(dev, "gpio get irq failed\n");
 876		else
 877			client->irq = gpiod_to_irq(gpiod_int);
 878	}
 879
 880	data->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
 881	if (IS_ERR(data->gpiod_rst)) {
 882		dev_warn(dev, "gpio get reset pin failed\n");
 883		data->gpiod_rst = NULL;
 884	}
 885}
 886
 887static int sx9500_probe(struct i2c_client *client)
 888{
 889	int ret;
 890	struct iio_dev *indio_dev;
 891	struct sx9500_data *data;
 892
 893	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 894	if (indio_dev == NULL)
 895		return -ENOMEM;
 896
 897	data = iio_priv(indio_dev);
 898	data->client = client;
 899	mutex_init(&data->mutex);
 900	init_completion(&data->completion);
 901	data->trigger_enabled = false;
 902
 903	data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config);
 904	if (IS_ERR(data->regmap))
 905		return PTR_ERR(data->regmap);
 906
 907	indio_dev->name = SX9500_DRIVER_NAME;
 908	indio_dev->channels = sx9500_channels;
 909	indio_dev->num_channels = ARRAY_SIZE(sx9500_channels);
 910	indio_dev->info = &sx9500_info;
 911	indio_dev->modes = INDIO_DIRECT_MODE;
 912	i2c_set_clientdata(client, indio_dev);
 913
 914	sx9500_gpio_probe(client, data);
 915
 916	ret = sx9500_init_device(indio_dev);
 917	if (ret < 0)
 918		return ret;
 919
 920	if (client->irq <= 0)
 921		dev_warn(&client->dev, "no valid irq found\n");
 922	else {
 923		ret = devm_request_threaded_irq(&client->dev, client->irq,
 924				sx9500_irq_handler, sx9500_irq_thread_handler,
 925				IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 926				"sx9500_event", indio_dev);
 927		if (ret < 0)
 928			return ret;
 929
 930		data->trig = devm_iio_trigger_alloc(&client->dev,
 931				"%s-dev%d", indio_dev->name, iio_device_id(indio_dev));
 932		if (!data->trig)
 933			return -ENOMEM;
 934
 935		data->trig->ops = &sx9500_trigger_ops;
 936		iio_trigger_set_drvdata(data->trig, indio_dev);
 937
 938		ret = iio_trigger_register(data->trig);
 939		if (ret)
 940			return ret;
 941	}
 942
 943	ret = iio_triggered_buffer_setup(indio_dev, NULL,
 944					 sx9500_trigger_handler,
 945					 &sx9500_buffer_setup_ops);
 946	if (ret < 0)
 947		goto out_trigger_unregister;
 948
 949	ret = iio_device_register(indio_dev);
 950	if (ret < 0)
 951		goto out_buffer_cleanup;
 952
 953	return 0;
 954
 955out_buffer_cleanup:
 956	iio_triggered_buffer_cleanup(indio_dev);
 957out_trigger_unregister:
 958	if (client->irq > 0)
 959		iio_trigger_unregister(data->trig);
 960
 961	return ret;
 962}
 963
 964static void sx9500_remove(struct i2c_client *client)
 965{
 966	struct iio_dev *indio_dev = i2c_get_clientdata(client);
 967	struct sx9500_data *data = iio_priv(indio_dev);
 968
 969	iio_device_unregister(indio_dev);
 970	iio_triggered_buffer_cleanup(indio_dev);
 971	if (client->irq > 0)
 972		iio_trigger_unregister(data->trig);
 973}
 974
 975static int sx9500_suspend(struct device *dev)
 976{
 977	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 978	struct sx9500_data *data = iio_priv(indio_dev);
 979	int ret;
 980
 981	mutex_lock(&data->mutex);
 982	ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0,
 983			  &data->suspend_ctrl0);
 984	if (ret < 0)
 985		goto out;
 986
 987	/*
 988	 * Scan period doesn't matter because when all the sensors are
 989	 * deactivated the device is in sleep mode.
 990	 */
 991	ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 0);
 992
 993out:
 994	mutex_unlock(&data->mutex);
 995	return ret;
 996}
 997
 998static int sx9500_resume(struct device *dev)
 999{
1000	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1001	struct sx9500_data *data = iio_priv(indio_dev);
1002	int ret;
1003
1004	mutex_lock(&data->mutex);
1005	ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0,
1006			   data->suspend_ctrl0);
1007	mutex_unlock(&data->mutex);
1008
1009	return ret;
1010}
1011
1012static DEFINE_SIMPLE_DEV_PM_OPS(sx9500_pm_ops, sx9500_suspend, sx9500_resume);
1013
1014static const struct acpi_device_id sx9500_acpi_match[] = {
1015	{"SSX9500", 0},
1016	{"SASX9500", 0},
1017	{ }
1018};
1019MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match);
1020
1021static const struct of_device_id sx9500_of_match[] = {
1022	{ .compatible = "semtech,sx9500", },
1023	{ }
1024};
1025MODULE_DEVICE_TABLE(of, sx9500_of_match);
1026
1027static const struct i2c_device_id sx9500_id[] = {
1028	{ "sx9500" },
1029	{ }
1030};
1031MODULE_DEVICE_TABLE(i2c, sx9500_id);
1032
1033static struct i2c_driver sx9500_driver = {
1034	.driver = {
1035		.name	= SX9500_DRIVER_NAME,
1036		.acpi_match_table = sx9500_acpi_match,
1037		.of_match_table = sx9500_of_match,
1038		.pm = pm_sleep_ptr(&sx9500_pm_ops),
1039	},
1040	.probe		= sx9500_probe,
1041	.remove		= sx9500_remove,
1042	.id_table	= sx9500_id,
1043};
1044module_i2c_driver(sx9500_driver);
1045
1046MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
1047MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor");
1048MODULE_LICENSE("GPL v2");