xref: /linux/drivers/iio/proximity/as3935.c (revision ca55b2fef3a9373fcfc30f82fd26bc7fccbda732) 
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 buf[2] ____cacheline_aligned;
68 };
69 
70 static const struct iio_chan_spec as3935_channels[] = {
71 	{
72 		.type           = IIO_PROXIMITY,
73 		.info_mask_separate =
74 			BIT(IIO_CHAN_INFO_RAW) |
75 			BIT(IIO_CHAN_INFO_PROCESSED),
76 		.scan_index     = 0,
77 		.scan_type = {
78 			.sign           = 'u',
79 			.realbits       = 6,
80 			.storagebits    = 8,
81 		},
82 	},
83 	IIO_CHAN_SOFT_TIMESTAMP(1),
84 };
85 
86 static int as3935_read(struct as3935_state *st, unsigned int reg, int *val)
87 {
88 	u8 cmd;
89 	int ret;
90 
91 	cmd = (AS3935_READ_DATA | AS3935_ADDRESS(reg)) >> 8;
92 	ret = spi_w8r8(st->spi, cmd);
93 	if (ret < 0)
94 		return ret;
95 	*val = ret;
96 
97 	return 0;
98 }
99 
100 static int as3935_write(struct as3935_state *st,
101 				unsigned int reg,
102 				unsigned int val)
103 {
104 	u8 *buf = st->buf;
105 
106 	buf[0] = (AS3935_WRITE_DATA | AS3935_ADDRESS(reg)) >> 8;
107 	buf[1] = val;
108 
109 	return spi_write(st->spi, buf, 2);
110 }
111 
112 static ssize_t as3935_sensor_sensitivity_show(struct device *dev,
113 					struct device_attribute *attr,
114 					char *buf)
115 {
116 	struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
117 	int val, ret;
118 
119 	ret = as3935_read(st, AS3935_AFE_GAIN, &val);
120 	if (ret)
121 		return ret;
122 	val = (val & AS3935_AFE_MASK) >> 1;
123 
124 	return sprintf(buf, "%d\n", val);
125 }
126 
127 static ssize_t as3935_sensor_sensitivity_store(struct device *dev,
128 					struct device_attribute *attr,
129 					const char *buf, size_t len)
130 {
131 	struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
132 	unsigned long val;
133 	int ret;
134 
135 	ret = kstrtoul((const char *) buf, 10, &val);
136 	if (ret)
137 		return -EINVAL;
138 
139 	if (val > AS3935_AFE_GAIN_MAX)
140 		return -EINVAL;
141 
142 	as3935_write(st, AS3935_AFE_GAIN, val << 1);
143 
144 	return len;
145 }
146 
147 static IIO_DEVICE_ATTR(sensor_sensitivity, S_IRUGO | S_IWUSR,
148 	as3935_sensor_sensitivity_show, as3935_sensor_sensitivity_store, 0);
149 
150 
151 static struct attribute *as3935_attributes[] = {
152 	&iio_dev_attr_sensor_sensitivity.dev_attr.attr,
153 	NULL,
154 };
155 
156 static struct attribute_group as3935_attribute_group = {
157 	.attrs = as3935_attributes,
158 };
159 
160 static int as3935_read_raw(struct iio_dev *indio_dev,
161 			   struct iio_chan_spec const *chan,
162 			   int *val,
163 			   int *val2,
164 			   long m)
165 {
166 	struct as3935_state *st = iio_priv(indio_dev);
167 	int ret;
168 
169 
170 	switch (m) {
171 	case IIO_CHAN_INFO_PROCESSED:
172 	case IIO_CHAN_INFO_RAW:
173 		*val2 = 0;
174 		ret = as3935_read(st, AS3935_DATA, val);
175 		if (ret)
176 			return ret;
177 
178 		if (m == IIO_CHAN_INFO_RAW)
179 			return IIO_VAL_INT;
180 
181 		/* storm out of range */
182 		if (*val == AS3935_DATA_MASK)
183 			return -EINVAL;
184 		*val *= 1000;
185 		break;
186 	default:
187 		return -EINVAL;
188 	}
189 
190 	return IIO_VAL_INT;
191 }
192 
193 static const struct iio_info as3935_info = {
194 	.driver_module = THIS_MODULE,
195 	.attrs = &as3935_attribute_group,
196 	.read_raw = &as3935_read_raw,
197 };
198 
199 static irqreturn_t as3935_trigger_handler(int irq, void *private)
200 {
201 	struct iio_poll_func *pf = private;
202 	struct iio_dev *indio_dev = pf->indio_dev;
203 	struct as3935_state *st = iio_priv(indio_dev);
204 	int val, ret;
205 
206 	ret = as3935_read(st, AS3935_DATA, &val);
207 	if (ret)
208 		goto err_read;
209 	val &= AS3935_DATA_MASK;
210 	val *= 1000;
211 
212 	iio_push_to_buffers_with_timestamp(indio_dev, &val, pf->timestamp);
213 err_read:
214 	iio_trigger_notify_done(indio_dev->trig);
215 
216 	return IRQ_HANDLED;
217 }
218 
219 static const struct iio_trigger_ops iio_interrupt_trigger_ops = {
220 	.owner = THIS_MODULE,
221 };
222 
223 static void as3935_event_work(struct work_struct *work)
224 {
225 	struct as3935_state *st;
226 	int val;
227 
228 	st = container_of(work, struct as3935_state, work.work);
229 
230 	as3935_read(st, AS3935_INT, &val);
231 	val &= AS3935_INT_MASK;
232 
233 	switch (val) {
234 	case AS3935_EVENT_INT:
235 		iio_trigger_poll(st->trig);
236 		break;
237 	case AS3935_NOISE_INT:
238 		dev_warn(&st->spi->dev, "noise level is too high");
239 		break;
240 	}
241 }
242 
243 static irqreturn_t as3935_interrupt_handler(int irq, void *private)
244 {
245 	struct iio_dev *indio_dev = private;
246 	struct as3935_state *st = iio_priv(indio_dev);
247 
248 	/*
249 	 * Delay work for >2 milliseconds after an interrupt to allow
250 	 * estimated distance to recalculated.
251 	 */
252 
253 	schedule_delayed_work(&st->work, msecs_to_jiffies(3));
254 
255 	return IRQ_HANDLED;
256 }
257 
258 static void calibrate_as3935(struct as3935_state *st)
259 {
260 	mutex_lock(&st->lock);
261 
262 	/* mask disturber interrupt bit */
263 	as3935_write(st, AS3935_INT, BIT(5));
264 
265 	as3935_write(st, AS3935_CALIBRATE, 0x96);
266 	as3935_write(st, AS3935_TUNE_CAP,
267 		BIT(5) | (st->tune_cap / TUNE_CAP_DIV));
268 
269 	mdelay(2);
270 	as3935_write(st, AS3935_TUNE_CAP, (st->tune_cap / TUNE_CAP_DIV));
271 
272 	mutex_unlock(&st->lock);
273 }
274 
275 #ifdef CONFIG_PM_SLEEP
276 static int as3935_suspend(struct device *dev)
277 {
278 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
279 	struct as3935_state *st = iio_priv(indio_dev);
280 	int val, ret;
281 
282 	mutex_lock(&st->lock);
283 	ret = as3935_read(st, AS3935_AFE_GAIN, &val);
284 	if (ret)
285 		goto err_suspend;
286 	val |= AS3935_AFE_PWR_BIT;
287 
288 	ret = as3935_write(st, AS3935_AFE_GAIN, val);
289 
290 err_suspend:
291 	mutex_unlock(&st->lock);
292 
293 	return ret;
294 }
295 
296 static int as3935_resume(struct device *dev)
297 {
298 	struct iio_dev *indio_dev = dev_get_drvdata(dev);
299 	struct as3935_state *st = iio_priv(indio_dev);
300 	int val, ret;
301 
302 	mutex_lock(&st->lock);
303 	ret = as3935_read(st, AS3935_AFE_GAIN, &val);
304 	if (ret)
305 		goto err_resume;
306 	val &= ~AS3935_AFE_PWR_BIT;
307 	ret = as3935_write(st, AS3935_AFE_GAIN, val);
308 
309 err_resume:
310 	mutex_unlock(&st->lock);
311 
312 	return ret;
313 }
314 
315 static SIMPLE_DEV_PM_OPS(as3935_pm_ops, as3935_suspend, as3935_resume);
316 #define AS3935_PM_OPS (&as3935_pm_ops)
317 
318 #else
319 #define AS3935_PM_OPS NULL
320 #endif
321 
322 static int as3935_probe(struct spi_device *spi)
323 {
324 	struct iio_dev *indio_dev;
325 	struct iio_trigger *trig;
326 	struct as3935_state *st;
327 	struct device_node *np = spi->dev.of_node;
328 	int ret;
329 
330 	/* Be sure lightning event interrupt is specified */
331 	if (!spi->irq) {
332 		dev_err(&spi->dev, "unable to get event interrupt\n");
333 		return -EINVAL;
334 	}
335 
336 	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
337 	if (!indio_dev)
338 		return -ENOMEM;
339 
340 	st = iio_priv(indio_dev);
341 	st->spi = spi;
342 	st->tune_cap = 0;
343 
344 	spi_set_drvdata(spi, indio_dev);
345 	mutex_init(&st->lock);
346 	INIT_DELAYED_WORK(&st->work, as3935_event_work);
347 
348 	ret = of_property_read_u32(np,
349 			"ams,tuning-capacitor-pf", &st->tune_cap);
350 	if (ret) {
351 		st->tune_cap = 0;
352 		dev_warn(&spi->dev,
353 			"no tuning-capacitor-pf set, defaulting to %d",
354 			st->tune_cap);
355 	}
356 
357 	if (st->tune_cap > MAX_PF_CAP) {
358 		dev_err(&spi->dev,
359 			"wrong tuning-capacitor-pf setting of %d\n",
360 			st->tune_cap);
361 		return -EINVAL;
362 	}
363 
364 	indio_dev->dev.parent = &spi->dev;
365 	indio_dev->name = spi_get_device_id(spi)->name;
366 	indio_dev->channels = as3935_channels;
367 	indio_dev->num_channels = ARRAY_SIZE(as3935_channels);
368 	indio_dev->modes = INDIO_DIRECT_MODE;
369 	indio_dev->info = &as3935_info;
370 
371 	trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
372 				      indio_dev->name, indio_dev->id);
373 
374 	if (!trig)
375 		return -ENOMEM;
376 
377 	st->trig = trig;
378 	trig->dev.parent = indio_dev->dev.parent;
379 	iio_trigger_set_drvdata(trig, indio_dev);
380 	trig->ops = &iio_interrupt_trigger_ops;
381 
382 	ret = iio_trigger_register(trig);
383 	if (ret) {
384 		dev_err(&spi->dev, "failed to register trigger\n");
385 		return ret;
386 	}
387 
388 	ret = iio_triggered_buffer_setup(indio_dev, NULL,
389 		&as3935_trigger_handler, NULL);
390 
391 	if (ret) {
392 		dev_err(&spi->dev, "cannot setup iio trigger\n");
393 		goto unregister_trigger;
394 	}
395 
396 	calibrate_as3935(st);
397 
398 	ret = devm_request_irq(&spi->dev, spi->irq,
399 				&as3935_interrupt_handler,
400 				IRQF_TRIGGER_RISING,
401 				dev_name(&spi->dev),
402 				indio_dev);
403 
404 	if (ret) {
405 		dev_err(&spi->dev, "unable to request irq\n");
406 		goto unregister_buffer;
407 	}
408 
409 	ret = iio_device_register(indio_dev);
410 	if (ret < 0) {
411 		dev_err(&spi->dev, "unable to register device\n");
412 		goto unregister_buffer;
413 	}
414 	return 0;
415 
416 unregister_buffer:
417 	iio_triggered_buffer_cleanup(indio_dev);
418 
419 unregister_trigger:
420 	iio_trigger_unregister(st->trig);
421 
422 	return ret;
423 }
424 
425 static int as3935_remove(struct spi_device *spi)
426 {
427 	struct iio_dev *indio_dev = spi_get_drvdata(spi);
428 	struct as3935_state *st = iio_priv(indio_dev);
429 
430 	iio_device_unregister(indio_dev);
431 	iio_triggered_buffer_cleanup(indio_dev);
432 	iio_trigger_unregister(st->trig);
433 
434 	return 0;
435 }
436 
437 static const struct spi_device_id as3935_id[] = {
438 	{"as3935", 0},
439 	{},
440 };
441 MODULE_DEVICE_TABLE(spi, as3935_id);
442 
443 static struct spi_driver as3935_driver = {
444 	.driver = {
445 		.name	= "as3935",
446 		.owner	= THIS_MODULE,
447 		.pm	= AS3935_PM_OPS,
448 	},
449 	.probe		= as3935_probe,
450 	.remove		= as3935_remove,
451 	.id_table	= as3935_id,
452 };
453 module_spi_driver(as3935_driver);
454 
455 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
456 MODULE_DESCRIPTION("AS3935 lightning sensor");
457 MODULE_LICENSE("GPL");
458 MODULE_ALIAS("spi:as3935");
459