2 * as3935.c - Support for AS3935 Franklin lightning sensor
4 * Copyright (C) 2014 Matt Ranostay <mranostay@gmail.com>
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.
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.
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>
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)
42 #define AS3935_NFLWDTH 0x01
43 #define AS3935_NFLWDTH_MASK 0x7f
45 #define AS3935_INT 0x03
46 #define AS3935_INT_MASK 0x0f
47 #define AS3935_DISTURB_INT BIT(2)
48 #define AS3935_EVENT_INT BIT(3)
49 #define AS3935_NOISE_INT BIT(0)
51 #define AS3935_DATA 0x07
52 #define AS3935_DATA_MASK 0x3F
54 #define AS3935_TUNE_CAP 0x08
55 #define AS3935_DEFAULTS 0x3C
56 #define AS3935_CALIBRATE 0x3D
58 #define AS3935_READ_DATA BIT(14)
59 #define AS3935_ADDRESS(x) ((x) << 8)
61 #define MAX_PF_CAP 120
62 #define TUNE_CAP_DIV 8
65 struct spi_device *spi;
66 struct iio_trigger *trig;
68 struct delayed_work work;
70 unsigned long noise_tripped;
73 /* Ensure timestamp is naturally aligned */
76 s64 timestamp __aligned(8);
78 u8 buf[2] ____cacheline_aligned;
81 static const struct iio_chan_spec as3935_channels[] = {
83 .type = IIO_PROXIMITY,
85 BIT(IIO_CHAN_INFO_RAW) |
86 BIT(IIO_CHAN_INFO_PROCESSED) |
87 BIT(IIO_CHAN_INFO_SCALE),
95 IIO_CHAN_SOFT_TIMESTAMP(1),
98 static int as3935_read(struct as3935_state *st, unsigned int reg, int *val)
103 cmd = (AS3935_READ_DATA | AS3935_ADDRESS(reg)) >> 8;
104 ret = spi_w8r8(st->spi, cmd);
112 static int as3935_write(struct as3935_state *st,
118 buf[0] = AS3935_ADDRESS(reg) >> 8;
121 return spi_write(st->spi, buf, 2);
124 static ssize_t as3935_sensor_sensitivity_show(struct device *dev,
125 struct device_attribute *attr,
128 struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
131 ret = as3935_read(st, AS3935_AFE_GAIN, &val);
134 val = (val & AS3935_AFE_MASK) >> 1;
136 return sprintf(buf, "%d\n", val);
139 static ssize_t as3935_sensor_sensitivity_store(struct device *dev,
140 struct device_attribute *attr,
141 const char *buf, size_t len)
143 struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
147 ret = kstrtoul((const char *) buf, 10, &val);
151 if (val > AS3935_AFE_GAIN_MAX)
154 as3935_write(st, AS3935_AFE_GAIN, val << 1);
159 static ssize_t as3935_noise_level_tripped_show(struct device *dev,
160 struct device_attribute *attr,
163 struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
166 mutex_lock(&st->lock);
167 ret = sprintf(buf, "%d\n", !time_after(jiffies, st->noise_tripped + HZ));
168 mutex_unlock(&st->lock);
173 static IIO_DEVICE_ATTR(sensor_sensitivity, S_IRUGO | S_IWUSR,
174 as3935_sensor_sensitivity_show, as3935_sensor_sensitivity_store, 0);
176 static IIO_DEVICE_ATTR(noise_level_tripped, S_IRUGO,
177 as3935_noise_level_tripped_show, NULL, 0);
179 static struct attribute *as3935_attributes[] = {
180 &iio_dev_attr_sensor_sensitivity.dev_attr.attr,
181 &iio_dev_attr_noise_level_tripped.dev_attr.attr,
185 static const struct attribute_group as3935_attribute_group = {
186 .attrs = as3935_attributes,
189 static int as3935_read_raw(struct iio_dev *indio_dev,
190 struct iio_chan_spec const *chan,
195 struct as3935_state *st = iio_priv(indio_dev);
200 case IIO_CHAN_INFO_PROCESSED:
201 case IIO_CHAN_INFO_RAW:
203 ret = as3935_read(st, AS3935_DATA, val);
207 /* storm out of range */
208 if (*val == AS3935_DATA_MASK)
211 if (m == IIO_CHAN_INFO_RAW)
214 if (m == IIO_CHAN_INFO_PROCESSED)
217 case IIO_CHAN_INFO_SCALE:
227 static const struct iio_info as3935_info = {
228 .driver_module = THIS_MODULE,
229 .attrs = &as3935_attribute_group,
230 .read_raw = &as3935_read_raw,
233 static irqreturn_t as3935_trigger_handler(int irq, void *private)
235 struct iio_poll_func *pf = private;
236 struct iio_dev *indio_dev = pf->indio_dev;
237 struct as3935_state *st = iio_priv(indio_dev);
240 ret = as3935_read(st, AS3935_DATA, &val);
244 st->scan.chan = val & AS3935_DATA_MASK;
245 iio_push_to_buffers_with_timestamp(indio_dev, &st->scan,
246 iio_get_time_ns(indio_dev));
248 iio_trigger_notify_done(indio_dev->trig);
253 static const struct iio_trigger_ops iio_interrupt_trigger_ops = {
254 .owner = THIS_MODULE,
257 static void as3935_event_work(struct work_struct *work)
259 struct as3935_state *st;
263 st = container_of(work, struct as3935_state, work.work);
265 ret = as3935_read(st, AS3935_INT, &val);
267 dev_warn(&st->spi->dev, "read error\n");
271 val &= AS3935_INT_MASK;
274 case AS3935_EVENT_INT:
275 iio_trigger_poll_chained(st->trig);
277 case AS3935_DISTURB_INT:
278 case AS3935_NOISE_INT:
279 mutex_lock(&st->lock);
280 st->noise_tripped = jiffies;
281 mutex_unlock(&st->lock);
282 dev_warn(&st->spi->dev, "noise level is too high\n");
287 static irqreturn_t as3935_interrupt_handler(int irq, void *private)
289 struct iio_dev *indio_dev = private;
290 struct as3935_state *st = iio_priv(indio_dev);
293 * Delay work for >2 milliseconds after an interrupt to allow
294 * estimated distance to recalculated.
297 schedule_delayed_work(&st->work, msecs_to_jiffies(3));
302 static void calibrate_as3935(struct as3935_state *st)
304 as3935_write(st, AS3935_DEFAULTS, 0x96);
305 as3935_write(st, AS3935_CALIBRATE, 0x96);
306 as3935_write(st, AS3935_TUNE_CAP,
307 BIT(5) | (st->tune_cap / TUNE_CAP_DIV));
310 as3935_write(st, AS3935_TUNE_CAP, (st->tune_cap / TUNE_CAP_DIV));
311 as3935_write(st, AS3935_NFLWDTH, st->nflwdth_reg);
314 #ifdef CONFIG_PM_SLEEP
315 static int as3935_suspend(struct device *dev)
317 struct iio_dev *indio_dev = dev_get_drvdata(dev);
318 struct as3935_state *st = iio_priv(indio_dev);
321 mutex_lock(&st->lock);
322 ret = as3935_read(st, AS3935_AFE_GAIN, &val);
325 val |= AS3935_AFE_PWR_BIT;
327 ret = as3935_write(st, AS3935_AFE_GAIN, val);
330 mutex_unlock(&st->lock);
335 static int as3935_resume(struct device *dev)
337 struct iio_dev *indio_dev = dev_get_drvdata(dev);
338 struct as3935_state *st = iio_priv(indio_dev);
341 mutex_lock(&st->lock);
342 ret = as3935_read(st, AS3935_AFE_GAIN, &val);
345 val &= ~AS3935_AFE_PWR_BIT;
346 ret = as3935_write(st, AS3935_AFE_GAIN, val);
348 calibrate_as3935(st);
351 mutex_unlock(&st->lock);
356 static SIMPLE_DEV_PM_OPS(as3935_pm_ops, as3935_suspend, as3935_resume);
357 #define AS3935_PM_OPS (&as3935_pm_ops)
360 #define AS3935_PM_OPS NULL
363 static int as3935_probe(struct spi_device *spi)
365 struct iio_dev *indio_dev;
366 struct iio_trigger *trig;
367 struct as3935_state *st;
368 struct device_node *np = spi->dev.of_node;
371 /* Be sure lightning event interrupt is specified */
373 dev_err(&spi->dev, "unable to get event interrupt\n");
377 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
381 st = iio_priv(indio_dev);
384 spi_set_drvdata(spi, indio_dev);
385 mutex_init(&st->lock);
386 INIT_DELAYED_WORK(&st->work, as3935_event_work);
388 ret = of_property_read_u32(np,
389 "ams,tuning-capacitor-pf", &st->tune_cap);
393 "no tuning-capacitor-pf set, defaulting to %d",
397 if (st->tune_cap > MAX_PF_CAP) {
399 "wrong tuning-capacitor-pf setting of %d\n",
404 ret = of_property_read_u32(np,
405 "ams,nflwdth", &st->nflwdth_reg);
406 if (!ret && st->nflwdth_reg > AS3935_NFLWDTH_MASK) {
408 "invalid nflwdth setting of %d\n",
413 indio_dev->dev.parent = &spi->dev;
414 indio_dev->name = spi_get_device_id(spi)->name;
415 indio_dev->channels = as3935_channels;
416 indio_dev->num_channels = ARRAY_SIZE(as3935_channels);
417 indio_dev->modes = INDIO_DIRECT_MODE;
418 indio_dev->info = &as3935_info;
420 trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
421 indio_dev->name, indio_dev->id);
427 st->noise_tripped = jiffies - HZ;
428 trig->dev.parent = indio_dev->dev.parent;
429 iio_trigger_set_drvdata(trig, indio_dev);
430 trig->ops = &iio_interrupt_trigger_ops;
432 ret = iio_trigger_register(trig);
434 dev_err(&spi->dev, "failed to register trigger\n");
438 ret = iio_triggered_buffer_setup(indio_dev, iio_pollfunc_store_time,
439 &as3935_trigger_handler, NULL);
442 dev_err(&spi->dev, "cannot setup iio trigger\n");
443 goto unregister_trigger;
446 calibrate_as3935(st);
448 ret = devm_request_irq(&spi->dev, spi->irq,
449 &as3935_interrupt_handler,
455 dev_err(&spi->dev, "unable to request irq\n");
456 goto unregister_buffer;
459 ret = iio_device_register(indio_dev);
461 dev_err(&spi->dev, "unable to register device\n");
462 goto unregister_buffer;
467 iio_triggered_buffer_cleanup(indio_dev);
470 iio_trigger_unregister(st->trig);
475 static int as3935_remove(struct spi_device *spi)
477 struct iio_dev *indio_dev = spi_get_drvdata(spi);
478 struct as3935_state *st = iio_priv(indio_dev);
480 iio_device_unregister(indio_dev);
481 iio_triggered_buffer_cleanup(indio_dev);
482 iio_trigger_unregister(st->trig);
487 static const struct of_device_id as3935_of_match[] = {
488 { .compatible = "ams,as3935", },
491 MODULE_DEVICE_TABLE(of, as3935_of_match);
493 static const struct spi_device_id as3935_id[] = {
497 MODULE_DEVICE_TABLE(spi, as3935_id);
499 static struct spi_driver as3935_driver = {
502 .of_match_table = of_match_ptr(as3935_of_match),
505 .probe = as3935_probe,
506 .remove = as3935_remove,
507 .id_table = as3935_id,
509 module_spi_driver(as3935_driver);
511 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
512 MODULE_DESCRIPTION("AS3935 lightning sensor");
513 MODULE_LICENSE("GPL");