Commit | Line | Data |
---|---|---|
e071f6b8 BS |
1 | /* |
2 | * ADIS16060 Wide Bandwidth Yaw Rate Gyroscope with SPI driver | |
3 | * | |
4 | * Copyright 2010 Analog Devices Inc. | |
5 | * | |
6 | * Licensed under the GPL-2 or later. | |
7 | */ | |
8 | ||
45296236 | 9 | #include <linux/module.h> |
e071f6b8 BS |
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> | |
14f98326 | 17 | |
06458e27 JC |
18 | #include <linux/iio/iio.h> |
19 | #include <linux/iio/sysfs.h> | |
e071f6b8 | 20 | |
14f98326 JC |
21 | #define ADIS16060_GYRO 0x20 /* Measure Angular Rate (Gyro) */ |
22 | #define ADIS16060_TEMP_OUT 0x10 /* Measure Temperature */ | |
23 | #define ADIS16060_AIN2 0x80 /* Measure AIN2 */ | |
24 | #define ADIS16060_AIN1 0x40 /* Measure AIN1 */ | |
25 | ||
26 | /** | |
27 | * struct adis16060_state - device instance specific data | |
28 | * @us_w: actual spi_device to write config | |
29 | * @us_r: actual spi_device to read back data | |
25985edc | 30 | * @buf: transmit or receive buffer |
14f98326 JC |
31 | * @buf_lock: mutex to protect tx and rx |
32 | **/ | |
33 | struct adis16060_state { | |
34 | struct spi_device *us_w; | |
35 | struct spi_device *us_r; | |
14f98326 JC |
36 | struct mutex buf_lock; |
37 | ||
38 | u8 buf[3] ____cacheline_aligned; | |
39 | }; | |
e071f6b8 | 40 | |
3a5952f9 | 41 | static struct iio_dev *adis16060_iio_dev; |
e071f6b8 | 42 | |
4f2ca080 | 43 | static int adis16060_spi_write(struct iio_dev *indio_dev, u8 val) |
e071f6b8 BS |
44 | { |
45 | int ret; | |
3a5952f9 | 46 | struct adis16060_state *st = iio_priv(indio_dev); |
e071f6b8 BS |
47 | |
48 | mutex_lock(&st->buf_lock); | |
14f98326 JC |
49 | st->buf[2] = val; /* The last 8 bits clocked in are latched */ |
50 | ret = spi_write(st->us_w, st->buf, 3); | |
e071f6b8 BS |
51 | mutex_unlock(&st->buf_lock); |
52 | ||
53 | return ret; | |
54 | } | |
55 | ||
4f2ca080 | 56 | static int adis16060_spi_read(struct iio_dev *indio_dev, u16 *val) |
e071f6b8 BS |
57 | { |
58 | int ret; | |
3a5952f9 | 59 | struct adis16060_state *st = iio_priv(indio_dev); |
e071f6b8 BS |
60 | |
61 | mutex_lock(&st->buf_lock); | |
62 | ||
14f98326 | 63 | ret = spi_read(st->us_r, st->buf, 3); |
e071f6b8 | 64 | |
d14ae859 JC |
65 | /* The internal successive approximation ADC begins the |
66 | * conversion process on the falling edge of MSEL1 and | |
67 | * starts to place data MSB first on the DOUT line at | |
68 | * the 6th falling edge of SCLK | |
e071f6b8 BS |
69 | */ |
70 | if (ret == 0) | |
14f98326 JC |
71 | *val = ((st->buf[0] & 0x3) << 12) | |
72 | (st->buf[1] << 4) | | |
73 | ((st->buf[2] >> 4) & 0xF); | |
e071f6b8 BS |
74 | mutex_unlock(&st->buf_lock); |
75 | ||
76 | return ret; | |
77 | } | |
78 | ||
4f2ca080 JC |
79 | static int adis16060_read_raw(struct iio_dev *indio_dev, |
80 | struct iio_chan_spec const *chan, | |
81 | int *val, int *val2, | |
82 | long mask) | |
e071f6b8 | 83 | { |
4f2ca080 JC |
84 | u16 tval = 0; |
85 | int ret; | |
14f98326 | 86 | |
4f2ca080 | 87 | switch (mask) { |
fbaff213 | 88 | case IIO_CHAN_INFO_RAW: |
4f2ca080 JC |
89 | /* Take the iio_dev status lock */ |
90 | mutex_lock(&indio_dev->mlock); | |
91 | ret = adis16060_spi_write(indio_dev, chan->address); | |
92 | if (ret < 0) { | |
93 | mutex_unlock(&indio_dev->mlock); | |
94 | return ret; | |
95 | } | |
96 | ret = adis16060_spi_read(indio_dev, &tval); | |
97 | mutex_unlock(&indio_dev->mlock); | |
98 | *val = tval; | |
99 | return IIO_VAL_INT; | |
c8a9f805 | 100 | case IIO_CHAN_INFO_OFFSET: |
4f2ca080 JC |
101 | *val = -7; |
102 | *val2 = 461117; | |
103 | return IIO_VAL_INT_PLUS_MICRO; | |
c8a9f805 | 104 | case IIO_CHAN_INFO_SCALE: |
4f2ca080 JC |
105 | *val = 0; |
106 | *val2 = 34000; | |
107 | return IIO_VAL_INT_PLUS_MICRO; | |
108 | } | |
e071f6b8 | 109 | |
4f2ca080 | 110 | return -EINVAL; |
e071f6b8 BS |
111 | } |
112 | ||
6fe8135f | 113 | static const struct iio_info adis16060_info = { |
4f2ca080 | 114 | .read_raw = &adis16060_read_raw, |
6fe8135f JC |
115 | .driver_module = THIS_MODULE, |
116 | }; | |
117 | ||
4f2ca080 JC |
118 | static const struct iio_chan_spec adis16060_channels[] = { |
119 | { | |
41ea040c | 120 | .type = IIO_ANGL_VEL, |
4f2ca080 JC |
121 | .modified = 1, |
122 | .channel2 = IIO_MOD_Z, | |
cdcb0eab | 123 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
4f2ca080 JC |
124 | .address = ADIS16060_GYRO, |
125 | }, { | |
6835cb6b | 126 | .type = IIO_VOLTAGE, |
4f2ca080 JC |
127 | .indexed = 1, |
128 | .channel = 0, | |
cdcb0eab | 129 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
4f2ca080 JC |
130 | .address = ADIS16060_AIN1, |
131 | }, { | |
6835cb6b | 132 | .type = IIO_VOLTAGE, |
4f2ca080 JC |
133 | .indexed = 1, |
134 | .channel = 1, | |
cdcb0eab | 135 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), |
4f2ca080 JC |
136 | .address = ADIS16060_AIN2, |
137 | }, { | |
138 | .type = IIO_TEMP, | |
139 | .indexed = 1, | |
140 | .channel = 0, | |
cdcb0eab JC |
141 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | |
142 | BIT(IIO_CHAN_INFO_OFFSET) | BIT(IIO_CHAN_INFO_SCALE), | |
4f2ca080 JC |
143 | .address = ADIS16060_TEMP_OUT, |
144 | } | |
145 | }; | |
146 | ||
4ae1c61f | 147 | static int adis16060_r_probe(struct spi_device *spi) |
e071f6b8 | 148 | { |
26d25ae3 | 149 | int ret; |
3a5952f9 JC |
150 | struct adis16060_state *st; |
151 | struct iio_dev *indio_dev; | |
152 | ||
153 | /* setup the industrialio driver allocated elements */ | |
7cbb7537 | 154 | indio_dev = iio_device_alloc(sizeof(*st)); |
3a5952f9 JC |
155 | if (indio_dev == NULL) { |
156 | ret = -ENOMEM; | |
e071f6b8 BS |
157 | goto error_ret; |
158 | } | |
159 | /* this is only used for removal purposes */ | |
3a5952f9 JC |
160 | spi_set_drvdata(spi, indio_dev); |
161 | st = iio_priv(indio_dev); | |
e071f6b8 BS |
162 | st->us_r = spi; |
163 | mutex_init(&st->buf_lock); | |
e071f6b8 | 164 | |
4f2ca080 | 165 | indio_dev->name = spi->dev.driver->name; |
3a5952f9 JC |
166 | indio_dev->dev.parent = &spi->dev; |
167 | indio_dev->info = &adis16060_info; | |
168 | indio_dev->modes = INDIO_DIRECT_MODE; | |
4f2ca080 JC |
169 | indio_dev->channels = adis16060_channels; |
170 | indio_dev->num_channels = ARRAY_SIZE(adis16060_channels); | |
e071f6b8 | 171 | |
3a5952f9 | 172 | ret = iio_device_register(indio_dev); |
e071f6b8 | 173 | if (ret) |
d14ae859 | 174 | goto error_free_dev; |
e071f6b8 | 175 | |
3a5952f9 | 176 | adis16060_iio_dev = indio_dev; |
e071f6b8 BS |
177 | return 0; |
178 | ||
e071f6b8 | 179 | error_free_dev: |
7cbb7537 | 180 | iio_device_free(indio_dev); |
e071f6b8 BS |
181 | error_ret: |
182 | return ret; | |
183 | } | |
184 | ||
185 | /* fixme, confirm ordering in this function */ | |
447d4f29 | 186 | static int adis16060_r_remove(struct spi_device *spi) |
e071f6b8 | 187 | { |
3a5952f9 | 188 | iio_device_unregister(spi_get_drvdata(spi)); |
7cbb7537 | 189 | iio_device_free(spi_get_drvdata(spi)); |
e071f6b8 BS |
190 | |
191 | return 0; | |
192 | } | |
193 | ||
4ae1c61f | 194 | static int adis16060_w_probe(struct spi_device *spi) |
e071f6b8 BS |
195 | { |
196 | int ret; | |
3a5952f9 JC |
197 | struct iio_dev *indio_dev = adis16060_iio_dev; |
198 | struct adis16060_state *st; | |
199 | if (!indio_dev) { | |
e071f6b8 BS |
200 | ret = -ENODEV; |
201 | goto error_ret; | |
202 | } | |
3a5952f9 JC |
203 | st = iio_priv(indio_dev); |
204 | spi_set_drvdata(spi, indio_dev); | |
e071f6b8 BS |
205 | st->us_w = spi; |
206 | return 0; | |
207 | ||
208 | error_ret: | |
209 | return ret; | |
210 | } | |
211 | ||
447d4f29 | 212 | static int adis16060_w_remove(struct spi_device *spi) |
e071f6b8 BS |
213 | { |
214 | return 0; | |
215 | } | |
216 | ||
217 | static struct spi_driver adis16060_r_driver = { | |
218 | .driver = { | |
219 | .name = "adis16060_r", | |
220 | .owner = THIS_MODULE, | |
221 | }, | |
222 | .probe = adis16060_r_probe, | |
e543acf0 | 223 | .remove = adis16060_r_remove, |
e071f6b8 BS |
224 | }; |
225 | ||
226 | static struct spi_driver adis16060_w_driver = { | |
227 | .driver = { | |
228 | .name = "adis16060_w", | |
229 | .owner = THIS_MODULE, | |
230 | }, | |
231 | .probe = adis16060_w_probe, | |
e543acf0 | 232 | .remove = adis16060_w_remove, |
e071f6b8 BS |
233 | }; |
234 | ||
235 | static __init int adis16060_init(void) | |
236 | { | |
237 | int ret; | |
238 | ||
239 | ret = spi_register_driver(&adis16060_r_driver); | |
240 | if (ret < 0) | |
241 | return ret; | |
242 | ||
243 | ret = spi_register_driver(&adis16060_w_driver); | |
244 | if (ret < 0) { | |
245 | spi_unregister_driver(&adis16060_r_driver); | |
246 | return ret; | |
247 | } | |
248 | ||
249 | return 0; | |
250 | } | |
251 | module_init(adis16060_init); | |
252 | ||
253 | static __exit void adis16060_exit(void) | |
254 | { | |
255 | spi_unregister_driver(&adis16060_w_driver); | |
256 | spi_unregister_driver(&adis16060_r_driver); | |
257 | } | |
258 | module_exit(adis16060_exit); | |
259 | ||
260 | MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>"); | |
d14ae859 | 261 | MODULE_DESCRIPTION("Analog Devices ADIS16060 Yaw Rate Gyroscope Driver"); |
e071f6b8 | 262 | MODULE_LICENSE("GPL v2"); |