GNU Linux-libre 4.9.282-gnu1
[releases.git] / drivers / iio / imu / adis16480.c
1 /*
2  * ADIS16480 and similar IMUs driver
3  *
4  * Copyright 2012 Analog Devices Inc.
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 version 2 as
8  * published by the Free Software Foundation.
9  *
10  */
11
12 #include <linux/interrupt.h>
13 #include <linux/delay.h>
14 #include <linux/mutex.h>
15 #include <linux/device.h>
16 #include <linux/kernel.h>
17 #include <linux/spi/spi.h>
18 #include <linux/slab.h>
19 #include <linux/sysfs.h>
20 #include <linux/module.h>
21
22 #include <linux/iio/iio.h>
23 #include <linux/iio/sysfs.h>
24 #include <linux/iio/buffer.h>
25 #include <linux/iio/imu/adis.h>
26
27 #include <linux/debugfs.h>
28
29 #define ADIS16480_PAGE_SIZE 0x80
30
31 #define ADIS16480_REG(page, reg) ((page) * ADIS16480_PAGE_SIZE + (reg))
32
33 #define ADIS16480_REG_PAGE_ID 0x00 /* Same address on each page */
34 #define ADIS16480_REG_SEQ_CNT                   ADIS16480_REG(0x00, 0x06)
35 #define ADIS16480_REG_SYS_E_FLA                 ADIS16480_REG(0x00, 0x08)
36 #define ADIS16480_REG_DIAG_STS                  ADIS16480_REG(0x00, 0x0A)
37 #define ADIS16480_REG_ALM_STS                   ADIS16480_REG(0x00, 0x0C)
38 #define ADIS16480_REG_TEMP_OUT                  ADIS16480_REG(0x00, 0x0E)
39 #define ADIS16480_REG_X_GYRO_OUT                ADIS16480_REG(0x00, 0x10)
40 #define ADIS16480_REG_Y_GYRO_OUT                ADIS16480_REG(0x00, 0x14)
41 #define ADIS16480_REG_Z_GYRO_OUT                ADIS16480_REG(0x00, 0x18)
42 #define ADIS16480_REG_X_ACCEL_OUT               ADIS16480_REG(0x00, 0x1C)
43 #define ADIS16480_REG_Y_ACCEL_OUT               ADIS16480_REG(0x00, 0x20)
44 #define ADIS16480_REG_Z_ACCEL_OUT               ADIS16480_REG(0x00, 0x24)
45 #define ADIS16480_REG_X_MAGN_OUT                ADIS16480_REG(0x00, 0x28)
46 #define ADIS16480_REG_Y_MAGN_OUT                ADIS16480_REG(0x00, 0x2A)
47 #define ADIS16480_REG_Z_MAGN_OUT                ADIS16480_REG(0x00, 0x2C)
48 #define ADIS16480_REG_BAROM_OUT                 ADIS16480_REG(0x00, 0x2E)
49 #define ADIS16480_REG_X_DELTAANG_OUT            ADIS16480_REG(0x00, 0x40)
50 #define ADIS16480_REG_Y_DELTAANG_OUT            ADIS16480_REG(0x00, 0x44)
51 #define ADIS16480_REG_Z_DELTAANG_OUT            ADIS16480_REG(0x00, 0x48)
52 #define ADIS16480_REG_X_DELTAVEL_OUT            ADIS16480_REG(0x00, 0x4C)
53 #define ADIS16480_REG_Y_DELTAVEL_OUT            ADIS16480_REG(0x00, 0x50)
54 #define ADIS16480_REG_Z_DELTAVEL_OUT            ADIS16480_REG(0x00, 0x54)
55 #define ADIS16480_REG_PROD_ID                   ADIS16480_REG(0x00, 0x7E)
56
57 #define ADIS16480_REG_X_GYRO_SCALE              ADIS16480_REG(0x02, 0x04)
58 #define ADIS16480_REG_Y_GYRO_SCALE              ADIS16480_REG(0x02, 0x06)
59 #define ADIS16480_REG_Z_GYRO_SCALE              ADIS16480_REG(0x02, 0x08)
60 #define ADIS16480_REG_X_ACCEL_SCALE             ADIS16480_REG(0x02, 0x0A)
61 #define ADIS16480_REG_Y_ACCEL_SCALE             ADIS16480_REG(0x02, 0x0C)
62 #define ADIS16480_REG_Z_ACCEL_SCALE             ADIS16480_REG(0x02, 0x0E)
63 #define ADIS16480_REG_X_GYRO_BIAS               ADIS16480_REG(0x02, 0x10)
64 #define ADIS16480_REG_Y_GYRO_BIAS               ADIS16480_REG(0x02, 0x14)
65 #define ADIS16480_REG_Z_GYRO_BIAS               ADIS16480_REG(0x02, 0x18)
66 #define ADIS16480_REG_X_ACCEL_BIAS              ADIS16480_REG(0x02, 0x1C)
67 #define ADIS16480_REG_Y_ACCEL_BIAS              ADIS16480_REG(0x02, 0x20)
68 #define ADIS16480_REG_Z_ACCEL_BIAS              ADIS16480_REG(0x02, 0x24)
69 #define ADIS16480_REG_X_HARD_IRON               ADIS16480_REG(0x02, 0x28)
70 #define ADIS16480_REG_Y_HARD_IRON               ADIS16480_REG(0x02, 0x2A)
71 #define ADIS16480_REG_Z_HARD_IRON               ADIS16480_REG(0x02, 0x2C)
72 #define ADIS16480_REG_BAROM_BIAS                ADIS16480_REG(0x02, 0x40)
73 #define ADIS16480_REG_FLASH_CNT                 ADIS16480_REG(0x02, 0x7C)
74
75 #define ADIS16480_REG_GLOB_CMD                  ADIS16480_REG(0x03, 0x02)
76 #define ADIS16480_REG_FNCTIO_CTRL               ADIS16480_REG(0x03, 0x06)
77 #define ADIS16480_REG_GPIO_CTRL                 ADIS16480_REG(0x03, 0x08)
78 #define ADIS16480_REG_CONFIG                    ADIS16480_REG(0x03, 0x0A)
79 #define ADIS16480_REG_DEC_RATE                  ADIS16480_REG(0x03, 0x0C)
80 #define ADIS16480_REG_SLP_CNT                   ADIS16480_REG(0x03, 0x10)
81 #define ADIS16480_REG_FILTER_BNK0               ADIS16480_REG(0x03, 0x16)
82 #define ADIS16480_REG_FILTER_BNK1               ADIS16480_REG(0x03, 0x18)
83 #define ADIS16480_REG_ALM_CNFG0                 ADIS16480_REG(0x03, 0x20)
84 #define ADIS16480_REG_ALM_CNFG1                 ADIS16480_REG(0x03, 0x22)
85 #define ADIS16480_REG_ALM_CNFG2                 ADIS16480_REG(0x03, 0x24)
86 #define ADIS16480_REG_XG_ALM_MAGN               ADIS16480_REG(0x03, 0x28)
87 #define ADIS16480_REG_YG_ALM_MAGN               ADIS16480_REG(0x03, 0x2A)
88 #define ADIS16480_REG_ZG_ALM_MAGN               ADIS16480_REG(0x03, 0x2C)
89 #define ADIS16480_REG_XA_ALM_MAGN               ADIS16480_REG(0x03, 0x2E)
90 #define ADIS16480_REG_YA_ALM_MAGN               ADIS16480_REG(0x03, 0x30)
91 #define ADIS16480_REG_ZA_ALM_MAGN               ADIS16480_REG(0x03, 0x32)
92 #define ADIS16480_REG_XM_ALM_MAGN               ADIS16480_REG(0x03, 0x34)
93 #define ADIS16480_REG_YM_ALM_MAGN               ADIS16480_REG(0x03, 0x36)
94 #define ADIS16480_REG_ZM_ALM_MAGN               ADIS16480_REG(0x03, 0x38)
95 #define ADIS16480_REG_BR_ALM_MAGN               ADIS16480_REG(0x03, 0x3A)
96 #define ADIS16480_REG_FIRM_REV                  ADIS16480_REG(0x03, 0x78)
97 #define ADIS16480_REG_FIRM_DM                   ADIS16480_REG(0x03, 0x7A)
98 #define ADIS16480_REG_FIRM_Y                    ADIS16480_REG(0x03, 0x7C)
99
100 #define ADIS16480_REG_SERIAL_NUM                ADIS16480_REG(0x04, 0x20)
101
102 /* Each filter coefficent bank spans two pages */
103 #define ADIS16480_FIR_COEF(page) (x < 60 ? ADIS16480_REG(page, (x) + 8) : \
104                 ADIS16480_REG((page) + 1, (x) - 60 + 8))
105 #define ADIS16480_FIR_COEF_A(x)                 ADIS16480_FIR_COEF(0x05, (x))
106 #define ADIS16480_FIR_COEF_B(x)                 ADIS16480_FIR_COEF(0x07, (x))
107 #define ADIS16480_FIR_COEF_C(x)                 ADIS16480_FIR_COEF(0x09, (x))
108 #define ADIS16480_FIR_COEF_D(x)                 ADIS16480_FIR_COEF(0x0B, (x))
109
110 struct adis16480_chip_info {
111         unsigned int num_channels;
112         const struct iio_chan_spec *channels;
113         unsigned int gyro_max_val;
114         unsigned int gyro_max_scale;
115         unsigned int accel_max_val;
116         unsigned int accel_max_scale;
117 };
118
119 struct adis16480 {
120         const struct adis16480_chip_info *chip_info;
121
122         struct adis adis;
123 };
124
125 #ifdef CONFIG_DEBUG_FS
126
127 static ssize_t adis16480_show_firmware_revision(struct file *file,
128                 char __user *userbuf, size_t count, loff_t *ppos)
129 {
130         struct adis16480 *adis16480 = file->private_data;
131         char buf[7];
132         size_t len;
133         u16 rev;
134         int ret;
135
136         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_FIRM_REV, &rev);
137         if (ret < 0)
138                 return ret;
139
140         len = scnprintf(buf, sizeof(buf), "%x.%x\n", rev >> 8, rev & 0xff);
141
142         return simple_read_from_buffer(userbuf, count, ppos, buf, len);
143 }
144
145 static const struct file_operations adis16480_firmware_revision_fops = {
146         .open = simple_open,
147         .read = adis16480_show_firmware_revision,
148         .llseek = default_llseek,
149         .owner = THIS_MODULE,
150 };
151
152 static ssize_t adis16480_show_firmware_date(struct file *file,
153                 char __user *userbuf, size_t count, loff_t *ppos)
154 {
155         struct adis16480 *adis16480 = file->private_data;
156         u16 md, year;
157         char buf[12];
158         size_t len;
159         int ret;
160
161         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_FIRM_Y, &year);
162         if (ret < 0)
163                 return ret;
164
165         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_FIRM_DM, &md);
166         if (ret < 0)
167                 return ret;
168
169         len = snprintf(buf, sizeof(buf), "%.2x-%.2x-%.4x\n",
170                         md >> 8, md & 0xff, year);
171
172         return simple_read_from_buffer(userbuf, count, ppos, buf, len);
173 }
174
175 static const struct file_operations adis16480_firmware_date_fops = {
176         .open = simple_open,
177         .read = adis16480_show_firmware_date,
178         .llseek = default_llseek,
179         .owner = THIS_MODULE,
180 };
181
182 static int adis16480_show_serial_number(void *arg, u64 *val)
183 {
184         struct adis16480 *adis16480 = arg;
185         u16 serial;
186         int ret;
187
188         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_SERIAL_NUM,
189                 &serial);
190         if (ret < 0)
191                 return ret;
192
193         *val = serial;
194
195         return 0;
196 }
197 DEFINE_SIMPLE_ATTRIBUTE(adis16480_serial_number_fops,
198         adis16480_show_serial_number, NULL, "0x%.4llx\n");
199
200 static int adis16480_show_product_id(void *arg, u64 *val)
201 {
202         struct adis16480 *adis16480 = arg;
203         u16 prod_id;
204         int ret;
205
206         ret = adis_read_reg_16(&adis16480->adis, ADIS16480_REG_PROD_ID,
207                 &prod_id);
208         if (ret < 0)
209                 return ret;
210
211         *val = prod_id;
212
213         return 0;
214 }
215 DEFINE_SIMPLE_ATTRIBUTE(adis16480_product_id_fops,
216         adis16480_show_product_id, NULL, "%llu\n");
217
218 static int adis16480_show_flash_count(void *arg, u64 *val)
219 {
220         struct adis16480 *adis16480 = arg;
221         u32 flash_count;
222         int ret;
223
224         ret = adis_read_reg_32(&adis16480->adis, ADIS16480_REG_FLASH_CNT,
225                 &flash_count);
226         if (ret < 0)
227                 return ret;
228
229         *val = flash_count;
230
231         return 0;
232 }
233 DEFINE_SIMPLE_ATTRIBUTE(adis16480_flash_count_fops,
234         adis16480_show_flash_count, NULL, "%lld\n");
235
236 static int adis16480_debugfs_init(struct iio_dev *indio_dev)
237 {
238         struct adis16480 *adis16480 = iio_priv(indio_dev);
239
240         debugfs_create_file("firmware_revision", 0400,
241                 indio_dev->debugfs_dentry, adis16480,
242                 &adis16480_firmware_revision_fops);
243         debugfs_create_file("firmware_date", 0400, indio_dev->debugfs_dentry,
244                 adis16480, &adis16480_firmware_date_fops);
245         debugfs_create_file("serial_number", 0400, indio_dev->debugfs_dentry,
246                 adis16480, &adis16480_serial_number_fops);
247         debugfs_create_file("product_id", 0400, indio_dev->debugfs_dentry,
248                 adis16480, &adis16480_product_id_fops);
249         debugfs_create_file("flash_count", 0400, indio_dev->debugfs_dentry,
250                 adis16480, &adis16480_flash_count_fops);
251
252         return 0;
253 }
254
255 #else
256
257 static int adis16480_debugfs_init(struct iio_dev *indio_dev)
258 {
259         return 0;
260 }
261
262 #endif
263
264 static int adis16480_set_freq(struct iio_dev *indio_dev, int val, int val2)
265 {
266         struct adis16480 *st = iio_priv(indio_dev);
267         unsigned int t;
268
269         if (val < 0 || val2 < 0)
270                 return -EINVAL;
271
272         t =  val * 1000 + val2 / 1000;
273         if (t == 0)
274                 return -EINVAL;
275
276         t = 2460000 / t;
277         if (t > 2048)
278                 t = 2048;
279
280         if (t != 0)
281                 t--;
282
283         return adis_write_reg_16(&st->adis, ADIS16480_REG_DEC_RATE, t);
284 }
285
286 static int adis16480_get_freq(struct iio_dev *indio_dev, int *val, int *val2)
287 {
288         struct adis16480 *st = iio_priv(indio_dev);
289         uint16_t t;
290         int ret;
291         unsigned freq;
292
293         ret = adis_read_reg_16(&st->adis, ADIS16480_REG_DEC_RATE, &t);
294         if (ret < 0)
295                 return ret;
296
297         freq = 2460000 / (t + 1);
298         *val = freq / 1000;
299         *val2 = (freq % 1000) * 1000;
300
301         return IIO_VAL_INT_PLUS_MICRO;
302 }
303
304 enum {
305         ADIS16480_SCAN_GYRO_X,
306         ADIS16480_SCAN_GYRO_Y,
307         ADIS16480_SCAN_GYRO_Z,
308         ADIS16480_SCAN_ACCEL_X,
309         ADIS16480_SCAN_ACCEL_Y,
310         ADIS16480_SCAN_ACCEL_Z,
311         ADIS16480_SCAN_MAGN_X,
312         ADIS16480_SCAN_MAGN_Y,
313         ADIS16480_SCAN_MAGN_Z,
314         ADIS16480_SCAN_BARO,
315         ADIS16480_SCAN_TEMP,
316 };
317
318 static const unsigned int adis16480_calibbias_regs[] = {
319         [ADIS16480_SCAN_GYRO_X] = ADIS16480_REG_X_GYRO_BIAS,
320         [ADIS16480_SCAN_GYRO_Y] = ADIS16480_REG_Y_GYRO_BIAS,
321         [ADIS16480_SCAN_GYRO_Z] = ADIS16480_REG_Z_GYRO_BIAS,
322         [ADIS16480_SCAN_ACCEL_X] = ADIS16480_REG_X_ACCEL_BIAS,
323         [ADIS16480_SCAN_ACCEL_Y] = ADIS16480_REG_Y_ACCEL_BIAS,
324         [ADIS16480_SCAN_ACCEL_Z] = ADIS16480_REG_Z_ACCEL_BIAS,
325         [ADIS16480_SCAN_MAGN_X] = ADIS16480_REG_X_HARD_IRON,
326         [ADIS16480_SCAN_MAGN_Y] = ADIS16480_REG_Y_HARD_IRON,
327         [ADIS16480_SCAN_MAGN_Z] = ADIS16480_REG_Z_HARD_IRON,
328         [ADIS16480_SCAN_BARO] = ADIS16480_REG_BAROM_BIAS,
329 };
330
331 static const unsigned int adis16480_calibscale_regs[] = {
332         [ADIS16480_SCAN_GYRO_X] = ADIS16480_REG_X_GYRO_SCALE,
333         [ADIS16480_SCAN_GYRO_Y] = ADIS16480_REG_Y_GYRO_SCALE,
334         [ADIS16480_SCAN_GYRO_Z] = ADIS16480_REG_Z_GYRO_SCALE,
335         [ADIS16480_SCAN_ACCEL_X] = ADIS16480_REG_X_ACCEL_SCALE,
336         [ADIS16480_SCAN_ACCEL_Y] = ADIS16480_REG_Y_ACCEL_SCALE,
337         [ADIS16480_SCAN_ACCEL_Z] = ADIS16480_REG_Z_ACCEL_SCALE,
338 };
339
340 static int adis16480_set_calibbias(struct iio_dev *indio_dev,
341         const struct iio_chan_spec *chan, int bias)
342 {
343         unsigned int reg = adis16480_calibbias_regs[chan->scan_index];
344         struct adis16480 *st = iio_priv(indio_dev);
345
346         switch (chan->type) {
347         case IIO_MAGN:
348         case IIO_PRESSURE:
349                 if (bias < -0x8000 || bias >= 0x8000)
350                         return -EINVAL;
351                 return adis_write_reg_16(&st->adis, reg, bias);
352         case IIO_ANGL_VEL:
353         case IIO_ACCEL:
354                 return adis_write_reg_32(&st->adis, reg, bias);
355         default:
356                 break;
357         }
358
359         return -EINVAL;
360 }
361
362 static int adis16480_get_calibbias(struct iio_dev *indio_dev,
363         const struct iio_chan_spec *chan, int *bias)
364 {
365         unsigned int reg = adis16480_calibbias_regs[chan->scan_index];
366         struct adis16480 *st = iio_priv(indio_dev);
367         uint16_t val16;
368         uint32_t val32;
369         int ret;
370
371         switch (chan->type) {
372         case IIO_MAGN:
373         case IIO_PRESSURE:
374                 ret = adis_read_reg_16(&st->adis, reg, &val16);
375                 if (ret == 0)
376                         *bias = sign_extend32(val16, 15);
377                 break;
378         case IIO_ANGL_VEL:
379         case IIO_ACCEL:
380                 ret = adis_read_reg_32(&st->adis, reg, &val32);
381                 if (ret == 0)
382                         *bias = sign_extend32(val32, 31);
383                 break;
384         default:
385                         ret = -EINVAL;
386         }
387
388         if (ret < 0)
389                 return ret;
390
391         return IIO_VAL_INT;
392 }
393
394 static int adis16480_set_calibscale(struct iio_dev *indio_dev,
395         const struct iio_chan_spec *chan, int scale)
396 {
397         unsigned int reg = adis16480_calibscale_regs[chan->scan_index];
398         struct adis16480 *st = iio_priv(indio_dev);
399
400         if (scale < -0x8000 || scale >= 0x8000)
401                 return -EINVAL;
402
403         return adis_write_reg_16(&st->adis, reg, scale);
404 }
405
406 static int adis16480_get_calibscale(struct iio_dev *indio_dev,
407         const struct iio_chan_spec *chan, int *scale)
408 {
409         unsigned int reg = adis16480_calibscale_regs[chan->scan_index];
410         struct adis16480 *st = iio_priv(indio_dev);
411         uint16_t val16;
412         int ret;
413
414         ret = adis_read_reg_16(&st->adis, reg, &val16);
415         if (ret < 0)
416                 return ret;
417
418         *scale = sign_extend32(val16, 15);
419         return IIO_VAL_INT;
420 }
421
422 static const unsigned int adis16480_def_filter_freqs[] = {
423         310,
424         55,
425         275,
426         63,
427 };
428
429 static const unsigned int ad16480_filter_data[][2] = {
430         [ADIS16480_SCAN_GYRO_X]         = { ADIS16480_REG_FILTER_BNK0, 0 },
431         [ADIS16480_SCAN_GYRO_Y]         = { ADIS16480_REG_FILTER_BNK0, 3 },
432         [ADIS16480_SCAN_GYRO_Z]         = { ADIS16480_REG_FILTER_BNK0, 6 },
433         [ADIS16480_SCAN_ACCEL_X]        = { ADIS16480_REG_FILTER_BNK0, 9 },
434         [ADIS16480_SCAN_ACCEL_Y]        = { ADIS16480_REG_FILTER_BNK0, 12 },
435         [ADIS16480_SCAN_ACCEL_Z]        = { ADIS16480_REG_FILTER_BNK1, 0 },
436         [ADIS16480_SCAN_MAGN_X]         = { ADIS16480_REG_FILTER_BNK1, 3 },
437         [ADIS16480_SCAN_MAGN_Y]         = { ADIS16480_REG_FILTER_BNK1, 6 },
438         [ADIS16480_SCAN_MAGN_Z]         = { ADIS16480_REG_FILTER_BNK1, 9 },
439 };
440
441 static int adis16480_get_filter_freq(struct iio_dev *indio_dev,
442         const struct iio_chan_spec *chan, int *freq)
443 {
444         struct adis16480 *st = iio_priv(indio_dev);
445         unsigned int enable_mask, offset, reg;
446         uint16_t val;
447         int ret;
448
449         reg = ad16480_filter_data[chan->scan_index][0];
450         offset = ad16480_filter_data[chan->scan_index][1];
451         enable_mask = BIT(offset + 2);
452
453         ret = adis_read_reg_16(&st->adis, reg, &val);
454         if (ret < 0)
455                 return ret;
456
457         if (!(val & enable_mask))
458                 *freq = 0;
459         else
460                 *freq = adis16480_def_filter_freqs[(val >> offset) & 0x3];
461
462         return IIO_VAL_INT;
463 }
464
465 static int adis16480_set_filter_freq(struct iio_dev *indio_dev,
466         const struct iio_chan_spec *chan, unsigned int freq)
467 {
468         struct adis16480 *st = iio_priv(indio_dev);
469         unsigned int enable_mask, offset, reg;
470         unsigned int diff, best_diff;
471         unsigned int i, best_freq;
472         uint16_t val;
473         int ret;
474
475         reg = ad16480_filter_data[chan->scan_index][0];
476         offset = ad16480_filter_data[chan->scan_index][1];
477         enable_mask = BIT(offset + 2);
478
479         ret = adis_read_reg_16(&st->adis, reg, &val);
480         if (ret < 0)
481                 return ret;
482
483         if (freq == 0) {
484                 val &= ~enable_mask;
485         } else {
486                 best_freq = 0;
487                 best_diff = 310;
488                 for (i = 0; i < ARRAY_SIZE(adis16480_def_filter_freqs); i++) {
489                         if (adis16480_def_filter_freqs[i] >= freq) {
490                                 diff = adis16480_def_filter_freqs[i] - freq;
491                                 if (diff < best_diff) {
492                                         best_diff = diff;
493                                         best_freq = i;
494                                 }
495                         }
496                 }
497
498                 val &= ~(0x3 << offset);
499                 val |= best_freq << offset;
500                 val |= enable_mask;
501         }
502
503         return adis_write_reg_16(&st->adis, reg, val);
504 }
505
506 static int adis16480_read_raw(struct iio_dev *indio_dev,
507         const struct iio_chan_spec *chan, int *val, int *val2, long info)
508 {
509         struct adis16480 *st = iio_priv(indio_dev);
510
511         switch (info) {
512         case IIO_CHAN_INFO_RAW:
513                 return adis_single_conversion(indio_dev, chan, 0, val);
514         case IIO_CHAN_INFO_SCALE:
515                 switch (chan->type) {
516                 case IIO_ANGL_VEL:
517                         *val = st->chip_info->gyro_max_scale;
518                         *val2 = st->chip_info->gyro_max_val;
519                         return IIO_VAL_FRACTIONAL;
520                 case IIO_ACCEL:
521                         *val = st->chip_info->accel_max_scale;
522                         *val2 = st->chip_info->accel_max_val;
523                         return IIO_VAL_FRACTIONAL;
524                 case IIO_MAGN:
525                         *val = 0;
526                         *val2 = 100; /* 0.0001 gauss */
527                         return IIO_VAL_INT_PLUS_MICRO;
528                 case IIO_TEMP:
529                         *val = 5;
530                         *val2 = 650000; /* 5.65 milli degree Celsius */
531                         return IIO_VAL_INT_PLUS_MICRO;
532                 case IIO_PRESSURE:
533                         *val = 0;
534                         *val2 = 4000; /* 40ubar = 0.004 kPa */
535                         return IIO_VAL_INT_PLUS_MICRO;
536                 default:
537                         return -EINVAL;
538                 }
539         case IIO_CHAN_INFO_OFFSET:
540                 /* Only the temperature channel has a offset */
541                 *val = 4425; /* 25 degree Celsius = 0x0000 */
542                 return IIO_VAL_INT;
543         case IIO_CHAN_INFO_CALIBBIAS:
544                 return adis16480_get_calibbias(indio_dev, chan, val);
545         case IIO_CHAN_INFO_CALIBSCALE:
546                 return adis16480_get_calibscale(indio_dev, chan, val);
547         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
548                 return adis16480_get_filter_freq(indio_dev, chan, val);
549         case IIO_CHAN_INFO_SAMP_FREQ:
550                 return adis16480_get_freq(indio_dev, val, val2);
551         default:
552                 return -EINVAL;
553         }
554 }
555
556 static int adis16480_write_raw(struct iio_dev *indio_dev,
557         const struct iio_chan_spec *chan, int val, int val2, long info)
558 {
559         switch (info) {
560         case IIO_CHAN_INFO_CALIBBIAS:
561                 return adis16480_set_calibbias(indio_dev, chan, val);
562         case IIO_CHAN_INFO_CALIBSCALE:
563                 return adis16480_set_calibscale(indio_dev, chan, val);
564         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
565                 return adis16480_set_filter_freq(indio_dev, chan, val);
566         case IIO_CHAN_INFO_SAMP_FREQ:
567                 return adis16480_set_freq(indio_dev, val, val2);
568
569         default:
570                 return -EINVAL;
571         }
572 }
573
574 #define ADIS16480_MOD_CHANNEL(_type, _mod, _address, _si, _info_sep, _bits) \
575         { \
576                 .type = (_type), \
577                 .modified = 1, \
578                 .channel2 = (_mod), \
579                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
580                         BIT(IIO_CHAN_INFO_CALIBBIAS) | \
581                         _info_sep, \
582                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
583                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
584                 .address = (_address), \
585                 .scan_index = (_si), \
586                 .scan_type = { \
587                         .sign = 's', \
588                         .realbits = (_bits), \
589                         .storagebits = (_bits), \
590                         .endianness = IIO_BE, \
591                 }, \
592         }
593
594 #define ADIS16480_GYRO_CHANNEL(_mod) \
595         ADIS16480_MOD_CHANNEL(IIO_ANGL_VEL, IIO_MOD_ ## _mod, \
596         ADIS16480_REG_ ## _mod ## _GYRO_OUT, ADIS16480_SCAN_GYRO_ ## _mod, \
597         BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \
598         BIT(IIO_CHAN_INFO_CALIBSCALE), \
599         32)
600
601 #define ADIS16480_ACCEL_CHANNEL(_mod) \
602         ADIS16480_MOD_CHANNEL(IIO_ACCEL, IIO_MOD_ ## _mod, \
603         ADIS16480_REG_ ## _mod ## _ACCEL_OUT, ADIS16480_SCAN_ACCEL_ ## _mod, \
604         BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \
605         BIT(IIO_CHAN_INFO_CALIBSCALE), \
606         32)
607
608 #define ADIS16480_MAGN_CHANNEL(_mod) \
609         ADIS16480_MOD_CHANNEL(IIO_MAGN, IIO_MOD_ ## _mod, \
610         ADIS16480_REG_ ## _mod ## _MAGN_OUT, ADIS16480_SCAN_MAGN_ ## _mod, \
611         BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY), \
612         16)
613
614 #define ADIS16480_PRESSURE_CHANNEL() \
615         { \
616                 .type = IIO_PRESSURE, \
617                 .indexed = 1, \
618                 .channel = 0, \
619                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
620                         BIT(IIO_CHAN_INFO_CALIBBIAS) | \
621                         BIT(IIO_CHAN_INFO_SCALE), \
622                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
623                 .address = ADIS16480_REG_BAROM_OUT, \
624                 .scan_index = ADIS16480_SCAN_BARO, \
625                 .scan_type = { \
626                         .sign = 's', \
627                         .realbits = 32, \
628                         .storagebits = 32, \
629                         .endianness = IIO_BE, \
630                 }, \
631         }
632
633 #define ADIS16480_TEMP_CHANNEL() { \
634                 .type = IIO_TEMP, \
635                 .indexed = 1, \
636                 .channel = 0, \
637                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
638                         BIT(IIO_CHAN_INFO_SCALE) | \
639                         BIT(IIO_CHAN_INFO_OFFSET), \
640                 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
641                 .address = ADIS16480_REG_TEMP_OUT, \
642                 .scan_index = ADIS16480_SCAN_TEMP, \
643                 .scan_type = { \
644                         .sign = 's', \
645                         .realbits = 16, \
646                         .storagebits = 16, \
647                         .endianness = IIO_BE, \
648                 }, \
649         }
650
651 static const struct iio_chan_spec adis16480_channels[] = {
652         ADIS16480_GYRO_CHANNEL(X),
653         ADIS16480_GYRO_CHANNEL(Y),
654         ADIS16480_GYRO_CHANNEL(Z),
655         ADIS16480_ACCEL_CHANNEL(X),
656         ADIS16480_ACCEL_CHANNEL(Y),
657         ADIS16480_ACCEL_CHANNEL(Z),
658         ADIS16480_MAGN_CHANNEL(X),
659         ADIS16480_MAGN_CHANNEL(Y),
660         ADIS16480_MAGN_CHANNEL(Z),
661         ADIS16480_PRESSURE_CHANNEL(),
662         ADIS16480_TEMP_CHANNEL(),
663         IIO_CHAN_SOFT_TIMESTAMP(11)
664 };
665
666 static const struct iio_chan_spec adis16485_channels[] = {
667         ADIS16480_GYRO_CHANNEL(X),
668         ADIS16480_GYRO_CHANNEL(Y),
669         ADIS16480_GYRO_CHANNEL(Z),
670         ADIS16480_ACCEL_CHANNEL(X),
671         ADIS16480_ACCEL_CHANNEL(Y),
672         ADIS16480_ACCEL_CHANNEL(Z),
673         ADIS16480_TEMP_CHANNEL(),
674         IIO_CHAN_SOFT_TIMESTAMP(7)
675 };
676
677 enum adis16480_variant {
678         ADIS16375,
679         ADIS16480,
680         ADIS16485,
681         ADIS16488,
682 };
683
684 static const struct adis16480_chip_info adis16480_chip_info[] = {
685         [ADIS16375] = {
686                 .channels = adis16485_channels,
687                 .num_channels = ARRAY_SIZE(adis16485_channels),
688                 /*
689                  * storing the value in rad/degree and the scale in degree
690                  * gives us the result in rad and better precession than
691                  * storing the scale directly in rad.
692                  */
693                 .gyro_max_val = IIO_RAD_TO_DEGREE(22887),
694                 .gyro_max_scale = 300,
695                 .accel_max_val = IIO_M_S_2_TO_G(21973),
696                 .accel_max_scale = 18,
697         },
698         [ADIS16480] = {
699                 .channels = adis16480_channels,
700                 .num_channels = ARRAY_SIZE(adis16480_channels),
701                 .gyro_max_val = IIO_RAD_TO_DEGREE(22500),
702                 .gyro_max_scale = 450,
703                 .accel_max_val = IIO_M_S_2_TO_G(12500),
704                 .accel_max_scale = 10,
705         },
706         [ADIS16485] = {
707                 .channels = adis16485_channels,
708                 .num_channels = ARRAY_SIZE(adis16485_channels),
709                 .gyro_max_val = IIO_RAD_TO_DEGREE(22500),
710                 .gyro_max_scale = 450,
711                 .accel_max_val = IIO_M_S_2_TO_G(20000),
712                 .accel_max_scale = 5,
713         },
714         [ADIS16488] = {
715                 .channels = adis16480_channels,
716                 .num_channels = ARRAY_SIZE(adis16480_channels),
717                 .gyro_max_val = IIO_RAD_TO_DEGREE(22500),
718                 .gyro_max_scale = 450,
719                 .accel_max_val = IIO_M_S_2_TO_G(22500),
720                 .accel_max_scale = 18,
721         },
722 };
723
724 static const struct iio_info adis16480_info = {
725         .read_raw = &adis16480_read_raw,
726         .write_raw = &adis16480_write_raw,
727         .update_scan_mode = adis_update_scan_mode,
728         .driver_module = THIS_MODULE,
729         .debugfs_reg_access = adis_debugfs_reg_access,
730 };
731
732 static int adis16480_stop_device(struct iio_dev *indio_dev)
733 {
734         struct adis16480 *st = iio_priv(indio_dev);
735         int ret;
736
737         ret = adis_write_reg_16(&st->adis, ADIS16480_REG_SLP_CNT, BIT(9));
738         if (ret)
739                 dev_err(&indio_dev->dev,
740                         "Could not power down device: %d\n", ret);
741
742         return ret;
743 }
744
745 static int adis16480_enable_irq(struct adis *adis, bool enable)
746 {
747         return adis_write_reg_16(adis, ADIS16480_REG_FNCTIO_CTRL,
748                 enable ? BIT(3) : 0);
749 }
750
751 static int adis16480_initial_setup(struct iio_dev *indio_dev)
752 {
753         struct adis16480 *st = iio_priv(indio_dev);
754         uint16_t prod_id;
755         unsigned int device_id;
756         int ret;
757
758         adis_reset(&st->adis);
759         msleep(70);
760
761         ret = adis_write_reg_16(&st->adis, ADIS16480_REG_GLOB_CMD, BIT(1));
762         if (ret)
763                 return ret;
764         msleep(30);
765
766         ret = adis_check_status(&st->adis);
767         if (ret)
768                 return ret;
769
770         ret = adis_read_reg_16(&st->adis, ADIS16480_REG_PROD_ID, &prod_id);
771         if (ret)
772                 return ret;
773
774         ret = sscanf(indio_dev->name, "adis%u\n", &device_id);
775         if (ret != 1)
776                 return -EINVAL;
777
778         if (prod_id != device_id)
779                 dev_warn(&indio_dev->dev, "Device ID(%u) and product ID(%u) do not match.",
780                                 device_id, prod_id);
781
782         return 0;
783 }
784
785 #define ADIS16480_DIAG_STAT_XGYRO_FAIL 0
786 #define ADIS16480_DIAG_STAT_YGYRO_FAIL 1
787 #define ADIS16480_DIAG_STAT_ZGYRO_FAIL 2
788 #define ADIS16480_DIAG_STAT_XACCL_FAIL 3
789 #define ADIS16480_DIAG_STAT_YACCL_FAIL 4
790 #define ADIS16480_DIAG_STAT_ZACCL_FAIL 5
791 #define ADIS16480_DIAG_STAT_XMAGN_FAIL 8
792 #define ADIS16480_DIAG_STAT_YMAGN_FAIL 9
793 #define ADIS16480_DIAG_STAT_ZMAGN_FAIL 10
794 #define ADIS16480_DIAG_STAT_BARO_FAIL 11
795
796 static const char * const adis16480_status_error_msgs[] = {
797         [ADIS16480_DIAG_STAT_XGYRO_FAIL] = "X-axis gyroscope self-test failure",
798         [ADIS16480_DIAG_STAT_YGYRO_FAIL] = "Y-axis gyroscope self-test failure",
799         [ADIS16480_DIAG_STAT_ZGYRO_FAIL] = "Z-axis gyroscope self-test failure",
800         [ADIS16480_DIAG_STAT_XACCL_FAIL] = "X-axis accelerometer self-test failure",
801         [ADIS16480_DIAG_STAT_YACCL_FAIL] = "Y-axis accelerometer self-test failure",
802         [ADIS16480_DIAG_STAT_ZACCL_FAIL] = "Z-axis accelerometer self-test failure",
803         [ADIS16480_DIAG_STAT_XMAGN_FAIL] = "X-axis magnetometer self-test failure",
804         [ADIS16480_DIAG_STAT_YMAGN_FAIL] = "Y-axis magnetometer self-test failure",
805         [ADIS16480_DIAG_STAT_ZMAGN_FAIL] = "Z-axis magnetometer self-test failure",
806         [ADIS16480_DIAG_STAT_BARO_FAIL] = "Barometer self-test failure",
807 };
808
809 static const struct adis_data adis16480_data = {
810         .diag_stat_reg = ADIS16480_REG_DIAG_STS,
811         .glob_cmd_reg = ADIS16480_REG_GLOB_CMD,
812         .has_paging = true,
813
814         .read_delay = 5,
815         .write_delay = 5,
816
817         .status_error_msgs = adis16480_status_error_msgs,
818         .status_error_mask = BIT(ADIS16480_DIAG_STAT_XGYRO_FAIL) |
819                 BIT(ADIS16480_DIAG_STAT_YGYRO_FAIL) |
820                 BIT(ADIS16480_DIAG_STAT_ZGYRO_FAIL) |
821                 BIT(ADIS16480_DIAG_STAT_XACCL_FAIL) |
822                 BIT(ADIS16480_DIAG_STAT_YACCL_FAIL) |
823                 BIT(ADIS16480_DIAG_STAT_ZACCL_FAIL) |
824                 BIT(ADIS16480_DIAG_STAT_XMAGN_FAIL) |
825                 BIT(ADIS16480_DIAG_STAT_YMAGN_FAIL) |
826                 BIT(ADIS16480_DIAG_STAT_ZMAGN_FAIL) |
827                 BIT(ADIS16480_DIAG_STAT_BARO_FAIL),
828
829         .enable_irq = adis16480_enable_irq,
830 };
831
832 static int adis16480_probe(struct spi_device *spi)
833 {
834         const struct spi_device_id *id = spi_get_device_id(spi);
835         struct iio_dev *indio_dev;
836         struct adis16480 *st;
837         int ret;
838
839         indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
840         if (indio_dev == NULL)
841                 return -ENOMEM;
842
843         spi_set_drvdata(spi, indio_dev);
844
845         st = iio_priv(indio_dev);
846
847         st->chip_info = &adis16480_chip_info[id->driver_data];
848         indio_dev->dev.parent = &spi->dev;
849         indio_dev->name = spi_get_device_id(spi)->name;
850         indio_dev->channels = st->chip_info->channels;
851         indio_dev->num_channels = st->chip_info->num_channels;
852         indio_dev->info = &adis16480_info;
853         indio_dev->modes = INDIO_DIRECT_MODE;
854
855         ret = adis_init(&st->adis, indio_dev, spi, &adis16480_data);
856         if (ret)
857                 return ret;
858
859         ret = adis_setup_buffer_and_trigger(&st->adis, indio_dev, NULL);
860         if (ret)
861                 return ret;
862
863         ret = adis16480_initial_setup(indio_dev);
864         if (ret)
865                 goto error_cleanup_buffer;
866
867         ret = iio_device_register(indio_dev);
868         if (ret)
869                 goto error_stop_device;
870
871         adis16480_debugfs_init(indio_dev);
872
873         return 0;
874
875 error_stop_device:
876         adis16480_stop_device(indio_dev);
877 error_cleanup_buffer:
878         adis_cleanup_buffer_and_trigger(&st->adis, indio_dev);
879         return ret;
880 }
881
882 static int adis16480_remove(struct spi_device *spi)
883 {
884         struct iio_dev *indio_dev = spi_get_drvdata(spi);
885         struct adis16480 *st = iio_priv(indio_dev);
886
887         iio_device_unregister(indio_dev);
888         adis16480_stop_device(indio_dev);
889
890         adis_cleanup_buffer_and_trigger(&st->adis, indio_dev);
891
892         return 0;
893 }
894
895 static const struct spi_device_id adis16480_ids[] = {
896         { "adis16375", ADIS16375 },
897         { "adis16480", ADIS16480 },
898         { "adis16485", ADIS16485 },
899         { "adis16488", ADIS16488 },
900         { }
901 };
902 MODULE_DEVICE_TABLE(spi, adis16480_ids);
903
904 static struct spi_driver adis16480_driver = {
905         .driver = {
906                 .name = "adis16480",
907         },
908         .id_table = adis16480_ids,
909         .probe = adis16480_probe,
910         .remove = adis16480_remove,
911 };
912 module_spi_driver(adis16480_driver);
913
914 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
915 MODULE_DESCRIPTION("Analog Devices ADIS16480 IMU driver");
916 MODULE_LICENSE("GPL v2");