1 /*
2 * Freescale MMA9551L Intelligent Motion-Sensing Platform driver
3 * Copyright (c) 2014, Intel Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 */
14
15 #include <linux/module.h>
16 #include <linux/i2c.h>
17 #include <linux/interrupt.h>
18 #include <linux/slab.h>
19 #include <linux/acpi.h>
20 #include <linux/delay.h>
21 #include <linux/gpio/consumer.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/sysfs.h>
24 #include <linux/iio/events.h>
25 #include <linux/pm_runtime.h>
26 #include "mma9551_core.h"
27
28 #define MMA9551_DRV_NAME "mma9551"
29 #define MMA9551_IRQ_NAME "mma9551_event"
30 #define MMA9551_GPIO_COUNT 4
31
32 /* Tilt application (inclination in IIO terms). */
33 #define MMA9551_TILT_XZ_ANG_REG 0x00
34 #define MMA9551_TILT_YZ_ANG_REG 0x01
35 #define MMA9551_TILT_XY_ANG_REG 0x02
36 #define MMA9551_TILT_ANGFLG BIT(7)
37 #define MMA9551_TILT_QUAD_REG 0x03
38 #define MMA9551_TILT_XY_QUAD_SHIFT 0
39 #define MMA9551_TILT_YZ_QUAD_SHIFT 2
40 #define MMA9551_TILT_XZ_QUAD_SHIFT 4
41 #define MMA9551_TILT_CFG_REG 0x01
42 #define MMA9551_TILT_ANG_THRESH_MASK GENMASK(3, 0)
43
44 #define MMA9551_DEFAULT_SAMPLE_RATE 122 /* Hz */
45
46 /* Tilt events are mapped to the first three GPIO pins. */
47 enum mma9551_tilt_axis {
48 mma9551_x = 0,
49 mma9551_y,
50 mma9551_z,
51 };
52
53 struct mma9551_data {
54 struct i2c_client *client;
55 struct mutex mutex;
56 int event_enabled[3];
57 int irqs[MMA9551_GPIO_COUNT];
58 };
59
mma9551_read_incli_chan(struct i2c_client * client,const struct iio_chan_spec * chan,int * val)60 static int mma9551_read_incli_chan(struct i2c_client *client,
61 const struct iio_chan_spec *chan,
62 int *val)
63 {
64 u8 quad_shift, angle, quadrant;
65 u16 reg_addr;
66 int ret;
67
68 switch (chan->channel2) {
69 case IIO_MOD_X:
70 reg_addr = MMA9551_TILT_YZ_ANG_REG;
71 quad_shift = MMA9551_TILT_YZ_QUAD_SHIFT;
72 break;
73 case IIO_MOD_Y:
74 reg_addr = MMA9551_TILT_XZ_ANG_REG;
75 quad_shift = MMA9551_TILT_XZ_QUAD_SHIFT;
76 break;
77 case IIO_MOD_Z:
78 reg_addr = MMA9551_TILT_XY_ANG_REG;
79 quad_shift = MMA9551_TILT_XY_QUAD_SHIFT;
80 break;
81 default:
82 return -EINVAL;
83 }
84
85 ret = mma9551_set_power_state(client, true);
86 if (ret < 0)
87 return ret;
88
89 ret = mma9551_read_status_byte(client, MMA9551_APPID_TILT,
90 reg_addr, &angle);
91 if (ret < 0)
92 goto out_poweroff;
93
94 ret = mma9551_read_status_byte(client, MMA9551_APPID_TILT,
95 MMA9551_TILT_QUAD_REG, &quadrant);
96 if (ret < 0)
97 goto out_poweroff;
98
99 angle &= ~MMA9551_TILT_ANGFLG;
100 quadrant = (quadrant >> quad_shift) & 0x03;
101
102 if (quadrant == 1 || quadrant == 3)
103 *val = 90 * (quadrant + 1) - angle;
104 else
105 *val = angle + 90 * quadrant;
106
107 ret = IIO_VAL_INT;
108
109 out_poweroff:
110 mma9551_set_power_state(client, false);
111 return ret;
112 }
113
mma9551_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)114 static int mma9551_read_raw(struct iio_dev *indio_dev,
115 struct iio_chan_spec const *chan,
116 int *val, int *val2, long mask)
117 {
118 struct mma9551_data *data = iio_priv(indio_dev);
119 int ret;
120
121 switch (mask) {
122 case IIO_CHAN_INFO_PROCESSED:
123 switch (chan->type) {
124 case IIO_INCLI:
125 mutex_lock(&data->mutex);
126 ret = mma9551_read_incli_chan(data->client, chan, val);
127 mutex_unlock(&data->mutex);
128 return ret;
129 default:
130 return -EINVAL;
131 }
132 case IIO_CHAN_INFO_RAW:
133 switch (chan->type) {
134 case IIO_ACCEL:
135 mutex_lock(&data->mutex);
136 ret = mma9551_read_accel_chan(data->client,
137 chan, val, val2);
138 mutex_unlock(&data->mutex);
139 return ret;
140 default:
141 return -EINVAL;
142 }
143 case IIO_CHAN_INFO_SCALE:
144 switch (chan->type) {
145 case IIO_ACCEL:
146 return mma9551_read_accel_scale(val, val2);
147 default:
148 return -EINVAL;
149 }
150 default:
151 return -EINVAL;
152 }
153 }
154
mma9551_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)155 static int mma9551_read_event_config(struct iio_dev *indio_dev,
156 const struct iio_chan_spec *chan,
157 enum iio_event_type type,
158 enum iio_event_direction dir)
159 {
160 struct mma9551_data *data = iio_priv(indio_dev);
161
162 switch (chan->type) {
163 case IIO_INCLI:
164 /* IIO counts axes from 1, because IIO_NO_MOD is 0. */
165 return data->event_enabled[chan->channel2 - 1];
166 default:
167 return -EINVAL;
168 }
169 }
170
mma9551_config_incli_event(struct iio_dev * indio_dev,enum iio_modifier axis,int state)171 static int mma9551_config_incli_event(struct iio_dev *indio_dev,
172 enum iio_modifier axis,
173 int state)
174 {
175 struct mma9551_data *data = iio_priv(indio_dev);
176 enum mma9551_tilt_axis mma_axis;
177 int ret;
178
179 /* IIO counts axes from 1, because IIO_NO_MOD is 0. */
180 mma_axis = axis - 1;
181
182 if (data->event_enabled[mma_axis] == state)
183 return 0;
184
185 if (state == 0) {
186 ret = mma9551_gpio_config(data->client,
187 (enum mma9551_gpio_pin)mma_axis,
188 MMA9551_APPID_NONE, 0, 0);
189 if (ret < 0)
190 return ret;
191
192 ret = mma9551_set_power_state(data->client, false);
193 if (ret < 0)
194 return ret;
195 } else {
196 int bitnum;
197
198 /* Bit 7 of each angle register holds the angle flag. */
199 switch (axis) {
200 case IIO_MOD_X:
201 bitnum = 7 + 8 * MMA9551_TILT_YZ_ANG_REG;
202 break;
203 case IIO_MOD_Y:
204 bitnum = 7 + 8 * MMA9551_TILT_XZ_ANG_REG;
205 break;
206 case IIO_MOD_Z:
207 bitnum = 7 + 8 * MMA9551_TILT_XY_ANG_REG;
208 break;
209 default:
210 return -EINVAL;
211 }
212
213
214 ret = mma9551_set_power_state(data->client, true);
215 if (ret < 0)
216 return ret;
217
218 ret = mma9551_gpio_config(data->client,
219 (enum mma9551_gpio_pin)mma_axis,
220 MMA9551_APPID_TILT, bitnum, 0);
221 if (ret < 0) {
222 mma9551_set_power_state(data->client, false);
223 return ret;
224 }
225 }
226
227 data->event_enabled[mma_axis] = state;
228
229 return ret;
230 }
231
mma9551_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,int state)232 static int mma9551_write_event_config(struct iio_dev *indio_dev,
233 const struct iio_chan_spec *chan,
234 enum iio_event_type type,
235 enum iio_event_direction dir,
236 int state)
237 {
238 struct mma9551_data *data = iio_priv(indio_dev);
239 int ret;
240
241 switch (chan->type) {
242 case IIO_INCLI:
243 mutex_lock(&data->mutex);
244 ret = mma9551_config_incli_event(indio_dev,
245 chan->channel2, state);
246 mutex_unlock(&data->mutex);
247 return ret;
248 default:
249 return -EINVAL;
250 }
251 }
252
mma9551_write_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)253 static int mma9551_write_event_value(struct iio_dev *indio_dev,
254 const struct iio_chan_spec *chan,
255 enum iio_event_type type,
256 enum iio_event_direction dir,
257 enum iio_event_info info,
258 int val, int val2)
259 {
260 struct mma9551_data *data = iio_priv(indio_dev);
261 int ret;
262
263 switch (chan->type) {
264 case IIO_INCLI:
265 if (val2 != 0 || val < 1 || val > 10)
266 return -EINVAL;
267 mutex_lock(&data->mutex);
268 ret = mma9551_update_config_bits(data->client,
269 MMA9551_APPID_TILT,
270 MMA9551_TILT_CFG_REG,
271 MMA9551_TILT_ANG_THRESH_MASK,
272 val);
273 mutex_unlock(&data->mutex);
274 return ret;
275 default:
276 return -EINVAL;
277 }
278 }
279
mma9551_read_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)280 static int mma9551_read_event_value(struct iio_dev *indio_dev,
281 const struct iio_chan_spec *chan,
282 enum iio_event_type type,
283 enum iio_event_direction dir,
284 enum iio_event_info info,
285 int *val, int *val2)
286 {
287 struct mma9551_data *data = iio_priv(indio_dev);
288 int ret;
289 u8 tmp;
290
291 switch (chan->type) {
292 case IIO_INCLI:
293 mutex_lock(&data->mutex);
294 ret = mma9551_read_config_byte(data->client,
295 MMA9551_APPID_TILT,
296 MMA9551_TILT_CFG_REG, &tmp);
297 mutex_unlock(&data->mutex);
298 if (ret < 0)
299 return ret;
300 *val = tmp & MMA9551_TILT_ANG_THRESH_MASK;
301 *val2 = 0;
302 return IIO_VAL_INT;
303 default:
304 return -EINVAL;
305 }
306 }
307
308 static const struct iio_event_spec mma9551_incli_event = {
309 .type = IIO_EV_TYPE_ROC,
310 .dir = IIO_EV_DIR_RISING,
311 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
312 .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE),
313 };
314
315 #define MMA9551_INCLI_CHANNEL(axis) { \
316 .type = IIO_INCLI, \
317 .modified = 1, \
318 .channel2 = axis, \
319 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
320 .event_spec = &mma9551_incli_event, \
321 .num_event_specs = 1, \
322 }
323
324 static const struct iio_chan_spec mma9551_channels[] = {
325 MMA9551_ACCEL_CHANNEL(IIO_MOD_X),
326 MMA9551_ACCEL_CHANNEL(IIO_MOD_Y),
327 MMA9551_ACCEL_CHANNEL(IIO_MOD_Z),
328
329 MMA9551_INCLI_CHANNEL(IIO_MOD_X),
330 MMA9551_INCLI_CHANNEL(IIO_MOD_Y),
331 MMA9551_INCLI_CHANNEL(IIO_MOD_Z),
332 };
333
334 static const struct iio_info mma9551_info = {
335 .driver_module = THIS_MODULE,
336 .read_raw = mma9551_read_raw,
337 .read_event_config = mma9551_read_event_config,
338 .write_event_config = mma9551_write_event_config,
339 .read_event_value = mma9551_read_event_value,
340 .write_event_value = mma9551_write_event_value,
341 };
342
mma9551_event_handler(int irq,void * private)343 static irqreturn_t mma9551_event_handler(int irq, void *private)
344 {
345 struct iio_dev *indio_dev = private;
346 struct mma9551_data *data = iio_priv(indio_dev);
347 int i, ret, mma_axis = -1;
348 u16 reg;
349 u8 val;
350
351 mutex_lock(&data->mutex);
352
353 for (i = 0; i < 3; i++)
354 if (irq == data->irqs[i]) {
355 mma_axis = i;
356 break;
357 }
358
359 if (mma_axis == -1) {
360 /* IRQ was triggered on 4th line, which we don't use. */
361 dev_warn(&data->client->dev,
362 "irq triggered on unused line %d\n", data->irqs[3]);
363 goto out;
364 }
365
366 switch (mma_axis) {
367 case mma9551_x:
368 reg = MMA9551_TILT_YZ_ANG_REG;
369 break;
370 case mma9551_y:
371 reg = MMA9551_TILT_XZ_ANG_REG;
372 break;
373 case mma9551_z:
374 reg = MMA9551_TILT_XY_ANG_REG;
375 break;
376 }
377
378 /*
379 * Read the angle even though we don't use it, otherwise we
380 * won't get any further interrupts.
381 */
382 ret = mma9551_read_status_byte(data->client, MMA9551_APPID_TILT,
383 reg, &val);
384 if (ret < 0) {
385 dev_err(&data->client->dev,
386 "error %d reading tilt register in IRQ\n", ret);
387 goto out;
388 }
389
390 iio_push_event(indio_dev,
391 IIO_MOD_EVENT_CODE(IIO_INCLI, 0, (mma_axis + 1),
392 IIO_EV_TYPE_ROC, IIO_EV_DIR_RISING),
393 iio_get_time_ns(indio_dev));
394
395 out:
396 mutex_unlock(&data->mutex);
397
398 return IRQ_HANDLED;
399 }
400
mma9551_init(struct mma9551_data * data)401 static int mma9551_init(struct mma9551_data *data)
402 {
403 int ret;
404
405 ret = mma9551_read_version(data->client);
406 if (ret)
407 return ret;
408
409 return mma9551_set_device_state(data->client, true);
410 }
411
mma9551_gpio_probe(struct iio_dev * indio_dev)412 static int mma9551_gpio_probe(struct iio_dev *indio_dev)
413 {
414 struct gpio_desc *gpio;
415 int i, ret;
416 struct mma9551_data *data = iio_priv(indio_dev);
417 struct device *dev = &data->client->dev;
418
419 for (i = 0; i < MMA9551_GPIO_COUNT; i++) {
420 gpio = devm_gpiod_get_index(dev, NULL, i, GPIOD_IN);
421 if (IS_ERR(gpio)) {
422 dev_err(dev, "acpi gpio get index failed\n");
423 return PTR_ERR(gpio);
424 }
425
426 ret = gpiod_to_irq(gpio);
427 if (ret < 0)
428 return ret;
429
430 data->irqs[i] = ret;
431 ret = devm_request_threaded_irq(dev, data->irqs[i],
432 NULL, mma9551_event_handler,
433 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
434 MMA9551_IRQ_NAME, indio_dev);
435 if (ret < 0) {
436 dev_err(dev, "request irq %d failed\n", data->irqs[i]);
437 return ret;
438 }
439
440 dev_dbg(dev, "gpio resource, no:%d irq:%d\n",
441 desc_to_gpio(gpio), data->irqs[i]);
442 }
443
444 return 0;
445 }
446
mma9551_match_acpi_device(struct device * dev)447 static const char *mma9551_match_acpi_device(struct device *dev)
448 {
449 const struct acpi_device_id *id;
450
451 id = acpi_match_device(dev->driver->acpi_match_table, dev);
452 if (!id)
453 return NULL;
454
455 return dev_name(dev);
456 }
457
mma9551_probe(struct i2c_client * client,const struct i2c_device_id * id)458 static int mma9551_probe(struct i2c_client *client,
459 const struct i2c_device_id *id)
460 {
461 struct mma9551_data *data;
462 struct iio_dev *indio_dev;
463 const char *name = NULL;
464 int ret;
465
466 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
467 if (!indio_dev)
468 return -ENOMEM;
469
470 data = iio_priv(indio_dev);
471 i2c_set_clientdata(client, indio_dev);
472 data->client = client;
473
474 if (id)
475 name = id->name;
476 else if (ACPI_HANDLE(&client->dev))
477 name = mma9551_match_acpi_device(&client->dev);
478
479 ret = mma9551_init(data);
480 if (ret < 0)
481 return ret;
482
483 mutex_init(&data->mutex);
484
485 indio_dev->dev.parent = &client->dev;
486 indio_dev->channels = mma9551_channels;
487 indio_dev->num_channels = ARRAY_SIZE(mma9551_channels);
488 indio_dev->name = name;
489 indio_dev->modes = INDIO_DIRECT_MODE;
490 indio_dev->info = &mma9551_info;
491
492 ret = mma9551_gpio_probe(indio_dev);
493 if (ret < 0)
494 goto out_poweroff;
495
496 ret = pm_runtime_set_active(&client->dev);
497 if (ret < 0)
498 goto out_poweroff;
499
500 pm_runtime_enable(&client->dev);
501 pm_runtime_set_autosuspend_delay(&client->dev,
502 MMA9551_AUTO_SUSPEND_DELAY_MS);
503 pm_runtime_use_autosuspend(&client->dev);
504
505 ret = iio_device_register(indio_dev);
506 if (ret < 0) {
507 dev_err(&client->dev, "unable to register iio device\n");
508 goto out_poweroff;
509 }
510
511 return 0;
512
513 out_poweroff:
514 mma9551_set_device_state(client, false);
515
516 return ret;
517 }
518
mma9551_remove(struct i2c_client * client)519 static int mma9551_remove(struct i2c_client *client)
520 {
521 struct iio_dev *indio_dev = i2c_get_clientdata(client);
522 struct mma9551_data *data = iio_priv(indio_dev);
523
524 iio_device_unregister(indio_dev);
525
526 pm_runtime_disable(&client->dev);
527 pm_runtime_set_suspended(&client->dev);
528 pm_runtime_put_noidle(&client->dev);
529
530 mutex_lock(&data->mutex);
531 mma9551_set_device_state(data->client, false);
532 mutex_unlock(&data->mutex);
533
534 return 0;
535 }
536
537 #ifdef CONFIG_PM
mma9551_runtime_suspend(struct device * dev)538 static int mma9551_runtime_suspend(struct device *dev)
539 {
540 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
541 struct mma9551_data *data = iio_priv(indio_dev);
542 int ret;
543
544 mutex_lock(&data->mutex);
545 ret = mma9551_set_device_state(data->client, false);
546 mutex_unlock(&data->mutex);
547 if (ret < 0) {
548 dev_err(&data->client->dev, "powering off device failed\n");
549 return -EAGAIN;
550 }
551
552 return 0;
553 }
554
mma9551_runtime_resume(struct device * dev)555 static int mma9551_runtime_resume(struct device *dev)
556 {
557 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
558 struct mma9551_data *data = iio_priv(indio_dev);
559 int ret;
560
561 ret = mma9551_set_device_state(data->client, true);
562 if (ret < 0)
563 return ret;
564
565 mma9551_sleep(MMA9551_DEFAULT_SAMPLE_RATE);
566
567 return 0;
568 }
569 #endif
570
571 #ifdef CONFIG_PM_SLEEP
mma9551_suspend(struct device * dev)572 static int mma9551_suspend(struct device *dev)
573 {
574 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
575 struct mma9551_data *data = iio_priv(indio_dev);
576 int ret;
577
578 mutex_lock(&data->mutex);
579 ret = mma9551_set_device_state(data->client, false);
580 mutex_unlock(&data->mutex);
581
582 return ret;
583 }
584
mma9551_resume(struct device * dev)585 static int mma9551_resume(struct device *dev)
586 {
587 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
588 struct mma9551_data *data = iio_priv(indio_dev);
589 int ret;
590
591 mutex_lock(&data->mutex);
592 ret = mma9551_set_device_state(data->client, true);
593 mutex_unlock(&data->mutex);
594
595 return ret;
596 }
597 #endif
598
599 static const struct dev_pm_ops mma9551_pm_ops = {
600 SET_SYSTEM_SLEEP_PM_OPS(mma9551_suspend, mma9551_resume)
601 SET_RUNTIME_PM_OPS(mma9551_runtime_suspend,
602 mma9551_runtime_resume, NULL)
603 };
604
605 static const struct acpi_device_id mma9551_acpi_match[] = {
606 {"MMA9551", 0},
607 {},
608 };
609
610 MODULE_DEVICE_TABLE(acpi, mma9551_acpi_match);
611
612 static const struct i2c_device_id mma9551_id[] = {
613 {"mma9551", 0},
614 {}
615 };
616
617 MODULE_DEVICE_TABLE(i2c, mma9551_id);
618
619 static struct i2c_driver mma9551_driver = {
620 .driver = {
621 .name = MMA9551_DRV_NAME,
622 .acpi_match_table = ACPI_PTR(mma9551_acpi_match),
623 .pm = &mma9551_pm_ops,
624 },
625 .probe = mma9551_probe,
626 .remove = mma9551_remove,
627 .id_table = mma9551_id,
628 };
629
630 module_i2c_driver(mma9551_driver);
631
632 MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
633 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
634 MODULE_LICENSE("GPL v2");
635 MODULE_DESCRIPTION("MMA9551L motion-sensing platform driver");
636