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_INT 0x03
43 #define AS3935_INT_MASK 0x07
44 #define AS3935_EVENT_INT BIT(3)
45 #define AS3935_NOISE_INT BIT(1)
47 #define AS3935_DATA 0x07
48 #define AS3935_DATA_MASK 0x3F
50 #define AS3935_TUNE_CAP 0x08
51 #define AS3935_CALIBRATE 0x3D
53 #define AS3935_WRITE_DATA BIT(15)
54 #define AS3935_READ_DATA BIT(14)
55 #define AS3935_ADDRESS(x) ((x) << 8)
57 #define MAX_PF_CAP 120
58 #define TUNE_CAP_DIV 8
61 struct spi_device
*spi
;
62 struct iio_trigger
*trig
;
64 struct delayed_work work
;
67 u8 buffer
[16]; /* 8-bit data + 56-bit padding + 64-bit timestamp */
68 u8 buf
[2] ____cacheline_aligned
;
71 static const struct iio_chan_spec as3935_channels
[] = {
73 .type
= IIO_PROXIMITY
,
75 BIT(IIO_CHAN_INFO_RAW
) |
76 BIT(IIO_CHAN_INFO_PROCESSED
) |
77 BIT(IIO_CHAN_INFO_SCALE
),
85 IIO_CHAN_SOFT_TIMESTAMP(1),
88 static int as3935_read(struct as3935_state
*st
, unsigned int reg
, int *val
)
93 cmd
= (AS3935_READ_DATA
| AS3935_ADDRESS(reg
)) >> 8;
94 ret
= spi_w8r8(st
->spi
, cmd
);
102 static int as3935_write(struct as3935_state
*st
,
108 buf
[0] = (AS3935_WRITE_DATA
| AS3935_ADDRESS(reg
)) >> 8;
111 return spi_write(st
->spi
, buf
, 2);
114 static ssize_t
as3935_sensor_sensitivity_show(struct device
*dev
,
115 struct device_attribute
*attr
,
118 struct as3935_state
*st
= iio_priv(dev_to_iio_dev(dev
));
121 ret
= as3935_read(st
, AS3935_AFE_GAIN
, &val
);
124 val
= (val
& AS3935_AFE_MASK
) >> 1;
126 return sprintf(buf
, "%d\n", val
);
129 static ssize_t
as3935_sensor_sensitivity_store(struct device
*dev
,
130 struct device_attribute
*attr
,
131 const char *buf
, size_t len
)
133 struct as3935_state
*st
= iio_priv(dev_to_iio_dev(dev
));
137 ret
= kstrtoul((const char *) buf
, 10, &val
);
141 if (val
> AS3935_AFE_GAIN_MAX
)
144 as3935_write(st
, AS3935_AFE_GAIN
, val
<< 1);
149 static IIO_DEVICE_ATTR(sensor_sensitivity
, S_IRUGO
| S_IWUSR
,
150 as3935_sensor_sensitivity_show
, as3935_sensor_sensitivity_store
, 0);
153 static struct attribute
*as3935_attributes
[] = {
154 &iio_dev_attr_sensor_sensitivity
.dev_attr
.attr
,
158 static struct attribute_group as3935_attribute_group
= {
159 .attrs
= as3935_attributes
,
162 static int as3935_read_raw(struct iio_dev
*indio_dev
,
163 struct iio_chan_spec
const *chan
,
168 struct as3935_state
*st
= iio_priv(indio_dev
);
173 case IIO_CHAN_INFO_PROCESSED
:
174 case IIO_CHAN_INFO_RAW
:
176 ret
= as3935_read(st
, AS3935_DATA
, val
);
180 if (m
== IIO_CHAN_INFO_RAW
)
183 /* storm out of range */
184 if (*val
== AS3935_DATA_MASK
)
187 if (m
== IIO_CHAN_INFO_PROCESSED
)
190 case IIO_CHAN_INFO_SCALE
:
200 static const struct iio_info as3935_info
= {
201 .driver_module
= THIS_MODULE
,
202 .attrs
= &as3935_attribute_group
,
203 .read_raw
= &as3935_read_raw
,
206 static irqreturn_t
as3935_trigger_handler(int irq
, void *private)
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
);
213 ret
= as3935_read(st
, AS3935_DATA
, &val
);
217 st
->buffer
[0] = val
& AS3935_DATA_MASK
;
218 iio_push_to_buffers_with_timestamp(indio_dev
, &st
->buffer
,
221 iio_trigger_notify_done(indio_dev
->trig
);
226 static const struct iio_trigger_ops iio_interrupt_trigger_ops
= {
227 .owner
= THIS_MODULE
,
230 static void as3935_event_work(struct work_struct
*work
)
232 struct as3935_state
*st
;
235 st
= container_of(work
, struct as3935_state
, work
.work
);
237 as3935_read(st
, AS3935_INT
, &val
);
238 val
&= AS3935_INT_MASK
;
241 case AS3935_EVENT_INT
:
242 iio_trigger_poll(st
->trig
);
244 case AS3935_NOISE_INT
:
245 dev_warn(&st
->spi
->dev
, "noise level is too high");
250 static irqreturn_t
as3935_interrupt_handler(int irq
, void *private)
252 struct iio_dev
*indio_dev
= private;
253 struct as3935_state
*st
= iio_priv(indio_dev
);
256 * Delay work for >2 milliseconds after an interrupt to allow
257 * estimated distance to recalculated.
260 schedule_delayed_work(&st
->work
, msecs_to_jiffies(3));
265 static void calibrate_as3935(struct as3935_state
*st
)
267 mutex_lock(&st
->lock
);
269 /* mask disturber interrupt bit */
270 as3935_write(st
, AS3935_INT
, BIT(5));
272 as3935_write(st
, AS3935_CALIBRATE
, 0x96);
273 as3935_write(st
, AS3935_TUNE_CAP
,
274 BIT(5) | (st
->tune_cap
/ TUNE_CAP_DIV
));
277 as3935_write(st
, AS3935_TUNE_CAP
, (st
->tune_cap
/ TUNE_CAP_DIV
));
279 mutex_unlock(&st
->lock
);
282 #ifdef CONFIG_PM_SLEEP
283 static int as3935_suspend(struct device
*dev
)
285 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
286 struct as3935_state
*st
= iio_priv(indio_dev
);
289 mutex_lock(&st
->lock
);
290 ret
= as3935_read(st
, AS3935_AFE_GAIN
, &val
);
293 val
|= AS3935_AFE_PWR_BIT
;
295 ret
= as3935_write(st
, AS3935_AFE_GAIN
, val
);
298 mutex_unlock(&st
->lock
);
303 static int as3935_resume(struct device
*dev
)
305 struct iio_dev
*indio_dev
= dev_get_drvdata(dev
);
306 struct as3935_state
*st
= iio_priv(indio_dev
);
309 mutex_lock(&st
->lock
);
310 ret
= as3935_read(st
, AS3935_AFE_GAIN
, &val
);
313 val
&= ~AS3935_AFE_PWR_BIT
;
314 ret
= as3935_write(st
, AS3935_AFE_GAIN
, val
);
317 mutex_unlock(&st
->lock
);
322 static SIMPLE_DEV_PM_OPS(as3935_pm_ops
, as3935_suspend
, as3935_resume
);
323 #define AS3935_PM_OPS (&as3935_pm_ops)
326 #define AS3935_PM_OPS NULL
329 static int as3935_probe(struct spi_device
*spi
)
331 struct iio_dev
*indio_dev
;
332 struct iio_trigger
*trig
;
333 struct as3935_state
*st
;
334 struct device_node
*np
= spi
->dev
.of_node
;
337 /* Be sure lightning event interrupt is specified */
339 dev_err(&spi
->dev
, "unable to get event interrupt\n");
343 indio_dev
= devm_iio_device_alloc(&spi
->dev
, sizeof(*st
));
347 st
= iio_priv(indio_dev
);
351 spi_set_drvdata(spi
, indio_dev
);
352 mutex_init(&st
->lock
);
353 INIT_DELAYED_WORK(&st
->work
, as3935_event_work
);
355 ret
= of_property_read_u32(np
,
356 "ams,tuning-capacitor-pf", &st
->tune_cap
);
360 "no tuning-capacitor-pf set, defaulting to %d",
364 if (st
->tune_cap
> MAX_PF_CAP
) {
366 "wrong tuning-capacitor-pf setting of %d\n",
371 indio_dev
->dev
.parent
= &spi
->dev
;
372 indio_dev
->name
= spi_get_device_id(spi
)->name
;
373 indio_dev
->channels
= as3935_channels
;
374 indio_dev
->num_channels
= ARRAY_SIZE(as3935_channels
);
375 indio_dev
->modes
= INDIO_DIRECT_MODE
;
376 indio_dev
->info
= &as3935_info
;
378 trig
= devm_iio_trigger_alloc(&spi
->dev
, "%s-dev%d",
379 indio_dev
->name
, indio_dev
->id
);
385 trig
->dev
.parent
= indio_dev
->dev
.parent
;
386 iio_trigger_set_drvdata(trig
, indio_dev
);
387 trig
->ops
= &iio_interrupt_trigger_ops
;
389 ret
= iio_trigger_register(trig
);
391 dev_err(&spi
->dev
, "failed to register trigger\n");
395 ret
= iio_triggered_buffer_setup(indio_dev
, NULL
,
396 &as3935_trigger_handler
, NULL
);
399 dev_err(&spi
->dev
, "cannot setup iio trigger\n");
400 goto unregister_trigger
;
403 calibrate_as3935(st
);
405 ret
= devm_request_irq(&spi
->dev
, spi
->irq
,
406 &as3935_interrupt_handler
,
412 dev_err(&spi
->dev
, "unable to request irq\n");
413 goto unregister_buffer
;
416 ret
= iio_device_register(indio_dev
);
418 dev_err(&spi
->dev
, "unable to register device\n");
419 goto unregister_buffer
;
424 iio_triggered_buffer_cleanup(indio_dev
);
427 iio_trigger_unregister(st
->trig
);
432 static int as3935_remove(struct spi_device
*spi
)
434 struct iio_dev
*indio_dev
= spi_get_drvdata(spi
);
435 struct as3935_state
*st
= iio_priv(indio_dev
);
437 iio_device_unregister(indio_dev
);
438 iio_triggered_buffer_cleanup(indio_dev
);
439 iio_trigger_unregister(st
->trig
);
444 static const struct of_device_id as3935_of_match
[] = {
445 { .compatible
= "ams,as3935", },
448 MODULE_DEVICE_TABLE(of
, as3935_of_match
);
450 static const struct spi_device_id as3935_id
[] = {
454 MODULE_DEVICE_TABLE(spi
, as3935_id
);
456 static struct spi_driver as3935_driver
= {
459 .of_match_table
= of_match_ptr(as3935_of_match
),
462 .probe
= as3935_probe
,
463 .remove
= as3935_remove
,
464 .id_table
= as3935_id
,
466 module_spi_driver(as3935_driver
);
468 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
469 MODULE_DESCRIPTION("AS3935 lightning sensor");
470 MODULE_LICENSE("GPL");
471 MODULE_ALIAS("spi:as3935");