1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/acpi.h>
14#include <linux/gpio/consumer.h>
15#include <linux/i2c.h>
16#include <linux/interrupt.h>
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/iio/buffer.h>
20#include <linux/iio/iio.h>
21#include <linux/iio/sysfs.h>
22#include <linux/iio/trigger.h>
23#include <linux/iio/triggered_buffer.h>
24#include <linux/iio/trigger_consumer.h>
25
26#define STK8BA50_REG_XOUT 0x02
27#define STK8BA50_REG_YOUT 0x04
28#define STK8BA50_REG_ZOUT 0x06
29#define STK8BA50_REG_RANGE 0x0F
30#define STK8BA50_REG_BWSEL 0x10
31#define STK8BA50_REG_POWMODE 0x11
32#define STK8BA50_REG_SWRST 0x14
33#define STK8BA50_REG_INTEN2 0x17
34#define STK8BA50_REG_INTMAP2 0x1A
35
36#define STK8BA50_MODE_NORMAL 0
37#define STK8BA50_MODE_SUSPEND 1
38#define STK8BA50_MODE_POWERBIT BIT(7)
39#define STK8BA50_DATA_SHIFT 6
40#define STK8BA50_RESET_CMD 0xB6
41#define STK8BA50_SR_1792HZ_IDX 7
42#define STK8BA50_DREADY_INT_MASK 0x10
43#define STK8BA50_DREADY_INT_MAP 0x81
44#define STK8BA50_ALL_CHANNEL_MASK 7
45#define STK8BA50_ALL_CHANNEL_SIZE 6
46
47#define STK8BA50_DRIVER_NAME "stk8ba50"
48#define STK8BA50_GPIO "stk8ba50_gpio"
49#define STK8BA50_IRQ_NAME "stk8ba50_event"
50
51#define STK8BA50_SCALE_AVAIL "0.0384 0.0767 0.1534 0.3069"
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69static const struct {
70 u8 reg_val;
71 u32 scale_val;
72} stk8ba50_scale_table[] = {
73 {3, 38400}, {5, 76700}, {8, 153400}, {12, 306900}
74};
75
76
77static const struct {
78 u8 reg_val;
79 u16 samp_freq;
80} stk8ba50_samp_freq_table[] = {
81 {0x08, 14}, {0x09, 25}, {0x0A, 56}, {0x0B, 112},
82 {0x0C, 224}, {0x0D, 448}, {0x0E, 896}, {0x0F, 1792}
83};
84
85
86static const int stk8ba50_channel_table[] = {
87 STK8BA50_REG_XOUT,
88 STK8BA50_REG_YOUT,
89 STK8BA50_REG_ZOUT
90};
91
92struct stk8ba50_data {
93 struct i2c_client *client;
94 struct mutex lock;
95 int range;
96 u8 sample_rate_idx;
97 struct iio_trigger *dready_trig;
98 bool dready_trigger_on;
99
100
101
102
103
104 s16 buffer[8];
105};
106
107#define STK8BA50_ACCEL_CHANNEL(index, reg, axis) { \
108 .type = IIO_ACCEL, \
109 .address = reg, \
110 .modified = 1, \
111 .channel2 = IIO_MOD_##axis, \
112 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
113 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
114 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
115 .scan_index = index, \
116 .scan_type = { \
117 .sign = 's', \
118 .realbits = 10, \
119 .storagebits = 16, \
120 .shift = STK8BA50_DATA_SHIFT, \
121 .endianness = IIO_CPU, \
122 }, \
123}
124
125static const struct iio_chan_spec stk8ba50_channels[] = {
126 STK8BA50_ACCEL_CHANNEL(0, STK8BA50_REG_XOUT, X),
127 STK8BA50_ACCEL_CHANNEL(1, STK8BA50_REG_YOUT, Y),
128 STK8BA50_ACCEL_CHANNEL(2, STK8BA50_REG_ZOUT, Z),
129 IIO_CHAN_SOFT_TIMESTAMP(3),
130};
131
132static IIO_CONST_ATTR(in_accel_scale_available, STK8BA50_SCALE_AVAIL);
133
134static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("14 25 56 112 224 448 896 1792");
135
136static struct attribute *stk8ba50_attributes[] = {
137 &iio_const_attr_in_accel_scale_available.dev_attr.attr,
138 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
139 NULL,
140};
141
142static const struct attribute_group stk8ba50_attribute_group = {
143 .attrs = stk8ba50_attributes
144};
145
146static int stk8ba50_read_accel(struct stk8ba50_data *data, u8 reg)
147{
148 int ret;
149 struct i2c_client *client = data->client;
150
151 ret = i2c_smbus_read_word_data(client, reg);
152 if (ret < 0) {
153 dev_err(&client->dev, "register read failed\n");
154 return ret;
155 }
156
157 return ret;
158}
159
160static int stk8ba50_data_rdy_trigger_set_state(struct iio_trigger *trig,
161 bool state)
162{
163 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
164 struct stk8ba50_data *data = iio_priv(indio_dev);
165 int ret;
166
167 if (state)
168 ret = i2c_smbus_write_byte_data(data->client,
169 STK8BA50_REG_INTEN2, STK8BA50_DREADY_INT_MASK);
170 else
171 ret = i2c_smbus_write_byte_data(data->client,
172 STK8BA50_REG_INTEN2, 0x00);
173
174 if (ret < 0)
175 dev_err(&data->client->dev, "failed to set trigger state\n");
176 else
177 data->dready_trigger_on = state;
178
179 return ret;
180}
181
182static const struct iio_trigger_ops stk8ba50_trigger_ops = {
183 .set_trigger_state = stk8ba50_data_rdy_trigger_set_state,
184 .owner = THIS_MODULE,
185};
186
187static int stk8ba50_set_power(struct stk8ba50_data *data, bool mode)
188{
189 int ret;
190 u8 masked_reg;
191 struct i2c_client *client = data->client;
192
193 ret = i2c_smbus_read_byte_data(client, STK8BA50_REG_POWMODE);
194 if (ret < 0)
195 goto exit_err;
196
197 if (mode)
198 masked_reg = ret | STK8BA50_MODE_POWERBIT;
199 else
200 masked_reg = ret & (~STK8BA50_MODE_POWERBIT);
201
202 ret = i2c_smbus_write_byte_data(client, STK8BA50_REG_POWMODE,
203 masked_reg);
204 if (ret < 0)
205 goto exit_err;
206
207 return ret;
208
209exit_err:
210 dev_err(&client->dev, "failed to change sensor mode\n");
211 return ret;
212}
213
214static int stk8ba50_read_raw(struct iio_dev *indio_dev,
215 struct iio_chan_spec const *chan,
216 int *val, int *val2, long mask)
217{
218 struct stk8ba50_data *data = iio_priv(indio_dev);
219 int ret;
220
221 switch (mask) {
222 case IIO_CHAN_INFO_RAW:
223 if (iio_buffer_enabled(indio_dev))
224 return -EBUSY;
225 mutex_lock(&data->lock);
226 ret = stk8ba50_set_power(data, STK8BA50_MODE_NORMAL);
227 if (ret < 0) {
228 mutex_unlock(&data->lock);
229 return -EINVAL;
230 }
231 ret = stk8ba50_read_accel(data, chan->address);
232 if (ret < 0) {
233 stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
234 mutex_unlock(&data->lock);
235 return -EINVAL;
236 }
237 *val = sign_extend32(ret >> STK8BA50_DATA_SHIFT, 9);
238 stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
239 mutex_unlock(&data->lock);
240 return IIO_VAL_INT;
241 case IIO_CHAN_INFO_SCALE:
242 *val = 0;
243 *val2 = stk8ba50_scale_table[data->range].scale_val;
244 return IIO_VAL_INT_PLUS_MICRO;
245 case IIO_CHAN_INFO_SAMP_FREQ:
246 *val = stk8ba50_samp_freq_table
247 [data->sample_rate_idx].samp_freq;
248 *val2 = 0;
249 return IIO_VAL_INT;
250 }
251
252 return -EINVAL;
253}
254
255static int stk8ba50_write_raw(struct iio_dev *indio_dev,
256 struct iio_chan_spec const *chan,
257 int val, int val2, long mask)
258{
259 int ret;
260 int i;
261 int index = -1;
262 struct stk8ba50_data *data = iio_priv(indio_dev);
263
264 switch (mask) {
265 case IIO_CHAN_INFO_SCALE:
266 if (val != 0)
267 return -EINVAL;
268
269 for (i = 0; i < ARRAY_SIZE(stk8ba50_scale_table); i++)
270 if (val2 == stk8ba50_scale_table[i].scale_val) {
271 index = i;
272 break;
273 }
274 if (index < 0)
275 return -EINVAL;
276
277 ret = i2c_smbus_write_byte_data(data->client,
278 STK8BA50_REG_RANGE,
279 stk8ba50_scale_table[index].reg_val);
280 if (ret < 0)
281 dev_err(&data->client->dev,
282 "failed to set measurement range\n");
283 else
284 data->range = index;
285
286 return ret;
287 case IIO_CHAN_INFO_SAMP_FREQ:
288 for (i = 0; i < ARRAY_SIZE(stk8ba50_samp_freq_table); i++)
289 if (val == stk8ba50_samp_freq_table[i].samp_freq) {
290 index = i;
291 break;
292 }
293 if (index < 0)
294 return -EINVAL;
295
296 ret = i2c_smbus_write_byte_data(data->client,
297 STK8BA50_REG_BWSEL,
298 stk8ba50_samp_freq_table[index].reg_val);
299 if (ret < 0)
300 dev_err(&data->client->dev,
301 "failed to set sampling rate\n");
302 else
303 data->sample_rate_idx = index;
304
305 return ret;
306 }
307
308 return -EINVAL;
309}
310
311static const struct iio_info stk8ba50_info = {
312 .driver_module = THIS_MODULE,
313 .read_raw = stk8ba50_read_raw,
314 .write_raw = stk8ba50_write_raw,
315 .attrs = &stk8ba50_attribute_group,
316};
317
318static irqreturn_t stk8ba50_trigger_handler(int irq, void *p)
319{
320 struct iio_poll_func *pf = p;
321 struct iio_dev *indio_dev = pf->indio_dev;
322 struct stk8ba50_data *data = iio_priv(indio_dev);
323 int bit, ret, i = 0;
324
325 mutex_lock(&data->lock);
326
327
328
329
330 if (*(indio_dev->active_scan_mask) == STK8BA50_ALL_CHANNEL_MASK) {
331 ret = i2c_smbus_read_i2c_block_data(data->client,
332 STK8BA50_REG_XOUT,
333 STK8BA50_ALL_CHANNEL_SIZE,
334 (u8 *)data->buffer);
335 if (ret < STK8BA50_ALL_CHANNEL_SIZE) {
336 dev_err(&data->client->dev, "register read failed\n");
337 goto err;
338 }
339 } else {
340 for_each_set_bit(bit, indio_dev->active_scan_mask,
341 indio_dev->masklength) {
342 ret = stk8ba50_read_accel(data,
343 stk8ba50_channel_table[bit]);
344 if (ret < 0)
345 goto err;
346
347 data->buffer[i++] = ret;
348 }
349 }
350 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
351 pf->timestamp);
352err:
353 mutex_unlock(&data->lock);
354 iio_trigger_notify_done(indio_dev->trig);
355
356 return IRQ_HANDLED;
357}
358
359static irqreturn_t stk8ba50_data_rdy_trig_poll(int irq, void *private)
360{
361 struct iio_dev *indio_dev = private;
362 struct stk8ba50_data *data = iio_priv(indio_dev);
363
364 if (data->dready_trigger_on)
365 iio_trigger_poll(data->dready_trig);
366
367 return IRQ_HANDLED;
368}
369
370static int stk8ba50_buffer_preenable(struct iio_dev *indio_dev)
371{
372 struct stk8ba50_data *data = iio_priv(indio_dev);
373
374 return stk8ba50_set_power(data, STK8BA50_MODE_NORMAL);
375}
376
377static int stk8ba50_buffer_postdisable(struct iio_dev *indio_dev)
378{
379 struct stk8ba50_data *data = iio_priv(indio_dev);
380
381 return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
382}
383
384static const struct iio_buffer_setup_ops stk8ba50_buffer_setup_ops = {
385 .preenable = stk8ba50_buffer_preenable,
386 .postenable = iio_triggered_buffer_postenable,
387 .predisable = iio_triggered_buffer_predisable,
388 .postdisable = stk8ba50_buffer_postdisable,
389};
390
391static int stk8ba50_gpio_probe(struct i2c_client *client)
392{
393 struct device *dev;
394 struct gpio_desc *gpio;
395 int ret;
396
397 if (!client)
398 return -EINVAL;
399
400 dev = &client->dev;
401
402
403 gpio = devm_gpiod_get_index(dev, STK8BA50_GPIO, 0, GPIOD_IN);
404 if (IS_ERR(gpio)) {
405 dev_err(dev, "acpi gpio get index failed\n");
406 return PTR_ERR(gpio);
407 }
408
409 ret = gpiod_to_irq(gpio);
410 dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
411
412 return ret;
413}
414
415static int stk8ba50_probe(struct i2c_client *client,
416 const struct i2c_device_id *id)
417{
418 int ret;
419 struct iio_dev *indio_dev;
420 struct stk8ba50_data *data;
421
422 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
423 if (!indio_dev) {
424 dev_err(&client->dev, "iio allocation failed!\n");
425 return -ENOMEM;
426 }
427
428 data = iio_priv(indio_dev);
429 data->client = client;
430 i2c_set_clientdata(client, indio_dev);
431 mutex_init(&data->lock);
432
433 indio_dev->dev.parent = &client->dev;
434 indio_dev->info = &stk8ba50_info;
435 indio_dev->name = STK8BA50_DRIVER_NAME;
436 indio_dev->modes = INDIO_DIRECT_MODE;
437 indio_dev->channels = stk8ba50_channels;
438 indio_dev->num_channels = ARRAY_SIZE(stk8ba50_channels);
439
440
441 ret = i2c_smbus_write_byte_data(client,
442 STK8BA50_REG_SWRST, STK8BA50_RESET_CMD);
443 if (ret < 0) {
444 dev_err(&client->dev, "failed to reset sensor\n");
445 goto err_power_off;
446 }
447
448
449 data->range = 0;
450
451
452 data->sample_rate_idx = STK8BA50_SR_1792HZ_IDX;
453
454
455 ret = i2c_smbus_write_byte_data(client,
456 STK8BA50_REG_INTEN2, STK8BA50_DREADY_INT_MASK);
457 if (ret < 0) {
458 dev_err(&client->dev, "failed to set up interrupts\n");
459 goto err_power_off;
460 }
461 ret = i2c_smbus_write_byte_data(client,
462 STK8BA50_REG_INTMAP2, STK8BA50_DREADY_INT_MAP);
463 if (ret < 0) {
464 dev_err(&client->dev, "failed to set up interrupts\n");
465 goto err_power_off;
466 }
467
468 if (client->irq < 0)
469 client->irq = stk8ba50_gpio_probe(client);
470
471 if (client->irq >= 0) {
472 ret = devm_request_threaded_irq(&client->dev, client->irq,
473 stk8ba50_data_rdy_trig_poll,
474 NULL,
475 IRQF_TRIGGER_RISING |
476 IRQF_ONESHOT,
477 STK8BA50_IRQ_NAME,
478 indio_dev);
479 if (ret < 0) {
480 dev_err(&client->dev, "request irq %d failed\n",
481 client->irq);
482 goto err_power_off;
483 }
484
485 data->dready_trig = devm_iio_trigger_alloc(&client->dev,
486 "%s-dev%d",
487 indio_dev->name,
488 indio_dev->id);
489 if (!data->dready_trig) {
490 ret = -ENOMEM;
491 goto err_power_off;
492 }
493
494 data->dready_trig->dev.parent = &client->dev;
495 data->dready_trig->ops = &stk8ba50_trigger_ops;
496 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
497 ret = iio_trigger_register(data->dready_trig);
498 if (ret) {
499 dev_err(&client->dev, "iio trigger register failed\n");
500 goto err_power_off;
501 }
502 }
503
504 ret = iio_triggered_buffer_setup(indio_dev,
505 iio_pollfunc_store_time,
506 stk8ba50_trigger_handler,
507 &stk8ba50_buffer_setup_ops);
508 if (ret < 0) {
509 dev_err(&client->dev, "iio triggered buffer setup failed\n");
510 goto err_trigger_unregister;
511 }
512
513 ret = iio_device_register(indio_dev);
514 if (ret < 0) {
515 dev_err(&client->dev, "device_register failed\n");
516 goto err_buffer_cleanup;
517 }
518
519 return ret;
520
521err_buffer_cleanup:
522 iio_triggered_buffer_cleanup(indio_dev);
523err_trigger_unregister:
524 if (data->dready_trig)
525 iio_trigger_unregister(data->dready_trig);
526err_power_off:
527 stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
528 return ret;
529}
530
531static int stk8ba50_remove(struct i2c_client *client)
532{
533 struct iio_dev *indio_dev = i2c_get_clientdata(client);
534 struct stk8ba50_data *data = iio_priv(indio_dev);
535
536 iio_device_unregister(indio_dev);
537 iio_triggered_buffer_cleanup(indio_dev);
538
539 if (data->dready_trig)
540 iio_trigger_unregister(data->dready_trig);
541
542 return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
543}
544
545#ifdef CONFIG_PM_SLEEP
546static int stk8ba50_suspend(struct device *dev)
547{
548 struct stk8ba50_data *data;
549
550 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
551
552 return stk8ba50_set_power(data, STK8BA50_MODE_SUSPEND);
553}
554
555static int stk8ba50_resume(struct device *dev)
556{
557 struct stk8ba50_data *data;
558
559 data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
560
561 return stk8ba50_set_power(data, STK8BA50_MODE_NORMAL);
562}
563
564static SIMPLE_DEV_PM_OPS(stk8ba50_pm_ops, stk8ba50_suspend, stk8ba50_resume);
565
566#define STK8BA50_PM_OPS (&stk8ba50_pm_ops)
567#else
568#define STK8BA50_PM_OPS NULL
569#endif
570
571static const struct i2c_device_id stk8ba50_i2c_id[] = {
572 {"stk8ba50", 0},
573 {}
574};
575MODULE_DEVICE_TABLE(i2c, stk8ba50_i2c_id);
576
577static const struct acpi_device_id stk8ba50_acpi_id[] = {
578 {"STK8BA50", 0},
579 {}
580};
581
582MODULE_DEVICE_TABLE(acpi, stk8ba50_acpi_id);
583
584static struct i2c_driver stk8ba50_driver = {
585 .driver = {
586 .name = "stk8ba50",
587 .pm = STK8BA50_PM_OPS,
588 .acpi_match_table = ACPI_PTR(stk8ba50_acpi_id),
589 },
590 .probe = stk8ba50_probe,
591 .remove = stk8ba50_remove,
592 .id_table = stk8ba50_i2c_id,
593};
594
595module_i2c_driver(stk8ba50_driver);
596
597MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
598MODULE_DESCRIPTION("STK8BA50 3-Axis Accelerometer driver");
599MODULE_LICENSE("GPL v2");
600
