veml6030.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * VEML6030, VMEL6035 and VEML7700 Ambient Light Sensors
   4 *
   5 * Copyright (c) 2019, Rishi Gupta <gupt21@gmail.com>
   6 *
   7 * VEML6030:
   8 * Datasheet: https://www.vishay.com/docs/84366/veml6030.pdf
   9 * Appnote-84367: https://www.vishay.com/docs/84367/designingveml6030.pdf
  10 *
  11 * VEML6035:
  12 * Datasheet: https://www.vishay.com/docs/84889/veml6035.pdf
  13 * Appnote-84944: https://www.vishay.com/docs/84944/designingveml6035.pdf
  14 *
  15 * VEML7700:
  16 * Datasheet: https://www.vishay.com/docs/84286/veml7700.pdf
  17 * Appnote-84323: https://www.vishay.com/docs/84323/designingveml7700.pdf
  18 */
  19
  20#include <linux/bitfield.h>
  21#include <linux/module.h>
  22#include <linux/i2c.h>
  23#include <linux/err.h>
  24#include <linux/regmap.h>
  25#include <linux/interrupt.h>
  26#include <linux/pm_runtime.h>
  27#include <linux/units.h>
  28#include <linux/regulator/consumer.h>
  29#include <linux/iio/iio.h>
  30#include <linux/iio/sysfs.h>
  31#include <linux/iio/events.h>
  32#include <linux/iio/iio-gts-helper.h>
  33#include <linux/iio/trigger_consumer.h>
  34#include <linux/iio/triggered_buffer.h>
  35
  36/* Device registers */
  37#define VEML6030_REG_ALS_CONF   0x00
  38#define VEML6030_REG_ALS_WH     0x01
  39#define VEML6030_REG_ALS_WL     0x02
  40#define VEML6030_REG_ALS_PSM    0x03
  41#define VEML6030_REG_ALS_DATA   0x04
  42#define VEML6030_REG_WH_DATA    0x05
  43#define VEML6030_REG_ALS_INT    0x06
  44#define VEML6030_REG_DATA(ch)   (VEML6030_REG_ALS_DATA + (ch))
  45
  46/* Bit masks for specific functionality */
  47#define VEML6030_ALS_IT       GENMASK(9, 6)
  48#define VEML6030_PSM          GENMASK(2, 1)
  49#define VEML6030_ALS_PERS     GENMASK(5, 4)
  50#define VEML6030_ALS_GAIN     GENMASK(12, 11)
  51#define VEML6030_PSM_EN       BIT(0)
  52#define VEML6030_INT_TH_LOW   BIT(15)
  53#define VEML6030_INT_TH_HIGH  BIT(14)
  54#define VEML6030_ALS_INT_EN   BIT(1)
  55#define VEML6030_ALS_SD       BIT(0)
  56
  57#define VEML6035_GAIN_M       GENMASK(12, 10)
  58#define VEML6035_GAIN         BIT(10)
  59#define VEML6035_DG           BIT(11)
  60#define VEML6035_SENS         BIT(12)
  61#define VEML6035_INT_CHAN     BIT(3)
  62#define VEML6035_CHAN_EN      BIT(2)
  63
  64/* Regfields */
  65#define VEML6030_GAIN_RF      REG_FIELD(VEML6030_REG_ALS_CONF, 11, 12)
  66#define VEML6030_IT_RF        REG_FIELD(VEML6030_REG_ALS_CONF, 6, 9)
  67
  68#define VEML6035_GAIN_RF      REG_FIELD(VEML6030_REG_ALS_CONF, 10, 12)
  69
  70/* Maximum scales x 10000 to work with integers */
  71#define VEML6030_MAX_SCALE    21504
  72#define VEML6035_MAX_SCALE    4096
  73
  74enum veml6030_scan {
  75	VEML6030_SCAN_ALS,
  76	VEML6030_SCAN_WH,
  77	VEML6030_SCAN_TIMESTAMP,
  78};
  79
  80struct veml6030_rf {
  81	struct regmap_field *it;
  82	struct regmap_field *gain;
  83};
  84
  85struct veml603x_chip {
  86	const char *name;
  87	const struct iio_chan_spec *channels;
  88	const int num_channels;
  89	const struct reg_field gain_rf;
  90	const struct reg_field it_rf;
  91	const int max_scale;
  92	int (*hw_init)(struct iio_dev *indio_dev, struct device *dev);
  93	int (*set_info)(struct iio_dev *indio_dev);
  94};
  95
  96/*
  97 * The resolution depends on both gain and integration time. The
  98 * cur_resolution stores one of the resolution mentioned in the
  99 * table during startup and gets updated whenever integration time
 100 * or gain is changed.
 101 *
 102 * Table 'resolution and maximum detection range' in the appnotes
 103 * is visualized as a 2D array. The cur_gain stores index of gain
 104 * in this table (0-3 for VEML6030, 0-5 for VEML6035) while the
 105 * cur_integration_time holds index of integration time (0-5).
 106 */
 107struct veml6030_data {
 108	struct i2c_client *client;
 109	struct regmap *regmap;
 110	struct veml6030_rf rf;
 111	const struct veml603x_chip *chip;
 112	struct iio_gts gts;
 113
 114};
 115
 116#define VEML6030_SEL_IT_25MS  0x0C
 117#define VEML6030_SEL_IT_50MS  0x08
 118#define VEML6030_SEL_IT_100MS 0x00
 119#define VEML6030_SEL_IT_200MS 0x01
 120#define VEML6030_SEL_IT_400MS 0x02
 121#define VEML6030_SEL_IT_800MS 0x03
 122static const struct iio_itime_sel_mul veml6030_it_sel[] = {
 123	GAIN_SCALE_ITIME_US(25000, VEML6030_SEL_IT_25MS, 1),
 124	GAIN_SCALE_ITIME_US(50000, VEML6030_SEL_IT_50MS, 2),
 125	GAIN_SCALE_ITIME_US(100000, VEML6030_SEL_IT_100MS, 4),
 126	GAIN_SCALE_ITIME_US(200000, VEML6030_SEL_IT_200MS, 8),
 127	GAIN_SCALE_ITIME_US(400000, VEML6030_SEL_IT_400MS, 16),
 128	GAIN_SCALE_ITIME_US(800000, VEML6030_SEL_IT_800MS, 32),
 129};
 130
 131/* Gains are multiplied by 8 to work with integers. The values in the
 132 * iio-gts tables don't need corrections because the maximum value of
 133 * the scale refers to GAIN = x1, and the rest of the values are
 134 * obtained from the resulting linear function.
 135 */
 136#define VEML6030_SEL_MILLI_GAIN_X125  2
 137#define VEML6030_SEL_MILLI_GAIN_X250  3
 138#define VEML6030_SEL_MILLI_GAIN_X1000 0
 139#define VEML6030_SEL_MILLI_GAIN_X2000 1
 140static const struct iio_gain_sel_pair veml6030_gain_sel[] = {
 141	GAIN_SCALE_GAIN(1, VEML6030_SEL_MILLI_GAIN_X125),
 142	GAIN_SCALE_GAIN(2, VEML6030_SEL_MILLI_GAIN_X250),
 143	GAIN_SCALE_GAIN(8, VEML6030_SEL_MILLI_GAIN_X1000),
 144	GAIN_SCALE_GAIN(16, VEML6030_SEL_MILLI_GAIN_X2000),
 145};
 146
 147#define VEML6035_SEL_MILLI_GAIN_X125  4
 148#define VEML6035_SEL_MILLI_GAIN_X250  5
 149#define VEML6035_SEL_MILLI_GAIN_X500  7
 150#define VEML6035_SEL_MILLI_GAIN_X1000 0
 151#define VEML6035_SEL_MILLI_GAIN_X2000 1
 152#define VEML6035_SEL_MILLI_GAIN_X4000 3
 153static const struct iio_gain_sel_pair veml6035_gain_sel[] = {
 154	GAIN_SCALE_GAIN(1, VEML6035_SEL_MILLI_GAIN_X125),
 155	GAIN_SCALE_GAIN(2, VEML6035_SEL_MILLI_GAIN_X250),
 156	GAIN_SCALE_GAIN(4, VEML6035_SEL_MILLI_GAIN_X500),
 157	GAIN_SCALE_GAIN(8, VEML6035_SEL_MILLI_GAIN_X1000),
 158	GAIN_SCALE_GAIN(16, VEML6035_SEL_MILLI_GAIN_X2000),
 159	GAIN_SCALE_GAIN(32, VEML6035_SEL_MILLI_GAIN_X4000),
 160};
 161
 162/*
 163 * Persistence = 1/2/4/8 x integration time
 164 * Minimum time for which light readings must stay above configured
 165 * threshold to assert the interrupt.
 166 */
 167static const char * const period_values[] = {
 168		"0.1 0.2 0.4 0.8",
 169		"0.2 0.4 0.8 1.6",
 170		"0.4 0.8 1.6 3.2",
 171		"0.8 1.6 3.2 6.4",
 172		"0.05 0.1 0.2 0.4",
 173		"0.025 0.050 0.1 0.2"
 174};
 175
 176/*
 177 * Return list of valid period values in seconds corresponding to
 178 * the currently active integration time.
 179 */
 180static ssize_t in_illuminance_period_available_show(struct device *dev,
 181				struct device_attribute *attr, char *buf)
 182{
 183	struct veml6030_data *data = iio_priv(dev_to_iio_dev(dev));
 184	int ret, reg, x;
 185
 186	ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, &reg);
 187	if (ret) {
 188		dev_err(&data->client->dev,
 189				"can't read als conf register %d\n", ret);
 190		return ret;
 191	}
 192
 193	ret = ((reg >> 6) & 0xF);
 194	switch (ret) {
 195	case 0:
 196	case 1:
 197	case 2:
 198	case 3:
 199		x = ret;
 200		break;
 201	case 8:
 202		x = 4;
 203		break;
 204	case 12:
 205		x = 5;
 206		break;
 207	default:
 208		return -EINVAL;
 209	}
 210
 211	return sysfs_emit(buf, "%s\n", period_values[x]);
 212}
 213
 214static IIO_DEVICE_ATTR_RO(in_illuminance_period_available, 0);
 215
 216static struct attribute *veml6030_event_attributes[] = {
 217	&iio_dev_attr_in_illuminance_period_available.dev_attr.attr,
 218	NULL
 219};
 220
 221static const struct attribute_group veml6030_event_attr_group = {
 222	.attrs = veml6030_event_attributes,
 223};
 224
 225static int veml6030_als_pwr_on(struct veml6030_data *data)
 226{
 227	int ret;
 228
 229	ret = regmap_clear_bits(data->regmap, VEML6030_REG_ALS_CONF,
 230				VEML6030_ALS_SD);
 231	if (ret)
 232		return ret;
 233
 234	/* Wait 4 ms to let processor & oscillator start correctly */
 235	fsleep(4000);
 236
 237	return 0;
 238}
 239
 240static int veml6030_als_shut_down(struct veml6030_data *data)
 241{
 242	return regmap_set_bits(data->regmap, VEML6030_REG_ALS_CONF,
 243				 VEML6030_ALS_SD);
 244}
 245
 246static void veml6030_als_shut_down_action(void *data)
 247{
 248	veml6030_als_shut_down(data);
 249}
 250
 251static const struct iio_event_spec veml6030_event_spec[] = {
 252	{
 253		.type = IIO_EV_TYPE_THRESH,
 254		.dir = IIO_EV_DIR_RISING,
 255		.mask_separate = BIT(IIO_EV_INFO_VALUE),
 256	}, {
 257		.type = IIO_EV_TYPE_THRESH,
 258		.dir = IIO_EV_DIR_FALLING,
 259		.mask_separate = BIT(IIO_EV_INFO_VALUE),
 260	}, {
 261		.type = IIO_EV_TYPE_THRESH,
 262		.dir = IIO_EV_DIR_EITHER,
 263		.mask_separate = BIT(IIO_EV_INFO_PERIOD) |
 264		BIT(IIO_EV_INFO_ENABLE),
 265	},
 266};
 267
 268/* Channel number */
 269enum veml6030_chan {
 270	CH_ALS,
 271	CH_WHITE,
 272};
 273
 274static const struct iio_chan_spec veml6030_channels[] = {
 275	{
 276		.type = IIO_LIGHT,
 277		.channel = CH_ALS,
 278		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 279				BIT(IIO_CHAN_INFO_PROCESSED) |
 280				BIT(IIO_CHAN_INFO_INT_TIME) |
 281				BIT(IIO_CHAN_INFO_SCALE),
 282		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
 283						     BIT(IIO_CHAN_INFO_SCALE),
 284		.event_spec = veml6030_event_spec,
 285		.num_event_specs = ARRAY_SIZE(veml6030_event_spec),
 286		.scan_index = VEML6030_SCAN_ALS,
 287		.scan_type = {
 288			.sign = 'u',
 289			.realbits = 16,
 290			.storagebits = 16,
 291			.endianness = IIO_CPU,
 292		},
 293	},
 294	{
 295		.type = IIO_INTENSITY,
 296		.channel = CH_WHITE,
 297		.modified = 1,
 298		.channel2 = IIO_MOD_LIGHT_BOTH,
 299		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 300				BIT(IIO_CHAN_INFO_INT_TIME) |
 301				BIT(IIO_CHAN_INFO_SCALE),
 302		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
 303						     BIT(IIO_CHAN_INFO_SCALE),
 304		.scan_index = VEML6030_SCAN_WH,
 305		.scan_type = {
 306			.sign = 'u',
 307			.realbits = 16,
 308			.storagebits = 16,
 309			.endianness = IIO_CPU,
 310		},
 311	},
 312	IIO_CHAN_SOFT_TIMESTAMP(VEML6030_SCAN_TIMESTAMP),
 313};
 314
 315static const struct iio_chan_spec veml7700_channels[] = {
 316	{
 317		.type = IIO_LIGHT,
 318		.channel = CH_ALS,
 319		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 320				BIT(IIO_CHAN_INFO_PROCESSED) |
 321				BIT(IIO_CHAN_INFO_INT_TIME) |
 322				BIT(IIO_CHAN_INFO_SCALE),
 323		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
 324						     BIT(IIO_CHAN_INFO_SCALE),
 325		.scan_index = VEML6030_SCAN_ALS,
 326		.scan_type = {
 327			.sign = 'u',
 328			.realbits = 16,
 329			.storagebits = 16,
 330			.endianness = IIO_CPU,
 331		},
 332	},
 333	{
 334		.type = IIO_INTENSITY,
 335		.channel = CH_WHITE,
 336		.modified = 1,
 337		.channel2 = IIO_MOD_LIGHT_BOTH,
 338		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 339				BIT(IIO_CHAN_INFO_INT_TIME) |
 340				BIT(IIO_CHAN_INFO_SCALE),
 341		.info_mask_shared_by_all_available = BIT(IIO_CHAN_INFO_INT_TIME) |
 342						     BIT(IIO_CHAN_INFO_SCALE),
 343		.scan_index = VEML6030_SCAN_WH,
 344		.scan_type = {
 345			.sign = 'u',
 346			.realbits = 16,
 347			.storagebits = 16,
 348			.endianness = IIO_CPU,
 349		},
 350	},
 351	IIO_CHAN_SOFT_TIMESTAMP(VEML6030_SCAN_TIMESTAMP),
 352};
 353
 354static const struct regmap_range veml6030_readable_ranges[] = {
 355	regmap_reg_range(VEML6030_REG_ALS_CONF, VEML6030_REG_ALS_INT),
 356};
 357
 358static const struct regmap_access_table veml6030_readable_table = {
 359	.yes_ranges = veml6030_readable_ranges,
 360	.n_yes_ranges = ARRAY_SIZE(veml6030_readable_ranges),
 361};
 362
 363static const struct regmap_range veml6030_writable_ranges[] = {
 364	regmap_reg_range(VEML6030_REG_ALS_CONF, VEML6030_REG_ALS_PSM),
 365};
 366
 367static const struct regmap_access_table veml6030_writable_table = {
 368	.yes_ranges = veml6030_writable_ranges,
 369	.n_yes_ranges = ARRAY_SIZE(veml6030_writable_ranges),
 370};
 371
 372static const struct regmap_range veml6030_volatile_ranges[] = {
 373	regmap_reg_range(VEML6030_REG_ALS_DATA, VEML6030_REG_WH_DATA),
 374};
 375
 376static const struct regmap_access_table veml6030_volatile_table = {
 377	.yes_ranges = veml6030_volatile_ranges,
 378	.n_yes_ranges = ARRAY_SIZE(veml6030_volatile_ranges),
 379};
 380
 381static const struct regmap_config veml6030_regmap_config = {
 382	.name = "veml6030_regmap",
 383	.reg_bits = 8,
 384	.val_bits = 16,
 385	.max_register = VEML6030_REG_ALS_INT,
 386	.val_format_endian = REGMAP_ENDIAN_LITTLE,
 387	.rd_table = &veml6030_readable_table,
 388	.wr_table = &veml6030_writable_table,
 389	.volatile_table = &veml6030_volatile_table,
 390	.cache_type = REGCACHE_RBTREE,
 391};
 392
 393static int veml6030_get_it(struct veml6030_data *data, int *val, int *val2)
 394{
 395	int ret, it_idx;
 396
 397	ret = regmap_field_read(data->rf.it, &it_idx);
 398	if (ret)
 399		return ret;
 400
 401	ret = iio_gts_find_int_time_by_sel(&data->gts, it_idx);
 402	if (ret < 0)
 403		return ret;
 404
 405	*val2 = ret;
 406	*val = 0;
 407
 408	return IIO_VAL_INT_PLUS_MICRO;
 409}
 410
 411static int veml6030_set_it(struct iio_dev *indio_dev, int val, int val2)
 412{
 413	struct veml6030_data *data = iio_priv(indio_dev);
 414	int ret, gain_idx, it_idx, new_gain, prev_gain, prev_it;
 415	bool in_range;
 416
 417	if (val || !iio_gts_valid_time(&data->gts, val2))
 418		return -EINVAL;
 419
 420	ret = regmap_field_read(data->rf.it, &it_idx);
 421	if (ret)
 422		return ret;
 423
 424	ret = regmap_field_read(data->rf.gain, &gain_idx);
 425	if (ret)
 426		return ret;
 427
 428	prev_it = iio_gts_find_int_time_by_sel(&data->gts, it_idx);
 429	if (prev_it < 0)
 430		return prev_it;
 431
 432	if (prev_it == val2)
 433		return 0;
 434
 435	prev_gain = iio_gts_find_gain_by_sel(&data->gts, gain_idx);
 436	if (prev_gain < 0)
 437		return prev_gain;
 438
 439	ret = iio_gts_find_new_gain_by_gain_time_min(&data->gts, prev_gain, prev_it,
 440						     val2, &new_gain, &in_range);
 441	if (ret)
 442		return ret;
 443
 444	if (!in_range)
 445		dev_dbg(&data->client->dev, "Optimal gain out of range\n");
 446
 447	ret = iio_gts_find_sel_by_int_time(&data->gts, val2);
 448	if (ret < 0)
 449		return ret;
 450
 451	ret = regmap_field_write(data->rf.it, ret);
 452	if (ret)
 453		return ret;
 454
 455	ret = iio_gts_find_sel_by_gain(&data->gts, new_gain);
 456	if (ret < 0)
 457		return ret;
 458
 459	return regmap_field_write(data->rf.gain, ret);
 460}
 461
 462static int veml6030_read_persistence(struct iio_dev *indio_dev,
 463						int *val, int *val2)
 464{
 465	int ret, reg, period, x, y;
 466	struct veml6030_data *data = iio_priv(indio_dev);
 467
 468	ret = veml6030_get_it(data, &x, &y);
 469	if (ret < 0)
 470		return ret;
 471
 472	ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, &reg);
 473	if (ret) {
 474		dev_err(&data->client->dev,
 475				"can't read als conf register %d\n", ret);
 476	}
 477
 478	/* integration time multiplied by 1/2/4/8 */
 479	period = y * (1 << ((reg >> 4) & 0x03));
 480
 481	*val = period / 1000000;
 482	*val2 = period % 1000000;
 483
 484	return IIO_VAL_INT_PLUS_MICRO;
 485}
 486
 487static int veml6030_write_persistence(struct iio_dev *indio_dev,
 488						int val, int val2)
 489{
 490	int ret, period, x, y;
 491	struct veml6030_data *data = iio_priv(indio_dev);
 492
 493	ret = veml6030_get_it(data, &x, &y);
 494	if (ret < 0)
 495		return ret;
 496
 497	if (!val) {
 498		period = val2 / y;
 499	} else {
 500		if ((val == 1) && (val2 == 600000))
 501			period = 1600000 / y;
 502		else if ((val == 3) && (val2 == 200000))
 503			period = 3200000 / y;
 504		else if ((val == 6) && (val2 == 400000))
 505			period = 6400000 / y;
 506		else
 507			period = -1;
 508	}
 509
 510	if (period <= 0 || period > 8 || hweight8(period) != 1)
 511		return -EINVAL;
 512
 513	ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF,
 514				VEML6030_ALS_PERS, (ffs(period) - 1) << 4);
 515	if (ret)
 516		dev_err(&data->client->dev,
 517				"can't set persistence value %d\n", ret);
 518
 519	return ret;
 520}
 521
 522static int veml6030_set_scale(struct iio_dev *indio_dev, int val, int val2)
 523{
 524	int ret, gain_sel, it_idx, it_sel;
 525	struct veml6030_data *data = iio_priv(indio_dev);
 526
 527	ret = regmap_field_read(data->rf.it, &it_idx);
 528	if (ret)
 529		return ret;
 530
 531	ret = iio_gts_find_gain_time_sel_for_scale(&data->gts, val, val2,
 532						   &gain_sel, &it_sel);
 533	if (ret)
 534		return ret;
 535
 536	ret = regmap_field_write(data->rf.it, it_sel);
 537	if (ret)
 538		return ret;
 539
 540	ret = regmap_field_write(data->rf.gain, gain_sel);
 541	if (ret)
 542		return ret;
 543
 544	return 0;
 545}
 546
 547static int veml6030_read_thresh(struct iio_dev *indio_dev,
 548						int *val, int *val2, int dir)
 549{
 550	int ret, reg;
 551	struct veml6030_data *data = iio_priv(indio_dev);
 552
 553	if (dir == IIO_EV_DIR_RISING)
 554		ret = regmap_read(data->regmap, VEML6030_REG_ALS_WH, &reg);
 555	else
 556		ret = regmap_read(data->regmap, VEML6030_REG_ALS_WL, &reg);
 557	if (ret) {
 558		dev_err(&data->client->dev,
 559				"can't read als threshold value %d\n", ret);
 560		return ret;
 561	}
 562
 563	*val = reg & 0xffff;
 564	return IIO_VAL_INT;
 565}
 566
 567static int veml6030_write_thresh(struct iio_dev *indio_dev,
 568						int val, int val2, int dir)
 569{
 570	int ret;
 571	struct veml6030_data *data = iio_priv(indio_dev);
 572
 573	if (val > 0xFFFF || val < 0 || val2)
 574		return -EINVAL;
 575
 576	if (dir == IIO_EV_DIR_RISING) {
 577		ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, val);
 578		if (ret)
 579			dev_err(&data->client->dev,
 580					"can't set high threshold %d\n", ret);
 581	} else {
 582		ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, val);
 583		if (ret)
 584			dev_err(&data->client->dev,
 585					"can't set low threshold %d\n", ret);
 586	}
 587
 588	return ret;
 589}
 590
 591static int veml6030_get_total_gain(struct veml6030_data *data)
 592{
 593	int gain, it, reg, ret;
 594
 595	ret = regmap_field_read(data->rf.gain, &reg);
 596	if (ret)
 597		return ret;
 598
 599	gain = iio_gts_find_gain_by_sel(&data->gts, reg);
 600	if (gain < 0)
 601		return gain;
 602
 603	ret = regmap_field_read(data->rf.it, &reg);
 604	if (ret)
 605		return ret;
 606
 607	it = iio_gts_find_int_time_by_sel(&data->gts, reg);
 608	if (it < 0)
 609		return it;
 610
 611	return iio_gts_get_total_gain(&data->gts, gain, it);
 612}
 613
 614static int veml6030_get_scale(struct veml6030_data *data, int *val, int *val2)
 615{
 616	int gain, it, reg, ret;
 617
 618	ret = regmap_field_read(data->rf.gain, &reg);
 619	if (ret)
 620		return ret;
 621
 622	gain = iio_gts_find_gain_by_sel(&data->gts, reg);
 623	if (gain < 0)
 624		return gain;
 625
 626	ret = regmap_field_read(data->rf.it, &reg);
 627	if (ret)
 628		return ret;
 629
 630	it = iio_gts_find_int_time_by_sel(&data->gts, reg);
 631	if (it < 0)
 632		return it;
 633
 634	ret = iio_gts_get_scale(&data->gts, gain, it, val, val2);
 635	if (ret)
 636		return ret;
 637
 638	return IIO_VAL_INT_PLUS_NANO;
 639}
 640
 641static int veml6030_process_als(struct veml6030_data *data, int raw,
 642				int *val, int *val2)
 643{
 644	int total_gain;
 645
 646	total_gain = veml6030_get_total_gain(data);
 647	if (total_gain < 0)
 648		return total_gain;
 649
 650	*val = raw * data->chip->max_scale / total_gain / 10000;
 651	*val2 = raw * data->chip->max_scale / total_gain % 10000 * 100;
 652
 653	return IIO_VAL_INT_PLUS_MICRO;
 654}
 655
 656/*
 657 * Provide both raw as well as light reading in lux.
 658 * light (in lux) = resolution * raw reading
 659 */
 660static int veml6030_read_raw(struct iio_dev *indio_dev,
 661			    struct iio_chan_spec const *chan, int *val,
 662			    int *val2, long mask)
 663{
 664	int ret, reg;
 665	struct veml6030_data *data = iio_priv(indio_dev);
 666	struct regmap *regmap = data->regmap;
 667	struct device *dev = &data->client->dev;
 668
 669	switch (mask) {
 670	case IIO_CHAN_INFO_RAW:
 671	case IIO_CHAN_INFO_PROCESSED:
 672		switch (chan->type) {
 673		case IIO_LIGHT:
 674			ret = regmap_read(regmap, VEML6030_REG_ALS_DATA, &reg);
 675			if (ret < 0) {
 676				dev_err(dev, "can't read als data %d\n", ret);
 677				return ret;
 678			}
 679			if (mask == IIO_CHAN_INFO_PROCESSED)
 680				return veml6030_process_als(data, reg, val, val2);
 681
 682			*val = reg;
 683			return IIO_VAL_INT;
 684		case IIO_INTENSITY:
 685			ret = regmap_read(regmap, VEML6030_REG_WH_DATA, &reg);
 686			if (ret < 0) {
 687				dev_err(dev, "can't read white data %d\n", ret);
 688				return ret;
 689			}
 690			*val = reg;
 691			return IIO_VAL_INT;
 692		default:
 693			return -EINVAL;
 694		}
 695	case IIO_CHAN_INFO_INT_TIME:
 696		return veml6030_get_it(data, val, val2);
 697	case IIO_CHAN_INFO_SCALE:
 698		return veml6030_get_scale(data, val, val2);
 699	default:
 700		return -EINVAL;
 701	}
 702}
 703
 704static int veml6030_read_avail(struct iio_dev *indio_dev,
 705			       struct iio_chan_spec const *chan,
 706			       const int **vals, int *type, int *length,
 707			       long mask)
 708{
 709	struct veml6030_data *data = iio_priv(indio_dev);
 710
 711	switch (mask) {
 712	case IIO_CHAN_INFO_INT_TIME:
 713		return iio_gts_avail_times(&data->gts, vals, type, length);
 714	case IIO_CHAN_INFO_SCALE:
 715		return iio_gts_all_avail_scales(&data->gts, vals, type, length);
 716	}
 717
 718	return -EINVAL;
 719}
 720
 721static int veml6030_write_raw(struct iio_dev *indio_dev,
 722				struct iio_chan_spec const *chan,
 723				int val, int val2, long mask)
 724{
 725	switch (mask) {
 726	case IIO_CHAN_INFO_INT_TIME:
 727		return veml6030_set_it(indio_dev, val, val2);
 728	case IIO_CHAN_INFO_SCALE:
 729		return veml6030_set_scale(indio_dev, val, val2);
 730	default:
 731		return -EINVAL;
 732	}
 733}
 734
 735static int veml6030_write_raw_get_fmt(struct iio_dev *indio_dev,
 736				      struct iio_chan_spec const *chan,
 737				      long mask)
 738{
 739	switch (mask) {
 740	case IIO_CHAN_INFO_SCALE:
 741		return IIO_VAL_INT_PLUS_NANO;
 742	case IIO_CHAN_INFO_INT_TIME:
 743		return IIO_VAL_INT_PLUS_MICRO;
 744	default:
 745		return -EINVAL;
 746	}
 747}
 748
 749static int veml6030_read_event_val(struct iio_dev *indio_dev,
 750		const struct iio_chan_spec *chan, enum iio_event_type type,
 751		enum iio_event_direction dir, enum iio_event_info info,
 752		int *val, int *val2)
 753{
 754	switch (info) {
 755	case IIO_EV_INFO_VALUE:
 756		switch (dir) {
 757		case IIO_EV_DIR_RISING:
 758		case IIO_EV_DIR_FALLING:
 759			return veml6030_read_thresh(indio_dev, val, val2, dir);
 760		default:
 761			return -EINVAL;
 762		}
 763		break;
 764	case IIO_EV_INFO_PERIOD:
 765		return veml6030_read_persistence(indio_dev, val, val2);
 766	default:
 767		return -EINVAL;
 768	}
 769}
 770
 771static int veml6030_write_event_val(struct iio_dev *indio_dev,
 772		const struct iio_chan_spec *chan, enum iio_event_type type,
 773		enum iio_event_direction dir, enum iio_event_info info,
 774		int val, int val2)
 775{
 776	switch (info) {
 777	case IIO_EV_INFO_VALUE:
 778		return veml6030_write_thresh(indio_dev, val, val2, dir);
 779	case IIO_EV_INFO_PERIOD:
 780		return veml6030_write_persistence(indio_dev, val, val2);
 781	default:
 782		return -EINVAL;
 783	}
 784}
 785
 786static int veml6030_read_interrupt_config(struct iio_dev *indio_dev,
 787		const struct iio_chan_spec *chan, enum iio_event_type type,
 788		enum iio_event_direction dir)
 789{
 790	int ret, reg;
 791	struct veml6030_data *data = iio_priv(indio_dev);
 792
 793	ret = regmap_read(data->regmap, VEML6030_REG_ALS_CONF, &reg);
 794	if (ret) {
 795		dev_err(&data->client->dev,
 796				"can't read als conf register %d\n", ret);
 797		return ret;
 798	}
 799
 800	if (reg & VEML6030_ALS_INT_EN)
 801		return 1;
 802	else
 803		return 0;
 804}
 805
 806/*
 807 * Sensor should not be measuring light when interrupt is configured.
 808 * Therefore correct sequence to configure interrupt functionality is:
 809 * shut down -> enable/disable interrupt -> power on
 810 *
 811 * state = 1 enables interrupt, state = 0 disables interrupt
 812 */
 813static int veml6030_write_interrupt_config(struct iio_dev *indio_dev,
 814		const struct iio_chan_spec *chan, enum iio_event_type type,
 815		enum iio_event_direction dir, bool state)
 816{
 817	int ret;
 818	struct veml6030_data *data = iio_priv(indio_dev);
 819
 820	ret = veml6030_als_shut_down(data);
 821	if (ret < 0) {
 822		dev_err(&data->client->dev,
 823			"can't disable als to configure interrupt %d\n", ret);
 824		return ret;
 825	}
 826
 827	/* enable interrupt + power on */
 828	ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_CONF,
 829			VEML6030_ALS_INT_EN | VEML6030_ALS_SD, state << 1);
 830	if (ret)
 831		dev_err(&data->client->dev,
 832			"can't enable interrupt & poweron als %d\n", ret);
 833
 834	return ret;
 835}
 836
 837static const struct iio_info veml6030_info = {
 838	.read_raw  = veml6030_read_raw,
 839	.read_avail  = veml6030_read_avail,
 840	.write_raw = veml6030_write_raw,
 841	.write_raw_get_fmt = veml6030_write_raw_get_fmt,
 842	.read_event_value = veml6030_read_event_val,
 843	.write_event_value	= veml6030_write_event_val,
 844	.read_event_config = veml6030_read_interrupt_config,
 845	.write_event_config	= veml6030_write_interrupt_config,
 846	.event_attrs = &veml6030_event_attr_group,
 847};
 848
 849static const struct iio_info veml6030_info_no_irq = {
 850	.read_raw  = veml6030_read_raw,
 851	.read_avail  = veml6030_read_avail,
 852	.write_raw = veml6030_write_raw,
 853	.write_raw_get_fmt = veml6030_write_raw_get_fmt,
 854};
 855
 856static irqreturn_t veml6030_event_handler(int irq, void *private)
 857{
 858	int ret, reg, evtdir;
 859	struct iio_dev *indio_dev = private;
 860	struct veml6030_data *data = iio_priv(indio_dev);
 861
 862	ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &reg);
 863	if (ret) {
 864		dev_err(&data->client->dev,
 865				"can't read als interrupt register %d\n", ret);
 866		return IRQ_HANDLED;
 867	}
 868
 869	/* Spurious interrupt handling */
 870	if (!(reg & (VEML6030_INT_TH_HIGH | VEML6030_INT_TH_LOW)))
 871		return IRQ_NONE;
 872
 873	if (reg & VEML6030_INT_TH_HIGH)
 874		evtdir = IIO_EV_DIR_RISING;
 875	else
 876		evtdir = IIO_EV_DIR_FALLING;
 877
 878	iio_push_event(indio_dev, IIO_UNMOD_EVENT_CODE(IIO_INTENSITY,
 879					0, IIO_EV_TYPE_THRESH, evtdir),
 880					iio_get_time_ns(indio_dev));
 881
 882	return IRQ_HANDLED;
 883}
 884
 885static irqreturn_t veml6030_trigger_handler(int irq, void *p)
 886{
 887	struct iio_poll_func *pf = p;
 888	struct iio_dev *iio = pf->indio_dev;
 889	struct veml6030_data *data = iio_priv(iio);
 890	unsigned int reg;
 891	int ch, ret, i = 0;
 892	struct {
 893		u16 chans[2];
 894		aligned_s64 timestamp;
 895	} scan = { };
 896
 897	iio_for_each_active_channel(iio, ch) {
 898		ret = regmap_read(data->regmap, VEML6030_REG_DATA(ch),
 899				  &reg);
 900		if (ret)
 901			goto done;
 902
 903		scan.chans[i++] = reg;
 904	}
 905
 906	iio_push_to_buffers_with_ts(iio, &scan, sizeof(scan), pf->timestamp);
 907
 908done:
 909	iio_trigger_notify_done(iio->trig);
 910
 911	return IRQ_HANDLED;
 912}
 913
 914static int veml6030_set_info(struct iio_dev *indio_dev)
 915{
 916	struct veml6030_data *data = iio_priv(indio_dev);
 917	struct i2c_client *client = data->client;
 918	int ret;
 919
 920	if (client->irq) {
 921		ret = devm_request_threaded_irq(&client->dev, client->irq,
 922						NULL, veml6030_event_handler,
 923						IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 924						indio_dev->name, indio_dev);
 925		if (ret < 0)
 926			return dev_err_probe(&client->dev, ret,
 927					     "irq %d request failed\n",
 928					     client->irq);
 929
 930		indio_dev->info = &veml6030_info;
 931	} else {
 932		indio_dev->info = &veml6030_info_no_irq;
 933	}
 934
 935	return 0;
 936}
 937
 938static int veml7700_set_info(struct iio_dev *indio_dev)
 939{
 940	indio_dev->info = &veml6030_info_no_irq;
 941
 942	return 0;
 943}
 944
 945static int veml6030_regfield_init(struct iio_dev *indio_dev)
 946{
 947	struct veml6030_data *data = iio_priv(indio_dev);
 948	struct regmap *regmap = data->regmap;
 949	struct device *dev = &data->client->dev;
 950	struct regmap_field *rm_field;
 951	struct veml6030_rf *rf = &data->rf;
 952
 953	rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->it_rf);
 954	if (IS_ERR(rm_field))
 955		return PTR_ERR(rm_field);
 956	rf->it = rm_field;
 957
 958	rm_field = devm_regmap_field_alloc(dev, regmap, data->chip->gain_rf);
 959	if (IS_ERR(rm_field))
 960		return PTR_ERR(rm_field);
 961	rf->gain = rm_field;
 962
 963	return 0;
 964}
 965
 966/*
 967 * Set ALS gain to 1/8, integration time to 100 ms, PSM to mode 2,
 968 * persistence to 1 x integration time and the threshold
 969 * interrupt disabled by default. First shutdown the sensor,
 970 * update registers and then power on the sensor.
 971 */
 972static int veml6030_hw_init(struct iio_dev *indio_dev, struct device *dev)
 973{
 974	int ret, val;
 975	struct veml6030_data *data = iio_priv(indio_dev);
 976
 977	ret = devm_iio_init_iio_gts(dev, 2, 150400000,
 978				    veml6030_gain_sel, ARRAY_SIZE(veml6030_gain_sel),
 979				    veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel),
 980				    &data->gts);
 981	if (ret)
 982		return dev_err_probe(dev, ret, "failed to init iio gts\n");
 983
 984	ret = veml6030_als_shut_down(data);
 985	if (ret)
 986		return dev_err_probe(dev, ret, "can't shutdown als\n");
 987
 988	ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF, 0x1001);
 989	if (ret)
 990		return dev_err_probe(dev, ret, "can't setup als configs\n");
 991
 992	ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM,
 993				 VEML6030_PSM | VEML6030_PSM_EN, 0x03);
 994	if (ret)
 995		return dev_err_probe(dev, ret, "can't setup default PSM\n");
 996
 997	ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF);
 998	if (ret)
 999		return dev_err_probe(dev, ret, "can't setup high threshold\n");
