1/*
2 * ADIS16240 Programmable Impact Sensor and Recorder driver
3 *
4 * Copyright 2010 Analog Devices Inc.
5 *
6 * Licensed under the GPL-2 or later.
7 */
8
9#include <linux/interrupt.h>
10#include <linux/irq.h>
11#include <linux/gpio.h>
12#include <linux/delay.h>
13#include <linux/mutex.h>
14#include <linux/device.h>
15#include <linux/kernel.h>
16#include <linux/spi/spi.h>
17#include <linux/slab.h>
18#include <linux/sysfs.h>
19#include <linux/list.h>
20#include <linux/module.h>
21
22#include "../iio.h"
23#include "../sysfs.h"
24#include "../buffer.h"
25
26#include "adis16240.h"
27
28#define DRIVER_NAME		"adis16240"
29
30static int adis16240_check_status(struct iio_dev *indio_dev);
31
32/**
33 * adis16240_spi_write_reg_8() - write single byte to a register
34 * @indio_dev: iio_dev associated with device
35 * @reg_address: the address of the register to be written
36 * @val: the value to write
37 **/
38static int adis16240_spi_write_reg_8(struct iio_dev *indio_dev,
39				     u8 reg_address,
40				     u8 val)
41{
42	int ret;
43	struct adis16240_state *st = iio_priv(indio_dev);
44
45	mutex_lock(&st->buf_lock);
46	st->tx[0] = ADIS16240_WRITE_REG(reg_address);
47	st->tx[1] = val;
48
49	ret = spi_write(st->us, st->tx, 2);
50	mutex_unlock(&st->buf_lock);
51
52	return ret;
53}
54
55/**
56 * adis16240_spi_write_reg_16() - write 2 bytes to a pair of registers
57 * @indio_dev: iio_dev for this device
58 * @reg_address: the address of the lower of the two registers. Second register
59 *               is assumed to have address one greater.
60 * @val: value to be written
61 **/
62static int adis16240_spi_write_reg_16(struct iio_dev *indio_dev,
63				      u8 lower_reg_address,
64				      u16 value)
65{
66	int ret;
67	struct spi_message msg;
68	struct adis16240_state *st = iio_priv(indio_dev);
69	struct spi_transfer xfers[] = {
70		{
71			.tx_buf = st->tx,
72			.bits_per_word = 8,
73			.len = 2,
74			.cs_change = 1,
75			.delay_usecs = 35,
76		}, {
77			.tx_buf = st->tx + 2,
78			.bits_per_word = 8,
79			.len = 2,
80			.delay_usecs = 35,
81		},
82	};
83
84	mutex_lock(&st->buf_lock);
85	st->tx[0] = ADIS16240_WRITE_REG(lower_reg_address);
86	st->tx[1] = value & 0xFF;
87	st->tx[2] = ADIS16240_WRITE_REG(lower_reg_address + 1);
88	st->tx[3] = (value >> 8) & 0xFF;
89
90	spi_message_init(&msg);
91	spi_message_add_tail(&xfers[0], &msg);
92	spi_message_add_tail(&xfers[1], &msg);
93	ret = spi_sync(st->us, &msg);
94	mutex_unlock(&st->buf_lock);
95
96	return ret;
97}
98
99/**
100 * adis16240_spi_read_reg_16() - read 2 bytes from a 16-bit register
101 * @indio_dev: iio_dev for this device
102 * @reg_address: the address of the lower of the two registers. Second register
103 *               is assumed to have address one greater.
104 * @val: somewhere to pass back the value read
105 **/
106static int adis16240_spi_read_reg_16(struct iio_dev *indio_dev,
107		u8 lower_reg_address,
108		u16 *val)
109{
110	struct spi_message msg;
111	struct adis16240_state *st = iio_priv(indio_dev);
112	int ret;
113	struct spi_transfer xfers[] = {
114		{
115			.tx_buf = st->tx,
116			.bits_per_word = 8,
117			.len = 2,
118			.cs_change = 1,
119			.delay_usecs = 35,
120		}, {
121			.rx_buf = st->rx,
122			.bits_per_word = 8,
123			.len = 2,
124			.cs_change = 1,
125			.delay_usecs = 35,
126		},
127	};
128
129	mutex_lock(&st->buf_lock);
130	st->tx[0] = ADIS16240_READ_REG(lower_reg_address);
131	st->tx[1] = 0;
132	st->tx[2] = 0;
133	st->tx[3] = 0;
134
135	spi_message_init(&msg);
136	spi_message_add_tail(&xfers[0], &msg);
137	spi_message_add_tail(&xfers[1], &msg);
138	ret = spi_sync(st->us, &msg);
139	if (ret) {
140		dev_err(&st->us->dev,
141			"problem when reading 16 bit register 0x%02X",
142			lower_reg_address);
143		goto error_ret;
144	}
145	*val = (st->rx[0] << 8) | st->rx[1];
146
147error_ret:
148	mutex_unlock(&st->buf_lock);
149	return ret;
150}
151
152static ssize_t adis16240_spi_read_signed(struct device *dev,
153		struct device_attribute *attr,
154		char *buf,
155		unsigned bits)
156{
157	struct iio_dev *indio_dev = dev_get_drvdata(dev);
158	int ret;
159	s16 val = 0;
160	unsigned shift = 16 - bits;
161	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
162
163	ret = adis16240_spi_read_reg_16(indio_dev,
164					this_attr->address, (u16 *)&val);
165	if (ret)
166		return ret;
167
168	if (val & ADIS16240_ERROR_ACTIVE)
169		adis16240_check_status(indio_dev);
170
171	val = ((s16)(val << shift) >> shift);
172	return sprintf(buf, "%d\n", val);
173}
174
175static ssize_t adis16240_read_12bit_signed(struct device *dev,
176		struct device_attribute *attr,
177		char *buf)
178{
179	ssize_t ret;
180	struct iio_dev *indio_dev = dev_get_drvdata(dev);
181
182	/* Take the iio_dev status lock */
183	mutex_lock(&indio_dev->mlock);
184	ret =  adis16240_spi_read_signed(dev, attr, buf, 12);
185	mutex_unlock(&indio_dev->mlock);
186
187	return ret;
188}
189
190static int adis16240_reset(struct iio_dev *indio_dev)
191{
192	int ret;
193	ret = adis16240_spi_write_reg_8(indio_dev,
194			ADIS16240_GLOB_CMD,
195			ADIS16240_GLOB_CMD_SW_RESET);
196	if (ret)
197		dev_err(&indio_dev->dev, "problem resetting device");
198
199	return ret;
200}
201
202static ssize_t adis16240_write_reset(struct device *dev,
203		struct device_attribute *attr,
204		const char *buf, size_t len)
205{
206	struct iio_dev *indio_dev = dev_get_drvdata(dev);
207
208	if (len < 1)
209		return -EINVAL;
210	switch (buf[0]) {
211	case '1':
212	case 'y':
213	case 'Y':
214		return adis16240_reset(indio_dev);
215	}
216	return -EINVAL;
217}
218
219int adis16240_set_irq(struct iio_dev *indio_dev, bool enable)
220{
221	int ret = 0;
222	u16 msc;
223
224	ret = adis16240_spi_read_reg_16(indio_dev,
225					ADIS16240_MSC_CTRL, &msc);
226	if (ret)
227		goto error_ret;
228
229	msc |= ADIS16240_MSC_CTRL_ACTIVE_HIGH;
230	msc &= ~ADIS16240_MSC_CTRL_DATA_RDY_DIO2;
231	if (enable)
232		msc |= ADIS16240_MSC_CTRL_DATA_RDY_EN;
233	else
234		msc &= ~ADIS16240_MSC_CTRL_DATA_RDY_EN;
235
236	ret = adis16240_spi_write_reg_16(indio_dev,
237					 ADIS16240_MSC_CTRL, msc);
238
239error_ret:
240	return ret;
241}
242
243static int adis16240_self_test(struct iio_dev *indio_dev)
244{
245	int ret;
246	ret = adis16240_spi_write_reg_16(indio_dev,
247			ADIS16240_MSC_CTRL,
248			ADIS16240_MSC_CTRL_SELF_TEST_EN);
249	if (ret) {
250		dev_err(&indio_dev->dev, "problem starting self test");
251		goto err_ret;
252	}
253
254	msleep(ADIS16240_STARTUP_DELAY);
255
256	adis16240_check_status(indio_dev);
257
258err_ret:
259	return ret;
260}
261
262static int adis16240_check_status(struct iio_dev *indio_dev)
263{
264	u16 status;
265	int ret;
266	struct device *dev = &indio_dev->dev;
267
268	ret = adis16240_spi_read_reg_16(indio_dev,
269					ADIS16240_DIAG_STAT, &status);
270
271	if (ret < 0) {
272		dev_err(dev, "Reading status failed\n");
273		goto error_ret;
274	}
275
276	ret = status & 0x2F;
277	if (status & ADIS16240_DIAG_STAT_PWRON_FAIL)
278		dev_err(dev, "Power-on, self-test fail\n");
279	if (status & ADIS16240_DIAG_STAT_SPI_FAIL)
280		dev_err(dev, "SPI failure\n");
281	if (status & ADIS16240_DIAG_STAT_FLASH_UPT)
282		dev_err(dev, "Flash update failed\n");
283	if (status & ADIS16240_DIAG_STAT_POWER_HIGH)
284		dev_err(dev, "Power supply above 3.625V\n");
285	if (status & ADIS16240_DIAG_STAT_POWER_LOW)
286		dev_err(dev, "Power supply below 2.225V\n");
287
288error_ret:
289	return ret;
290}
291
292static int adis16240_initial_setup(struct iio_dev *indio_dev)
293{
294	int ret;
295	struct device *dev = &indio_dev->dev;
296
297	/* Disable IRQ */
298	ret = adis16240_set_irq(indio_dev, false);
299	if (ret) {
300		dev_err(dev, "disable irq failed");
301		goto err_ret;
302	}
303
304	/* Do self test */
305	ret = adis16240_self_test(indio_dev);
306	if (ret) {
307		dev_err(dev, "self test failure");
308		goto err_ret;
309	}
310
311	/* Read status register to check the result */
312	ret = adis16240_check_status(indio_dev);
313	if (ret) {
314		adis16240_reset(indio_dev);
315		dev_err(dev, "device not playing ball -> reset");
316		msleep(ADIS16240_STARTUP_DELAY);
317		ret = adis16240_check_status(indio_dev);
318		if (ret) {
319			dev_err(dev, "giving up");
320			goto err_ret;
321		}
322	}
323
324err_ret:
325	return ret;
326}
327
328static IIO_DEVICE_ATTR(in_accel_xyz_squared_peak_raw, S_IRUGO,
329		       adis16240_read_12bit_signed, NULL,
330		       ADIS16240_XYZPEAK_OUT);
331
332static IIO_DEVICE_ATTR(reset, S_IWUSR, NULL, adis16240_write_reset, 0);
333
334static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("4096");
335
336enum adis16240_chan {
337	in_supply,
338	in_aux,
339	accel_x,
340	accel_y,
341	accel_z,
342	temp,
343};
344
345static const u8 adis16240_addresses[6][3] = {
346	[in_supply] = { ADIS16240_SUPPLY_OUT },
347	[in_aux] = { ADIS16240_AUX_ADC },
348	[accel_x] = { ADIS16240_XACCL_OUT, ADIS16240_XACCL_OFF,
349		      ADIS16240_XPEAK_OUT },
350	[accel_y] = { ADIS16240_YACCL_OUT, ADIS16240_YACCL_OFF,
351		      ADIS16240_YPEAK_OUT },
352	[accel_z] = { ADIS16240_ZACCL_OUT, ADIS16240_ZACCL_OFF,
353		      ADIS16240_ZPEAK_OUT },
354	[temp] = { ADIS16240_TEMP_OUT },
355};
356
357static int adis16240_read_raw(struct iio_dev *indio_dev,
358			      struct iio_chan_spec const *chan,
359			      int *val, int *val2,
360			      long mask)
361{
362	int ret;
363	int bits;
364	u8 addr;
365	s16 val16;
366
367	switch (mask) {
368	case 0:
369		mutex_lock(&indio_dev->mlock);
370		addr = adis16240_addresses[chan->address][0];
371		ret = adis16240_spi_read_reg_16(indio_dev, addr, &val16);
372		if (ret) {
373			mutex_unlock(&indio_dev->mlock);
374			return ret;
375		}
376
377		if (val16 & ADIS16240_ERROR_ACTIVE) {
378			ret = adis16240_check_status(indio_dev);
379			if (ret) {
380				mutex_unlock(&indio_dev->mlock);
381				return ret;
382			}
383		}
384		val16 = val16 & ((1 << chan->scan_type.realbits) - 1);
385		if (chan->scan_type.sign == 's')
386			val16 = (s16)(val16 <<
387				      (16 - chan->scan_type.realbits)) >>
388				(16 - chan->scan_type.realbits);
389		*val = val16;
390		mutex_unlock(&indio_dev->mlock);
391		return IIO_VAL_INT;
392	case IIO_CHAN_INFO_SCALE:
393		switch (chan->type) {
394		case IIO_VOLTAGE:
395			*val = 0;
396			if (chan->channel == 0)
397				*val2 = 4880;
398			else
399				return -EINVAL;
400			return IIO_VAL_INT_PLUS_MICRO;
401		case IIO_TEMP:
402			*val = 0;
403			*val2 = 244000;
404			return IIO_VAL_INT_PLUS_MICRO;
405		case IIO_ACCEL:
406			*val = 0;
407			*val2 = 504062;
408			return IIO_VAL_INT_PLUS_MICRO;
409		default:
410			return -EINVAL;
411		}
412		break;
413	case IIO_CHAN_INFO_PEAK_SCALE:
414		*val = 6;
415		*val2 = 629295;
416		return IIO_VAL_INT_PLUS_MICRO;
417	case IIO_CHAN_INFO_OFFSET:
418		*val = 25;
419		return IIO_VAL_INT;
420	case IIO_CHAN_INFO_CALIBBIAS:
421		bits = 10;
422		mutex_lock(&indio_dev->mlock);
423		addr = adis16240_addresses[chan->address][1];
424		ret = adis16240_spi_read_reg_16(indio_dev, addr, &val16);
425		if (ret) {
426			mutex_unlock(&indio_dev->mlock);
427			return ret;
428		}
429		val16 &= (1 << bits) - 1;
430		val16 = (s16)(val16 << (16 - bits)) >> (16 - bits);
431		*val = val16;
432		mutex_unlock(&indio_dev->mlock);
433		return IIO_VAL_INT;
434	case IIO_CHAN_INFO_PEAK:
435		bits = 10;
436		mutex_lock(&indio_dev->mlock);
437		addr = adis16240_addresses[chan->address][2];
438		ret = adis16240_spi_read_reg_16(indio_dev, addr, &val16);
439		if (ret) {
440			mutex_unlock(&indio_dev->mlock);
441			return ret;
442		}
443		val16 &= (1 << bits) - 1;
444		val16 = (s16)(val16 << (16 - bits)) >> (16 - bits);
445		*val = val16;
446		mutex_unlock(&indio_dev->mlock);
447		return IIO_VAL_INT;
448	}
449	return -EINVAL;
450}
451
452static int adis16240_write_raw(struct iio_dev *indio_dev,
453			       struct iio_chan_spec const *chan,
454			       int val,
455			       int val2,
456			       long mask)
457{
458	int bits = 10;
459	s16 val16;
460	u8 addr;
461	switch (mask) {
462	case IIO_CHAN_INFO_CALIBBIAS:
463		val16 = val & ((1 << bits) - 1);
464		addr = adis16240_addresses[chan->address][1];
465		return adis16240_spi_write_reg_16(indio_dev, addr, val16);
466	}
467	return -EINVAL;
468}
469
470static struct iio_chan_spec adis16240_channels[] = {
471	IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, "supply", 0, 0,
472		 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
473		 in_supply, ADIS16240_SCAN_SUPPLY,
474		 IIO_ST('u', 10, 16, 0), 0),
475	IIO_CHAN(IIO_VOLTAGE, 0, 1, 0, NULL, 1, 0,
476		 0,
477		 in_aux, ADIS16240_SCAN_AUX_ADC,
478		 IIO_ST('u', 10, 16, 0), 0),
479	IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_X,
480		 IIO_CHAN_INFO_SCALE_SHARED_BIT |
481		 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT,
482		 accel_x, ADIS16240_SCAN_ACC_X,
483		 IIO_ST('s', 10, 16, 0), 0),
484	IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Y,
485		 IIO_CHAN_INFO_SCALE_SHARED_BIT |
486		 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT,
487		 accel_y, ADIS16240_SCAN_ACC_Y,
488		 IIO_ST('s', 10, 16, 0), 0),
489	IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Z,
490		 IIO_CHAN_INFO_SCALE_SHARED_BIT |
491		 IIO_CHAN_INFO_CALIBBIAS_SEPARATE_BIT,
492		 accel_z, ADIS16240_SCAN_ACC_Z,
493		 IIO_ST('s', 10, 16, 0), 0),
494	IIO_CHAN(IIO_TEMP, 0, 1, 0, NULL, 0, 0,
495		 IIO_CHAN_INFO_SCALE_SEPARATE_BIT,
496		 temp, ADIS16240_SCAN_TEMP,
497		 IIO_ST('u', 10, 16, 0), 0),
498	IIO_CHAN_SOFT_TIMESTAMP(6)
499};
500
501static struct attribute *adis16240_attributes[] = {
502	&iio_dev_attr_in_accel_xyz_squared_peak_raw.dev_attr.attr,
503	&iio_const_attr_sampling_frequency_available.dev_attr.attr,
504	&iio_dev_attr_reset.dev_attr.attr,
505	NULL
506};
507
508static const struct attribute_group adis16240_attribute_group = {
509	.attrs = adis16240_attributes,
510};
511
512static const struct iio_info adis16240_info = {
513	.attrs = &adis16240_attribute_group,
514	.read_raw = &adis16240_read_raw,
515	.write_raw = &adis16240_write_raw,
516	.driver_module = THIS_MODULE,
517};
518
519static int __devinit adis16240_probe(struct spi_device *spi)
520{
521	int ret;
522	struct adis16240_state *st;
523	struct iio_dev *indio_dev;
524
525	/* setup the industrialio driver allocated elements */
526	indio_dev = iio_allocate_device(sizeof(*st));
527	if (indio_dev == NULL) {
528		ret = -ENOMEM;
529		goto error_ret;
530	}
531	st = iio_priv(indio_dev);
532	/* this is only used for removal purposes */
533	spi_set_drvdata(spi, indio_dev);
534
535	st->us = spi;
536	mutex_init(&st->buf_lock);
537
538	indio_dev->name = spi->dev.driver->name;
539	indio_dev->dev.parent = &spi->dev;
540	indio_dev->info = &adis16240_info;
541	indio_dev->channels = adis16240_channels;
542	indio_dev->num_channels = ARRAY_SIZE(adis16240_channels);
543	indio_dev->modes = INDIO_DIRECT_MODE;
544
545	ret = adis16240_configure_ring(indio_dev);
546	if (ret)
547		goto error_free_dev;
548
549	ret = iio_buffer_register(indio_dev,
550				  adis16240_channels,
551				  ARRAY_SIZE(adis16240_channels));
552	if (ret) {
553		printk(KERN_ERR "failed to initialize the ring\n");
554		goto error_unreg_ring_funcs;
555	}
556
557	if (spi->irq) {
558		ret = adis16240_probe_trigger(indio_dev);
559		if (ret)
560			goto error_uninitialize_ring;
561	}
562
563	/* Get the device into a sane initial state */
564	ret = adis16240_initial_setup(indio_dev);
565	if (ret)
566		goto error_remove_trigger;
567	ret = iio_device_register(indio_dev);
568	if (ret)
569		goto error_remove_trigger;
570	return 0;
571
572error_remove_trigger:
573	adis16240_remove_trigger(indio_dev);
574error_uninitialize_ring:
575	iio_buffer_unregister(indio_dev);
576error_unreg_ring_funcs:
577	adis16240_unconfigure_ring(indio_dev);
578error_free_dev:
579	iio_free_device(indio_dev);
580error_ret:
581	return ret;
582}
583
584static int adis16240_remove(struct spi_device *spi)
585{
586
587	struct iio_dev *indio_dev = spi_get_drvdata(spi);
588
589	flush_scheduled_work();
590
591	iio_device_unregister(indio_dev);
592	adis16240_remove_trigger(indio_dev);
593	iio_buffer_unregister(indio_dev);
594	adis16240_unconfigure_ring(indio_dev);
595	iio_free_device(indio_dev);
596
597	return 0;
598}
599
600static struct spi_driver adis16240_driver = {
601	.driver = {
602		.name = "adis16240",
603		.owner = THIS_MODULE,
604	},
605	.probe = adis16240_probe,
606	.remove = __devexit_p(adis16240_remove),
607};
608module_spi_driver(adis16240_driver);
609
610MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
611MODULE_DESCRIPTION("Analog Devices Programmable Impact Sensor and Recorder");
612MODULE_LICENSE("GPL v2");
613MODULE_ALIAS("spi:adis16240");
614