[deliverable/linux.git] / drivers / iio / proximity / as3935.c

/*
 * as3935.c - Support for AS3935 Franklin lightning sensor
 *
 * Copyright (C) 2014 Matt Ranostay <mranostay@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/workqueue.h>
#include <linux/mutex.h>
#include <linux/err.h>
#include <linux/irq.h>
#include <linux/gpio.h>
#include <linux/spi/spi.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/trigger.h>
#include <linux/iio/trigger_consumer.h>
#include <linux/iio/buffer.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/of_gpio.h>


#define AS3935_AFE_GAIN		0x00
#define AS3935_AFE_MASK		0x3F
#define AS3935_AFE_GAIN_MAX	0x1F
#define AS3935_AFE_PWR_BIT	BIT(0)

#define AS3935_INT		0x03
#define AS3935_INT_MASK		0x07
#define AS3935_EVENT_INT	BIT(3)
#define AS3935_NOISE_INT	BIT(1)

#define AS3935_DATA		0x07
#define AS3935_DATA_MASK	0x3F

#define AS3935_TUNE_CAP		0x08
#define AS3935_CALIBRATE	0x3D

#define AS3935_WRITE_DATA	BIT(15)
#define AS3935_READ_DATA	BIT(14)
#define AS3935_ADDRESS(x)	((x) << 8)

#define MAX_PF_CAP		120
#define TUNE_CAP_DIV		8

struct as3935_state {
	struct spi_device *spi;
	struct iio_trigger *trig;
	struct mutex lock;
	struct delayed_work work;

	u32 tune_cap;
	u8 buf[2] ____cacheline_aligned;
};

static const struct iio_chan_spec as3935_channels[] = {
	{
		.type           = IIO_PROXIMITY,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) |
			BIT(IIO_CHAN_INFO_PROCESSED),
		.scan_index     = 0,
		.scan_type = {
			.sign           = 'u',
			.realbits       = 6,
			.storagebits    = 8,
		},
	},
	IIO_CHAN_SOFT_TIMESTAMP(1),
};

static int as3935_read(struct as3935_state *st, unsigned int reg, int *val)
{
	u8 cmd;
	int ret;

	cmd = (AS3935_READ_DATA | AS3935_ADDRESS(reg)) >> 8;
	ret = spi_w8r8(st->spi, cmd);
	if (ret < 0)
		return ret;
	*val = ret;

	return 0;
}

static int as3935_write(struct as3935_state *st,
				unsigned int reg,
				unsigned int val)
{
	u8 *buf = st->buf;

	buf[0] = (AS3935_WRITE_DATA | AS3935_ADDRESS(reg)) >> 8;
	buf[1] = val;

	return spi_write(st->spi, buf, 2);
}

static ssize_t as3935_sensor_sensitivity_show(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
	int val, ret;

	ret = as3935_read(st, AS3935_AFE_GAIN, &val);
	if (ret)
		return ret;
	val = (val & AS3935_AFE_MASK) >> 1;

	return sprintf(buf, "%d\n", val);
}

static ssize_t as3935_sensor_sensitivity_store(struct device *dev,
					struct device_attribute *attr,
					const char *buf, size_t len)
{
	struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
	unsigned long val;
	int ret;

	ret = kstrtoul((const char *) buf, 10, &val);
	if (ret)
		return -EINVAL;

	if (val > AS3935_AFE_GAIN_MAX)
		return -EINVAL;

	as3935_write(st, AS3935_AFE_GAIN, val << 1);

	return len;
}

static IIO_DEVICE_ATTR(sensor_sensitivity, S_IRUGO | S_IWUSR,
	as3935_sensor_sensitivity_show, as3935_sensor_sensitivity_store, 0);


static struct attribute *as3935_attributes[] = {
	&iio_dev_attr_sensor_sensitivity.dev_attr.attr,
	NULL,
};

static struct attribute_group as3935_attribute_group = {
	.attrs = as3935_attributes,
};

static int as3935_read_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan,
			   int *val,
			   int *val2,
			   long m)
{
	struct as3935_state *st = iio_priv(indio_dev);
	int ret;


	switch (m) {
	case IIO_CHAN_INFO_PROCESSED:
	case IIO_CHAN_INFO_RAW:
		*val2 = 0;
		ret = as3935_read(st, AS3935_DATA, val);
		if (ret)
			return ret;

		if (m == IIO_CHAN_INFO_RAW)
			return IIO_VAL_INT;

		/* storm out of range */
		if (*val == AS3935_DATA_MASK)
			return -EINVAL;
		*val *= 1000;
		break;
	default:
		return -EINVAL;
	}

	return IIO_VAL_INT;
}

static const struct iio_info as3935_info = {
	.driver_module = THIS_MODULE,
	.attrs = &as3935_attribute_group,
	.read_raw = &as3935_read_raw,
};