1000
1001	ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000);
1002	if (ret)
1003		return dev_err_probe(dev, ret, "can't setup low threshold\n");
1004
1005	ret = veml6030_als_pwr_on(data);
1006	if (ret)
1007		return dev_err_probe(dev, ret, "can't poweron als\n");
1008
1009	ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data);
1010	if (ret < 0)
1011		return ret;
1012
1013	/* Clear stale interrupt status bits if any during start */
1014	ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val);
1015	if (ret < 0)
1016		return dev_err_probe(dev, ret,
1017				     "can't clear als interrupt status\n");
1018
1019	return ret;
1020}
1021
1022/*
1023 * Set ALS gain to 1/8, integration time to 100 ms, ALS and WHITE
1024 * channel enabled, ALS channel interrupt, PSM enabled,
1025 * PSM_WAIT = 0.8 s, persistence to 1 x integration time and the
1026 * threshold interrupt disabled by default. First shutdown the sensor,
1027 * update registers and then power on the sensor.
1028 */
1029static int veml6035_hw_init(struct iio_dev *indio_dev, struct device *dev)
1030{
1031	int ret, val;
1032	struct veml6030_data *data = iio_priv(indio_dev);
1033
1034	ret = devm_iio_init_iio_gts(dev, 0, 409600000,
1035				    veml6035_gain_sel, ARRAY_SIZE(veml6035_gain_sel),
1036				    veml6030_it_sel, ARRAY_SIZE(veml6030_it_sel),
1037				    &data->gts);
1038	if (ret)
1039		return dev_err_probe(dev, ret, "failed to init iio gts\n");
1040
1041	ret = veml6030_als_shut_down(data);
1042	if (ret)
1043		return dev_err_probe(dev, ret, "can't shutdown als\n");
1044
1045	ret = regmap_write(data->regmap, VEML6030_REG_ALS_CONF,
1046			   VEML6035_SENS | VEML6035_CHAN_EN | VEML6030_ALS_SD);
1047	if (ret)
1048		return dev_err_probe(dev, ret, "can't setup als configs\n");
1049
1050	ret = regmap_update_bits(data->regmap, VEML6030_REG_ALS_PSM,
1051				 VEML6030_PSM | VEML6030_PSM_EN, 0x03);
1052	if (ret)
1053		return dev_err_probe(dev, ret, "can't setup default PSM\n");
1054
1055	ret = regmap_write(data->regmap, VEML6030_REG_ALS_WH, 0xFFFF);
1056	if (ret)
1057		return dev_err_probe(dev, ret, "can't setup high threshold\n");
1058
1059	ret = regmap_write(data->regmap, VEML6030_REG_ALS_WL, 0x0000);
1060	if (ret)
1061		return dev_err_probe(dev, ret, "can't setup low threshold\n");
1062
1063	ret = veml6030_als_pwr_on(data);
1064	if (ret)
1065		return dev_err_probe(dev, ret, "can't poweron als\n");
1066
1067	ret = devm_add_action_or_reset(dev, veml6030_als_shut_down_action, data);
1068	if (ret < 0)
1069		return ret;
1070
1071	/* Clear stale interrupt status bits if any during start */
1072	ret = regmap_read(data->regmap, VEML6030_REG_ALS_INT, &val);
1073	if (ret < 0)
1074		return dev_err_probe(dev, ret,
1075				     "can't clear als interrupt status\n");
1076
1077	return 0;
1078}
1079
1080static int veml6030_probe(struct i2c_client *client)
1081{
1082	int ret;
1083	struct veml6030_data *data;
1084	struct iio_dev *indio_dev;
1085	struct regmap *regmap;
1086
1087	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
1088		return dev_err_probe(&client->dev, -EOPNOTSUPP,
1089				     "i2c adapter doesn't support plain i2c\n");
1090
1091	regmap = devm_regmap_init_i2c(client, &veml6030_regmap_config);
1092	if (IS_ERR(regmap))
1093		return dev_err_probe(&client->dev, PTR_ERR(regmap),
1094				     "can't setup regmap\n");
1095
1096	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1097	if (!indio_dev)
1098		return -ENOMEM;
1099
1100	data = iio_priv(indio_dev);
1101	i2c_set_clientdata(client, indio_dev);
1102	data->client = client;
1103	data->regmap = regmap;
1104
1105	ret = devm_regulator_get_enable(&client->dev, "vdd");
1106	if (ret)
1107		return dev_err_probe(&client->dev, ret,
1108				     "failed to enable regulator\n");
1109
1110	data->chip = i2c_get_match_data(client);
1111	if (!data->chip)
1112		return -EINVAL;
1113
1114	indio_dev->name = data->chip->name;
1115	indio_dev->channels = data->chip->channels;
1116	indio_dev->num_channels = data->chip->num_channels;
1117	indio_dev->modes = INDIO_DIRECT_MODE;
1118
1119	ret = data->chip->set_info(indio_dev);
1120	if (ret < 0)
1121		return ret;
1122
1123	ret = veml6030_regfield_init(indio_dev);
1124	if (ret)
1125		return dev_err_probe(&client->dev, ret,
1126				     "failed to init regfields\n");
1127
1128	ret = data->chip->hw_init(indio_dev, &client->dev);
1129	if (ret < 0)
1130		return ret;
1131
1132	ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, NULL,
1133					      veml6030_trigger_handler, NULL);
1134	if (ret)
1135		return dev_err_probe(&client->dev, ret,
1136				     "Failed to register triggered buffer");
1137
1138	return devm_iio_device_register(&client->dev, indio_dev);
1139}
1140
1141static int veml6030_runtime_suspend(struct device *dev)
1142{
1143	int ret;
1144	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1145	struct veml6030_data *data = iio_priv(indio_dev);
1146
1147	ret = veml6030_als_shut_down(data);
1148	if (ret < 0)
1149		dev_err(&data->client->dev, "can't suspend als %d\n", ret);
1150
1151	return ret;
1152}
1153
1154static int veml6030_runtime_resume(struct device *dev)
1155{
1156	int ret;
1157	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1158	struct veml6030_data *data = iio_priv(indio_dev);
1159
1160	ret = veml6030_als_pwr_on(data);
1161	if (ret < 0)
1162		dev_err(&data->client->dev, "can't resume als %d\n", ret);
1163
1164	return ret;
1165}
1166
1167static DEFINE_RUNTIME_DEV_PM_OPS(veml6030_pm_ops, veml6030_runtime_suspend,
1168				 veml6030_runtime_resume, NULL);
1169
1170static const struct veml603x_chip veml6030_chip = {
1171	.name = "veml6030",
1172	.channels = veml6030_channels,
1173	.num_channels = ARRAY_SIZE(veml6030_channels),
1174	.gain_rf = VEML6030_GAIN_RF,
1175	.it_rf = VEML6030_IT_RF,
1176	.max_scale = VEML6030_MAX_SCALE,
1177	.hw_init = veml6030_hw_init,
1178	.set_info = veml6030_set_info,
1179};
1180
1181static const struct veml603x_chip veml6035_chip = {
1182	.name = "veml6035",
1183	.channels = veml6030_channels,
1184	.num_channels = ARRAY_SIZE(veml6030_channels),
1185	.gain_rf = VEML6035_GAIN_RF,
1186	.it_rf = VEML6030_IT_RF,
1187	.max_scale = VEML6035_MAX_SCALE,
1188	.hw_init = veml6035_hw_init,
1189	.set_info = veml6030_set_info,
1190};
1191
1192static const struct veml603x_chip veml7700_chip = {
1193	.name = "veml7700",
1194	.channels = veml7700_channels,
1195	.num_channels = ARRAY_SIZE(veml7700_channels),
1196	.gain_rf = VEML6030_GAIN_RF,
1197	.it_rf = VEML6030_IT_RF,
1198	.max_scale = VEML6030_MAX_SCALE,
1199	.hw_init = veml6030_hw_init,
1200	.set_info = veml7700_set_info,
1201};
1202
1203static const struct of_device_id veml6030_of_match[] = {
1204	{
1205		.compatible = "vishay,veml6030",
1206		.data = &veml6030_chip,
1207	},
1208	{
1209		.compatible = "vishay,veml6035",
1210		.data = &veml6035_chip,
1211	},
1212	{
1213		.compatible = "vishay,veml7700",
1214		.data = &veml7700_chip,
1215	},
1216	{ }
1217};
1218MODULE_DEVICE_TABLE(of, veml6030_of_match);
1219
1220static const struct i2c_device_id veml6030_id[] = {
1221	{ "veml6030", (kernel_ulong_t)&veml6030_chip},
1222	{ "veml6035", (kernel_ulong_t)&veml6035_chip},
1223	{ "veml7700", (kernel_ulong_t)&veml7700_chip},
1224	{ }
1225};
1226MODULE_DEVICE_TABLE(i2c, veml6030_id);
1227
1228static struct i2c_driver veml6030_driver = {
1229	.driver = {
1230		.name = "veml6030",
1231		.of_match_table = veml6030_of_match,
1232		.pm = pm_ptr(&veml6030_pm_ops),
1233	},
1234	.probe = veml6030_probe,
1235	.id_table = veml6030_id,
1236};
1237module_i2c_driver(veml6030_driver);
1238
1239MODULE_AUTHOR("Rishi Gupta <gupt21@gmail.com>");
1240MODULE_DESCRIPTION("VEML6030 Ambient Light Sensor");
1241MODULE_LICENSE("GPL v2");
1242MODULE_IMPORT_NS("IIO_GTS_HELPER");