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