xref: /openbmc/linux/drivers/iio/accel/mma9551.c (revision 7cf15f42)
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