2 * ADXRS450 Digital Output Gyroscope Driver
4 * Copyright 2011 Analog Devices Inc.
6 * Licensed under the GPL-2.
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>
24 #include "../adc/adc.h"
29 * adxrs450_spi_read_reg_16() - read 2 bytes from a register pair
30 * @dev: device associated with child of actual iio_dev
31 * @reg_address: the address of the lower of the two registers,which should be an even address,
32 * Second register's address is reg_address + 1.
33 * @val: somewhere to pass back the value read
35 static int adxrs450_spi_read_reg_16(struct device *dev,
39 struct spi_message msg;
40 struct iio_dev *indio_dev = dev_get_drvdata(dev);
41 struct adxrs450_state *st = iio_dev_get_devdata(indio_dev);
43 struct spi_transfer xfers[] = {
56 mutex_lock(&st->buf_lock);
57 st->tx[0] = ADXRS450_READ_DATA | (reg_address >> 7);
58 st->tx[1] = reg_address << 1;
62 if (!(hweight32(be32_to_cpu(*(u32 *)st->tx)) & 1))
63 st->tx[3] |= ADXRS450_P;
65 spi_message_init(&msg);
66 spi_message_add_tail(&xfers[0], &msg);
67 spi_message_add_tail(&xfers[1], &msg);
68 ret = spi_sync(st->us, &msg);
70 dev_err(&st->us->dev, "problem while reading 16 bit register 0x%02x\n",
75 *val = (be32_to_cpu(*(u32 *)st->rx) >> 5) & 0xFFFF;
78 mutex_unlock(&st->buf_lock);
83 * adxrs450_spi_write_reg_16() - write 2 bytes data to a register pair
84 * @dev: device associated with child of actual actual iio_dev
85 * @reg_address: the address of the lower of the two registers,which should be an even address,
86 * Second register's address is reg_address + 1.
87 * @val: value to be written.
89 static int adxrs450_spi_write_reg_16(struct device *dev,
93 struct spi_message msg;
94 struct iio_dev *indio_dev = dev_get_drvdata(dev);
95 struct adxrs450_state *st = iio_dev_get_devdata(indio_dev);
97 struct spi_transfer xfers = {
104 mutex_lock(&st->buf_lock);
105 st->tx[0] = ADXRS450_WRITE_DATA | reg_address >> 7;
106 st->tx[1] = reg_address << 1 | val >> 15;
107 st->tx[2] = val >> 7;
108 st->tx[3] = val << 1;
110 if (!(hweight32(be32_to_cpu(*(u32 *)st->tx)) & 1))
111 st->tx[3] |= ADXRS450_P;
113 spi_message_init(&msg);
114 spi_message_add_tail(&xfers, &msg);
115 ret = spi_sync(st->us, &msg);
117 dev_err(&st->us->dev, "problem while writing 16 bit register 0x%02x\n",
119 mutex_unlock(&st->buf_lock);
124 * adxrs450_spi_sensor_data() - read 2 bytes sensor data
125 * @dev: device associated with child of actual iio_dev
126 * @val: somewhere to pass back the value read
128 static int adxrs450_spi_sensor_data(struct device *dev, u16 *val)
130 struct spi_message msg;
131 struct iio_dev *indio_dev = dev_get_drvdata(dev);
132 struct adxrs450_state *st = iio_dev_get_devdata(indio_dev);
134 struct spi_transfer xfers[] = {
147 mutex_lock(&st->buf_lock);
148 st->tx[0] = ADXRS450_SENSOR_DATA;
153 spi_message_init(&msg);
154 spi_message_add_tail(&xfers[0], &msg);
155 spi_message_add_tail(&xfers[1], &msg);
156 ret = spi_sync(st->us, &msg);
158 dev_err(&st->us->dev, "Problem while reading sensor data\n");
162 *val = (be32_to_cpu(*(u32 *)st->rx) >> 10) & 0xFFFF;
165 mutex_unlock(&st->buf_lock);
170 * adxrs450_spi_initial() - use for initializing procedure.
171 * @st: device instance specific data
172 * @val: somewhere to pass back the value read
174 static int adxrs450_spi_initial(struct adxrs450_state *st,
177 struct spi_message msg;
179 struct spi_transfer xfers = {
186 mutex_lock(&st->buf_lock);
187 st->tx[0] = ADXRS450_SENSOR_DATA;
192 st->tx[3] |= (ADXRS450_CHK | ADXRS450_P);
193 spi_message_init(&msg);
194 spi_message_add_tail(&xfers, &msg);
195 ret = spi_sync(st->us, &msg);
197 dev_err(&st->us->dev, "Problem while reading initializing data\n");
201 *val = be32_to_cpu(*(u32 *)st->rx);
204 mutex_unlock(&st->buf_lock);
208 static ssize_t adxrs450_read_temp(struct device *dev,
209 struct device_attribute *attr,
214 ret = adxrs450_spi_read_reg_16(dev,
219 return sprintf(buf, "%d\n", t);
222 static ssize_t adxrs450_read_quad(struct device *dev,
223 struct device_attribute *attr,
228 ret = adxrs450_spi_read_reg_16(dev,
233 return sprintf(buf, "%d\n", t);
236 static ssize_t adxrs450_write_dnc(struct device *dev,
237 struct device_attribute *attr,
244 ret = strict_strtol(buf, 10, &val);
247 ret = adxrs450_spi_write_reg_16(dev,
251 return ret ? ret : len;
254 static ssize_t adxrs450_read_sensor_data(struct device *dev,
255 struct device_attribute *attr,
261 ret = adxrs450_spi_sensor_data(dev, &t);
265 return sprintf(buf, "%d\n", t);
268 /* Recommended Startup Sequence by spec */
269 static int adxrs450_initial_setup(struct adxrs450_state *st)
274 struct device *dev = &st->indio_dev->dev;
276 msleep(ADXRS450_STARTUP_DELAY*2);
277 ret = adxrs450_spi_initial(st, &t, 1);
281 dev_err(&st->us->dev, "The initial response is not correct!\n");
286 msleep(ADXRS450_STARTUP_DELAY);
287 ret = adxrs450_spi_initial(st, &t, 0);
291 msleep(ADXRS450_STARTUP_DELAY);
292 ret = adxrs450_spi_initial(st, &t, 0);
295 if (((t & 0xff) | 0x01) != 0xff || ADXRS450_GET_ST(t) != 2) {
296 dev_err(&st->us->dev, "The second response is not correct!\n");
300 ret = adxrs450_spi_initial(st, &t, 0);
303 if (((t & 0xff) | 0x01) != 0xff || ADXRS450_GET_ST(t) != 2) {
304 dev_err(&st->us->dev, "The third response is not correct!\n");
308 ret = adxrs450_spi_read_reg_16(dev, ADXRS450_FAULT1, &data);
312 dev_err(&st->us->dev, "The device is not in normal status!\n");
315 ret = adxrs450_spi_read_reg_16(dev, ADXRS450_PID1, &data);
318 dev_info(&st->us->dev, "The Part ID is 0x%x\n", data);
320 ret = adxrs450_spi_read_reg_16(dev, ADXRS450_SNL, &data);
324 ret = adxrs450_spi_read_reg_16(dev, ADXRS450_SNH, &data);
328 dev_info(&st->us->dev, "The Serial Number is 0x%x\n", t);
333 static IIO_DEV_ATTR_GYRO_Z(adxrs450_read_sensor_data, 0);
334 static IIO_DEV_ATTR_TEMP_RAW(adxrs450_read_temp);
335 static IIO_DEV_ATTR_GYRO_Z_QUADRATURE_CORRECTION(adxrs450_read_quad, 0);
336 static IIO_DEV_ATTR_GYRO_Z_CALIBBIAS(S_IWUSR,
337 NULL, adxrs450_write_dnc, 0);
338 static IIO_CONST_ATTR(name, "adxrs450");
340 static struct attribute *adxrs450_attributes[] = {
341 &iio_dev_attr_gyro_z_raw.dev_attr.attr,
342 &iio_dev_attr_temp_raw.dev_attr.attr,
343 &iio_dev_attr_gyro_z_quadrature_correction_raw.dev_attr.attr,
344 &iio_dev_attr_gyro_z_calibbias.dev_attr.attr,
345 &iio_const_attr_name.dev_attr.attr,
349 static const struct attribute_group adxrs450_attribute_group = {
350 .attrs = adxrs450_attributes,
353 static int __devinit adxrs450_probe(struct spi_device *spi)
355 int ret, regdone = 0;
356 struct adxrs450_state *st = kzalloc(sizeof *st, GFP_KERNEL);
361 /* This is only used for removal purposes */
362 spi_set_drvdata(spi, st);
364 /* Allocate the comms buffers */
365 st->rx = kzalloc(sizeof(*st->rx)*ADXRS450_MAX_RX, GFP_KERNEL);
366 if (st->rx == NULL) {
370 st->tx = kzalloc(sizeof(*st->tx)*ADXRS450_MAX_TX, GFP_KERNEL);
371 if (st->tx == NULL) {
376 mutex_init(&st->buf_lock);
377 /* setup the industrialio driver allocated elements */
378 st->indio_dev = iio_allocate_device(0);
379 if (st->indio_dev == NULL) {
384 st->indio_dev->dev.parent = &spi->dev;
385 st->indio_dev->attrs = &adxrs450_attribute_group;
386 st->indio_dev->dev_data = (void *)(st);
387 st->indio_dev->driver_module = THIS_MODULE;
388 st->indio_dev->modes = INDIO_DIRECT_MODE;
390 ret = iio_device_register(st->indio_dev);
395 /* Get the device into a sane initial state */
396 ret = adxrs450_initial_setup(st);
404 iio_device_unregister(st->indio_dev);
406 iio_free_device(st->indio_dev);
417 static int adxrs450_remove(struct spi_device *spi)
419 struct adxrs450_state *st = spi_get_drvdata(spi);
421 iio_device_unregister(st->indio_dev);
429 static struct spi_driver adxrs450_driver = {
432 .owner = THIS_MODULE,
434 .probe = adxrs450_probe,
435 .remove = __devexit_p(adxrs450_remove),
438 static __init int adxrs450_init(void)
440 return spi_register_driver(&adxrs450_driver);
442 module_init(adxrs450_init);
444 static __exit void adxrs450_exit(void)
446 spi_unregister_driver(&adxrs450_driver);
448 module_exit(adxrs450_exit);
450 MODULE_AUTHOR("Cliff Cai <cliff.cai@xxxxxxxxxx>");
451 MODULE_DESCRIPTION("Analog Devices ADXRS450 Gyroscope SPI driver");
452 MODULE_LICENSE("GPL v2");