xref: /openbmc/linux/drivers/iio/proximity/as3935.c (revision bc5aa3a0) 
1 /*
2  * as3935.c - Support for AS3935 Franklin lightning sensor
3  *
4  * Copyright (C) 2014 Matt Ranostay <mranostay@gmail.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  */
17 
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/interrupt.h>
21 #include <linux/delay.h>
22 #include <linux/workqueue.h>
23 #include <linux/mutex.h>
24 #include <linux/err.h>
25 #include <linux/irq.h>
26 #include <linux/gpio.h>
27 #include <linux/spi/spi.h>
28 #include <linux/iio/iio.h>
29 #include <linux/iio/sysfs.h>
30 #include <linux/iio/trigger.h>
31 #include <linux/iio/trigger_consumer.h>
32 #include <linux/iio/buffer.h>
33 #include <linux/iio/triggered_buffer.h>
34 #include <linux/of_gpio.h>
35 
36 
37 #define AS3935_AFE_GAIN		0x00
38 #define AS3935_AFE_MASK		0x3F
39 #define AS3935_AFE_GAIN_MAX	0x1F
40 #define AS3935_AFE_PWR_BIT	BIT(0)
41 
42 #define AS3935_INT		0x03
43 #define AS3935_INT_MASK		0x07
44 #define AS3935_EVENT_INT	BIT(3)
45 #define AS3935_NOISE_INT	BIT(1)
46 
47 #define AS3935_DATA		0x07
48 #define AS3935_DATA_MASK	0x3F
49 
50 #define AS3935_TUNE_CAP		0x08
51 #define AS3935_CALIBRATE	0x3D
52 
53 #define AS3935_WRITE_DATA	BIT(15)
54 #define AS3935_READ_DATA	BIT(14)
55 #define AS3935_ADDRESS(x)	((x) << 8)
56 
57 #define MAX_PF_CAP		120
58 #define TUNE_CAP_DIV		8
59 
60 struct as3935_state {
61 	struct spi_device *spi;
62 	struct iio_trigger *trig;
63 	struct mutex lock;
64 	struct delayed_work work;
65 
66 	u32 tune_cap;
67 	u8 buffer[16]; /* 8-bit data + 56-bit padding + 64-bit timestamp */
68 	u8 buf[2] ____cacheline_aligned;
69 };
70 
71 static const struct iio_chan_spec as3935_channels[] = {
72 	{
73 		.type           = IIO_PROXIMITY,
74 		.info_mask_separate =
75 			BIT(IIO_CHAN_INFO_RAW) |
76 			BIT(IIO_CHAN_INFO_PROCESSED) |
77 			BIT(IIO_CHAN_INFO_SCALE),
78 		.scan_index     = 0,
79 		.scan_type = {
80 			.sign           = 'u',
81 			.realbits       = 6,
82 			.storagebits    = 8,
83 		},
84 	},
85 	IIO_CHAN_SOFT_TIMESTAMP(1),
86 };
87 
88 static int as3935_read(struct as3935_state *st, unsigned int reg, int *val)
89 {
90 	u8 cmd;
91 	int ret;
92 
93 	cmd = (AS3935_READ_DATA | AS3935_ADDRESS(reg)) >> 8;
94 	ret = spi_w8r8(st->spi, cmd);
95 	if (ret < 0)
96 		return ret;
97 	*val = ret;
98 
99 	return 0;
100 }
101 
102 static int as3935_write(struct as3935_state *st,
103 				unsigned int reg,
104 				unsigned int val)
105 {
106 	u8 *buf = st->buf;
107 
108 	buf[0] = (AS3935_WRITE_DATA | AS3935_ADDRESS(reg)) >> 8;
109 	buf[1] = val;
110 
111 	return spi_write(st->spi, buf, 2);
112 }
113 
114 static ssize_t as3935_sensor_sensitivity_show(struct device *dev,
115 					struct device_attribute *attr,
116 					char *buf)
117 {
118 	struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
119 	int val, ret;
120 
121 	ret = as3935_read(st, AS3935_AFE_GAIN, &val);
122 	if (ret)
123 		return ret;
124 	val = (val & AS3935_AFE_MASK) >> 1;
125 
126 	return sprintf(buf, "%d\n", val);
127 }
128 
129 static ssize_t as3935_sensor_sensitivity_store(struct device *dev,
130 					struct device_attribute *attr,
131 					const char *buf, size_t len)
132 {
133 	struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
134 	unsigned long val;
135 	int ret;
136 
137 	ret = kstrtoul((const char *) buf, 10, &val);
138 	if (ret)
139 		return -EINVAL;
140 
141 	if (val > AS3935_AFE_GAIN_MAX)
142 		return -EINVAL;
143 
144 	as3935_write(st, AS3935_AFE_GAIN, val << 1);
145 
146 	return len;
147 }
148 
149 static IIO_DEVICE_ATTR(sensor_sensitivity, S_IRUGO | S_IWUSR,
150 	as3935_sensor_sensitivity_show, as3935_sensor_sensitivity_store, 0);
151 
152 
153 static struct attribute *as3935_attributes[] = {
154 	&iio_dev_attr_sensor_sensitivity.dev_attr.attr,
155 	NULL,
156 };
157 
158 static struct attribute_group as3935_attribute_group = {
159 	.attrs = as3935_attributes,
160 };
161 
162 static int as3935_read_raw(struct iio_dev *indio_dev,
163 			   struct iio_chan_spec const *chan,
164 			   int *val,
165 			   int *val2,
166 			   long m)
167 {
168 	struct as3935_state *st = iio_priv(indio_dev);
169 	int ret;
170 
171 
172 	switch (m) {
173 	case IIO_CHAN_INFO_PROCESSED:
174 	case IIO_CHAN_INFO_RAW:
175 		*val2 = 0;
176 		ret = as3935_read(st, AS3935_DATA, val);
177 		if (ret)
178 			return ret;
179 
180 		if (m == IIO_CHAN_INFO_RAW)
181 			return IIO_VAL_INT;
182 
183 		/* storm out of range */
184 		if (*val == AS3935_DATA_MASK)
185 			return -EINVAL;
186 
187 		if (m == IIO_CHAN_INFO_PROCESSED)
188 			*val *= 1000;
189 		break;
190 	case IIO_CHAN_INFO_SCALE:
191 		*val = 1000;
192 		break;
193 	default:
194 		return -EINVAL;
195 	}
196 
197 	return IIO_VAL_INT;
198 }
199 
200 static const struct iio_info as3935_info = {
201 	.driver_module = THIS_MODULE,
202 	.attrs = &as3935_attribute_group,
203 	.read_raw = &as3935_read_raw,
204 };
205 
206 static irqreturn_t as3935_trigger_handler(int irq, void *private)
207 {
208 	struct iio_poll_func *pf = private;
209 	struct iio_dev *indio_dev = pf->indio_dev;
210 	struct as3935_state *st = iio_priv(indio_dev);
211 	int val, ret;
212 
213 	ret = as3935_read(st, AS3935_DATA, &val);
214 	if (ret)
215 		goto err_read;
216 
217 	st->buffer[0] = val & AS3935_DATA_MASK;
218 	iio_push_to_buffers_with_timestamp(indio_dev, &st->buffer,
219 					   pf->timestamp);
220 err_read:
221 	iio_trigger_notify_done(indio_dev->trig);
222 
223 	return IRQ_HANDLED;
224 }
225 
226 static const struct iio_trigger_ops iio_interrupt_trigger_ops = {
227 	.owner = THIS_MODULE,
228 };
229 
230 static void as3935_event_work(struct work_struct *work)
231 {
232 	struct as3935_state *st;
233 	int val;
234 	int ret;
235 
236 	st = container_of(work, struct as3935_state, work.work);
237 
238 	ret = as3935_read(st, AS3935_INT, &val);
239 	if (ret) {
240 		dev_warn(&st->spi->dev, "read error\n");
241 		return;
242 	}
243 
244 	val &= AS3935_INT_MASK;
245 
246 	switch (val) {
247 	case AS3935_EVENT_INT:
248 		iio_trigger_poll(st->trig);
249 		break;
250 	case AS3935_NOISE_INT:
251 		dev_warn(&st->spi->dev, "noise level is too high\n");
252 		break;
253 	}
254 }
255 
256 static irqreturn_t as3935_interrupt_handler(int irq, void *private)
257 {
258 	struct iio_dev *indio_dev = private;
259 	struct as3935_state *st = iio_priv(indio_dev);
260 
261 	/*
262 	 * Delay work for >2 milliseconds after an interrupt to allow
263 	 * estimated distance to recalculated.
264 	 */
265 
266 	schedule_delayed_work(&st->work, msecs_to_jiffies(3));
267 
268 	return IRQ_HANDLED;
269 }
270 
271 static void calibrate_as3935(struct as3935_state *st)
272 {
273 	mutex_lock(&st->lock);
274 
275 	/* mask disturber interrupt bit */
276 	as3935_write(st, AS3935_INT, BIT(5));
277 
278 	as3935_write(st, AS3935_CALIBRATE, 0x96);
279 	as3935_write(st, AS3935_TUNE_CAP,
280 		BIT(5) | (st->tune_cap / TUNE_CAP_DIV));
281 
282 	mdelay(2);
283 	as3935_write(st, AS3935_TUNE_CAP, (st->tune_cap / TUNE_CAP_DIV));
284 
285 	mutex_unlock(&st->lock);
286 }
287 
288 #ifdef CONFIG_PM_SLEEP
289 static int as3935_suspend(struct device *dev)
290 {
291 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
292 	struct as3935_state *st = iio_priv(indio_dev);
293 	int val, ret;
294 
295 	mutex_lock(&st->lock);
296 	ret = as3935_read(st, AS3935_AFE_GAIN, &val);
297 	if (ret)
298 		goto err_suspend;
299 	val |= AS3935_AFE_PWR_BIT;
300 
301 	ret = as3935_write(st, AS3935_AFE_GAIN, val);
302 
303 err_suspend:
304 	mutex_unlock(&st->lock);
305 
306 	return ret;
307 }
308 
309 static int as3935_resume(struct device *dev)
310 {
311 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
312 	struct as3935_state *st = iio_priv(indio_dev);
313 	int val, ret;
314 
315 	mutex_lock(&st->lock);
316 	ret = as3935_read(st, AS3935_AFE_GAIN, &val);
317 	if (ret)
318 		goto err_resume;
319 	val &= ~AS3935_AFE_PWR_BIT;
320 	ret = as3935_write(st, AS3935_AFE_GAIN, val);
321 
322 err_resume:
323 	mutex_unlock(&st->lock);
324 
325 	return ret;
326 }
327 
328 static SIMPLE_DEV_PM_OPS(as3935_pm_ops, as3935_suspend, as3935_resume);
329 #define AS3935_PM_OPS (&as3935_pm_ops)
330 
331 #else
332 #define AS3935_PM_OPS NULL
333 #endif
334 
335 static int as3935_probe(struct spi_device *spi)
336 {
337 	struct iio_dev *indio_dev;
338 	struct iio_trigger *trig;
339 	struct as3935_state *st;
340 	struct device_node *np = spi->dev.of_node;
341 	int ret;
342 
343 	/* Be sure lightning event interrupt is specified */
344 	if (!spi->irq) {
345 		dev_err(&spi->dev, "unable to get event interrupt\n");
346 		return -EINVAL;
347 	}
348 
349 	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
350 	if (!indio_dev)
351 		return -ENOMEM;
352 
353 	st = iio_priv(indio_dev);
354 	st->spi = spi;
355 
356 	spi_set_drvdata(spi, indio_dev);
357 	mutex_init(&st->lock);
358 	INIT_DELAYED_WORK(&st->work, as3935_event_work);
359 
360 	ret = of_property_read_u32(np,
361 			"ams,tuning-capacitor-pf", &st->tune_cap);
362 	if (ret) {
363 		st->tune_cap = 0;
364 		dev_warn(&spi->dev,
365 			"no tuning-capacitor-pf set, defaulting to %d",
366 			st->tune_cap);
367 	}
368 
369 	if (st->tune_cap > MAX_PF_CAP) {
370 		dev_err(&spi->dev,
371 			"wrong tuning-capacitor-pf setting of %d\n",
372 			st->tune_cap);
373 		return -EINVAL;
374 	}
375 
376 	indio_dev->dev.parent = &spi->dev;
377 	indio_dev->name = spi_get_device_id(spi)->name;
378 	indio_dev->channels = as3935_channels;
379 	indio_dev->num_channels = ARRAY_SIZE(as3935_channels);
380 	indio_dev->modes = INDIO_DIRECT_MODE;
381 	indio_dev->info = &as3935_info;
382 
383 	trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
384 				      indio_dev->name, indio_dev->id);
385 
386 	if (!trig)
387 		return -ENOMEM;
388 
389 	st->trig = trig;
390 	trig->dev.parent = indio_dev->dev.parent;
391 	iio_trigger_set_drvdata(trig, indio_dev);
392 	trig->ops = &iio_interrupt_trigger_ops;
393 
394 	ret = iio_trigger_register(trig);
395 	if (ret) {
396 		dev_err(&spi->dev, "failed to register trigger\n");
397 		return ret;
398 	}
399 
400 	ret = iio_triggered_buffer_setup(indio_dev, iio_pollfunc_store_time,
401 		&as3935_trigger_handler, NULL);
402 
403 	if (ret) {
404 		dev_err(&spi->dev, "cannot setup iio trigger\n");
405 		goto unregister_trigger;
406 	}
407 
408 	calibrate_as3935(st);
409 
410 	ret = devm_request_irq(&spi->dev, spi->irq,
411 				&as3935_interrupt_handler,
412 				IRQF_TRIGGER_RISING,
413 				dev_name(&spi->dev),
414 				indio_dev);
415 
416 	if (ret) {
417 		dev_err(&spi->dev, "unable to request irq\n");
418 		goto unregister_buffer;
419 	}
420 
421 	ret = iio_device_register(indio_dev);
422 	if (ret < 0) {
423 		dev_err(&spi->dev, "unable to register device\n");
424 		goto unregister_buffer;
425 	}
426 	return 0;
427 
428 unregister_buffer:
429 	iio_triggered_buffer_cleanup(indio_dev);
430 
431 unregister_trigger:
432 	iio_trigger_unregister(st->trig);
433 
434 	return ret;
435 }
436 
437 static int as3935_remove(struct spi_device *spi)
438 {
439 	struct iio_dev *indio_dev = spi_get_drvdata(spi);
440 	struct as3935_state *st = iio_priv(indio_dev);
441 
442 	iio_device_unregister(indio_dev);
443 	iio_triggered_buffer_cleanup(indio_dev);
444 	iio_trigger_unregister(st->trig);
445 
446 	return 0;
447 }
448 
449 static const struct of_device_id as3935_of_match[] = {
450 	{ .compatible = "ams,as3935", },
451 	{ /* sentinel */ },
452 };
453 MODULE_DEVICE_TABLE(of, as3935_of_match);
454 
455 static const struct spi_device_id as3935_id[] = {
456 	{"as3935", 0},
457 	{},
458 };
459 MODULE_DEVICE_TABLE(spi, as3935_id);
460 
461 static struct spi_driver as3935_driver = {
462 	.driver = {
463 		.name	= "as3935",
464 		.of_match_table = of_match_ptr(as3935_of_match),
465 		.pm	= AS3935_PM_OPS,
466 	},
467 	.probe		= as3935_probe,
468 	.remove		= as3935_remove,
469 	.id_table	= as3935_id,
470 };
471 module_spi_driver(as3935_driver);
472 
473 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
474 MODULE_DESCRIPTION("AS3935 lightning sensor");
475 MODULE_LICENSE("GPL");
476