1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* vcnl4000.c - Support for Vishay VCNL4000/4010/4020/4040/4200 combined ambient
4	* light and proximity sensor
5	*
6	* Copyright 2012 Peter Meerwald <pmeerw@pmeerw.net>
7	* Copyright 2019 Pursim SPC
8	* Copyright 2020 Mathieu Othacehe <m.othacehe@gmail.com>
9	*
10	* IIO driver for:
11	* VCNL4000/10/20 (7-bit I2C slave address 0x13)
12	* VCNL4040 (7-bit I2C slave address 0x60)
13	* VCNL4200 (7-bit I2C slave address 0x51)
14	*
15	* TODO:
16	* allow to adjust IR current
17	* interrupts (VCNL4040, VCNL4200)
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/delay.h>
25	#include <linux/pm_runtime.h>
26	#include <linux/interrupt.h>
27	#include <linux/units.h>
28
29	#include <linux/iio/buffer.h>
30	#include <linux/iio/events.h>
31	#include <linux/iio/iio.h>
32	#include <linux/iio/sysfs.h>
33	#include <linux/iio/trigger.h>
34	#include <linux/iio/trigger_consumer.h>
35	#include <linux/iio/triggered_buffer.h>
36
37	#define VCNL4000_DRV_NAME "vcnl4000"
38	#define VCNL4000_PROD_ID 0x01
39	#define VCNL4010_PROD_ID 0x02 /* for VCNL4020, VCNL4010 */
40	#define VCNL4040_PROD_ID 0x86
41	#define VCNL4200_PROD_ID 0x58
42
43	#define VCNL4000_COMMAND 0x80 /* Command register */
44	#define VCNL4000_PROD_REV 0x81 /* Product ID and Revision ID */
45	#define VCNL4010_PROX_RATE 0x82 /* Proximity rate */
46	#define VCNL4000_LED_CURRENT 0x83 /* IR LED current for proximity mode */
47	#define VCNL4000_AL_PARAM 0x84 /* Ambient light parameter register */
48	#define VCNL4010_ALS_PARAM 0x84 /* ALS rate */
49	#define VCNL4000_AL_RESULT_HI 0x85 /* Ambient light result register, MSB */
50	#define VCNL4000_AL_RESULT_LO 0x86 /* Ambient light result register, LSB */
51	#define VCNL4000_PS_RESULT_HI 0x87 /* Proximity result register, MSB */
52	#define VCNL4000_PS_RESULT_LO 0x88 /* Proximity result register, LSB */
53	#define VCNL4000_PS_MEAS_FREQ 0x89 /* Proximity test signal frequency */
54	#define VCNL4010_INT_CTRL 0x89 /* Interrupt control */
55	#define VCNL4000_PS_MOD_ADJ 0x8a /* Proximity modulator timing adjustment */
56	#define VCNL4010_LOW_THR_HI 0x8a /* Low threshold, MSB */
57	#define VCNL4010_LOW_THR_LO 0x8b /* Low threshold, LSB */
58	#define VCNL4010_HIGH_THR_HI 0x8c /* High threshold, MSB */
59	#define VCNL4010_HIGH_THR_LO 0x8d /* High threshold, LSB */
60	#define VCNL4010_ISR 0x8e /* Interrupt status */
61
62	#define VCNL4200_AL_CONF 0x00 /* Ambient light configuration */
63	#define VCNL4200_PS_CONF1 0x03 /* Proximity configuration */
64	#define VCNL4200_PS_CONF3 0x04 /* Proximity configuration */
65	#define VCNL4040_PS_THDL_LM 0x06 /* Proximity threshold low */
66	#define VCNL4040_PS_THDH_LM 0x07 /* Proximity threshold high */
67	#define VCNL4040_ALS_THDL_LM 0x02 /* Ambient light threshold low */
68	#define VCNL4040_ALS_THDH_LM 0x01 /* Ambient light threshold high */
69	#define VCNL4200_PS_DATA 0x08 /* Proximity data */
70	#define VCNL4200_AL_DATA 0x09 /* Ambient light data */
71	#define VCNL4040_INT_FLAGS 0x0b /* Interrupt register */
72	#define VCNL4200_INT_FLAGS 0x0d /* Interrupt register */
73	#define VCNL4200_DEV_ID 0x0e /* Device ID, slave address and version */
74
75	#define VCNL4040_DEV_ID 0x0c /* Device ID and version */
76
77	/* Bit masks for COMMAND register */
78	#define VCNL4000_AL_RDY BIT(6) /* ALS data ready? */
79	#define VCNL4000_PS_RDY BIT(5) /* proximity data ready? */
80	#define VCNL4000_AL_OD BIT(4) /* start on-demand ALS measurement */
81	#define VCNL4000_PS_OD BIT(3) /* start on-demand proximity measurement */
82	#define VCNL4000_ALS_EN BIT(2) /* start ALS measurement */
83	#define VCNL4000_PROX_EN BIT(1) /* start proximity measurement */
84	#define VCNL4000_SELF_TIMED_EN BIT(0) /* start self-timed measurement */
85
86	#define VCNL4040_ALS_CONF_ALS_SHUTDOWN BIT(0)
87	#define VCNL4040_ALS_CONF_IT GENMASK(7, 6) /* Ambient integration time */
88	#define VCNL4040_ALS_CONF_INT_EN BIT(1) /* Ambient light Interrupt enable */
89	#define VCNL4040_ALS_CONF_PERS GENMASK(3, 2) /* Ambient interrupt persistence setting */
90	#define VCNL4040_PS_CONF1_PS_SHUTDOWN BIT(0)
91	#define VCNL4040_PS_CONF2_PS_IT GENMASK(3, 1) /* Proximity integration time */
92	#define VCNL4040_CONF1_PS_PERS GENMASK(5, 4) /* Proximity interrupt persistence setting */
93	#define VCNL4040_PS_CONF2_PS_INT GENMASK(9, 8) /* Proximity interrupt mode */
94	#define VCNL4040_PS_CONF3_MPS GENMASK(6, 5) /* Proximity multi pulse number */
95	#define VCNL4040_PS_MS_LED_I GENMASK(10, 8) /* Proximity current */
96	#define VCNL4040_PS_IF_AWAY BIT(8) /* Proximity event cross low threshold */
97	#define VCNL4040_PS_IF_CLOSE BIT(9) /* Proximity event cross high threshold */
98	#define VCNL4040_ALS_RISING BIT(12) /* Ambient Light cross high threshold */
99	#define VCNL4040_ALS_FALLING BIT(13) /* Ambient Light cross low threshold */
100
101	/* Bit masks for interrupt registers. */
102	#define VCNL4010_INT_THR_SEL BIT(0) /* Select threshold interrupt source */
103	#define VCNL4010_INT_THR_EN BIT(1) /* Threshold interrupt type */
104	#define VCNL4010_INT_ALS_EN BIT(2) /* Enable on ALS data ready */
105	#define VCNL4010_INT_PROX_EN BIT(3) /* Enable on proximity data ready */
106
107	#define VCNL4010_INT_THR_HIGH 0 /* High threshold exceeded */
108	#define VCNL4010_INT_THR_LOW 1 /* Low threshold exceeded */
109	#define VCNL4010_INT_ALS 2 /* ALS data ready */
110	#define VCNL4010_INT_PROXIMITY 3 /* Proximity data ready */
111
112	#define VCNL4010_INT_THR \
113	(BIT(VCNL4010_INT_THR_LOW) | BIT(VCNL4010_INT_THR_HIGH))
114	#define VCNL4010_INT_DRDY \
115	(BIT(VCNL4010_INT_PROXIMITY) | BIT(VCNL4010_INT_ALS))
116
117	static const int vcnl4010_prox_sampling_frequency[][2] = {
118	{1, 950000},
119	{3, 906250},
120	{7, 812500},
121	{16, 625000},
122	{31, 250000},
123	{62, 500000},
124	{125, 0},
125	{250, 0},
126	};
127
128	static const int vcnl4040_ps_it_times[][2] = {
129	{0, 100},
130	{0, 150},
131	{0, 200},
132	{0, 250},
133	{0, 300},
134	{0, 350},
135	{0, 400},
136	{0, 800},
137	};
138
139	static const int vcnl4200_ps_it_times[][2] = {
140	{0, 96},
141	{0, 144},
142	{0, 192},
143	{0, 384},
144	{0, 768},
145	{0, 864},
146	};
147
148	static const int vcnl4040_als_it_times[][2] = {
149	{0, 80000},
150	{0, 160000},
151	{0, 320000},
152	{0, 640000},
153	};
154
155	static const int vcnl4200_als_it_times[][2] = {
156	{0, 50000},
157	{0, 100000},
158	{0, 200000},
159	{0, 400000},
160	};
161
162	static const int vcnl4040_ps_calibbias_ua[][2] = {
163	{0, 50000},
164	{0, 75000},
165	{0, 100000},
166	{0, 120000},
167	{0, 140000},
168	{0, 160000},
169	{0, 180000},
170	{0, 200000},
171	};
172
173	static const int vcnl4040_als_persistence[] = {1, 2, 4, 8};
174	static const int vcnl4040_ps_persistence[] = {1, 2, 3, 4};
175	static const int vcnl4040_ps_oversampling_ratio[] = {1, 2, 4, 8};
176
177	#define VCNL4000_SLEEP_DELAY_MS 2000 /* before we enter pm_runtime_suspend */
178
179	enum vcnl4000_device_ids {
180	VCNL4000,
181	VCNL4010,
182	VCNL4040,
183	VCNL4200,
184	};
185
186	struct vcnl4200_channel {
187	u8 reg;
188	ktime_t last_measurement;
189	ktime_t sampling_rate;
190	struct mutex lock;
191	};
192
193	struct vcnl4000_data {
194	struct i2c_client *client;
195	enum vcnl4000_device_ids id;
196	int rev;
197	int al_scale;
198	u8 ps_int; /* proximity interrupt mode */
199	u8 als_int; /* ambient light interrupt mode*/
200	const struct vcnl4000_chip_spec *chip_spec;
201	struct mutex vcnl4000_lock;
202	struct vcnl4200_channel vcnl4200_al;
203	struct vcnl4200_channel vcnl4200_ps;
204	uint32_t near_level;
205	};
206
207	struct vcnl4000_chip_spec {
208	const char *prod;
209	struct iio_chan_spec const *channels;
210	const int num_channels;
211	const struct iio_info *info;
212	const struct iio_buffer_setup_ops *buffer_setup_ops;
213	int (*init)(struct vcnl4000_data *data);
214	int (*measure_light)(struct vcnl4000_data *data, int *val);
215	int (*measure_proximity)(struct vcnl4000_data *data, int *val);
216	int (*set_power_state)(struct vcnl4000_data *data, bool on);
217	irqreturn_t (*irq_thread)(int irq, void *priv);
218	irqreturn_t (*trig_buffer_func)(int irq, void *priv);
219
220	u8 int_reg;
221	const int(*ps_it_times)[][2];
222	const int num_ps_it_times;
223	const int(*als_it_times)[][2];
224	const int num_als_it_times;
225	const unsigned int ulux_step;
226	};
227
228	static const struct i2c_device_id vcnl4000_id[] = {
229	{ "vcnl4000", VCNL4000 },
230	{ "vcnl4010", VCNL4010 },
231	{ "vcnl4020", VCNL4010 },
232	{ "vcnl4040", VCNL4040 },
233	{ "vcnl4200", VCNL4200 },
234	{ }
235	};
236	MODULE_DEVICE_TABLE(i2c, vcnl4000_id);
237
238	static int vcnl4000_set_power_state(struct vcnl4000_data *data, bool on)
239	{
240	/* no suspend op */
241	return 0;
242	}
243
244	static int vcnl4000_init(struct vcnl4000_data *data)
245	{
246	int ret, prod_id;
247
248	ret = i2c_smbus_read_byte_data(client: data->client, VCNL4000_PROD_REV);
249	if (ret < 0)
250	return ret;
251
252	prod_id = ret >> 4;
253	switch (prod_id) {
254	case VCNL4000_PROD_ID:
255	if (data->id != VCNL4000)
256	dev_warn(&data->client->dev,
257	"wrong device id, use vcnl4000");
258	break;
259	case VCNL4010_PROD_ID:
260	if (data->id != VCNL4010)
261	dev_warn(&data->client->dev,
262	"wrong device id, use vcnl4010/4020");
263	break;
264	default:
265	return -ENODEV;
266	}
267
268	data->rev = ret & 0xf;
269	data->al_scale = 250000;
270
271	return data->chip_spec->set_power_state(data, true);
272	};
273
274	static ssize_t vcnl4000_write_als_enable(struct vcnl4000_data *data, bool en)
275	{
276	int ret;
277
278	mutex_lock(&data->vcnl4000_lock);
279
280	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_AL_CONF);
281	if (ret < 0)
282	goto out;
283
284	if (en)
285	ret &= ~VCNL4040_ALS_CONF_ALS_SHUTDOWN;
286	else
287	ret |= VCNL4040_ALS_CONF_ALS_SHUTDOWN;
288
289	ret = i2c_smbus_write_word_data(client: data->client, VCNL4200_AL_CONF, value: ret);
290
291	out:
292	mutex_unlock(lock: &data->vcnl4000_lock);
293
294	return ret;
295	}
296
297	static ssize_t vcnl4000_write_ps_enable(struct vcnl4000_data *data, bool en)
298	{
299	int ret;
300
301	mutex_lock(&data->vcnl4000_lock);
302
303	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF1);
304	if (ret < 0)
305	goto out;
306
307	if (en)
308	ret &= ~VCNL4040_PS_CONF1_PS_SHUTDOWN;
309	else
310	ret |= VCNL4040_PS_CONF1_PS_SHUTDOWN;
311
312	ret = i2c_smbus_write_word_data(client: data->client, VCNL4200_PS_CONF1, value: ret);
313
314	out:
315	mutex_unlock(lock: &data->vcnl4000_lock);
316
317	return ret;
318	}
319
320	static int vcnl4200_set_power_state(struct vcnl4000_data *data, bool on)
321	{
322	int ret;
323
324	/* Do not power down if interrupts are enabled */
325	if (!on && (data->ps_int || data->als_int))
326	return 0;
327
328	ret = vcnl4000_write_als_enable(data, en: on);
329	if (ret < 0)
330	return ret;
331
332	ret = vcnl4000_write_ps_enable(data, en: on);
333	if (ret < 0)
334	return ret;
335
336	if (on) {
337	/* Wait at least one integration cycle before fetching data */
338	data->vcnl4200_al.last_measurement = ktime_get();
339	data->vcnl4200_ps.last_measurement = ktime_get();
340	}
341
342	return 0;
343	}
344
345	static int vcnl4200_init(struct vcnl4000_data *data)
346	{
347	int ret, id;
348
349	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_DEV_ID);
350	if (ret < 0)
351	return ret;
352
353	id = ret & 0xff;
354
355	if (id != VCNL4200_PROD_ID) {
356	ret = i2c_smbus_read_word_data(client: data->client, VCNL4040_DEV_ID);
357	if (ret < 0)
358	return ret;
359
360	id = ret & 0xff;
361
362	if (id != VCNL4040_PROD_ID)
363	return -ENODEV;
364	}
365
366	dev_dbg(&data->client->dev, "device id 0x%x", id);
367
368	data->rev = (ret >> 8) & 0xf;
369	data->ps_int = 0;
370	data->als_int = 0;
371
372	data->vcnl4200_al.reg = VCNL4200_AL_DATA;
373	data->vcnl4200_ps.reg = VCNL4200_PS_DATA;
374	switch (id) {
375	case VCNL4200_PROD_ID:
376	/* Default wait time is 50ms, add 20% tolerance. */
377	data->vcnl4200_al.sampling_rate = ktime_set(secs: 0, nsecs: 60000 * 1000);
378	/* Default wait time is 4.8ms, add 20% tolerance. */
379	data->vcnl4200_ps.sampling_rate = ktime_set(secs: 0, nsecs: 5760 * 1000);
380	break;
381	case VCNL4040_PROD_ID:
382	/* Default wait time is 80ms, add 20% tolerance. */
383	data->vcnl4200_al.sampling_rate = ktime_set(secs: 0, nsecs: 96000 * 1000);
384	/* Default wait time is 5ms, add 20% tolerance. */
385	data->vcnl4200_ps.sampling_rate = ktime_set(secs: 0, nsecs: 6000 * 1000);
386	break;
387	}
388	data->al_scale = data->chip_spec->ulux_step;
389	mutex_init(&data->vcnl4200_al.lock);
390	mutex_init(&data->vcnl4200_ps.lock);
391
392	ret = data->chip_spec->set_power_state(data, true);
393	if (ret < 0)
394	return ret;
395
396	return 0;
397	};
398
399	static int vcnl4000_read_data(struct vcnl4000_data *data, u8 data_reg, int *val)
400	{
401	s32 ret;
402
403	ret = i2c_smbus_read_word_swapped(client: data->client, command: data_reg);
404	if (ret < 0)
405	return ret;
406
407	*val = ret;
408	return 0;
409	}
410
411	static int vcnl4000_write_data(struct vcnl4000_data *data, u8 data_reg, int val)
412	{
413	if (val > U16_MAX)
414	return -ERANGE;
415
416	return i2c_smbus_write_word_swapped(client: data->client, command: data_reg, value: val);
417	}
418
419
420	static int vcnl4000_measure(struct vcnl4000_data *data, u8 req_mask,
421	u8 rdy_mask, u8 data_reg, int *val)
422	{
423	int tries = 20;
424	int ret;
425
426	mutex_lock(&data->vcnl4000_lock);
427
428	ret = i2c_smbus_write_byte_data(client: data->client, VCNL4000_COMMAND,
429	value: req_mask);
430	if (ret < 0)
431	goto fail;
432
433	/* wait for data to become ready */
434	while (tries--) {
435	ret = i2c_smbus_read_byte_data(client: data->client, VCNL4000_COMMAND);
436	if (ret < 0)
437	goto fail;
438	if (ret & rdy_mask)
439	break;
440	msleep(msecs: 20); /* measurement takes up to 100 ms */
441	}
442
443	if (tries < 0) {
444	dev_err(&data->client->dev,
445	"vcnl4000_measure() failed, data not ready\n");
446	ret = -EIO;
447	goto fail;
448	}
449
450	ret = vcnl4000_read_data(data, data_reg, val);
451	if (ret < 0)
452	goto fail;
453
454	mutex_unlock(lock: &data->vcnl4000_lock);
455
456	return 0;
457
458	fail:
459	mutex_unlock(lock: &data->vcnl4000_lock);
460	return ret;
461	}
462
463	static int vcnl4200_measure(struct vcnl4000_data *data,
464	struct vcnl4200_channel *chan, int *val)
465	{
466	int ret;
467	s64 delta;
468	ktime_t next_measurement;
469
470	mutex_lock(&chan->lock);
471
472	next_measurement = ktime_add(chan->last_measurement,
473	chan->sampling_rate);
474	delta = ktime_us_delta(later: next_measurement, earlier: ktime_get());
475	if (delta > 0)
476	usleep_range(min: delta, max: delta + 500);
477	chan->last_measurement = ktime_get();
478
479	mutex_unlock(lock: &chan->lock);
480
481	ret = i2c_smbus_read_word_data(client: data->client, command: chan->reg);
482	if (ret < 0)
483	return ret;
484
485	*val = ret;
486
487	return 0;
488	}
489
490	static int vcnl4000_measure_light(struct vcnl4000_data *data, int *val)
491	{
492	return vcnl4000_measure(data,
493	VCNL4000_AL_OD, VCNL4000_AL_RDY,
494	VCNL4000_AL_RESULT_HI, val);
495	}
496
497	static int vcnl4200_measure_light(struct vcnl4000_data *data, int *val)
498	{
499	return vcnl4200_measure(data, chan: &data->vcnl4200_al, val);
500	}
501
502	static int vcnl4000_measure_proximity(struct vcnl4000_data *data, int *val)
503	{
504	return vcnl4000_measure(data,
505	VCNL4000_PS_OD, VCNL4000_PS_RDY,
506	VCNL4000_PS_RESULT_HI, val);
507	}
508
509	static int vcnl4200_measure_proximity(struct vcnl4000_data *data, int *val)
510	{
511	return vcnl4200_measure(data, chan: &data->vcnl4200_ps, val);
512	}
513
514	static int vcnl4010_read_proxy_samp_freq(struct vcnl4000_data *data, int *val,
515	int *val2)
516	{
517	int ret;
518
519	ret = i2c_smbus_read_byte_data(client: data->client, VCNL4010_PROX_RATE);
520	if (ret < 0)
521	return ret;
522
523	if (ret >= ARRAY_SIZE(vcnl4010_prox_sampling_frequency))
524	return -EINVAL;
525
526	*val = vcnl4010_prox_sampling_frequency[ret][0];
527	*val2 = vcnl4010_prox_sampling_frequency[ret][1];
528
529	return 0;
530	}
531
532	static bool vcnl4010_is_in_periodic_mode(struct vcnl4000_data *data)
533	{
534	int ret;
535
536	ret = i2c_smbus_read_byte_data(client: data->client, VCNL4000_COMMAND);
537	if (ret < 0)
538	return false;
539
540	return !!(ret & VCNL4000_SELF_TIMED_EN);
541	}
542
543	static int vcnl4000_set_pm_runtime_state(struct vcnl4000_data *data, bool on)
544	{
545	struct device *dev = &data->client->dev;
546	int ret;
547
548	if (on) {
549	ret = pm_runtime_resume_and_get(dev);
550	} else {
551	pm_runtime_mark_last_busy(dev);
552	ret = pm_runtime_put_autosuspend(dev);
553	}
554
555	return ret;
556	}
557
558	static int vcnl4040_read_als_it(struct vcnl4000_data *data, int *val, int *val2)
559	{
560	int ret;
561
562	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_AL_CONF);
563	if (ret < 0)
564	return ret;
565
566	ret = FIELD_GET(VCNL4040_ALS_CONF_IT, ret);
567	if (ret >= data->chip_spec->num_als_it_times)
568	return -EINVAL;
569
570	*val = (*data->chip_spec->als_it_times)[ret][0];
571	*val2 = (*data->chip_spec->als_it_times)[ret][1];
572
573	return 0;
574	}
575
576	static ssize_t vcnl4040_write_als_it(struct vcnl4000_data *data, int val)
577	{
578	unsigned int i;
579	int ret;
580	u16 regval;
581
582	for (i = 0; i < data->chip_spec->num_als_it_times; i++) {
583	if (val == (*data->chip_spec->als_it_times)[i][1])
584	break;
585	}
586
587	if (i == data->chip_spec->num_als_it_times)
588	return -EINVAL;
589
590	data->vcnl4200_al.sampling_rate = ktime_set(secs: 0, nsecs: val * 1200);
591	data->al_scale = div_u64(dividend: mul_u32_u32(a: data->chip_spec->ulux_step,
592	b: (*data->chip_spec->als_it_times)[0][1]),
593	divisor: val);
594
595	mutex_lock(&data->vcnl4000_lock);
596
597	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_AL_CONF);
598	if (ret < 0)
599	goto out_unlock;
600
601	regval = FIELD_PREP(VCNL4040_ALS_CONF_IT, i);
602	regval |= (ret & ~VCNL4040_ALS_CONF_IT);
603	ret = i2c_smbus_write_word_data(client: data->client,
604	VCNL4200_AL_CONF,
605	value: regval);
606
607	out_unlock:
608	mutex_unlock(lock: &data->vcnl4000_lock);
609	return ret;
610	}
611
612	static int vcnl4040_read_ps_it(struct vcnl4000_data *data, int *val, int *val2)
613	{
614	int ret;
615
616	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF1);
617	if (ret < 0)
618	return ret;
619
620	ret = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret);
621
622	if (ret >= data->chip_spec->num_ps_it_times)
623	return -EINVAL;
624
625	*val = (*data->chip_spec->ps_it_times)[ret][0];
626	*val2 = (*data->chip_spec->ps_it_times)[ret][1];
627
628	return 0;
629	}
630
631	static ssize_t vcnl4040_write_ps_it(struct vcnl4000_data *data, int val)
632	{
633	unsigned int i;
634	int ret, index = -1;
635	u16 regval;
636
637	for (i = 0; i < data->chip_spec->num_ps_it_times; i++) {
638	if (val == (*data->chip_spec->ps_it_times)[i][1]) {
639	index = i;
640	break;
641	}
642	}
643
644	if (index < 0)
645	return -EINVAL;
646
647	data->vcnl4200_ps.sampling_rate = ktime_set(secs: 0, nsecs: val * 60 * NSEC_PER_USEC);
648
649	mutex_lock(&data->vcnl4000_lock);
650
651	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF1);
652	if (ret < 0)
653	goto out;
654
655	regval = (ret & ~VCNL4040_PS_CONF2_PS_IT) |
656	FIELD_PREP(VCNL4040_PS_CONF2_PS_IT, index);
657	ret = i2c_smbus_write_word_data(client: data->client, VCNL4200_PS_CONF1,
658	value: regval);
659
660	out:
661	mutex_unlock(lock: &data->vcnl4000_lock);
662	return ret;
663	}
664
665	static ssize_t vcnl4040_read_als_period(struct vcnl4000_data *data, int *val, int *val2)
666	{
667	int ret, ret_pers, it;
668	int64_t val_c;
669
670	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_AL_CONF);
671	if (ret < 0)
672	return ret;
673
674	ret_pers = FIELD_GET(VCNL4040_ALS_CONF_PERS, ret);
675	if (ret_pers >= ARRAY_SIZE(vcnl4040_als_persistence))
676	return -EINVAL;
677
678	it = FIELD_GET(VCNL4040_ALS_CONF_IT, ret);
679	if (it >= data->chip_spec->num_als_it_times)
680	return -EINVAL;
681
682	val_c = mul_u32_u32(a: (*data->chip_spec->als_it_times)[it][1],
683	b: vcnl4040_als_persistence[ret_pers]);
684	*val = div_u64_rem(dividend: val_c, MICRO, remainder: val2);
685
686	return IIO_VAL_INT_PLUS_MICRO;
687	}
688
689	static ssize_t vcnl4040_write_als_period(struct vcnl4000_data *data, int val, int val2)
690	{
691	unsigned int i;
692	int ret, it;
693	u16 regval;
694	u64 val_n = mul_u32_u32(a: val, MICRO) + val2;
695
696	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_AL_CONF);
697	if (ret < 0)
698	return ret;
699
700	it = FIELD_GET(VCNL4040_ALS_CONF_IT, ret);
701	if (it >= data->chip_spec->num_als_it_times)
702	return -EINVAL;
703
704	for (i = 0; i < ARRAY_SIZE(vcnl4040_als_persistence) - 1; i++) {
705	if (val_n < mul_u32_u32(a: vcnl4040_als_persistence[i],
706	b: (*data->chip_spec->als_it_times)[it][1]))
707	break;
708	}
709
710	mutex_lock(&data->vcnl4000_lock);
711
712	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_AL_CONF);
713	if (ret < 0)
714	goto out_unlock;
715
716	regval = FIELD_PREP(VCNL4040_ALS_CONF_PERS, i);
717	regval |= (ret & ~VCNL4040_ALS_CONF_PERS);
718	ret = i2c_smbus_write_word_data(client: data->client, VCNL4200_AL_CONF,
719	value: regval);
720
721	out_unlock:
722	mutex_unlock(lock: &data->vcnl4000_lock);
723	return ret;
724	}
725
726	static ssize_t vcnl4040_read_ps_period(struct vcnl4000_data *data, int *val, int *val2)
727	{
728	int ret, ret_pers, it;
729
730	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF1);
731	if (ret < 0)
732	return ret;
733
734	ret_pers = FIELD_GET(VCNL4040_CONF1_PS_PERS, ret);
735	if (ret_pers >= ARRAY_SIZE(vcnl4040_ps_persistence))
736	return -EINVAL;
737
738	it = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret);
739	if (it >= data->chip_spec->num_ps_it_times)
740	return -EINVAL;
741
742	*val = (*data->chip_spec->ps_it_times)[it][0];
743	*val2 = (*data->chip_spec->ps_it_times)[it][1] *
744	vcnl4040_ps_persistence[ret_pers];
745
746	return IIO_VAL_INT_PLUS_MICRO;
747	}
748
749	static ssize_t vcnl4040_write_ps_period(struct vcnl4000_data *data, int val, int val2)
750	{
751	int ret, it, i;
752	u16 regval;
753
754	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF1);
755	if (ret < 0)
756	return ret;
757
758	it = FIELD_GET(VCNL4040_PS_CONF2_PS_IT, ret);
759	if (it >= data->chip_spec->num_ps_it_times)
760	return -EINVAL;
761
762	if (val > 0)
763	i = ARRAY_SIZE(vcnl4040_ps_persistence) - 1;
764	else {
765	for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_persistence) - 1; i++) {
766	if (val2 <= vcnl4040_ps_persistence[i] *
767	(*data->chip_spec->ps_it_times)[it][1])
768	break;
769	}
770	}
771
772	mutex_lock(&data->vcnl4000_lock);
773
774	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF1);
775	if (ret < 0)
776	goto out_unlock;
777
778	regval = FIELD_PREP(VCNL4040_CONF1_PS_PERS, i);
779	regval |= (ret & ~VCNL4040_CONF1_PS_PERS);
780	ret = i2c_smbus_write_word_data(client: data->client, VCNL4200_PS_CONF1,
781	value: regval);
782
783	out_unlock:
784	mutex_unlock(lock: &data->vcnl4000_lock);
785	return ret;
786	}
787
788	static ssize_t vcnl4040_read_ps_oversampling_ratio(struct vcnl4000_data *data, int *val)
789	{
790	int ret;
791
792	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF3);
793	if (ret < 0)
794	return ret;
795
796	ret = FIELD_GET(VCNL4040_PS_CONF3_MPS, ret);
797	if (ret >= ARRAY_SIZE(vcnl4040_ps_oversampling_ratio))
798	return -EINVAL;
799
800	*val = vcnl4040_ps_oversampling_ratio[ret];
801
802	return ret;
803	}
804
805	static ssize_t vcnl4040_write_ps_oversampling_ratio(struct vcnl4000_data *data, int val)
806	{
807	unsigned int i;
808	int ret;
809	u16 regval;
810
811	for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_oversampling_ratio); i++) {
812	if (val == vcnl4040_ps_oversampling_ratio[i])
813	break;
814	}
815
816	if (i >= ARRAY_SIZE(vcnl4040_ps_oversampling_ratio))
817	return -EINVAL;
818
819	mutex_lock(&data->vcnl4000_lock);
820
821	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF3);
822	if (ret < 0)
823	goto out_unlock;
824
825	regval = FIELD_PREP(VCNL4040_PS_CONF3_MPS, i);
826	regval |= (ret & ~VCNL4040_PS_CONF3_MPS);
827	ret = i2c_smbus_write_word_data(client: data->client, VCNL4200_PS_CONF3,
828	value: regval);
829
830	out_unlock:
831	mutex_unlock(lock: &data->vcnl4000_lock);
832	return ret;
833	}
834
835	static ssize_t vcnl4040_read_ps_calibbias(struct vcnl4000_data *data, int *val, int *val2)
836	{
837	int ret;
838
839	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF3);
840	if (ret < 0)
841	return ret;
842
843	ret = FIELD_GET(VCNL4040_PS_MS_LED_I, ret);
844	if (ret >= ARRAY_SIZE(vcnl4040_ps_calibbias_ua))
845	return -EINVAL;
846
847	*val = vcnl4040_ps_calibbias_ua[ret][0];
848	*val2 = vcnl4040_ps_calibbias_ua[ret][1];
849
850	return ret;
851	}
852
853	static ssize_t vcnl4040_write_ps_calibbias(struct vcnl4000_data *data, int val)
854	{
855	unsigned int i;
856	int ret;
857	u16 regval;
858
859	for (i = 0; i < ARRAY_SIZE(vcnl4040_ps_calibbias_ua); i++) {
860	if (val == vcnl4040_ps_calibbias_ua[i][1])
861	break;
862	}
863
864	if (i >= ARRAY_SIZE(vcnl4040_ps_calibbias_ua))
865	return -EINVAL;
866
867	mutex_lock(&data->vcnl4000_lock);
868
869	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF3);
870	if (ret < 0)
871	goto out_unlock;
872
873	regval = (ret & ~VCNL4040_PS_MS_LED_I);
874	regval |= FIELD_PREP(VCNL4040_PS_MS_LED_I, i);
875	ret = i2c_smbus_write_word_data(client: data->client, VCNL4200_PS_CONF3,
876	value: regval);
877
878	out_unlock:
879	mutex_unlock(lock: &data->vcnl4000_lock);
880	return ret;
881	}
882
883	static int vcnl4000_read_raw(struct iio_dev *indio_dev,
884	struct iio_chan_spec const *chan,
885	int *val, int *val2, long mask)
886	{
887	int ret;
888	struct vcnl4000_data *data = iio_priv(indio_dev);
889
890	switch (mask) {
891	case IIO_CHAN_INFO_RAW:
892	ret = vcnl4000_set_pm_runtime_state(data, on: true);
893	if (ret < 0)
894	return ret;
895
896	switch (chan->type) {
897	case IIO_LIGHT:
898	ret = data->chip_spec->measure_light(data, val);
899	if (!ret)
900	ret = IIO_VAL_INT;
901	break;
902	case IIO_PROXIMITY:
903	ret = data->chip_spec->measure_proximity(data, val);
904	if (!ret)
905	ret = IIO_VAL_INT;
906	break;
907	default:
908	ret = -EINVAL;
909	}
910	vcnl4000_set_pm_runtime_state(data, on: false);
911	return ret;
912	case IIO_CHAN_INFO_SCALE:
913	if (chan->type != IIO_LIGHT)
914	return -EINVAL;
915
916	*val = 0;
917	*val2 = data->al_scale;
918	return IIO_VAL_INT_PLUS_MICRO;
919	case IIO_CHAN_INFO_INT_TIME:
920	switch (chan->type) {
921	case IIO_LIGHT:
922	ret = vcnl4040_read_als_it(data, val, val2);
923	break;
924	case IIO_PROXIMITY:
925	ret = vcnl4040_read_ps_it(data, val, val2);
926	break;
927	default:
928	return -EINVAL;
929	}
930	if (ret < 0)
931	return ret;
932	return IIO_VAL_INT_PLUS_MICRO;
933	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
934	switch (chan->type) {
935	case IIO_PROXIMITY:
936	ret = vcnl4040_read_ps_oversampling_ratio(data, val);
937	if (ret < 0)
938	return ret;
939	return IIO_VAL_INT;
940	default:
941	return -EINVAL;
942	}
943	case IIO_CHAN_INFO_CALIBBIAS:
944	switch (chan->type) {
945	case IIO_PROXIMITY:
946	ret = vcnl4040_read_ps_calibbias(data, val, val2);
947	if (ret < 0)
948	return ret;
949	return IIO_VAL_INT_PLUS_MICRO;
950	default:
951	return -EINVAL;
952	}
953	default:
954	return -EINVAL;
955	}
956	}
957
958	static int vcnl4040_write_raw(struct iio_dev *indio_dev,
959	struct iio_chan_spec const *chan,
960	int val, int val2, long mask)
961	{
962	struct vcnl4000_data *data = iio_priv(indio_dev);
963
964	switch (mask) {
965	case IIO_CHAN_INFO_INT_TIME:
966	if (val != 0)
967	return -EINVAL;
968	switch (chan->type) {
969	case IIO_LIGHT:
970	return vcnl4040_write_als_it(data, val: val2);
971	case IIO_PROXIMITY:
972	return vcnl4040_write_ps_it(data, val: val2);
973	default:
974	return -EINVAL;
975	}
976	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
977	switch (chan->type) {
978	case IIO_PROXIMITY:
979	return vcnl4040_write_ps_oversampling_ratio(data, val);
980	default:
981	return -EINVAL;
982	}
983	case IIO_CHAN_INFO_CALIBBIAS:
984	switch (chan->type) {
985	case IIO_PROXIMITY:
986	return vcnl4040_write_ps_calibbias(data, val: val2);
987	default:
988	return -EINVAL;
989	}
990	default:
991	return -EINVAL;
992	}
993	}
994
995	static int vcnl4040_read_avail(struct iio_dev *indio_dev,
996	struct iio_chan_spec const *chan,
997	const int **vals, int *type, int *length,
998	long mask)
999	{
1000	struct vcnl4000_data *data = iio_priv(indio_dev);
1001
1002	switch (mask) {
1003	case IIO_CHAN_INFO_INT_TIME:
1004	switch (chan->type) {
1005	case IIO_LIGHT:
1006	*vals = (int *)(*data->chip_spec->als_it_times);
1007	*length = 2 * data->chip_spec->num_als_it_times;
1008	break;
1009	case IIO_PROXIMITY:
1010	*vals = (int *)(*data->chip_spec->ps_it_times);
1011	*length = 2 * data->chip_spec->num_ps_it_times;
1012	break;
1013	default:
1014	return -EINVAL;
1015	}
1016	*type = IIO_VAL_INT_PLUS_MICRO;
1017	return IIO_AVAIL_LIST;
1018	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
1019	switch (chan->type) {
1020	case IIO_PROXIMITY:
1021	*vals = (int *)vcnl4040_ps_oversampling_ratio;
1022	*length = ARRAY_SIZE(vcnl4040_ps_oversampling_ratio);
1023	*type = IIO_VAL_INT;
1024	return IIO_AVAIL_LIST;
1025	default:
1026	return -EINVAL;
1027	}
1028	case IIO_CHAN_INFO_CALIBBIAS:
1029	switch (chan->type) {
1030	case IIO_PROXIMITY:
1031	*vals = (int *)vcnl4040_ps_calibbias_ua;
1032	*length = 2 * ARRAY_SIZE(vcnl4040_ps_calibbias_ua);
1033	*type = IIO_VAL_INT_PLUS_MICRO;
1034	return IIO_AVAIL_LIST;
1035	default:
1036	return -EINVAL;
1037	}
1038	default:
1039	return -EINVAL;
1040	}
1041	}
1042
1043	static int vcnl4010_read_raw(struct iio_dev *indio_dev,
1044	struct iio_chan_spec const *chan,
1045	int *val, int *val2, long mask)
1046	{
1047	int ret;
1048	struct vcnl4000_data *data = iio_priv(indio_dev);
1049
1050	switch (mask) {
1051	case IIO_CHAN_INFO_RAW:
1052	case IIO_CHAN_INFO_SCALE:
1053	ret = iio_device_claim_direct_mode(indio_dev);
1054	if (ret)
1055	return ret;
1056
1057	/* Protect against event capture. */
1058	if (vcnl4010_is_in_periodic_mode(data)) {
1059	ret = -EBUSY;
1060	} else {
1061	ret = vcnl4000_read_raw(indio_dev, chan, val, val2,
1062	mask);
1063	}
1064
1065	iio_device_release_direct_mode(indio_dev);
1066	return ret;
1067	case IIO_CHAN_INFO_SAMP_FREQ:
1068	switch (chan->type) {
1069	case IIO_PROXIMITY:
1070	ret = vcnl4010_read_proxy_samp_freq(data, val, val2);
1071	if (ret < 0)
1072	return ret;
1073	return IIO_VAL_INT_PLUS_MICRO;
1074	default:
1075	return -EINVAL;
1076	}
1077	default:
1078	return -EINVAL;
1079	}
1080	}
1081
1082	static int vcnl4010_read_avail(struct iio_dev *indio_dev,
1083	struct iio_chan_spec const *chan,
1084	const int **vals, int *type, int *length,
1085	long mask)
1086	{
1087	switch (mask) {
1088	case IIO_CHAN_INFO_SAMP_FREQ:
1089	*vals = (int *)vcnl4010_prox_sampling_frequency;
1090	*type = IIO_VAL_INT_PLUS_MICRO;
1091	*length = 2 * ARRAY_SIZE(vcnl4010_prox_sampling_frequency);
1092	return IIO_AVAIL_LIST;
1093	default:
1094	return -EINVAL;
1095	}
1096	}
1097
1098	static int vcnl4010_write_proxy_samp_freq(struct vcnl4000_data *data, int val,
1099	int val2)
1100	{
1101	unsigned int i;
1102	int index = -1;
1103
1104	for (i = 0; i < ARRAY_SIZE(vcnl4010_prox_sampling_frequency); i++) {
1105	if (val == vcnl4010_prox_sampling_frequency[i][0] &&
1106	val2 == vcnl4010_prox_sampling_frequency[i][1]) {
1107	index = i;
1108	break;
1109	}
1110	}
1111
1112	if (index < 0)
1113	return -EINVAL;
1114
1115	return i2c_smbus_write_byte_data(client: data->client, VCNL4010_PROX_RATE,
1116	value: index);
1117	}
1118
1119	static int vcnl4010_write_raw(struct iio_dev *indio_dev,
1120	struct iio_chan_spec const *chan,
1121	int val, int val2, long mask)
1122	{
1123	int ret;
1124	struct vcnl4000_data *data = iio_priv(indio_dev);
1125
1126	ret = iio_device_claim_direct_mode(indio_dev);
1127	if (ret)
1128	return ret;
1129
1130	/* Protect against event capture. */
1131	if (vcnl4010_is_in_periodic_mode(data)) {
1132	ret = -EBUSY;
1133	goto end;
1134	}
1135
1136	switch (mask) {
1137	case IIO_CHAN_INFO_SAMP_FREQ:
1138	switch (chan->type) {
1139	case IIO_PROXIMITY:
1140	ret = vcnl4010_write_proxy_samp_freq(data, val, val2);
1141	goto end;
1142	default:
1143	ret = -EINVAL;
1144	goto end;
1145	}
1146	default:
1147	ret = -EINVAL;
1148	goto end;
1149	}
1150
1151	end:
1152	iio_device_release_direct_mode(indio_dev);
1153	return ret;
1154	}
1155
1156	static int vcnl4010_read_event(struct iio_dev *indio_dev,
1157	const struct iio_chan_spec *chan,
1158	enum iio_event_type type,
1159	enum iio_event_direction dir,
1160	enum iio_event_info info,
1161	int *val, int *val2)
1162	{
1163	int ret;
1164	struct vcnl4000_data *data = iio_priv(indio_dev);
1165
1166	switch (info) {
1167	case IIO_EV_INFO_VALUE:
1168	switch (dir) {
1169	case IIO_EV_DIR_RISING:
1170	ret = vcnl4000_read_data(data, VCNL4010_HIGH_THR_HI,
1171	val);
1172	if (ret < 0)
1173	return ret;
1174	return IIO_VAL_INT;
1175	case IIO_EV_DIR_FALLING:
1176	ret = vcnl4000_read_data(data, VCNL4010_LOW_THR_HI,
1177	val);
1178	if (ret < 0)
1179	return ret;
1180	return IIO_VAL_INT;
1181	default:
1182	return -EINVAL;
1183	}
1184	default:
1185	return -EINVAL;
1186	}
1187	}
1188
1189	static int vcnl4010_write_event(struct iio_dev *indio_dev,
1190	const struct iio_chan_spec *chan,
1191	enum iio_event_type type,
1192	enum iio_event_direction dir,
1193	enum iio_event_info info,
1194	int val, int val2)
1195	{
1196	int ret;
1197	struct vcnl4000_data *data = iio_priv(indio_dev);
1198
1199	switch (info) {
1200	case IIO_EV_INFO_VALUE:
1201	switch (dir) {
1202	case IIO_EV_DIR_RISING:
1203	ret = vcnl4000_write_data(data, VCNL4010_HIGH_THR_HI,
1204	val);
1205	if (ret < 0)
1206	return ret;
1207	return IIO_VAL_INT;
1208	case IIO_EV_DIR_FALLING:
1209	ret = vcnl4000_write_data(data, VCNL4010_LOW_THR_HI,
1210	val);
1211	if (ret < 0)
1212	return ret;
1213	return IIO_VAL_INT;
1214	default:
1215	return -EINVAL;
1216	}
1217	default:
1218	return -EINVAL;
1219	}
1220	}
1221
1222	static int vcnl4040_read_event(struct iio_dev *indio_dev,
1223	const struct iio_chan_spec *chan,
1224	enum iio_event_type type,
1225	enum iio_event_direction dir,
1226	enum iio_event_info info,
1227	int *val, int *val2)
1228	{
1229	int ret;
1230	struct vcnl4000_data *data = iio_priv(indio_dev);
1231
1232	switch (chan->type) {
1233	case IIO_LIGHT:
1234	switch (info) {
1235	case IIO_EV_INFO_PERIOD:
1236	return vcnl4040_read_als_period(data, val, val2);
1237	case IIO_EV_INFO_VALUE:
1238	switch (dir) {
1239	case IIO_EV_DIR_RISING:
1240	ret = i2c_smbus_read_word_data(client: data->client,
1241	VCNL4040_ALS_THDH_LM);
1242	break;
1243	case IIO_EV_DIR_FALLING:
1244	ret = i2c_smbus_read_word_data(client: data->client,
1245	VCNL4040_ALS_THDL_LM);
1246	break;
1247	default:
1248	return -EINVAL;
1249	}
1250	break;
1251	default:
1252	return -EINVAL;
1253	}
1254	break;
1255	case IIO_PROXIMITY:
1256	switch (info) {
1257	case IIO_EV_INFO_PERIOD:
1258	return vcnl4040_read_ps_period(data, val, val2);
1259	case IIO_EV_INFO_VALUE:
1260	switch (dir) {
1261	case IIO_EV_DIR_RISING:
1262	ret = i2c_smbus_read_word_data(client: data->client,
1263	VCNL4040_PS_THDH_LM);
1264	break;
1265	case IIO_EV_DIR_FALLING:
1266	ret = i2c_smbus_read_word_data(client: data->client,
1267	VCNL4040_PS_THDL_LM);
1268	break;
1269	default:
1270	return -EINVAL;
1271	}
1272	break;
1273	default:
1274	return -EINVAL;
1275	}
1276	break;
1277	default:
1278	return -EINVAL;
1279	}
1280	if (ret < 0)
1281	return ret;
1282	*val = ret;
1283	return IIO_VAL_INT;
1284	}
1285
1286	static int vcnl4040_write_event(struct iio_dev *indio_dev,
1287	const struct iio_chan_spec *chan,
1288	enum iio_event_type type,
1289	enum iio_event_direction dir,
1290	enum iio_event_info info,
1291	int val, int val2)
1292	{
1293	int ret;
1294	struct vcnl4000_data *data = iio_priv(indio_dev);
1295
1296	switch (chan->type) {
1297	case IIO_LIGHT:
1298	switch (info) {
1299	case IIO_EV_INFO_PERIOD:
1300	return vcnl4040_write_als_period(data, val, val2);
1301	case IIO_EV_INFO_VALUE:
1302	switch (dir) {
1303	case IIO_EV_DIR_RISING:
1304	ret = i2c_smbus_write_word_data(client: data->client,
1305	VCNL4040_ALS_THDH_LM,
1306	value: val);
1307	break;
1308	case IIO_EV_DIR_FALLING:
1309	ret = i2c_smbus_write_word_data(client: data->client,
1310	VCNL4040_ALS_THDL_LM,
1311	value: val);
1312	break;
1313	default:
1314	return -EINVAL;
1315	}
1316	break;
1317	default:
1318	return -EINVAL;
1319	}
1320	break;
1321	case IIO_PROXIMITY:
1322	switch (info) {
1323	case IIO_EV_INFO_PERIOD:
1324	return vcnl4040_write_ps_period(data, val, val2);
1325	case IIO_EV_INFO_VALUE:
1326	switch (dir) {
1327	case IIO_EV_DIR_RISING:
1328	ret = i2c_smbus_write_word_data(client: data->client,
1329	VCNL4040_PS_THDH_LM,
1330	value: val);
1331	break;
1332	case IIO_EV_DIR_FALLING:
1333	ret = i2c_smbus_write_word_data(client: data->client,
1334	VCNL4040_PS_THDL_LM,
1335	value: val);
1336	break;
1337	default:
1338	return -EINVAL;
1339	}
1340	break;
1341	default:
1342	return -EINVAL;
1343	}
1344	break;
1345	default:
1346	return -EINVAL;
1347	}
1348	if (ret < 0)
1349	return ret;
1350	return IIO_VAL_INT;
1351	}
1352
1353	static bool vcnl4010_is_thr_enabled(struct vcnl4000_data *data)
1354	{
1355	int ret;
1356
1357	ret = i2c_smbus_read_byte_data(client: data->client, VCNL4010_INT_CTRL);
1358	if (ret < 0)
1359	return false;
1360
1361	return !!(ret & VCNL4010_INT_THR_EN);
1362	}
1363
1364	static int vcnl4010_read_event_config(struct iio_dev *indio_dev,
1365	const struct iio_chan_spec *chan,
1366	enum iio_event_type type,
1367	enum iio_event_direction dir)
1368	{
1369	struct vcnl4000_data *data = iio_priv(indio_dev);
1370
1371	switch (chan->type) {
1372	case IIO_PROXIMITY:
1373	return vcnl4010_is_thr_enabled(data);
1374	default:
1375	return -EINVAL;
1376	}
1377	}
1378
1379	static int vcnl4010_config_threshold(struct iio_dev *indio_dev, bool state)
1380	{
1381	struct vcnl4000_data *data = iio_priv(indio_dev);
1382	int ret;
1383	int icr;
1384	int command;
1385
1386	if (state) {
1387	ret = iio_device_claim_direct_mode(indio_dev);
1388	if (ret)
1389	return ret;
1390
1391	/* Enable periodic measurement of proximity data. */
1392	command = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN;
1393
1394	/*
1395	* Enable interrupts on threshold, for proximity data by
1396	* default.
1397	*/
1398	icr = VCNL4010_INT_THR_EN;
1399	} else {
1400	if (!vcnl4010_is_thr_enabled(data))
1401	return 0;
1402
1403	command = 0;
1404	icr = 0;
1405	}
1406
1407	ret = i2c_smbus_write_byte_data(client: data->client, VCNL4000_COMMAND,
1408	value: command);
1409	if (ret < 0)
1410	goto end;
1411
1412	ret = i2c_smbus_write_byte_data(client: data->client, VCNL4010_INT_CTRL, value: icr);
1413
1414	end:
1415	if (state)
1416	iio_device_release_direct_mode(indio_dev);
1417
1418	return ret;
1419	}
1420
1421	static int vcnl4010_write_event_config(struct iio_dev *indio_dev,
1422	const struct iio_chan_spec *chan,
1423	enum iio_event_type type,
1424	enum iio_event_direction dir,
1425	int state)
1426	{
1427	switch (chan->type) {
1428	case IIO_PROXIMITY:
1429	return vcnl4010_config_threshold(indio_dev, state);
1430	default:
1431	return -EINVAL;
1432	}
1433	}
1434
1435	static int vcnl4040_read_event_config(struct iio_dev *indio_dev,
1436	const struct iio_chan_spec *chan,
1437	enum iio_event_type type,
1438	enum iio_event_direction dir)
1439	{
1440	int ret;
1441	struct vcnl4000_data *data = iio_priv(indio_dev);
1442
1443	switch (chan->type) {
1444	case IIO_LIGHT:
1445	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_AL_CONF);
1446	if (ret < 0)
1447	return ret;
1448
1449	data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, ret);
1450
1451	return data->als_int;
1452	case IIO_PROXIMITY:
1453	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF1);
1454	if (ret < 0)
1455	return ret;
1456
1457	data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, ret);
1458
1459	return (dir == IIO_EV_DIR_RISING) ?
1460	FIELD_GET(VCNL4040_PS_IF_AWAY, ret) :
1461	FIELD_GET(VCNL4040_PS_IF_CLOSE, ret);
1462	default:
1463	return -EINVAL;
1464	}
1465	}
1466
1467	static int vcnl4040_write_event_config(struct iio_dev *indio_dev,
1468	const struct iio_chan_spec *chan,
1469	enum iio_event_type type,
1470	enum iio_event_direction dir, int state)
1471	{
1472	int ret = -EINVAL;
1473	u16 val, mask;
1474	struct vcnl4000_data *data = iio_priv(indio_dev);
1475
1476	mutex_lock(&data->vcnl4000_lock);
1477
1478	switch (chan->type) {
1479	case IIO_LIGHT:
1480	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_AL_CONF);
1481	if (ret < 0)
1482	goto out;
1483
1484	mask = VCNL4040_ALS_CONF_INT_EN;
1485	if (state)
1486	val = (ret | mask);
1487	else
1488	val = (ret & ~mask);
1489
1490	data->als_int = FIELD_GET(VCNL4040_ALS_CONF_INT_EN, val);
1491	ret = i2c_smbus_write_word_data(client: data->client, VCNL4200_AL_CONF,
1492	value: val);
1493	break;
1494	case IIO_PROXIMITY:
1495	ret = i2c_smbus_read_word_data(client: data->client, VCNL4200_PS_CONF1);
1496	if (ret < 0)
1497	goto out;
1498
1499	if (dir == IIO_EV_DIR_RISING)
1500	mask = VCNL4040_PS_IF_AWAY;
1501	else
1502	mask = VCNL4040_PS_IF_CLOSE;
1503
1504	val = state ? (ret | mask) : (ret & ~mask);
1505
1506	data->ps_int = FIELD_GET(VCNL4040_PS_CONF2_PS_INT, val);
1507	ret = i2c_smbus_write_word_data(client: data->client, VCNL4200_PS_CONF1,
1508	value: val);
1509	break;
1510	default:
1511	break;
1512	}
1513
1514	out:
1515	mutex_unlock(lock: &data->vcnl4000_lock);
1516
1517	return ret;
1518	}
1519
1520	static irqreturn_t vcnl4040_irq_thread(int irq, void *p)
1521	{
1522	struct iio_dev *indio_dev = p;
1523	struct vcnl4000_data *data = iio_priv(indio_dev);
1524	int ret;
1525
1526	ret = i2c_smbus_read_word_data(client: data->client, command: data->chip_spec->int_reg);
1527	if (ret < 0)
1528	return IRQ_HANDLED;
1529
1530	if (ret & VCNL4040_PS_IF_CLOSE) {
1531	iio_push_event(indio_dev,
1532	IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
1533	IIO_EV_TYPE_THRESH,
1534	IIO_EV_DIR_RISING),
1535	timestamp: iio_get_time_ns(indio_dev));
1536	}
1537
1538	if (ret & VCNL4040_PS_IF_AWAY) {
1539	iio_push_event(indio_dev,
1540	IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0,
1541	IIO_EV_TYPE_THRESH,
1542	IIO_EV_DIR_FALLING),
1543	timestamp: iio_get_time_ns(indio_dev));
1544	}
1545
1546	if (ret & VCNL4040_ALS_FALLING) {
1547	iio_push_event(indio_dev,
1548	IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0,
1549	IIO_EV_TYPE_THRESH,
1550	IIO_EV_DIR_FALLING),
1551	timestamp: iio_get_time_ns(indio_dev));
1552	}
1553
1554	if (ret & VCNL4040_ALS_RISING) {
1555	iio_push_event(indio_dev,
1556	IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0,
1557	IIO_EV_TYPE_THRESH,
1558	IIO_EV_DIR_RISING),
1559	timestamp: iio_get_time_ns(indio_dev));
1560	}
1561
1562	return IRQ_HANDLED;
1563	}
1564
1565	static ssize_t vcnl4000_read_near_level(struct iio_dev *indio_dev,
1566	uintptr_t priv,
1567	const struct iio_chan_spec *chan,
1568	char *buf)
1569	{
1570	struct vcnl4000_data *data = iio_priv(indio_dev);
1571
1572	return sprintf(buf, fmt: "%u\n", data->near_level);
1573	}
1574
1575	static irqreturn_t vcnl4010_irq_thread(int irq, void *p)
1576	{
1577	struct iio_dev *indio_dev = p;
1578	struct vcnl4000_data *data = iio_priv(indio_dev);
1579	unsigned long isr;
1580	int ret;
1581
1582	ret = i2c_smbus_read_byte_data(client: data->client, VCNL4010_ISR);
1583	if (ret < 0)
1584	goto end;
1585
1586	isr = ret;
1587
1588	if (isr & VCNL4010_INT_THR) {
1589	if (test_bit(VCNL4010_INT_THR_LOW, &isr)) {
1590	iio_push_event(indio_dev,
1591	IIO_UNMOD_EVENT_CODE(
1592	IIO_PROXIMITY,
1593	1,
1594	IIO_EV_TYPE_THRESH,
1595	IIO_EV_DIR_FALLING),
1596	timestamp: iio_get_time_ns(indio_dev));
1597	}
1598
1599	if (test_bit(VCNL4010_INT_THR_HIGH, &isr)) {
1600	iio_push_event(indio_dev,
1601	IIO_UNMOD_EVENT_CODE(
1602	IIO_PROXIMITY,
1603	1,
1604	IIO_EV_TYPE_THRESH,
1605	IIO_EV_DIR_RISING),
1606	timestamp: iio_get_time_ns(indio_dev));
1607	}
1608
1609	i2c_smbus_write_byte_data(client: data->client, VCNL4010_ISR,
1610	value: isr & VCNL4010_INT_THR);
1611	}
1612
1613	if (isr & VCNL4010_INT_DRDY && iio_buffer_enabled(indio_dev))
1614	iio_trigger_poll_nested(trig: indio_dev->trig);
1615
1616	end:
1617	return IRQ_HANDLED;
1618	}
1619
1620	static irqreturn_t vcnl4010_trigger_handler(int irq, void *p)
1621	{
1622	struct iio_poll_func *pf = p;
1623	struct iio_dev *indio_dev = pf->indio_dev;
1624	struct vcnl4000_data *data = iio_priv(indio_dev);
1625	const unsigned long *active_scan_mask = indio_dev->active_scan_mask;
1626	u16 buffer[8] __aligned(8) = {0}; /* 1x16-bit + naturally aligned ts */
1627	bool data_read = false;
1628	unsigned long isr;
1629	int val = 0;
1630	int ret;
1631
1632	ret = i2c_smbus_read_byte_data(client: data->client, VCNL4010_ISR);
1633	if (ret < 0)
1634	goto end;
1635
1636	isr = ret;
1637
1638	if (test_bit(0, active_scan_mask)) {
1639	if (test_bit(VCNL4010_INT_PROXIMITY, &isr)) {
1640	ret = vcnl4000_read_data(data,
1641	VCNL4000_PS_RESULT_HI,
1642	val: &val);
1643	if (ret < 0)
1644	goto end;
1645
1646	buffer[0] = val;
1647	data_read = true;
1648	}
1649	}
1650
1651	ret = i2c_smbus_write_byte_data(client: data->client, VCNL4010_ISR,
1652	value: isr & VCNL4010_INT_DRDY);
1653	if (ret < 0)
1654	goto end;
1655
1656	if (!data_read)
1657	goto end;
1658
1659	iio_push_to_buffers_with_timestamp(indio_dev, data: buffer,
1660	timestamp: iio_get_time_ns(indio_dev));
1661
1662	end:
1663	iio_trigger_notify_done(trig: indio_dev->trig);
1664	return IRQ_HANDLED;
1665	}
1666
1667	static int vcnl4010_buffer_postenable(struct iio_dev *indio_dev)
1668	{
1669	struct vcnl4000_data *data = iio_priv(indio_dev);
1670	int ret;
1671	int cmd;
1672
1673	/* Do not enable the buffer if we are already capturing events. */
1674	if (vcnl4010_is_in_periodic_mode(data))
1675	return -EBUSY;
1676
1677	ret = i2c_smbus_write_byte_data(client: data->client, VCNL4010_INT_CTRL,
1678	VCNL4010_INT_PROX_EN);
1679	if (ret < 0)
1680	return ret;
1681
1682	cmd = VCNL4000_SELF_TIMED_EN | VCNL4000_PROX_EN;
1683	return i2c_smbus_write_byte_data(client: data->client, VCNL4000_COMMAND, value: cmd);
1684	}
1685
1686	static int vcnl4010_buffer_predisable(struct iio_dev *indio_dev)
1687	{
1688	struct vcnl4000_data *data = iio_priv(indio_dev);
1689	int ret;
1690
1691	ret = i2c_smbus_write_byte_data(client: data->client, VCNL4010_INT_CTRL, value: 0);
1692	if (ret < 0)
1693	return ret;
1694
1695	return i2c_smbus_write_byte_data(client: data->client, VCNL4000_COMMAND, value: 0);
1696	}
1697
1698	static const struct iio_buffer_setup_ops vcnl4010_buffer_ops = {
1699	.postenable = &vcnl4010_buffer_postenable,
1700	.predisable = &vcnl4010_buffer_predisable,
1701	};
1702
1703	static const struct iio_chan_spec_ext_info vcnl4000_ext_info[] = {
1704	{
1705	.name = "nearlevel",
1706	.shared = IIO_SEPARATE,
1707	.read = vcnl4000_read_near_level,
1708	},
1709	{ /* sentinel */ }
1710	};
1711
1712	static const struct iio_event_spec vcnl4000_event_spec[] = {
1713	{
1714	.type = IIO_EV_TYPE_THRESH,
1715	.dir = IIO_EV_DIR_RISING,
1716	.mask_separate = BIT(IIO_EV_INFO_VALUE),
1717	}, {
1718	.type = IIO_EV_TYPE_THRESH,
1719	.dir = IIO_EV_DIR_FALLING,
1720	.mask_separate = BIT(IIO_EV_INFO_VALUE),
1721	}, {
1722	.type = IIO_EV_TYPE_THRESH,
1723	.dir = IIO_EV_DIR_EITHER,
1724	.mask_separate = BIT(IIO_EV_INFO_ENABLE),
1725	}
1726	};
1727
1728	static const struct iio_event_spec vcnl4040_als_event_spec[] = {
1729	{
1730	.type = IIO_EV_TYPE_THRESH,
1731	.dir = IIO_EV_DIR_RISING,
1732	.mask_separate = BIT(IIO_EV_INFO_VALUE),
1733	}, {
1734	.type = IIO_EV_TYPE_THRESH,
1735	.dir = IIO_EV_DIR_FALLING,
1736	.mask_separate = BIT(IIO_EV_INFO_VALUE),
1737	}, {
1738	.type = IIO_EV_TYPE_THRESH,
1739	.dir = IIO_EV_DIR_EITHER,
1740	.mask_separate = BIT(IIO_EV_INFO_ENABLE) | BIT(IIO_EV_INFO_PERIOD),
1741	},
1742	};
1743
1744	static const struct iio_event_spec vcnl4040_event_spec[] = {
1745	{
1746	.type = IIO_EV_TYPE_THRESH,
1747	.dir = IIO_EV_DIR_RISING,
1748	.mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
1749	}, {
1750	.type = IIO_EV_TYPE_THRESH,
1751	.dir = IIO_EV_DIR_FALLING,
1752	.mask_separate = BIT(IIO_EV_INFO_VALUE) | BIT(IIO_EV_INFO_ENABLE),
1753	}, {
1754	.type = IIO_EV_TYPE_THRESH,
1755	.dir = IIO_EV_DIR_EITHER,
1756	.mask_separate = BIT(IIO_EV_INFO_PERIOD),
1757	},
1758	};
1759
1760	static const struct iio_chan_spec vcnl4000_channels[] = {
1761	{
1762	.type = IIO_LIGHT,
1763	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1764	BIT(IIO_CHAN_INFO_SCALE),
1765	}, {
1766	.type = IIO_PROXIMITY,
1767	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
1768	.ext_info = vcnl4000_ext_info,
1769	}
1770	};
1771
1772	static const struct iio_chan_spec vcnl4010_channels[] = {
1773	{
1774	.type = IIO_LIGHT,
1775	.scan_index = -1,
1776	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1777	BIT(IIO_CHAN_INFO_SCALE),
1778	}, {
1779	.type = IIO_PROXIMITY,
1780	.scan_index = 0,
1781	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1782	BIT(IIO_CHAN_INFO_SAMP_FREQ),
1783	.info_mask_separate_available = BIT(IIO_CHAN_INFO_SAMP_FREQ),
1784	.event_spec = vcnl4000_event_spec,
1785	.num_event_specs = ARRAY_SIZE(vcnl4000_event_spec),
1786	.ext_info = vcnl4000_ext_info,
1787	.scan_type = {
1788	.sign = 'u',
1789	.realbits = 16,
1790	.storagebits = 16,
1791	.endianness = IIO_CPU,
1792	},
1793	},
1794	IIO_CHAN_SOFT_TIMESTAMP(1),
1795	};
1796
1797	static const struct iio_chan_spec vcnl4040_channels[] = {
1798	{
1799	.type = IIO_LIGHT,
1800	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1801	BIT(IIO_CHAN_INFO_SCALE) |
1802	BIT(IIO_CHAN_INFO_INT_TIME),
1803	.info_mask_separate_available = BIT(IIO_CHAN_INFO_INT_TIME),
1804	.event_spec = vcnl4040_als_event_spec,
1805	.num_event_specs = ARRAY_SIZE(vcnl4040_als_event_spec),
1806	}, {
1807	.type = IIO_PROXIMITY,
1808	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1809	BIT(IIO_CHAN_INFO_INT_TIME) |
1810	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) |
1811	BIT(IIO_CHAN_INFO_CALIBBIAS),
1812	.info_mask_separate_available = BIT(IIO_CHAN_INFO_INT_TIME) |
1813	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO) |
1814	BIT(IIO_CHAN_INFO_CALIBBIAS),
1815	.ext_info = vcnl4000_ext_info,
1816	.event_spec = vcnl4040_event_spec,
1817	.num_event_specs = ARRAY_SIZE(vcnl4040_event_spec),
1818	}
1819	};
1820
1821	static const struct iio_info vcnl4000_info = {
1822	.read_raw = vcnl4000_read_raw,
1823	};
1824
1825	static const struct iio_info vcnl4010_info = {
1826	.read_raw = vcnl4010_read_raw,
1827	.read_avail = vcnl4010_read_avail,
1828	.write_raw = vcnl4010_write_raw,
1829	.read_event_value = vcnl4010_read_event,
1830	.write_event_value = vcnl4010_write_event,
1831	.read_event_config = vcnl4010_read_event_config,
1832	.write_event_config = vcnl4010_write_event_config,
1833	};
1834
1835	static const struct iio_info vcnl4040_info = {
1836	.read_raw = vcnl4000_read_raw,
1837	.write_raw = vcnl4040_write_raw,
1838	.read_event_value = vcnl4040_read_event,
1839	.write_event_value = vcnl4040_write_event,
1840	.read_event_config = vcnl4040_read_event_config,
1841	.write_event_config = vcnl4040_write_event_config,
1842	.read_avail = vcnl4040_read_avail,
1843	};
1844
1845	static const struct vcnl4000_chip_spec vcnl4000_chip_spec_cfg[] = {
1846	[VCNL4000] = {
1847	.prod = "VCNL4000",
1848	.init = vcnl4000_init,
1849	.measure_light = vcnl4000_measure_light,
1850	.measure_proximity = vcnl4000_measure_proximity,
1851	.set_power_state = vcnl4000_set_power_state,
1852	.channels = vcnl4000_channels,
1853	.num_channels = ARRAY_SIZE(vcnl4000_channels),
1854	.info = &vcnl4000_info,
1855	},
1856	[VCNL4010] = {
1857	.prod = "VCNL4010/4020",
1858	.init = vcnl4000_init,
1859	.measure_light = vcnl4000_measure_light,
1860	.measure_proximity = vcnl4000_measure_proximity,
1861	.set_power_state = vcnl4000_set_power_state,
1862	.channels = vcnl4010_channels,
1863	.num_channels = ARRAY_SIZE(vcnl4010_channels),
1864	.info = &vcnl4010_info,
1865	.irq_thread = vcnl4010_irq_thread,
1866	.trig_buffer_func = vcnl4010_trigger_handler,
1867	.buffer_setup_ops = &vcnl4010_buffer_ops,
1868	},
1869	[VCNL4040] = {
1870	.prod = "VCNL4040",
1871	.init = vcnl4200_init,
1872	.measure_light = vcnl4200_measure_light,
1873	.measure_proximity = vcnl4200_measure_proximity,
1874	.set_power_state = vcnl4200_set_power_state,
1875	.channels = vcnl4040_channels,
1876	.num_channels = ARRAY_SIZE(vcnl4040_channels),
1877	.info = &vcnl4040_info,
1878	.irq_thread = vcnl4040_irq_thread,
1879	.int_reg = VCNL4040_INT_FLAGS,
1880	.ps_it_times = &vcnl4040_ps_it_times,
1881	.num_ps_it_times = ARRAY_SIZE(vcnl4040_ps_it_times),
1882	.als_it_times = &vcnl4040_als_it_times,
1883	.num_als_it_times = ARRAY_SIZE(vcnl4040_als_it_times),
1884	.ulux_step = 100000,
1885	},
1886	[VCNL4200] = {
1887	.prod = "VCNL4200",
1888	.init = vcnl4200_init,
1889	.measure_light = vcnl4200_measure_light,
1890	.measure_proximity = vcnl4200_measure_proximity,
1891	.set_power_state = vcnl4200_set_power_state,
1892	.channels = vcnl4040_channels,
1893	.num_channels = ARRAY_SIZE(vcnl4000_channels),
1894	.info = &vcnl4040_info,
1895	.irq_thread = vcnl4040_irq_thread,
1896	.int_reg = VCNL4200_INT_FLAGS,
1897	.ps_it_times = &vcnl4200_ps_it_times,
1898	.num_ps_it_times = ARRAY_SIZE(vcnl4200_ps_it_times),
1899	.als_it_times = &vcnl4200_als_it_times,
1900	.num_als_it_times = ARRAY_SIZE(vcnl4200_als_it_times),
1901	.ulux_step = 24000,
1902	},
1903	};
1904
1905	static const struct iio_trigger_ops vcnl4010_trigger_ops = {
1906	.validate_device = iio_trigger_validate_own_device,
1907	};
1908
1909	static int vcnl4010_probe_trigger(struct iio_dev *indio_dev)
1910	{
1911	struct vcnl4000_data *data = iio_priv(indio_dev);
1912	struct i2c_client *client = data->client;
1913	struct iio_trigger *trigger;
1914
1915	trigger = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
1916	indio_dev->name,
1917	iio_device_id(indio_dev));
1918	if (!trigger)
1919	return -ENOMEM;
1920
1921	trigger->ops = &vcnl4010_trigger_ops;
1922	iio_trigger_set_drvdata(trig: trigger, data: indio_dev);
1923
1924	return devm_iio_trigger_register(dev: &client->dev, trig_info: trigger);
1925	}
1926
1927	static int vcnl4000_probe(struct i2c_client *client)
1928	{
1929	const struct i2c_device_id *id = i2c_client_get_device_id(client);
1930	struct vcnl4000_data *data;
1931	struct iio_dev *indio_dev;
1932	int ret;
1933
1934	indio_dev = devm_iio_device_alloc(parent: &client->dev, sizeof_priv: sizeof(*data));
1935	if (!indio_dev)
1936	return -ENOMEM;
1937
1938	data = iio_priv(indio_dev);
1939	i2c_set_clientdata(client, data: indio_dev);
1940	data->client = client;
1941	data->id = id->driver_data;
1942	data->chip_spec = &vcnl4000_chip_spec_cfg[data->id];
1943
1944	mutex_init(&data->vcnl4000_lock);
1945
1946	ret = data->chip_spec->init(data);
1947	if (ret < 0)
1948	return ret;
1949
1950	dev_dbg(&client->dev, "%s Ambient light/proximity sensor, Rev: %02x\n",
1951	data->chip_spec->prod, data->rev);
1952
1953	if (device_property_read_u32(dev: &client->dev, propname: "proximity-near-level",
1954	val: &data->near_level))
1955	data->near_level = 0;
1956
1957	indio_dev->info = data->chip_spec->info;
1958	indio_dev->channels = data->chip_spec->channels;
1959	indio_dev->num_channels = data->chip_spec->num_channels;
1960	indio_dev->name = VCNL4000_DRV_NAME;
1961	indio_dev->modes = INDIO_DIRECT_MODE;
1962
1963	if (data->chip_spec->trig_buffer_func &&
1964	data->chip_spec->buffer_setup_ops) {
1965	ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev,
1966	NULL,
1967	data->chip_spec->trig_buffer_func,
1968	data->chip_spec->buffer_setup_ops);
1969	if (ret < 0) {
1970	dev_err(&client->dev,
1971	"unable to setup iio triggered buffer\n");
1972	return ret;
1973	}
1974	}
1975
1976	if (client->irq && data->chip_spec->irq_thread) {
1977	ret = devm_request_threaded_irq(dev: &client->dev, irq: client->irq,
1978	NULL, thread_fn: data->chip_spec->irq_thread,
1979	IRQF_TRIGGER_FALLING |
1980	IRQF_ONESHOT,
1981	devname: "vcnl4000_irq",
1982	dev_id: indio_dev);
1983	if (ret < 0) {
1984	dev_err(&client->dev, "irq request failed\n");
1985	return ret;
1986	}
1987
1988	ret = vcnl4010_probe_trigger(indio_dev);
1989	if (ret < 0)
1990	return ret;
1991	}
1992
1993	ret = pm_runtime_set_active(dev: &client->dev);
1994	if (ret < 0)
1995	goto fail_poweroff;
1996
1997	ret = iio_device_register(indio_dev);
1998	if (ret < 0)
1999	goto fail_poweroff;
2000
2001	pm_runtime_enable(dev: &client->dev);
2002	pm_runtime_set_autosuspend_delay(dev: &client->dev, VCNL4000_SLEEP_DELAY_MS);
2003	pm_runtime_use_autosuspend(dev: &client->dev);
2004
2005	return 0;
2006	fail_poweroff:
2007	data->chip_spec->set_power_state(data, false);
2008	return ret;
2009	}
2010
2011	static const struct of_device_id vcnl_4000_of_match[] = {
2012	{
2013	.compatible = "vishay,vcnl4000",
2014	.data = (void *)VCNL4000,
2015	},
2016	{
2017	.compatible = "vishay,vcnl4010",
2018	.data = (void *)VCNL4010,
2019	},
2020	{
2021	.compatible = "vishay,vcnl4020",
2022	.data = (void *)VCNL4010,
2023	},
2024	{
2025	.compatible = "vishay,vcnl4040",
2026	.data = (void *)VCNL4040,
2027	},
2028	{
2029	.compatible = "vishay,vcnl4200",
2030	.data = (void *)VCNL4200,
2031	},
2032	{},
2033	};
2034	MODULE_DEVICE_TABLE(of, vcnl_4000_of_match);
2035
2036	static void vcnl4000_remove(struct i2c_client *client)
2037	{
2038	struct iio_dev *indio_dev = i2c_get_clientdata(client);
2039	struct vcnl4000_data *data = iio_priv(indio_dev);
2040	int ret;
2041
2042	pm_runtime_dont_use_autosuspend(dev: &client->dev);
2043	pm_runtime_disable(dev: &client->dev);
2044	iio_device_unregister(indio_dev);
2045	pm_runtime_set_suspended(dev: &client->dev);
2046
2047	ret = data->chip_spec->set_power_state(data, false);
2048	if (ret)
2049	dev_warn(&client->dev, "Failed to power down (%pe)\n",
2050	ERR_PTR(ret));
2051	}
2052
2053	static int vcnl4000_runtime_suspend(struct device *dev)
2054	{
2055	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
2056	struct vcnl4000_data *data = iio_priv(indio_dev);
2057
2058	return data->chip_spec->set_power_state(data, false);
2059	}
2060
2061	static int vcnl4000_runtime_resume(struct device *dev)
2062	{
2063	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
2064	struct vcnl4000_data *data = iio_priv(indio_dev);
2065
2066	return data->chip_spec->set_power_state(data, true);
2067	}
2068
2069	static DEFINE_RUNTIME_DEV_PM_OPS(vcnl4000_pm_ops, vcnl4000_runtime_suspend,
2070	vcnl4000_runtime_resume, NULL);
2071
2072	static struct i2c_driver vcnl4000_driver = {
2073	.driver = {
2074	.name = VCNL4000_DRV_NAME,
2075	.pm = pm_ptr(&vcnl4000_pm_ops),
2076	.of_match_table = vcnl_4000_of_match,
2077	},
2078	.probe = vcnl4000_probe,
2079	.id_table = vcnl4000_id,
2080	.remove = vcnl4000_remove,
2081	};
2082
2083	module_i2c_driver(vcnl4000_driver);
2084
2085	MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
2086	MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>");
2087	MODULE_DESCRIPTION("Vishay VCNL4000 proximity/ambient light sensor driver");
2088	MODULE_LICENSE("GPL");
2089