Commit | Line | Data |
---|---|---|
ccd2b52f LPC |
1 | /* |
2 | * Common library for ADIS16XXX devices | |
3 | * | |
4 | * Copyright 2012 Analog Devices Inc. | |
5 | * Author: Lars-Peter Clausen <lars@metafoo.de> | |
6 | * | |
7 | * Licensed under the GPL-2 or later. | |
8 | */ | |
9 | ||
10 | #include <linux/delay.h> | |
11 | #include <linux/mutex.h> | |
12 | #include <linux/device.h> | |
13 | #include <linux/kernel.h> | |
14 | #include <linux/spi/spi.h> | |
15 | #include <linux/slab.h> | |
16 | #include <linux/sysfs.h> | |
17 | #include <linux/module.h> | |
18 | #include <asm/unaligned.h> | |
19 | ||
20 | #include <linux/iio/iio.h> | |
21 | #include <linux/iio/sysfs.h> | |
22 | #include <linux/iio/buffer.h> | |
ec04cb04 | 23 | #include <linux/iio/imu/adis.h> |
ccd2b52f LPC |
24 | |
25 | #define ADIS_MSC_CTRL_DATA_RDY_EN BIT(2) | |
26 | #define ADIS_MSC_CTRL_DATA_RDY_POL_HIGH BIT(1) | |
27 | #define ADIS_MSC_CTRL_DATA_RDY_DIO2 BIT(0) | |
28 | #define ADIS_GLOB_CMD_SW_RESET BIT(7) | |
29 | ||
57a1228a LPC |
30 | int adis_write_reg(struct adis *adis, unsigned int reg, |
31 | unsigned int value, unsigned int size) | |
ccd2b52f | 32 | { |
484a0bf0 | 33 | unsigned int page = reg / ADIS_PAGE_SIZE; |
57a1228a | 34 | int ret, i; |
ccd2b52f LPC |
35 | struct spi_message msg; |
36 | struct spi_transfer xfers[] = { | |
37 | { | |
38 | .tx_buf = adis->tx, | |
39 | .bits_per_word = 8, | |
40 | .len = 2, | |
41 | .cs_change = 1, | |
42 | .delay_usecs = adis->data->write_delay, | |
43 | }, { | |
44 | .tx_buf = adis->tx + 2, | |
45 | .bits_per_word = 8, | |
46 | .len = 2, | |
57a1228a LPC |
47 | .cs_change = 1, |
48 | .delay_usecs = adis->data->write_delay, | |
49 | }, { | |
50 | .tx_buf = adis->tx + 4, | |
51 | .bits_per_word = 8, | |
52 | .len = 2, | |
53 | .cs_change = 1, | |
54 | .delay_usecs = adis->data->write_delay, | |
55 | }, { | |
56 | .tx_buf = adis->tx + 6, | |
57 | .bits_per_word = 8, | |
58 | .len = 2, | |
ccd2b52f | 59 | .delay_usecs = adis->data->write_delay, |
484a0bf0 LPC |
60 | }, { |
61 | .tx_buf = adis->tx + 8, | |
62 | .bits_per_word = 8, | |
63 | .len = 2, | |
64 | .delay_usecs = adis->data->write_delay, | |
ccd2b52f LPC |
65 | }, |
66 | }; | |
67 | ||
68 | mutex_lock(&adis->txrx_lock); | |
ccd2b52f LPC |
69 | |
70 | spi_message_init(&msg); | |
484a0bf0 LPC |
71 | |
72 | if (adis->current_page != page) { | |
73 | adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID); | |
74 | adis->tx[1] = page; | |
75 | spi_message_add_tail(&xfers[0], &msg); | |
76 | } | |
77 | ||
57a1228a LPC |
78 | switch (size) { |
79 | case 4: | |
484a0bf0 LPC |
80 | adis->tx[8] = ADIS_WRITE_REG(reg + 3); |
81 | adis->tx[9] = (value >> 24) & 0xff; | |
82 | adis->tx[6] = ADIS_WRITE_REG(reg + 2); | |
83 | adis->tx[7] = (value >> 16) & 0xff; | |
57a1228a | 84 | case 2: |
484a0bf0 LPC |
85 | adis->tx[4] = ADIS_WRITE_REG(reg + 1); |
86 | adis->tx[5] = (value >> 8) & 0xff; | |
57a1228a | 87 | case 1: |
484a0bf0 LPC |
88 | adis->tx[2] = ADIS_WRITE_REG(reg); |
89 | adis->tx[3] = value & 0xff; | |
57a1228a LPC |
90 | break; |
91 | default: | |
92 | ret = -EINVAL; | |
93 | goto out_unlock; | |
94 | } | |
95 | ||
484a0bf0 | 96 | xfers[size].cs_change = 0; |
57a1228a | 97 | |
484a0bf0 | 98 | for (i = 1; i <= size; i++) |
57a1228a LPC |
99 | spi_message_add_tail(&xfers[i], &msg); |
100 | ||
ccd2b52f | 101 | ret = spi_sync(adis->spi, &msg); |
57a1228a LPC |
102 | if (ret) { |
103 | dev_err(&adis->spi->dev, "Failed to write register 0x%02X: %d\n", | |
104 | reg, ret); | |
484a0bf0 LPC |
105 | } else { |
106 | adis->current_page = page; | |
57a1228a LPC |
107 | } |
108 | ||
109 | out_unlock: | |
ccd2b52f LPC |
110 | mutex_unlock(&adis->txrx_lock); |
111 | ||
112 | return ret; | |
113 | } | |
57a1228a | 114 | EXPORT_SYMBOL_GPL(adis_write_reg); |
ccd2b52f LPC |
115 | |
116 | /** | |
57a1228a | 117 | * adis_read_reg() - read 2 bytes from a 16-bit register |
ccd2b52f LPC |
118 | * @adis: The adis device |
119 | * @reg: The address of the lower of the two registers | |
120 | * @val: The value read back from the device | |
121 | */ | |
57a1228a LPC |
122 | int adis_read_reg(struct adis *adis, unsigned int reg, |
123 | unsigned int *val, unsigned int size) | |
ccd2b52f | 124 | { |
484a0bf0 | 125 | unsigned int page = reg / ADIS_PAGE_SIZE; |
ccd2b52f LPC |
126 | struct spi_message msg; |
127 | int ret; | |
128 | struct spi_transfer xfers[] = { | |
129 | { | |
130 | .tx_buf = adis->tx, | |
131 | .bits_per_word = 8, | |
132 | .len = 2, | |
133 | .cs_change = 1, | |
484a0bf0 | 134 | .delay_usecs = adis->data->write_delay, |
ccd2b52f | 135 | }, { |
57a1228a | 136 | .tx_buf = adis->tx + 2, |
484a0bf0 LPC |
137 | .bits_per_word = 8, |
138 | .len = 2, | |
139 | .cs_change = 1, | |
140 | .delay_usecs = adis->data->read_delay, | |
141 | }, { | |
142 | .tx_buf = adis->tx + 4, | |
ccd2b52f LPC |
143 | .rx_buf = adis->rx, |
144 | .bits_per_word = 8, | |
145 | .len = 2, | |
57a1228a LPC |
146 | .cs_change = 1, |
147 | .delay_usecs = adis->data->read_delay, | |
148 | }, { | |
149 | .rx_buf = adis->rx + 2, | |
150 | .bits_per_word = 8, | |
151 | .len = 2, | |
ccd2b52f LPC |
152 | .delay_usecs = adis->data->read_delay, |
153 | }, | |
154 | }; | |
155 | ||
156 | mutex_lock(&adis->txrx_lock); | |
ccd2b52f | 157 | spi_message_init(&msg); |
57a1228a | 158 | |
484a0bf0 LPC |
159 | if (adis->current_page != page) { |
160 | adis->tx[0] = ADIS_WRITE_REG(ADIS_REG_PAGE_ID); | |
161 | adis->tx[1] = page; | |
162 | spi_message_add_tail(&xfers[0], &msg); | |
163 | } | |
164 | ||
57a1228a LPC |
165 | switch (size) { |
166 | case 4: | |
484a0bf0 | 167 | adis->tx[2] = ADIS_READ_REG(reg + 2); |
57a1228a LPC |
168 | adis->tx[3] = 0; |
169 | spi_message_add_tail(&xfers[1], &msg); | |
484a0bf0 LPC |
170 | case 2: |
171 | adis->tx[4] = ADIS_READ_REG(reg); | |
172 | adis->tx[5] = 0; | |
57a1228a | 173 | spi_message_add_tail(&xfers[2], &msg); |
484a0bf0 | 174 | spi_message_add_tail(&xfers[3], &msg); |
57a1228a LPC |
175 | break; |
176 | default: | |
177 | ret = -EINVAL; | |
178 | goto out_unlock; | |
179 | } | |
180 | ||
ccd2b52f LPC |
181 | ret = spi_sync(adis->spi, &msg); |
182 | if (ret) { | |
57a1228a | 183 | dev_err(&adis->spi->dev, "Failed to read register 0x%02X: %d\n", |
ccd2b52f | 184 | reg, ret); |
57a1228a | 185 | goto out_unlock; |
484a0bf0 LPC |
186 | } else { |
187 | adis->current_page = page; | |
ccd2b52f | 188 | } |
ccd2b52f | 189 | |
57a1228a LPC |
190 | switch (size) { |
191 | case 4: | |
192 | *val = get_unaligned_be32(adis->rx); | |
193 | break; | |
194 | case 2: | |
195 | *val = get_unaligned_be16(adis->rx + 2); | |
196 | break; | |
197 | } | |
198 | ||
199 | out_unlock: | |
ccd2b52f | 200 | mutex_unlock(&adis->txrx_lock); |
57a1228a | 201 | |
ccd2b52f LPC |
202 | return ret; |
203 | } | |
57a1228a | 204 | EXPORT_SYMBOL_GPL(adis_read_reg); |
ccd2b52f | 205 | |
78026a6f LPC |
206 | #ifdef CONFIG_DEBUG_FS |
207 | ||
208 | int adis_debugfs_reg_access(struct iio_dev *indio_dev, | |
209 | unsigned int reg, unsigned int writeval, unsigned int *readval) | |
210 | { | |
211 | struct adis *adis = iio_device_get_drvdata(indio_dev); | |
212 | ||
213 | if (readval) { | |
214 | uint16_t val16; | |
215 | int ret; | |
216 | ||
217 | ret = adis_read_reg_16(adis, reg, &val16); | |
218 | *readval = val16; | |
219 | ||
220 | return ret; | |
221 | } else { | |
222 | return adis_write_reg_16(adis, reg, writeval); | |
223 | } | |
224 | } | |
225 | EXPORT_SYMBOL(adis_debugfs_reg_access); | |
226 | ||
227 | #endif | |
228 | ||
ccd2b52f LPC |
229 | /** |
230 | * adis_enable_irq() - Enable or disable data ready IRQ | |
231 | * @adis: The adis device | |
232 | * @enable: Whether to enable the IRQ | |
233 | * | |
234 | * Returns 0 on success, negative error code otherwise | |
235 | */ | |
236 | int adis_enable_irq(struct adis *adis, bool enable) | |
237 | { | |
238 | int ret = 0; | |
239 | uint16_t msc; | |
240 | ||
2f3abe6c LPC |
241 | if (adis->data->enable_irq) |
242 | return adis->data->enable_irq(adis, enable); | |
243 | ||
ccd2b52f LPC |
244 | ret = adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc); |
245 | if (ret) | |
246 | goto error_ret; | |
247 | ||
248 | msc |= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH; | |
249 | msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2; | |
250 | if (enable) | |
251 | msc |= ADIS_MSC_CTRL_DATA_RDY_EN; | |
252 | else | |
253 | msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN; | |
254 | ||
255 | ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc); | |
256 | ||
257 | error_ret: | |
258 | return ret; | |
259 | } | |
260 | EXPORT_SYMBOL(adis_enable_irq); | |
261 | ||
262 | /** | |
263 | * adis_check_status() - Check the device for error conditions | |
264 | * @adis: The adis device | |
265 | * | |
266 | * Returns 0 on success, a negative error code otherwise | |
267 | */ | |
268 | int adis_check_status(struct adis *adis) | |
269 | { | |
270 | uint16_t status; | |
271 | int ret; | |
272 | int i; | |
273 | ||
274 | ret = adis_read_reg_16(adis, adis->data->diag_stat_reg, &status); | |
275 | if (ret < 0) | |
276 | return ret; | |
277 | ||
278 | status &= adis->data->status_error_mask; | |
279 | ||
280 | if (status == 0) | |
281 | return 0; | |
282 | ||
283 | for (i = 0; i < 16; ++i) { | |
284 | if (status & BIT(i)) { | |
285 | dev_err(&adis->spi->dev, "%s.\n", | |
286 | adis->data->status_error_msgs[i]); | |
287 | } | |
288 | } | |
289 | ||
290 | return -EIO; | |
291 | } | |
292 | EXPORT_SYMBOL_GPL(adis_check_status); | |
293 | ||
294 | /** | |
295 | * adis_reset() - Reset the device | |
296 | * @adis: The adis device | |
297 | * | |
298 | * Returns 0 on success, a negative error code otherwise | |
299 | */ | |
300 | int adis_reset(struct adis *adis) | |
301 | { | |
302 | int ret; | |
303 | ||
304 | ret = adis_write_reg_8(adis, adis->data->glob_cmd_reg, | |
305 | ADIS_GLOB_CMD_SW_RESET); | |
306 | if (ret) | |
307 | dev_err(&adis->spi->dev, "Failed to reset device: %d\n", ret); | |
308 | ||
309 | return ret; | |
310 | } | |
311 | EXPORT_SYMBOL_GPL(adis_reset); | |
312 | ||
313 | static int adis_self_test(struct adis *adis) | |
314 | { | |
315 | int ret; | |
316 | ||
317 | ret = adis_write_reg_16(adis, adis->data->msc_ctrl_reg, | |
318 | adis->data->self_test_mask); | |
319 | if (ret) { | |
320 | dev_err(&adis->spi->dev, "Failed to initiate self test: %d\n", | |
321 | ret); | |
322 | return ret; | |
323 | } | |
324 | ||
325 | msleep(adis->data->startup_delay); | |
326 | ||
327 | return adis_check_status(adis); | |
328 | } | |
329 | ||
330 | /** | |
331 | * adis_inital_startup() - Performs device self-test | |
332 | * @adis: The adis device | |
333 | * | |
334 | * Returns 0 if the device is operational, a negative error code otherwise. | |
335 | * | |
336 | * This function should be called early on in the device initialization sequence | |
337 | * to ensure that the device is in a sane and known state and that it is usable. | |
338 | */ | |
339 | int adis_initial_startup(struct adis *adis) | |
340 | { | |
341 | int ret; | |
342 | ||
343 | ret = adis_self_test(adis); | |
344 | if (ret) { | |
345 | dev_err(&adis->spi->dev, "Self-test failed, trying reset.\n"); | |
346 | adis_reset(adis); | |
347 | msleep(adis->data->startup_delay); | |
348 | ret = adis_self_test(adis); | |
349 | if (ret) { | |
350 | dev_err(&adis->spi->dev, "Second self-test failed, giving up.\n"); | |
351 | return ret; | |
352 | } | |
353 | } | |
354 | ||
355 | return 0; | |
356 | } | |
357 | EXPORT_SYMBOL_GPL(adis_initial_startup); | |
358 | ||
359 | /** | |
360 | * adis_single_conversion() - Performs a single sample conversion | |
361 | * @indio_dev: The IIO device | |
362 | * @chan: The IIO channel | |
363 | * @error_mask: Mask for the error bit | |
364 | * @val: Result of the conversion | |
365 | * | |
366 | * Returns IIO_VAL_INT on success, a negative error code otherwise. | |
367 | * | |
368 | * The function performs a single conversion on a given channel and post | |
369 | * processes the value accordingly to the channel spec. If a error_mask is given | |
370 | * the function will check if the mask is set in the returned raw value. If it | |
371 | * is set the function will perform a self-check. If the device does not report | |
372 | * a error bit in the channels raw value set error_mask to 0. | |
373 | */ | |
374 | int adis_single_conversion(struct iio_dev *indio_dev, | |
375 | const struct iio_chan_spec *chan, unsigned int error_mask, int *val) | |
376 | { | |
377 | struct adis *adis = iio_device_get_drvdata(indio_dev); | |
57a1228a | 378 | unsigned int uval; |
ccd2b52f LPC |
379 | int ret; |
380 | ||
381 | mutex_lock(&indio_dev->mlock); | |
382 | ||
57a1228a LPC |
383 | ret = adis_read_reg(adis, chan->address, &uval, |
384 | chan->scan_type.storagebits / 8); | |
ccd2b52f LPC |
385 | if (ret) |
386 | goto err_unlock; | |
387 | ||
57a1228a | 388 | if (uval & error_mask) { |
ccd2b52f LPC |
389 | ret = adis_check_status(adis); |
390 | if (ret) | |
391 | goto err_unlock; | |
392 | } | |
393 | ||
394 | if (chan->scan_type.sign == 's') | |
57a1228a | 395 | *val = sign_extend32(uval, chan->scan_type.realbits - 1); |
ccd2b52f | 396 | else |
57a1228a | 397 | *val = uval & ((1 << chan->scan_type.realbits) - 1); |
ccd2b52f LPC |
398 | |
399 | ret = IIO_VAL_INT; | |
400 | err_unlock: | |
401 | mutex_unlock(&indio_dev->mlock); | |
402 | return ret; | |
403 | } | |
404 | EXPORT_SYMBOL_GPL(adis_single_conversion); | |
405 | ||
406 | /** | |
407 | * adis_init() - Initialize adis device structure | |
408 | * @adis: The adis device | |
409 | * @indio_dev: The iio device | |
410 | * @spi: The spi device | |
411 | * @data: Chip specific data | |
412 | * | |
413 | * Returns 0 on success, a negative error code otherwise. | |
414 | * | |
415 | * This function must be called, before any other adis helper function may be | |
416 | * called. | |
417 | */ | |
418 | int adis_init(struct adis *adis, struct iio_dev *indio_dev, | |
419 | struct spi_device *spi, const struct adis_data *data) | |
420 | { | |
421 | mutex_init(&adis->txrx_lock); | |
422 | adis->spi = spi; | |
423 | adis->data = data; | |
424 | iio_device_set_drvdata(indio_dev, adis); | |
425 | ||
484a0bf0 LPC |
426 | if (data->has_paging) { |
427 | /* Need to set the page before first read/write */ | |
428 | adis->current_page = -1; | |
429 | } else { | |
430 | /* Page will always be 0 */ | |
431 | adis->current_page = 0; | |
432 | } | |
433 | ||
ccd2b52f LPC |
434 | return adis_enable_irq(adis, false); |
435 | } | |
436 | EXPORT_SYMBOL_GPL(adis_init); | |
437 | ||
438 | MODULE_LICENSE("GPL"); | |
439 | MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>"); | |
440 | MODULE_DESCRIPTION("Common library code for ADIS16XXX devices"); |