static irqreturn_t as3935_trigger_handler(int irq, void *private)
{
	struct iio_poll_func *pf = private;
	struct iio_dev *indio_dev = pf->indio_dev;
	struct as3935_state *st = iio_priv(indio_dev);
	int val, ret;

	ret = as3935_read(st, AS3935_DATA, &val);
	if (ret)
		goto err_read;
	val &= AS3935_DATA_MASK;
	val *= 1000;

	iio_push_to_buffers_with_timestamp(indio_dev, &val, pf->timestamp);
err_read:
	iio_trigger_notify_done(indio_dev->trig);

	return IRQ_HANDLED;
}

static const struct iio_trigger_ops iio_interrupt_trigger_ops = {
	.owner = THIS_MODULE,
};

static void as3935_event_work(struct work_struct *work)
{
	struct as3935_state *st;
	int val;

	st = container_of(work, struct as3935_state, work.work);

	as3935_read(st, AS3935_INT, &val);
	val &= AS3935_INT_MASK;

	switch (val) {
	case AS3935_EVENT_INT:
		iio_trigger_poll(st->trig);
		break;
	case AS3935_NOISE_INT:
		dev_warn(&st->spi->dev, "noise level is too high");
		break;
	}
}

static irqreturn_t as3935_interrupt_handler(int irq, void *private)
{
	struct iio_dev *indio_dev = private;
	struct as3935_state *st = iio_priv(indio_dev);

	/*
	 * Delay work for >2 milliseconds after an interrupt to allow
	 * estimated distance to recalculated.
	 */

	schedule_delayed_work(&st->work, msecs_to_jiffies(3));

	return IRQ_HANDLED;
}

static void calibrate_as3935(struct as3935_state *st)
{
	mutex_lock(&st->lock);

	/* mask disturber interrupt bit */
	as3935_write(st, AS3935_INT, BIT(5));

	as3935_write(st, AS3935_CALIBRATE, 0x96);
	as3935_write(st, AS3935_TUNE_CAP,
		BIT(5) | (st->tune_cap / TUNE_CAP_DIV));

	mdelay(2);
	as3935_write(st, AS3935_TUNE_CAP, (st->tune_cap / TUNE_CAP_DIV));

	mutex_unlock(&st->lock);
}

#ifdef CONFIG_PM_SLEEP
static int as3935_suspend(struct device *dev)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct as3935_state *st = iio_priv(indio_dev);
	int val, ret;

	mutex_lock(&st->lock);
	ret = as3935_read(st, AS3935_AFE_GAIN, &val);
	if (ret)
		goto err_suspend;
	val |= AS3935_AFE_PWR_BIT;

	ret = as3935_write(st, AS3935_AFE_GAIN, val);

err_suspend:
	mutex_unlock(&st->lock);

	return ret;
}

static int as3935_resume(struct device *dev)
{
	struct iio_dev *indio_dev = dev_get_drvdata(dev);
	struct as3935_state *st = iio_priv(indio_dev);
	int val, ret;

	mutex_lock(&st->lock);
	ret = as3935_read(st, AS3935_AFE_GAIN, &val);
	if (ret)
		goto err_resume;
	val &= ~AS3935_AFE_PWR_BIT;
	ret = as3935_write(st, AS3935_AFE_GAIN, val);

err_resume:
	mutex_unlock(&st->lock);

	return ret;
}

static SIMPLE_DEV_PM_OPS(as3935_pm_ops, as3935_suspend, as3935_resume);
#define AS3935_PM_OPS (&as3935_pm_ops)

#else
#define AS3935_PM_OPS NULL
#endif

static int as3935_probe(struct spi_device *spi)
{
	struct iio_dev *indio_dev;
	struct iio_trigger *trig;
	struct as3935_state *st;
	struct device_node *np = spi->dev.of_node;
	int ret;

	/* Be sure lightning event interrupt is specified */
	if (!spi->irq) {
		dev_err(&spi->dev, "unable to get event interrupt\n");
		return -EINVAL;
	}

	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
	if (!indio_dev)
		return -ENOMEM;

	st = iio_priv(indio_dev);
	st->spi = spi;
	st->tune_cap = 0;

	spi_set_drvdata(spi, indio_dev);
	mutex_init(&st->lock);
	INIT_DELAYED_WORK(&st->work, as3935_event_work);

	ret = of_property_read_u32(np,
			"ams,tuning-capacitor-pf", &st->tune_cap);
	if (ret) {
		st->tune_cap = 0;
		dev_warn(&spi->dev,
			"no tuning-capacitor-pf set, defaulting to %d",
			st->tune_cap);
	}

	if (st->tune_cap > MAX_PF_CAP) {
		dev_err(&spi->dev,
			"wrong tuning-capacitor-pf setting of %d\n",
			st->tune_cap);
		return -EINVAL;
	}

	indio_dev->dev.parent = &spi->dev;
	indio_dev->name = spi_get_device_id(spi)->name;
	indio_dev->channels = as3935_channels;
	indio_dev->num_channels = ARRAY_SIZE(as3935_channels);
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->info = &as3935_info;

	trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
				      indio_dev->name, indio_dev->id);

	if (!trig)
		return -ENOMEM;

	st->trig = trig;
	trig->dev.parent = indio_dev->dev.parent;
	iio_trigger_set_drvdata(trig, indio_dev);
	trig->ops = &iio_interrupt_trigger_ops;

	ret = iio_trigger_register(trig);
	if (ret) {
		dev_err(&spi->dev, "failed to register trigger\n");
		return ret;
	}

	ret = iio_triggered_buffer_setup(indio_dev, NULL,
		&as3935_trigger_handler, NULL);

	if (ret) {
		dev_err(&spi->dev, "cannot setup iio trigger\n");
		goto unregister_trigger;
	}

	calibrate_as3935(st);

	ret = devm_request_irq(&spi->dev, spi->irq,
				&as3935_interrupt_handler,
				IRQF_TRIGGER_RISING,
				dev_name(&spi->dev),
				indio_dev);

	if (ret) {
		dev_err(&spi->dev, "unable to request irq\n");
		goto unregister_buffer;
	}

	ret = iio_device_register(indio_dev);
	if (ret < 0) {
		dev_err(&spi->dev, "unable to register device\n");
		goto unregister_buffer;
	}
	return 0;

