1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright 2021 Google LLC.
4 *
5 * Common part of most Semtech SAR sensor.
6 */
7
8 #include <linux/bitops.h>
9 #include <linux/byteorder/generic.h>
10 #include <linux/delay.h>
11 #include <linux/device.h>
12 #include <linux/err.h>
13 #include <linux/export.h>
14 #include <linux/interrupt.h>
15 #include <linux/irqreturn.h>
16 #include <linux/i2c.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/regmap.h>
20 #include <linux/regulator/consumer.h>
21 #include <vdso/bits.h>
22
23 #include <linux/iio/buffer.h>
24 #include <linux/iio/events.h>
25 #include <linux/iio/iio.h>
26 #include <linux/iio/trigger.h>
27 #include <linux/iio/triggered_buffer.h>
28 #include <linux/iio/trigger_consumer.h>
29
30 #include "sx_common.h"
31
32 /* All Semtech SAR sensors have IRQ bit in the same order. */
33 #define SX_COMMON_CONVDONE_IRQ BIT(0)
34 #define SX_COMMON_FAR_IRQ BIT(2)
35 #define SX_COMMON_CLOSE_IRQ BIT(3)
36
37 const struct iio_event_spec sx_common_events[3] = {
38 {
39 .type = IIO_EV_TYPE_THRESH,
40 .dir = IIO_EV_DIR_RISING,
41 .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD),
42 },
43 {
44 .type = IIO_EV_TYPE_THRESH,
45 .dir = IIO_EV_DIR_FALLING,
46 .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD),
47 },
48 {
49 .type = IIO_EV_TYPE_THRESH,
50 .dir = IIO_EV_DIR_EITHER,
51 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
52 BIT(IIO_EV_INFO_HYSTERESIS) |
53 BIT(IIO_EV_INFO_VALUE),
54 },
55 };
56 EXPORT_SYMBOL_NS_GPL(sx_common_events, "SEMTECH_PROX");
57
sx_common_irq_handler(int irq,void * private)58 static irqreturn_t sx_common_irq_handler(int irq, void *private)
59 {
60 struct iio_dev *indio_dev = private;
61 struct sx_common_data *data = iio_priv(indio_dev);
62
63 if (data->trigger_enabled)
64 iio_trigger_poll(data->trig);
65
66 /*
67 * Even if no event is enabled, we need to wake the thread to clear the
68 * interrupt state by reading SX_COMMON_REG_IRQ_SRC.
69 * It is not possible to do that here because regmap_read takes a mutex.
70 */
71 return IRQ_WAKE_THREAD;
72 }
73
sx_common_push_events(struct iio_dev * indio_dev)74 static void sx_common_push_events(struct iio_dev *indio_dev)
75 {
76 int ret;
77 unsigned int val, chan;
78 struct sx_common_data *data = iio_priv(indio_dev);
79 s64 timestamp = iio_get_time_ns(indio_dev);
80 unsigned long prox_changed;
81
82 /* Read proximity state on all channels */
83 ret = regmap_read(data->regmap, data->chip_info->reg_stat, &val);
84 if (ret) {
85 dev_err(&data->client->dev, "i2c transfer error in irq\n");
86 return;
87 }
88
89 val >>= data->chip_info->stat_offset;
90
91 /*
92 * Only iterate over channels with changes on proximity status that have
93 * events enabled.
94 */
95 prox_changed = (data->chan_prox_stat ^ val) & data->chan_event;
96
97 for_each_set_bit(chan, &prox_changed, data->chip_info->num_channels) {
98 int dir;
99 u64 ev;
100
101 dir = (val & BIT(chan)) ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
102 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan,
103 IIO_EV_TYPE_THRESH, dir);
104
105 iio_push_event(indio_dev, ev, timestamp);
106 }
107 data->chan_prox_stat = val;
108 }
109
sx_common_enable_irq(struct sx_common_data * data,unsigned int irq)110 static int sx_common_enable_irq(struct sx_common_data *data, unsigned int irq)
111 {
112 if (!data->client->irq)
113 return 0;
114 return regmap_set_bits(data->regmap, data->chip_info->reg_irq_msk,
115 irq << data->chip_info->irq_msk_offset);
116 }
117
sx_common_disable_irq(struct sx_common_data * data,unsigned int irq)118 static int sx_common_disable_irq(struct sx_common_data *data, unsigned int irq)
119 {
120 if (!data->client->irq)
121 return 0;
122 return regmap_clear_bits(data->regmap, data->chip_info->reg_irq_msk,
123 irq << data->chip_info->irq_msk_offset);
124 }
125
sx_common_update_chan_en(struct sx_common_data * data,unsigned long chan_read,unsigned long chan_event)126 static int sx_common_update_chan_en(struct sx_common_data *data,
127 unsigned long chan_read,
128 unsigned long chan_event)
129 {
130 int ret;
131 unsigned long channels = chan_read | chan_event;
132
133 if ((data->chan_read | data->chan_event) != channels) {
134 ret = regmap_update_bits(data->regmap,
135 data->chip_info->reg_enable_chan,
136 data->chip_info->mask_enable_chan,
137 channels);
138 if (ret)
139 return ret;
140 }
141 data->chan_read = chan_read;
142 data->chan_event = chan_event;
143 return 0;
144 }
145
sx_common_get_read_channel(struct sx_common_data * data,int channel)146 static int sx_common_get_read_channel(struct sx_common_data *data, int channel)
147 {
148 return sx_common_update_chan_en(data, data->chan_read | BIT(channel),
149 data->chan_event);
150 }
151
sx_common_put_read_channel(struct sx_common_data * data,int channel)152 static int sx_common_put_read_channel(struct sx_common_data *data, int channel)
153 {
154 return sx_common_update_chan_en(data, data->chan_read & ~BIT(channel),
155 data->chan_event);
156 }
157
sx_common_get_event_channel(struct sx_common_data * data,int channel)158 static int sx_common_get_event_channel(struct sx_common_data *data, int channel)
159 {
160 return sx_common_update_chan_en(data, data->chan_read,
161 data->chan_event | BIT(channel));
162 }
163
sx_common_put_event_channel(struct sx_common_data * data,int channel)164 static int sx_common_put_event_channel(struct sx_common_data *data, int channel)
165 {
166 return sx_common_update_chan_en(data, data->chan_read,
167 data->chan_event & ~BIT(channel));
168 }
169
170 /**
171 * sx_common_read_proximity() - Read raw proximity value.
172 * @data: Internal data
173 * @chan: Channel to read
174 * @val: pointer to return read value.
175 *
176 * Request a conversion, wait for the sensor to be ready and
177 * return the raw proximity value.
178 */
sx_common_read_proximity(struct sx_common_data * data,const struct iio_chan_spec * chan,int * val)179 int sx_common_read_proximity(struct sx_common_data *data,
180 const struct iio_chan_spec *chan, int *val)
181 {
182 int ret;
183 __be16 rawval;
184
185 mutex_lock(&data->mutex);
186
187 ret = sx_common_get_read_channel(data, chan->channel);
188 if (ret)
189 goto out;
190
191 ret = sx_common_enable_irq(data, SX_COMMON_CONVDONE_IRQ);
192 if (ret)
193 goto out_put_channel;
194
195 mutex_unlock(&data->mutex);
196
197 if (data->client->irq) {
198 ret = wait_for_completion_interruptible(&data->completion);
199 reinit_completion(&data->completion);
200 } else {
201 ret = data->chip_info->ops.wait_for_sample(data);
202 }
203
204 mutex_lock(&data->mutex);
205
206 if (ret)
207 goto out_disable_irq;
208
209 ret = data->chip_info->ops.read_prox_data(data, chan, &rawval);
210 if (ret)
211 goto out_disable_irq;
212
213 *val = sign_extend32(be16_to_cpu(rawval), chan->scan_type.realbits - 1);
214
215 ret = sx_common_disable_irq(data, SX_COMMON_CONVDONE_IRQ);
216 if (ret)
217 goto out_put_channel;
218
219 ret = sx_common_put_read_channel(data, chan->channel);
220 if (ret)
221 goto out;
222
223 mutex_unlock(&data->mutex);
224
225 return IIO_VAL_INT;
226
227 out_disable_irq:
228 sx_common_disable_irq(data, SX_COMMON_CONVDONE_IRQ);
229 out_put_channel:
230 sx_common_put_read_channel(data, chan->channel);
231 out:
232 mutex_unlock(&data->mutex);
233
234 return ret;
235 }
236 EXPORT_SYMBOL_NS_GPL(sx_common_read_proximity, "SEMTECH_PROX");
237
238 /**
239 * sx_common_read_event_config() - Configure event setting.
240 * @indio_dev: iio device object
241 * @chan: Channel to read
242 * @type: Type of event (unused)
243 * @dir: Direction of event (unused)
244 *
245 * return if the given channel is used for event gathering.
246 */
sx_common_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)247 int sx_common_read_event_config(struct iio_dev *indio_dev,
248 const struct iio_chan_spec *chan,
249 enum iio_event_type type,
250 enum iio_event_direction dir)
251 {
252 struct sx_common_data *data = iio_priv(indio_dev);
253
254 return !!(data->chan_event & BIT(chan->channel));
255 }
256 EXPORT_SYMBOL_NS_GPL(sx_common_read_event_config, "SEMTECH_PROX");
257
258 /**
259 * sx_common_write_event_config() - Configure event setting.
260 * @indio_dev: iio device object
261 * @chan: Channel to enable
262 * @type: Type of event (unused)
263 * @dir: Direction of event (unused)
264 * @state: State of the event.
265 *
266 * Enable/Disable event on a given channel.
267 */
sx_common_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)268 int sx_common_write_event_config(struct iio_dev *indio_dev,
269 const struct iio_chan_spec *chan,
270 enum iio_event_type type,
271 enum iio_event_direction dir, bool state)
272 {
273 struct sx_common_data *data = iio_priv(indio_dev);
274 unsigned int eventirq = SX_COMMON_FAR_IRQ | SX_COMMON_CLOSE_IRQ;
275 int ret;
276
277 /* If the state hasn't changed, there's nothing to do. */
278 if (!!(data->chan_event & BIT(chan->channel)) == state)
279 return 0;
280
281 mutex_lock(&data->mutex);
282 if (state) {
283 ret = sx_common_get_event_channel(data, chan->channel);
284 if (ret)
285 goto out_unlock;
286 if (!(data->chan_event & ~BIT(chan->channel))) {
287 ret = sx_common_enable_irq(data, eventirq);
288 if (ret)
289 sx_common_put_event_channel(data, chan->channel);
290 }
291 } else {
292 ret = sx_common_put_event_channel(data, chan->channel);
293 if (ret)
294 goto out_unlock;
295 if (!data->chan_event) {
296 ret = sx_common_disable_irq(data, eventirq);
297 if (ret)
298 sx_common_get_event_channel(data, chan->channel);
299 }
300 }
301
302 out_unlock:
303 mutex_unlock(&data->mutex);
304 return ret;
305 }
306 EXPORT_SYMBOL_NS_GPL(sx_common_write_event_config, "SEMTECH_PROX");
307
sx_common_set_trigger_state(struct iio_trigger * trig,bool state)308 static int sx_common_set_trigger_state(struct iio_trigger *trig, bool state)
309 {
310 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
311 struct sx_common_data *data = iio_priv(indio_dev);
312 int ret = 0;
313
314 mutex_lock(&data->mutex);
315
316 if (state)
317 ret = sx_common_enable_irq(data, SX_COMMON_CONVDONE_IRQ);
318 else if (!data->chan_read)
319 ret = sx_common_disable_irq(data, SX_COMMON_CONVDONE_IRQ);
320 if (ret)
321 goto out;
322
323 data->trigger_enabled = state;
324
325 out:
326 mutex_unlock(&data->mutex);
327
328 return ret;
329 }
330
331 static const struct iio_trigger_ops sx_common_trigger_ops = {
332 .set_trigger_state = sx_common_set_trigger_state,
333 };
334
sx_common_irq_thread_handler(int irq,void * private)335 static irqreturn_t sx_common_irq_thread_handler(int irq, void *private)
336 {
337 struct iio_dev *indio_dev = private;
338 struct sx_common_data *data = iio_priv(indio_dev);
339 int ret;
340 unsigned int val;
341
342 mutex_lock(&data->mutex);
343
344 ret = regmap_read(data->regmap, SX_COMMON_REG_IRQ_SRC, &val);
345 if (ret) {
346 dev_err(&data->client->dev, "i2c transfer error in irq\n");
347 goto out;
348 }
349
350 if (val & ((SX_COMMON_FAR_IRQ | SX_COMMON_CLOSE_IRQ) << data->chip_info->irq_msk_offset))
351 sx_common_push_events(indio_dev);
352
353 if (val & (SX_COMMON_CONVDONE_IRQ << data->chip_info->irq_msk_offset))
354 complete(&data->completion);
355
356 out:
357 mutex_unlock(&data->mutex);
358
359 return IRQ_HANDLED;
360 }
361
sx_common_trigger_handler(int irq,void * private)362 static irqreturn_t sx_common_trigger_handler(int irq, void *private)
363 {
364 struct iio_poll_func *pf = private;
365 struct iio_dev *indio_dev = pf->indio_dev;
366 struct sx_common_data *data = iio_priv(indio_dev);
367 __be16 val;
368 int bit, ret, i = 0;
369
370 mutex_lock(&data->mutex);
371
372 iio_for_each_active_channel(indio_dev, bit) {
373 ret = data->chip_info->ops.read_prox_data(data,
374 &indio_dev->channels[bit],
375 &val);
376 if (ret)
377 goto out;
378
379 data->buffer.channels[i++] = val;
380 }
381
382 iio_push_to_buffers_with_timestamp(indio_dev, &data->buffer,
383 pf->timestamp);
384
385 out:
386 mutex_unlock(&data->mutex);
387
388 iio_trigger_notify_done(indio_dev->trig);
389
390 return IRQ_HANDLED;
391 }
392
sx_common_buffer_preenable(struct iio_dev * indio_dev)393 static int sx_common_buffer_preenable(struct iio_dev *indio_dev)
394 {
395 struct sx_common_data *data = iio_priv(indio_dev);
396 unsigned long channels = 0;
397 int bit, ret;
398
399 mutex_lock(&data->mutex);
400 iio_for_each_active_channel(indio_dev, bit)
401 __set_bit(indio_dev->channels[bit].channel, &channels);
402
403 ret = sx_common_update_chan_en(data, channels, data->chan_event);
404 mutex_unlock(&data->mutex);
405 return ret;
406 }
407
sx_common_buffer_postdisable(struct iio_dev * indio_dev)408 static int sx_common_buffer_postdisable(struct iio_dev *indio_dev)
409 {
410 struct sx_common_data *data = iio_priv(indio_dev);
411 int ret;
412
413 mutex_lock(&data->mutex);
414 ret = sx_common_update_chan_en(data, 0, data->chan_event);
415 mutex_unlock(&data->mutex);
416 return ret;
417 }
418
419 static const struct iio_buffer_setup_ops sx_common_buffer_setup_ops = {
420 .preenable = sx_common_buffer_preenable,
421 .postdisable = sx_common_buffer_postdisable,
422 };
423
424 #define SX_COMMON_SOFT_RESET 0xde
425
sx_common_init_device(struct device * dev,struct iio_dev * indio_dev)426 static int sx_common_init_device(struct device *dev, struct iio_dev *indio_dev)
427 {
428 struct sx_common_data *data = iio_priv(indio_dev);
429 struct sx_common_reg_default tmp;
430 const struct sx_common_reg_default *initval;
431 int ret;
432 unsigned int i, val;
433
434 ret = regmap_write(data->regmap, data->chip_info->reg_reset,
435 SX_COMMON_SOFT_RESET);
436 if (ret)
437 return ret;
438
439 usleep_range(1000, 2000); /* power-up time is ~1ms. */
440
441 /* Clear reset interrupt state by reading SX_COMMON_REG_IRQ_SRC. */
442 ret = regmap_read(data->regmap, SX_COMMON_REG_IRQ_SRC, &val);
443 if (ret)
444 return ret;
445
446 /* Program defaults from constant or BIOS. */
447 for (i = 0; i < data->chip_info->num_default_regs; i++) {
448 initval = data->chip_info->ops.get_default_reg(dev, i, &tmp);
449 ret = regmap_write(data->regmap, initval->reg, initval->def);
450 if (ret)
451 return ret;
452 }
453
454 return data->chip_info->ops.init_compensation(indio_dev);
455 }
456
457 /**
458 * sx_common_probe() - Common setup for Semtech SAR sensor
459 * @client: I2C client object
460 * @chip_info: Semtech sensor chip information.
461 * @regmap_config: Sensor registers map configuration.
462 */
sx_common_probe(struct i2c_client * client,const struct sx_common_chip_info * chip_info,const struct regmap_config * regmap_config)463 int sx_common_probe(struct i2c_client *client,
464 const struct sx_common_chip_info *chip_info,
465 const struct regmap_config *regmap_config)
466 {
467 static const char * const regulator_names[] = { "vdd", "svdd" };
468 struct device *dev = &client->dev;
469 struct iio_dev *indio_dev;
470 struct sx_common_data *data;
471 int ret;
472
473 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
474 if (!indio_dev)
475 return -ENOMEM;
476
477 data = iio_priv(indio_dev);
478
479 data->chip_info = chip_info;
480 data->client = client;
481 mutex_init(&data->mutex);
482 init_completion(&data->completion);
483
484 data->regmap = devm_regmap_init_i2c(client, regmap_config);
485 if (IS_ERR(data->regmap))
486 return dev_err_probe(dev, PTR_ERR(data->regmap),
487 "Could init register map\n");
488
489 ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(regulator_names),
490 regulator_names);
491 if (ret)
492 return dev_err_probe(dev, ret, "Unable to get regulators\n");
493
494 /* Must wait for Tpor time after initial power up */
495 usleep_range(1000, 1100);
496
497 ret = data->chip_info->ops.check_whoami(dev, indio_dev);
498 if (ret)
499 return dev_err_probe(dev, ret, "error reading WHOAMI\n");
500
501 indio_dev->modes = INDIO_DIRECT_MODE;
502
503 indio_dev->channels = data->chip_info->iio_channels;
504 indio_dev->num_channels = data->chip_info->num_iio_channels;
505 indio_dev->info = &data->chip_info->iio_info;
506
507 i2c_set_clientdata(client, indio_dev);
508
509 ret = sx_common_init_device(dev, indio_dev);
510 if (ret)
511 return dev_err_probe(dev, ret, "Unable to initialize sensor\n");
512
513 if (client->irq) {
514 ret = devm_request_threaded_irq(dev, client->irq,
515 sx_common_irq_handler,
516 sx_common_irq_thread_handler,
517 IRQF_ONESHOT,
518 "sx_event", indio_dev);
519 if (ret)
520 return dev_err_probe(dev, ret, "No IRQ\n");
521
522 data->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
523 indio_dev->name,
524 iio_device_id(indio_dev));
525 if (!data->trig)
526 return -ENOMEM;
527
528 data->trig->ops = &sx_common_trigger_ops;
529 iio_trigger_set_drvdata(data->trig, indio_dev);
530
531 ret = devm_iio_trigger_register(dev, data->trig);
532 if (ret)
533 return ret;
534 }
535
536 ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
537 iio_pollfunc_store_time,
538 sx_common_trigger_handler,
539 &sx_common_buffer_setup_ops);
540 if (ret)
541 return ret;
542
543 return devm_iio_device_register(dev, indio_dev);
544 }
545 EXPORT_SYMBOL_NS_GPL(sx_common_probe, "SEMTECH_PROX");
546
547 MODULE_AUTHOR("Gwendal Grignou <gwendal@chromium.org>");
548 MODULE_DESCRIPTION("Common functions and structures for Semtech sensor");
549 MODULE_LICENSE("GPL v2");
550