iio: accel: kxsd9: Fix raw read return
[pandora-kernel.git] / drivers / staging / iio / accel / kxsd9.c
1 /*
2  * kxsd9.c      simple support for the Kionix KXSD9 3D
3  *              accelerometer.
4  *
5  * Copyright (c) 2008-2009 Jonathan Cameron <jic23@cam.ac.uk>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  * The i2c interface is very similar, so shouldn't be a problem once
12  * I have a suitable wire made up.
13  *
14  * TODO:        Support the motion detector
15  *              Uses register address incrementing so could have a
16  *              heavily optimized ring buffer access function.
17  */
18
19 #include <linux/device.h>
20 #include <linux/kernel.h>
21 #include <linux/spi/spi.h>
22 #include <linux/sysfs.h>
23 #include <linux/slab.h>
24 #include <linux/module.h>
25
26 #include "../iio.h"
27 #include "../sysfs.h"
28
29 #define KXSD9_REG_X             0x00
30 #define KXSD9_REG_Y             0x02
31 #define KXSD9_REG_Z             0x04
32 #define KXSD9_REG_AUX           0x06
33 #define KXSD9_REG_RESET         0x0a
34 #define KXSD9_REG_CTRL_C        0x0c
35
36 #define KXSD9_FS_MASK           0x03
37
38 #define KXSD9_REG_CTRL_B        0x0d
39 #define KXSD9_REG_CTRL_A        0x0e
40
41 #define KXSD9_READ(a) (0x80 | (a))
42 #define KXSD9_WRITE(a) (a)
43
44 #define KXSD9_STATE_RX_SIZE 2
45 #define KXSD9_STATE_TX_SIZE 2
46 /**
47  * struct kxsd9_state - device related storage
48  * @buf_lock:   protect the rx and tx buffers.
49  * @us:         spi device
50  * @rx:         single rx buffer storage
51  * @tx:         single tx buffer storage
52  **/
53 struct kxsd9_state {
54         struct mutex buf_lock;
55         struct spi_device *us;
56         u8 rx[KXSD9_STATE_RX_SIZE] ____cacheline_aligned;
57         u8 tx[KXSD9_STATE_TX_SIZE];
58 };
59
60 #define KXSD9_SCALE_2G "0.011978"
61 #define KXSD9_SCALE_4G "0.023927"
62 #define KXSD9_SCALE_6G "0.035934"
63 #define KXSD9_SCALE_8G "0.047853"
64
65 /* reverse order */
66 static const int kxsd9_micro_scales[4] = { 47853, 35934, 23927, 11978 };
67
68 static int kxsd9_write_scale(struct iio_dev *indio_dev, int micro)
69 {
70         int ret, i;
71         struct kxsd9_state *st = iio_priv(indio_dev);
72         bool foundit = false;
73
74         for (i = 0; i < 4; i++)
75                 if (micro == kxsd9_micro_scales[i]) {
76                         foundit = true;
77                         break;
78                 }
79         if (!foundit)
80                 return -EINVAL;
81
82         mutex_lock(&st->buf_lock);
83         ret = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
84         if (ret < 0)
85                 goto error_ret;
86         st->tx[0] = KXSD9_WRITE(KXSD9_REG_CTRL_C);
87         st->tx[1] = (ret & ~KXSD9_FS_MASK) | i;
88
89         ret = spi_write(st->us, st->tx, 2);
90 error_ret:
91         mutex_unlock(&st->buf_lock);
92         return ret;
93 }
94
95 static int kxsd9_read(struct iio_dev *indio_dev, u8 address)
96 {
97         struct spi_message msg;
98         int ret;
99         struct kxsd9_state *st = iio_priv(indio_dev);
100         struct spi_transfer xfers[] = {
101                 {
102                         .bits_per_word = 8,
103                         .len = 1,
104                         .delay_usecs = 200,
105                         .tx_buf = st->tx,
106                 }, {
107                         .bits_per_word = 8,
108                         .len = 2,
109                         .rx_buf = st->rx,
110                 },
111         };
112
113         mutex_lock(&st->buf_lock);
114         st->tx[0] = KXSD9_READ(address);
115         spi_message_init(&msg);
116         spi_message_add_tail(&xfers[0], &msg);
117         spi_message_add_tail(&xfers[1], &msg);
118         ret = spi_sync(st->us, &msg);
119         if (ret)
120                 return ret;
121         return (((u16)(st->rx[0])) << 8) | (st->rx[1] & 0xF0);
122 }
123
124 static IIO_CONST_ATTR(accel_scale_available,
125                 KXSD9_SCALE_2G " "
126                 KXSD9_SCALE_4G " "
127                 KXSD9_SCALE_6G " "
128                 KXSD9_SCALE_8G);
129
130 static struct attribute *kxsd9_attributes[] = {
131         &iio_const_attr_accel_scale_available.dev_attr.attr,
132         NULL,
133 };
134
135 static int kxsd9_write_raw(struct iio_dev *indio_dev,
136                            struct iio_chan_spec const *chan,
137                            int val,
138                            int val2,
139                            long mask)
140 {
141         int ret = -EINVAL;
142
143         if (mask == (1 << IIO_CHAN_INFO_SCALE_SHARED)) {
144                 /* Check no integer component */
145                 if (val)
146                         return -EINVAL;
147                 ret = kxsd9_write_scale(indio_dev, val2);
148         }
149
150         return ret;
151 }
152
153 static int kxsd9_read_raw(struct iio_dev *indio_dev,
154                           struct iio_chan_spec const *chan,
155                           int *val, int *val2, long mask)
156 {
157         int ret = -EINVAL;
158         struct kxsd9_state *st = iio_priv(indio_dev);
159
160         switch (mask) {
161         case 0:
162                 ret = kxsd9_read(indio_dev, chan->address);
163                 if (ret < 0)
164                         goto error_ret;
165                 *val = ret;
166                 ret = IIO_VAL_INT;
167                 break;
168         case (1 << IIO_CHAN_INFO_SCALE_SHARED):
169                 ret = spi_w8r8(st->us, KXSD9_READ(KXSD9_REG_CTRL_C));
170                 if (ret < 0)
171                         goto error_ret;
172                 *val2 = kxsd9_micro_scales[ret & KXSD9_FS_MASK];
173                 ret = IIO_VAL_INT_PLUS_MICRO;
174                 break;
175         };
176
177 error_ret:
178         return ret;
179 };
180 #define KXSD9_ACCEL_CHAN(axis)                                          \
181         {                                                               \
182                 .type = IIO_ACCEL,                                      \
183                 .modified = 1,                                          \
184                 .channel2 = IIO_MOD_##axis,                             \
185                 .info_mask = 1 << IIO_CHAN_INFO_SCALE_SHARED,           \
186                 .address = KXSD9_REG_##axis,                            \
187         }
188
189 static struct iio_chan_spec kxsd9_channels[] = {
190         KXSD9_ACCEL_CHAN(X), KXSD9_ACCEL_CHAN(Y), KXSD9_ACCEL_CHAN(Z),
191         {
192                 .type = IIO_VOLTAGE,
193                 .indexed = 1,
194                 .address = KXSD9_REG_AUX,
195         }
196 };
197
198 static const struct attribute_group kxsd9_attribute_group = {
199         .attrs = kxsd9_attributes,
200 };
201
202 static int __devinit kxsd9_power_up(struct kxsd9_state *st)
203 {
204         int ret;
205
206         st->tx[0] = 0x0d;
207         st->tx[1] = 0x40;
208         ret = spi_write(st->us, st->tx, 2);
209         if (ret)
210                 return ret;
211
212         st->tx[0] = 0x0c;
213         st->tx[1] = 0x9b;
214         return spi_write(st->us, st->tx, 2);
215 };
216
217 static const struct iio_info kxsd9_info = {
218         .read_raw = &kxsd9_read_raw,
219         .write_raw = &kxsd9_write_raw,
220         .attrs = &kxsd9_attribute_group,
221         .driver_module = THIS_MODULE,
222 };
223
224 static int __devinit kxsd9_probe(struct spi_device *spi)
225 {
226         struct iio_dev *indio_dev;
227         struct kxsd9_state *st;
228         int ret = 0;
229
230         indio_dev = iio_allocate_device(sizeof(*st));
231         if (indio_dev == NULL) {
232                 ret = -ENOMEM;
233                 goto error_ret;
234         }
235         st = iio_priv(indio_dev);
236         spi_set_drvdata(spi, indio_dev);
237
238         st->us = spi;
239         mutex_init(&st->buf_lock);
240         indio_dev->channels = kxsd9_channels;
241         indio_dev->num_channels = ARRAY_SIZE(kxsd9_channels);
242         indio_dev->name = spi_get_device_id(spi)->name;
243         indio_dev->dev.parent = &spi->dev;
244         indio_dev->info = &kxsd9_info;
245         indio_dev->modes = INDIO_DIRECT_MODE;
246
247         ret = iio_device_register(indio_dev);
248         if (ret)
249                 goto error_free_dev;
250
251         spi->mode = SPI_MODE_0;
252         spi_setup(spi);
253         kxsd9_power_up(st);
254
255         return 0;
256
257 error_free_dev:
258         iio_free_device(indio_dev);
259 error_ret:
260         return ret;
261 }
262
263 static int __devexit kxsd9_remove(struct spi_device *spi)
264 {
265         iio_device_unregister(spi_get_drvdata(spi));
266         iio_free_device(spi_get_drvdata(spi));
267
268         return 0;
269 }
270
271 static const struct spi_device_id kxsd9_id[] = {
272         {"kxsd9", 0}
273 };
274
275 static struct spi_driver kxsd9_driver = {
276         .driver = {
277                 .name = "kxsd9",
278                 .owner = THIS_MODULE,
279         },
280         .probe = kxsd9_probe,
281         .remove = __devexit_p(kxsd9_remove),
282         .id_table = kxsd9_id,
283 };
284
285 static __init int kxsd9_spi_init(void)
286 {
287         return spi_register_driver(&kxsd9_driver);
288 }
289 module_init(kxsd9_spi_init);
290
291 static __exit void kxsd9_spi_exit(void)
292 {
293         spi_unregister_driver(&kxsd9_driver);
294 }
295 module_exit(kxsd9_spi_exit);
296
297 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
298 MODULE_DESCRIPTION("Kionix KXSD9 SPI driver");
299 MODULE_LICENSE("GPL v2");