unregister_buffer:
	iio_triggered_buffer_cleanup(indio_dev);

unregister_trigger:
	iio_trigger_unregister(st->trig);

	return ret;
}

static int as3935_remove(struct spi_device *spi)
{
	struct iio_dev *indio_dev = spi_get_drvdata(spi);
	struct as3935_state *st = iio_priv(indio_dev);

	iio_device_unregister(indio_dev);
	iio_triggered_buffer_cleanup(indio_dev);
	iio_trigger_unregister(st->trig);

	return 0;
}

static const struct of_device_id as3935_of_match[] = {
	{ .compatible = "ams,as3935", },
	{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, as3935_of_match);

static const struct spi_device_id as3935_id[] = {
	{"as3935", 0},
	{},
};
MODULE_DEVICE_TABLE(spi, as3935_id);

static struct spi_driver as3935_driver = {
	.driver = {
		.name	= "as3935",
		.of_match_table = of_match_ptr(as3935_of_match),
		.pm	= AS3935_PM_OPS,
	},
	.probe		= as3935_probe,
	.remove		= as3935_remove,
	.id_table	= as3935_id,
};
module_spi_driver(as3935_driver);

MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
MODULE_DESCRIPTION("AS3935 lightning sensor");
MODULE_LICENSE("GPL");
Commit	Line	Data
24ddb0e4 MR	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;
455f0049	98	}
24ddb0e4 MR	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);
455f0049	110	}
24ddb0e4 MR	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);
455f0049	125	}
24ddb0e4 MR	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;
455f0049	145	}
24ddb0e4 MR	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;
455f0049	217	}
24ddb0e4 MR	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:
398fd22b	235	iio_trigger_poll(st->trig);
24ddb0e4 MR	236	break;
	237	case AS3935_NOISE_INT:
	238	dev_warn(&st->spi->dev, "noise level is too high");
	239	break;
	240	}
455f0049	241	}
24ddb0e4 MR	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
9d9f7800	276	static int as3935_suspend(struct device *dev)
24ddb0e4	277	{
9d9f7800	278	struct iio_dev *indio_dev = dev_get_drvdata(dev);
24ddb0e4 MR	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
9d9f7800	296	static int as3935_resume(struct device *dev)
24ddb0e4	297	{
9d9f7800	298	struct iio_dev *indio_dev = dev_get_drvdata(dev);
24ddb0e4 MR	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	}
9d9f7800 LPC	314
	315	static SIMPLE_DEV_PM_OPS(as3935_pm_ops, as3935_suspend, as3935_resume);
	316	#define AS3935_PM_OPS (&as3935_pm_ops)
	317
24ddb0e4	318	#else
9d9f7800	319	#define AS3935_PM_OPS NULL
24ddb0e4 MR	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
f73cde60	336	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
24ddb0e4 MR	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;
455f0049	423	}
24ddb0e4 MR	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;
455f0049	435	}
24ddb0e4	436
8b7c826d JMC	437	static const struct of_device_id as3935_of_match[] = {
	438	{ .compatible = "ams,as3935", },
	439	{ /* sentinel */ },
	440	};
	441	MODULE_DEVICE_TABLE(of, as3935_of_match);
	442
24ddb0e4 MR	443	static const struct spi_device_id as3935_id[] = {
	444	{"as3935", 0},
	445	{},
	446	};
	447	MODULE_DEVICE_TABLE(spi, as3935_id);
	448
	449	static struct spi_driver as3935_driver = {
	450	.driver = {
	451	.name = "as3935",
8b7c826d	452	.of_match_table = of_match_ptr(as3935_of_match),
9d9f7800	453	.pm = AS3935_PM_OPS,
24ddb0e4 MR	454	},
	455	.probe = as3935_probe,
	456	.remove = as3935_remove,
	457	.id_table = as3935_id,
24ddb0e4 MR	458	};
	459	module_spi_driver(as3935_driver);
	460
	461	MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>");
	462	MODULE_DESCRIPTION("AS3935 lightning sensor");
	463	MODULE_LICENSE("GPL");