Commit | Line | Data |
---|---|---|
bf2a5600 TB |
1 | /** |
2 | * BMA220 Digital triaxial acceleration sensor driver | |
3 | * | |
4 | * Copyright (c) 2016, Intel Corporation. | |
5 | * | |
6 | * This file is subject to the terms and conditions of version 2 of | |
7 | * the GNU General Public License. See the file COPYING in the main | |
8 | * directory of this archive for more details. | |
9 | */ | |
10 | ||
11 | #include <linux/acpi.h> | |
12 | #include <linux/kernel.h> | |
13 | #include <linux/module.h> | |
194dc4c7 | 14 | #include <linux/iio/buffer.h> |
bf2a5600 TB |
15 | #include <linux/iio/iio.h> |
16 | #include <linux/iio/sysfs.h> | |
17 | #include <linux/spi/spi.h> | |
194dc4c7 TB |
18 | #include <linux/iio/trigger_consumer.h> |
19 | #include <linux/iio/triggered_buffer.h> | |
bf2a5600 TB |
20 | |
21 | #define BMA220_REG_ID 0x00 | |
22 | #define BMA220_REG_ACCEL_X 0x02 | |
23 | #define BMA220_REG_ACCEL_Y 0x03 | |
24 | #define BMA220_REG_ACCEL_Z 0x04 | |
25 | #define BMA220_REG_RANGE 0x11 | |
26 | #define BMA220_REG_SUSPEND 0x18 | |
27 | ||
28 | #define BMA220_CHIP_ID 0xDD | |
29 | #define BMA220_READ_MASK 0x80 | |
30 | #define BMA220_RANGE_MASK 0x03 | |
31 | #define BMA220_DATA_SHIFT 2 | |
32 | #define BMA220_SUSPEND_SLEEP 0xFF | |
33 | #define BMA220_SUSPEND_WAKE 0x00 | |
34 | ||
35 | #define BMA220_DEVICE_NAME "bma220" | |
36 | #define BMA220_SCALE_AVAILABLE "0.623 1.248 2.491 4.983" | |
37 | ||
38 | #define BMA220_ACCEL_CHANNEL(index, reg, axis) { \ | |
39 | .type = IIO_ACCEL, \ | |
40 | .address = reg, \ | |
41 | .modified = 1, \ | |
42 | .channel2 = IIO_MOD_##axis, \ | |
43 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ | |
44 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ | |
194dc4c7 TB |
45 | .scan_index = index, \ |
46 | .scan_type = { \ | |
47 | .sign = 's', \ | |
48 | .realbits = 6, \ | |
49 | .storagebits = 8, \ | |
50 | .shift = BMA220_DATA_SHIFT, \ | |
51 | .endianness = IIO_CPU, \ | |
52 | }, \ | |
bf2a5600 TB |
53 | } |
54 | ||
194dc4c7 TB |
55 | enum bma220_axis { |
56 | AXIS_X, | |
57 | AXIS_Y, | |
58 | AXIS_Z, | |
59 | }; | |
60 | ||
bf2a5600 TB |
61 | static IIO_CONST_ATTR(in_accel_scale_available, BMA220_SCALE_AVAILABLE); |
62 | ||
63 | static struct attribute *bma220_attributes[] = { | |
64 | &iio_const_attr_in_accel_scale_available.dev_attr.attr, | |
65 | NULL, | |
66 | }; | |
67 | ||
68 | static const struct attribute_group bma220_attribute_group = { | |
69 | .attrs = bma220_attributes, | |
70 | }; | |
71 | ||
72 | static const int bma220_scale_table[][4] = { | |
73 | {0, 623000}, {1, 248000}, {2, 491000}, {4, 983000} | |
74 | }; | |
75 | ||
76 | struct bma220_data { | |
77 | struct spi_device *spi_device; | |
78 | struct mutex lock; | |
194dc4c7 | 79 | s8 buffer[16]; /* 3x8-bit channels + 5x8 padding + 8x8 timestamp */ |
bf2a5600 TB |
80 | u8 tx_buf[2] ____cacheline_aligned; |
81 | }; | |
82 | ||
83 | static const struct iio_chan_spec bma220_channels[] = { | |
84 | BMA220_ACCEL_CHANNEL(0, BMA220_REG_ACCEL_X, X), | |
85 | BMA220_ACCEL_CHANNEL(1, BMA220_REG_ACCEL_Y, Y), | |
86 | BMA220_ACCEL_CHANNEL(2, BMA220_REG_ACCEL_Z, Z), | |
194dc4c7 | 87 | IIO_CHAN_SOFT_TIMESTAMP(3), |
bf2a5600 TB |
88 | }; |
89 | ||
90 | static inline int bma220_read_reg(struct spi_device *spi, u8 reg) | |
91 | { | |
92 | return spi_w8r8(spi, reg | BMA220_READ_MASK); | |
93 | } | |
94 | ||
194dc4c7 TB |
95 | static const unsigned long bma220_accel_scan_masks[] = { |
96 | BIT(AXIS_X) | BIT(AXIS_Y) | BIT(AXIS_Z), | |
97 | 0 | |
98 | }; | |
99 | ||
100 | static irqreturn_t bma220_trigger_handler(int irq, void *p) | |
101 | { | |
102 | int ret; | |
103 | struct iio_poll_func *pf = p; | |
104 | struct iio_dev *indio_dev = pf->indio_dev; | |
105 | struct bma220_data *data = iio_priv(indio_dev); | |
106 | struct spi_device *spi = data->spi_device; | |
107 | ||
108 | mutex_lock(&data->lock); | |
109 | data->tx_buf[0] = BMA220_REG_ACCEL_X | BMA220_READ_MASK; | |
110 | ret = spi_write_then_read(spi, data->tx_buf, 1, data->buffer, | |
111 | ARRAY_SIZE(bma220_channels) - 1); | |
112 | if (ret < 0) | |
113 | goto err; | |
114 | ||
115 | iio_push_to_buffers_with_timestamp(indio_dev, data->buffer, | |
116 | pf->timestamp); | |
117 | err: | |
118 | mutex_unlock(&data->lock); | |
119 | iio_trigger_notify_done(indio_dev->trig); | |
120 | ||
121 | return IRQ_HANDLED; | |
122 | } | |
123 | ||
bf2a5600 TB |
124 | static int bma220_read_raw(struct iio_dev *indio_dev, |
125 | struct iio_chan_spec const *chan, | |
126 | int *val, int *val2, long mask) | |
127 | { | |
128 | int ret; | |
129 | u8 range_idx; | |
130 | struct bma220_data *data = iio_priv(indio_dev); | |
131 | ||
132 | switch (mask) { | |
133 | case IIO_CHAN_INFO_RAW: | |
134 | ret = bma220_read_reg(data->spi_device, chan->address); | |
135 | if (ret < 0) | |
136 | return -EINVAL; | |
137 | *val = sign_extend32(ret >> BMA220_DATA_SHIFT, 5); | |
138 | return IIO_VAL_INT; | |
139 | case IIO_CHAN_INFO_SCALE: | |
140 | ret = bma220_read_reg(data->spi_device, BMA220_REG_RANGE); | |
141 | if (ret < 0) | |
142 | return ret; | |
143 | range_idx = ret & BMA220_RANGE_MASK; | |
144 | *val = bma220_scale_table[range_idx][0]; | |
145 | *val2 = bma220_scale_table[range_idx][1]; | |
146 | return IIO_VAL_INT_PLUS_MICRO; | |
147 | } | |
148 | ||
149 | return -EINVAL; | |
150 | } | |
151 | ||
152 | static int bma220_write_raw(struct iio_dev *indio_dev, | |
153 | struct iio_chan_spec const *chan, | |
154 | int val, int val2, long mask) | |
155 | { | |
156 | int i; | |
157 | int ret; | |
158 | int index = -1; | |
159 | struct bma220_data *data = iio_priv(indio_dev); | |
160 | ||
161 | switch (mask) { | |
162 | case IIO_CHAN_INFO_SCALE: | |
163 | for (i = 0; i < ARRAY_SIZE(bma220_scale_table); i++) | |
164 | if (val == bma220_scale_table[i][0] && | |
165 | val2 == bma220_scale_table[i][1]) { | |
166 | index = i; | |
167 | break; | |
168 | } | |
169 | if (index < 0) | |
170 | return -EINVAL; | |
171 | ||
172 | mutex_lock(&data->lock); | |
173 | data->tx_buf[0] = BMA220_REG_RANGE; | |
174 | data->tx_buf[1] = index; | |
175 | ret = spi_write(data->spi_device, data->tx_buf, | |
176 | sizeof(data->tx_buf)); | |
177 | if (ret < 0) | |
178 | dev_err(&data->spi_device->dev, | |
179 | "failed to set measurement range\n"); | |
180 | mutex_unlock(&data->lock); | |
181 | ||
182 | return 0; | |
183 | } | |
184 | ||
185 | return -EINVAL; | |
186 | } | |
187 | ||
188 | static const struct iio_info bma220_info = { | |
189 | .driver_module = THIS_MODULE, | |
190 | .read_raw = bma220_read_raw, | |
191 | .write_raw = bma220_write_raw, | |
192 | .attrs = &bma220_attribute_group, | |
193 | }; | |
194 | ||
195 | static int bma220_init(struct spi_device *spi) | |
196 | { | |
197 | int ret; | |
198 | ||
199 | ret = bma220_read_reg(spi, BMA220_REG_ID); | |
200 | if (ret != BMA220_CHIP_ID) | |
201 | return -ENODEV; | |
202 | ||
203 | /* Make sure the chip is powered on */ | |
204 | ret = bma220_read_reg(spi, BMA220_REG_SUSPEND); | |
205 | if (ret < 0) | |
206 | return ret; | |
207 | else if (ret == BMA220_SUSPEND_WAKE) | |
208 | return bma220_read_reg(spi, BMA220_REG_SUSPEND); | |
209 | ||
210 | return 0; | |
211 | } | |
212 | ||
213 | static int bma220_deinit(struct spi_device *spi) | |
214 | { | |
215 | int ret; | |
216 | ||
217 | /* Make sure the chip is powered off */ | |
218 | ret = bma220_read_reg(spi, BMA220_REG_SUSPEND); | |
219 | if (ret < 0) | |
220 | return ret; | |
221 | else if (ret == BMA220_SUSPEND_SLEEP) | |
222 | return bma220_read_reg(spi, BMA220_REG_SUSPEND); | |
223 | ||
224 | return 0; | |
225 | } | |
226 | ||
227 | static int bma220_probe(struct spi_device *spi) | |
228 | { | |
229 | int ret; | |
230 | struct iio_dev *indio_dev; | |
231 | struct bma220_data *data; | |
232 | ||
233 | indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data)); | |
234 | if (!indio_dev) { | |
235 | dev_err(&spi->dev, "iio allocation failed!\n"); | |
236 | return -ENOMEM; | |
237 | } | |
238 | ||
239 | data = iio_priv(indio_dev); | |
240 | data->spi_device = spi; | |
241 | spi_set_drvdata(spi, indio_dev); | |
242 | mutex_init(&data->lock); | |
243 | ||
244 | indio_dev->dev.parent = &spi->dev; | |
245 | indio_dev->info = &bma220_info; | |
246 | indio_dev->name = BMA220_DEVICE_NAME; | |
247 | indio_dev->modes = INDIO_DIRECT_MODE; | |
248 | indio_dev->channels = bma220_channels; | |
249 | indio_dev->num_channels = ARRAY_SIZE(bma220_channels); | |
194dc4c7 | 250 | indio_dev->available_scan_masks = bma220_accel_scan_masks; |
bf2a5600 TB |
251 | |
252 | ret = bma220_init(data->spi_device); | |
253 | if (ret < 0) | |
254 | return ret; | |
255 | ||
194dc4c7 TB |
256 | ret = iio_triggered_buffer_setup(indio_dev, NULL, |
257 | bma220_trigger_handler, NULL); | |
258 | if (ret < 0) { | |
259 | dev_err(&spi->dev, "iio triggered buffer setup failed\n"); | |
260 | goto err_suspend; | |
261 | } | |
262 | ||
bf2a5600 TB |
263 | ret = iio_device_register(indio_dev); |
264 | if (ret < 0) { | |
265 | dev_err(&spi->dev, "iio_device_register failed\n"); | |
194dc4c7 TB |
266 | iio_triggered_buffer_cleanup(indio_dev); |
267 | goto err_suspend; | |
bf2a5600 TB |
268 | } |
269 | ||
194dc4c7 TB |
270 | return 0; |
271 | ||
272 | err_suspend: | |
273 | return bma220_deinit(spi); | |
bf2a5600 TB |
274 | } |
275 | ||
276 | static int bma220_remove(struct spi_device *spi) | |
277 | { | |
278 | struct iio_dev *indio_dev = spi_get_drvdata(spi); | |
279 | ||
280 | iio_device_unregister(indio_dev); | |
194dc4c7 | 281 | iio_triggered_buffer_cleanup(indio_dev); |
bf2a5600 TB |
282 | |
283 | return bma220_deinit(spi); | |
284 | } | |
285 | ||
286 | #ifdef CONFIG_PM_SLEEP | |
287 | static int bma220_suspend(struct device *dev) | |
288 | { | |
289 | struct bma220_data *data = | |
290 | iio_priv(spi_get_drvdata(to_spi_device(dev))); | |
291 | ||
292 | /* The chip can be suspended/woken up by a simple register read. */ | |
293 | return bma220_read_reg(data->spi_device, BMA220_REG_SUSPEND); | |
294 | } | |
295 | ||
296 | static int bma220_resume(struct device *dev) | |
297 | { | |
298 | struct bma220_data *data = | |
299 | iio_priv(spi_get_drvdata(to_spi_device(dev))); | |
300 | ||
301 | return bma220_read_reg(data->spi_device, BMA220_REG_SUSPEND); | |
302 | } | |
303 | ||
304 | static SIMPLE_DEV_PM_OPS(bma220_pm_ops, bma220_suspend, bma220_resume); | |
305 | ||
306 | #define BMA220_PM_OPS (&bma220_pm_ops) | |
307 | #else | |
308 | #define BMA220_PM_OPS NULL | |
309 | #endif | |
310 | ||
311 | static const struct spi_device_id bma220_spi_id[] = { | |
312 | {"bma220", 0}, | |
313 | {} | |
314 | }; | |
315 | ||
316 | static const struct acpi_device_id bma220_acpi_id[] = { | |
317 | {"BMA0220", 0}, | |
318 | {} | |
319 | }; | |
320 | ||
321 | MODULE_DEVICE_TABLE(spi, bma220_spi_id); | |
322 | ||
323 | static struct spi_driver bma220_driver = { | |
324 | .driver = { | |
325 | .name = "bma220_spi", | |
326 | .pm = BMA220_PM_OPS, | |
327 | .acpi_match_table = ACPI_PTR(bma220_acpi_id), | |
328 | }, | |
329 | .probe = bma220_probe, | |
330 | .remove = bma220_remove, | |
331 | .id_table = bma220_spi_id, | |
332 | }; | |
333 | ||
334 | module_spi_driver(bma220_driver); | |
335 | ||
336 | MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>"); | |
337 | MODULE_DESCRIPTION("BMA220 acceleration sensor driver"); | |
338 | MODULE_LICENSE("GPL v2"); |