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