aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/iio
diff options
context:
space:
mode:
authorIrina Tirdea <irina.tirdea@intel.com>2015-01-29 13:45:10 -0500
committerJonathan Cameron <jic23@kernel.org>2015-01-30 15:34:59 -0500
commit40cb761306d6c19d80fe85f9ae52615932f76b71 (patch)
tree238c05112d8485c90dc227dae7c87d02efaffc95 /drivers/iio
parent81110933a94279afce73beecae568e704cf2b9b6 (diff)
iio: add driver for Freescale MMA9553
Add support for Freescale MMA9553L Intelligent Pedometer Platform. The following functionalities are supported: - step counter (counts the number of steps using a HW register) - step detector (generates an iio event at every step the user takes) - activity recognition (rest, walking, jogging, running) - speed - calories - distance To get accurate pedometer results, the user's height, weight and gender need to be configured. The specifications can be downloaded from: http://www.freescale.com/files/sensors/doc/ref_manual/MMA955xLSWRM.pdf http://www.freescale.com/files/sensors/doc/ref_manual/MMA9553LSWRM.pdf Signed-off-by: Irina Tirdea <irina.tirdea@intel.com> Signed-off-by: Jonathan Cameron <jic23@kernel.org>
Diffstat (limited to 'drivers/iio')
-rw-r--r--drivers/iio/accel/Kconfig10
-rw-r--r--drivers/iio/accel/Makefile1
-rw-r--r--drivers/iio/accel/mma9551_core.c183
-rw-r--r--drivers/iio/accel/mma9551_core.h17
-rw-r--r--drivers/iio/accel/mma9553.c1334
5 files changed, 1544 insertions, 1 deletions
diff --git a/drivers/iio/accel/Kconfig b/drivers/iio/accel/Kconfig
index c53047d28ad3..7c9a9a94a8ce 100644
--- a/drivers/iio/accel/Kconfig
+++ b/drivers/iio/accel/Kconfig
@@ -126,4 +126,14 @@ config MMA9551
126 To compile this driver as a module, choose M here: the module 126 To compile this driver as a module, choose M here: the module
127 will be called mma9551. 127 will be called mma9551.
128 128
129config MMA9553
130 tristate "Freescale MMA9553L Intelligent Pedometer Platform Driver"
131 depends on I2C
132 select MMA9551_CORE
133 help
134 Say yes here to build support for the Freescale MMA9553L
135 Intelligent Pedometer Platform Driver.
136
137 To compile this driver as a module, choose M here: the module
138 will be called mma9553.
129endmenu 139endmenu
diff --git a/drivers/iio/accel/Makefile b/drivers/iio/accel/Makefile
index 101a86d7b0a9..99d89e46cad1 100644
--- a/drivers/iio/accel/Makefile
+++ b/drivers/iio/accel/Makefile
@@ -12,6 +12,7 @@ obj-$(CONFIG_MMA8452) += mma8452.o
12 12
13obj-$(CONFIG_MMA9551_CORE) += mma9551_core.o 13obj-$(CONFIG_MMA9551_CORE) += mma9551_core.o
14obj-$(CONFIG_MMA9551) += mma9551.o 14obj-$(CONFIG_MMA9551) += mma9551.o
15obj-$(CONFIG_MMA9553) += mma9553.o
15 16
16obj-$(CONFIG_IIO_SSP_SENSORS_COMMONS) += ssp_accel_sensor.o 17obj-$(CONFIG_IIO_SSP_SENSORS_COMMONS) += ssp_accel_sensor.o
17 18
diff --git a/drivers/iio/accel/mma9551_core.c b/drivers/iio/accel/mma9551_core.c
index 7f1a73e6aa36..7f55a6d7cd03 100644
--- a/drivers/iio/accel/mma9551_core.c
+++ b/drivers/iio/accel/mma9551_core.c
@@ -53,6 +53,11 @@
53#define MMA9551_AFE_Y_ACCEL_REG 0x02 53#define MMA9551_AFE_Y_ACCEL_REG 0x02
54#define MMA9551_AFE_Z_ACCEL_REG 0x04 54#define MMA9551_AFE_Z_ACCEL_REG 0x04
55 55
56/* Reset/Suspend/Clear application */
57#define MMA9551_RSC_RESET 0x00
58#define MMA9551_RSC_OFFSET(mask) (3 - (ffs(mask) - 1) / 8)
59#define MMA9551_RSC_VAL(mask) (mask >> (((ffs(mask) - 1) / 8) * 8))
60
56/* 61/*
57 * A response is composed of: 62 * A response is composed of:
58 * - control registers: MB0-3 63 * - control registers: MB0-3
@@ -275,6 +280,64 @@ int mma9551_read_status_byte(struct i2c_client *client, u8 app_id,
275EXPORT_SYMBOL(mma9551_read_status_byte); 280EXPORT_SYMBOL(mma9551_read_status_byte);
276 281
277/** 282/**
283 * mma9551_read_config_word() - read 1 config word
284 * @client: I2C client
285 * @app_id: Application ID
286 * @reg: Application register
287 * @val: Pointer to store value read
288 *
289 * Read one configuration word from the device using MMA955xL command format.
290 * Commands to the MMA955xL platform consist of a write followed by one or
291 * more reads.
292 *
293 * Locking note: This function must be called with the device lock held.
294 * Locking is not handled inside the function. Callers should ensure they
295 * serialize access to the HW.
296 *
297 * Returns: 0 on success, negative value on failure.
298 */
299int mma9551_read_config_word(struct i2c_client *client, u8 app_id,
300 u16 reg, u16 *val)
301{
302 int ret;
303 __be16 v;
304
305 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
306 reg, NULL, 0, (u8 *)&v, 2);
307 *val = be16_to_cpu(v);
308
309 return ret;
310}
311EXPORT_SYMBOL(mma9551_read_config_word);
312
313/**
314 * mma9551_write_config_word() - write 1 config word
315 * @client: I2C client
316 * @app_id: Application ID
317 * @reg: Application register
318 * @val: Value to write
319 *
320 * Write one configuration word from the device using MMA955xL command format.
321 * Commands to the MMA955xL platform consist of a write followed by one or
322 * more reads.
323 *
324 * Locking note: This function must be called with the device lock held.
325 * Locking is not handled inside the function. Callers should ensure they
326 * serialize access to the HW.
327 *
328 * Returns: 0 on success, negative value on failure.
329 */
330int mma9551_write_config_word(struct i2c_client *client, u8 app_id,
331 u16 reg, u16 val)
332{
333 __be16 v = cpu_to_be16(val);
334
335 return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg,
336 (u8 *) &v, 2, NULL, 0);
337}
338EXPORT_SYMBOL(mma9551_write_config_word);
339
340/**
278 * mma9551_read_status_word() - read 1 status word 341 * mma9551_read_status_word() - read 1 status word
279 * @client: I2C client 342 * @client: I2C client
280 * @app_id: Application ID 343 * @app_id: Application ID
@@ -306,6 +369,107 @@ int mma9551_read_status_word(struct i2c_client *client, u8 app_id,
306EXPORT_SYMBOL(mma9551_read_status_word); 369EXPORT_SYMBOL(mma9551_read_status_word);
307 370
308/** 371/**
372 * mma9551_read_config_words() - read multiple config words
373 * @client: I2C client
374 * @app_id: Application ID
375 * @reg: Application register
376 * @len: Length of array to read in bytes
377 * @val: Array of words to read
378 *
379 * Read multiple configuration registers (word-sized registers).
380 *
381 * Locking note: This function must be called with the device lock held.
382 * Locking is not handled inside the function. Callers should ensure they
383 * serialize access to the HW.
384 *
385 * Returns: 0 on success, negative value on failure.
386 */
387int mma9551_read_config_words(struct i2c_client *client, u8 app_id,
388 u16 reg, u8 len, u16 *buf)
389{
390 int ret, i;
391 int len_words = len / sizeof(u16);
392 __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS];
393
394 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
395 reg, NULL, 0, (u8 *) be_buf, len);
396 if (ret < 0)
397 return ret;
398
399 for (i = 0; i < len_words; i++)
400 buf[i] = be16_to_cpu(be_buf[i]);
401
402 return 0;
403}
404EXPORT_SYMBOL(mma9551_read_config_words);
405
406/**
407 * mma9551_read_status_words() - read multiple status words
408 * @client: I2C client
409 * @app_id: Application ID
410 * @reg: Application register
411 * @len: Length of array to read in bytes
412 * @val: Array of words to read
413 *
414 * Read multiple status registers (word-sized registers).
415 *
416 * Locking note: This function must be called with the device lock held.
417 * Locking is not handled inside the function. Callers should ensure they
418 * serialize access to the HW.
419 *
420 * Returns: 0 on success, negative value on failure.
421 */
422int mma9551_read_status_words(struct i2c_client *client, u8 app_id,
423 u16 reg, u8 len, u16 *buf)
424{
425 int ret, i;
426 int len_words = len / sizeof(u16);
427 __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS];
428
429 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
430 reg, NULL, 0, (u8 *) be_buf, len);
431 if (ret < 0)
432 return ret;
433
434 for (i = 0; i < len_words; i++)
435 buf[i] = be16_to_cpu(be_buf[i]);
436
437 return 0;
438}
439EXPORT_SYMBOL(mma9551_read_status_words);
440
441/**
442 * mma9551_write_config_words() - write multiple config words
443 * @client: I2C client
444 * @app_id: Application ID
445 * @reg: Application register
446 * @len: Length of array to write in bytes
447 * @val: Array of words to write
448 *
449 * Write multiple configuration registers (word-sized registers).
450 *
451 * Locking note: This function must be called with the device lock held.
452 * Locking is not handled inside the function. Callers should ensure they
453 * serialize access to the HW.
454 *
455 * Returns: 0 on success, negative value on failure.
456 */
457int mma9551_write_config_words(struct i2c_client *client, u8 app_id,
458 u16 reg, u8 len, u16 *buf)
459{
460 int i;
461 int len_words = len / sizeof(u16);
462 __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS];
463
464 for (i = 0; i < len_words; i++)
465 be_buf[i] = cpu_to_be16(buf[i]);
466
467 return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG,
468 reg, (u8 *) be_buf, len, NULL, 0);
469}
470EXPORT_SYMBOL(mma9551_write_config_words);
471
472/**
309 * mma9551_update_config_bits() - update bits in register 473 * mma9551_update_config_bits() - update bits in register
310 * @client: I2C client 474 * @client: I2C client
311 * @app_id: Application ID 475 * @app_id: Application ID
@@ -609,6 +773,25 @@ int mma9551_read_accel_scale(int *val, int *val2)
609} 773}
610EXPORT_SYMBOL(mma9551_read_accel_scale); 774EXPORT_SYMBOL(mma9551_read_accel_scale);
611 775
776/**
777 * mma9551_app_reset() - reset application
778 * @client: I2C client
779 * @app_mask: Application to reset
780 *
781 * Reset the given application (using the Reset/Suspend/Clear
782 * Control Application)
783 *
784 * Returns: 0 on success, negative value on failure.
785 */
786int mma9551_app_reset(struct i2c_client *client, u32 app_mask)
787{
788 return mma9551_write_config_byte(client, MMA9551_APPID_RCS,
789 MMA9551_RSC_RESET +
790 MMA9551_RSC_OFFSET(app_mask),
791 MMA9551_RSC_VAL(app_mask));
792}
793EXPORT_SYMBOL(mma9551_app_reset);
794
612MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>"); 795MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
613MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>"); 796MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
614MODULE_LICENSE("GPL v2"); 797MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/accel/mma9551_core.h b/drivers/iio/accel/mma9551_core.h
index e6efd027f49a..edaa56b1078e 100644
--- a/drivers/iio/accel/mma9551_core.h
+++ b/drivers/iio/accel/mma9551_core.h
@@ -21,9 +21,13 @@
21#define MMA9551_APPID_AFE 0x06 21#define MMA9551_APPID_AFE 0x06
22#define MMA9551_APPID_TILT 0x0B 22#define MMA9551_APPID_TILT 0x0B
23#define MMA9551_APPID_SLEEP_WAKE 0x12 23#define MMA9551_APPID_SLEEP_WAKE 0x12
24#define MMA9551_APPID_RESET 0x17 24#define MMA9551_APPID_PEDOMETER 0x15
25#define MMA9551_APPID_RCS 0x17
25#define MMA9551_APPID_NONE 0xff 26#define MMA9551_APPID_NONE 0xff
26 27
28/* Reset/Suspend/Clear application app masks */
29#define MMA9551_RSC_PED BIT(21)
30
27#define MMA9551_AUTO_SUSPEND_DELAY_MS 2000 31#define MMA9551_AUTO_SUSPEND_DELAY_MS 2000
28 32
29enum mma9551_gpio_pin { 33enum mma9551_gpio_pin {
@@ -48,8 +52,18 @@ int mma9551_write_config_byte(struct i2c_client *client, u8 app_id,
48 u16 reg, u8 val); 52 u16 reg, u8 val);
49int mma9551_read_status_byte(struct i2c_client *client, u8 app_id, 53int mma9551_read_status_byte(struct i2c_client *client, u8 app_id,
50 u16 reg, u8 *val); 54 u16 reg, u8 *val);
55int mma9551_read_config_word(struct i2c_client *client, u8 app_id,
56 u16 reg, u16 *val);
57int mma9551_write_config_word(struct i2c_client *client, u8 app_id,
58 u16 reg, u16 val);
51int mma9551_read_status_word(struct i2c_client *client, u8 app_id, 59int mma9551_read_status_word(struct i2c_client *client, u8 app_id,
52 u16 reg, u16 *val); 60 u16 reg, u16 *val);
61int mma9551_read_config_words(struct i2c_client *client, u8 app_id,
62 u16 reg, u8 len, u16 *buf);
63int mma9551_read_status_words(struct i2c_client *client, u8 app_id,
64 u16 reg, u8 len, u16 *buf);
65int mma9551_write_config_words(struct i2c_client *client, u8 app_id,
66 u16 reg, u8 len, u16 *buf);
53int mma9551_update_config_bits(struct i2c_client *client, u8 app_id, 67int mma9551_update_config_bits(struct i2c_client *client, u8 app_id,
54 u16 reg, u8 mask, u8 val); 68 u16 reg, u8 mask, u8 val);
55int mma9551_gpio_config(struct i2c_client *client, enum mma9551_gpio_pin pin, 69int mma9551_gpio_config(struct i2c_client *client, enum mma9551_gpio_pin pin,
@@ -62,5 +76,6 @@ int mma9551_read_accel_chan(struct i2c_client *client,
62 const struct iio_chan_spec *chan, 76 const struct iio_chan_spec *chan,
63 int *val, int *val2); 77 int *val, int *val2);
64int mma9551_read_accel_scale(int *val, int *val2); 78int mma9551_read_accel_scale(int *val, int *val2);
79int mma9551_app_reset(struct i2c_client *client, u32 app_mask);
65 80
66#endif /* _MMA9551_CORE_H_ */ 81#endif /* _MMA9551_CORE_H_ */
diff --git a/drivers/iio/accel/mma9553.c b/drivers/iio/accel/mma9553.c
new file mode 100644
index 000000000000..d23ebf192f63
--- /dev/null
+++ b/drivers/iio/accel/mma9553.c
@@ -0,0 +1,1334 @@
1/*
2 * Freescale MMA9553L Intelligent Pedometer 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/gpio/consumer.h>
21#include <linux/iio/iio.h>
22#include <linux/iio/sysfs.h>
23#include <linux/iio/events.h>
24#include <linux/pm_runtime.h>
25#include "mma9551_core.h"
26
27#define MMA9553_DRV_NAME "mma9553"
28#define MMA9553_IRQ_NAME "mma9553_event"
29#define MMA9553_GPIO_NAME "mma9553_int"
30
31/* Pedometer configuration registers (R/W) */
32#define MMA9553_REG_CONF_SLEEPMIN 0x00
33#define MMA9553_REG_CONF_SLEEPMAX 0x02
34#define MMA9553_REG_CONF_SLEEPTHD 0x04
35#define MMA9553_MASK_CONF_WORD GENMASK(15, 0)
36
37#define MMA9553_REG_CONF_CONF_STEPLEN 0x06
38#define MMA9553_MASK_CONF_CONFIG BIT(15)
39#define MMA9553_MASK_CONF_ACT_DBCNTM BIT(14)
40#define MMA9553_MASK_CONF_SLP_DBCNTM BIT(13)
41#define MMA9553_MASK_CONF_STEPLEN GENMASK(7, 0)
42
43#define MMA9553_REG_CONF_HEIGHT_WEIGHT 0x08
44#define MMA9553_MASK_CONF_HEIGHT GENMASK(15, 8)
45#define MMA9553_MASK_CONF_WEIGHT GENMASK(7, 0)
46
47#define MMA9553_REG_CONF_FILTER 0x0A
48#define MMA9553_MASK_CONF_FILTSTEP GENMASK(15, 8)
49#define MMA9553_MASK_CONF_MALE BIT(7)
50#define MMA9553_MASK_CONF_FILTTIME GENMASK(6, 0)
51
52#define MMA9553_REG_CONF_SPEED_STEP 0x0C
53#define MMA9553_MASK_CONF_SPDPRD GENMASK(15, 8)
54#define MMA9553_MASK_CONF_STEPCOALESCE GENMASK(7, 0)
55
56#define MMA9553_REG_CONF_ACTTHD 0x0E
57
58/* Pedometer status registers (R-only) */
59#define MMA9553_REG_STATUS 0x00
60#define MMA9553_MASK_STATUS_MRGFL BIT(15)
61#define MMA9553_MASK_STATUS_SUSPCHG BIT(14)
62#define MMA9553_MASK_STATUS_STEPCHG BIT(13)
63#define MMA9553_MASK_STATUS_ACTCHG BIT(12)
64#define MMA9553_MASK_STATUS_SUSP BIT(11)
65#define MMA9553_MASK_STATUS_ACTIVITY (BIT(10) | BIT(9) | BIT(8))
66#define MMA9553_MASK_STATUS_VERSION 0x00FF
67
68#define MMA9553_REG_STEPCNT 0x02
69#define MMA9553_REG_DISTANCE 0x04
70#define MMA9553_REG_SPEED 0x06
71#define MMA9553_REG_CALORIES 0x08
72#define MMA9553_REG_SLEEPCNT 0x0A
73
74/* Pedometer events are always mapped to this pin. */
75#define MMA9553_DEFAULT_GPIO_PIN mma9551_gpio6
76#define MMA9553_DEFAULT_GPIO_POLARITY 0
77
78/* Bitnum used for gpio configuration = bit number in high status byte */
79#define STATUS_TO_BITNUM(bit) (ffs(bit) - 9)
80
81#define MMA9553_DEFAULT_SAMPLE_RATE 30 /* Hz */
82
83/*
84 * The internal activity level must be stable for ACTTHD samples before
85 * ACTIVITY is updated.The ACTIVITY variable contains the current activity
86 * level and is updated every time a step is detected or once a second
87 * if there are no steps.
88 */
89#define MMA9553_ACTIVITY_THD_TO_SEC(thd) ((thd) / MMA9553_DEFAULT_SAMPLE_RATE)
90#define MMA9553_ACTIVITY_SEC_TO_THD(sec) ((sec) * MMA9553_DEFAULT_SAMPLE_RATE)
91
92/*
93 * Autonomously suspend pedometer if acceleration vector magnitude
94 * is near 1g (4096 at 0.244 mg/LSB resolution) for 30 seconds.
95 */
96#define MMA9553_DEFAULT_SLEEPMIN 3688 /* 0,9 g */
97#define MMA9553_DEFAULT_SLEEPMAX 4508 /* 1,1 g */
98#define MMA9553_DEFAULT_SLEEPTHD (MMA9553_DEFAULT_SAMPLE_RATE * 30)
99
100#define MMA9553_CONFIG_RETRIES 2
101
102/* Status register - activity field */
103enum activity_level {
104 ACTIVITY_UNKNOWN,
105 ACTIVITY_REST,
106 ACTIVITY_WALKING,
107 ACTIVITY_JOGGING,
108 ACTIVITY_RUNNING,
109};
110
111static struct mma9553_event_info {
112 enum iio_chan_type type;
113 enum iio_modifier mod;
114 enum iio_event_direction dir;
115} mma9553_events_info[] = {
116 {
117 .type = IIO_STEPS,
118 .mod = IIO_NO_MOD,
119 .dir = IIO_EV_DIR_NONE,
120 },
121 {
122 .type = IIO_ACTIVITY,
123 .mod = IIO_MOD_STILL,
124 .dir = IIO_EV_DIR_RISING,
125 },
126 {
127 .type = IIO_ACTIVITY,
128 .mod = IIO_MOD_STILL,
129 .dir = IIO_EV_DIR_FALLING,
130 },
131 {
132 .type = IIO_ACTIVITY,
133 .mod = IIO_MOD_WALKING,
134 .dir = IIO_EV_DIR_RISING,
135 },
136 {
137 .type = IIO_ACTIVITY,
138 .mod = IIO_MOD_WALKING,
139 .dir = IIO_EV_DIR_FALLING,
140 },
141 {
142 .type = IIO_ACTIVITY,
143 .mod = IIO_MOD_JOGGING,
144 .dir = IIO_EV_DIR_RISING,
145 },
146 {
147 .type = IIO_ACTIVITY,
148 .mod = IIO_MOD_JOGGING,
149 .dir = IIO_EV_DIR_FALLING,
150 },
151 {
152 .type = IIO_ACTIVITY,
153 .mod = IIO_MOD_RUNNING,
154 .dir = IIO_EV_DIR_RISING,
155 },
156 {
157 .type = IIO_ACTIVITY,
158 .mod = IIO_MOD_RUNNING,
159 .dir = IIO_EV_DIR_FALLING,
160 },
161};
162
163#define MMA9553_EVENTS_INFO_SIZE ARRAY_SIZE(mma9553_events_info)
164
165struct mma9553_event {
166 struct mma9553_event_info *info;
167 bool enabled;
168};
169
170struct mma9553_conf_regs {
171 u16 sleepmin;
172 u16 sleepmax;
173 u16 sleepthd;
174 u16 config;
175 u16 height_weight;
176 u16 filter;
177 u16 speed_step;
178 u16 actthd;
179} __packed;
180
181struct mma9553_data {
182 struct i2c_client *client;
183 struct mutex mutex;
184 struct mma9553_conf_regs conf;
185 struct mma9553_event events[MMA9553_EVENTS_INFO_SIZE];
186 int num_events;
187 u8 gpio_bitnum;
188 /*
189 * This is used for all features that depend on step count:
190 * step count, distance, speed, calories.
191 */
192 bool stepcnt_enabled;
193 u16 stepcnt;
194 u8 activity;
195 s64 timestamp;
196};
197
198static u8 mma9553_get_bits(u16 val, u16 mask)
199{
200 return (val & mask) >> (ffs(mask) - 1);
201}
202
203static u16 mma9553_set_bits(u16 current_val, u16 val, u16 mask)
204{
205 return (current_val & ~mask) | (val << (ffs(mask) - 1));
206}
207
208static enum iio_modifier mma9553_activity_to_mod(enum activity_level activity)
209{
210 switch (activity) {
211 case ACTIVITY_RUNNING:
212 return IIO_MOD_RUNNING;
213 case ACTIVITY_JOGGING:
214 return IIO_MOD_JOGGING;
215 case ACTIVITY_WALKING:
216 return IIO_MOD_WALKING;
217 case ACTIVITY_REST:
218 return IIO_MOD_STILL;
219 case ACTIVITY_UNKNOWN:
220 default:
221 return IIO_NO_MOD;
222 }
223}
224
225static void mma9553_init_events(struct mma9553_data *data)
226{
227 int i;
228
229 data->num_events = MMA9553_EVENTS_INFO_SIZE;
230 for (i = 0; i < data->num_events; i++) {
231 data->events[i].info = &mma9553_events_info[i];
232 data->events[i].enabled = false;
233 }
234}
235
236static struct mma9553_event *mma9553_get_event(struct mma9553_data *data,
237 enum iio_chan_type type,
238 enum iio_modifier mod,
239 enum iio_event_direction dir)
240{
241 int i;
242
243 for (i = 0; i < data->num_events; i++)
244 if (data->events[i].info->type == type &&
245 data->events[i].info->mod == mod &&
246 data->events[i].info->dir == dir)
247 return &data->events[i];
248
249 return NULL;
250}
251
252static bool mma9553_is_any_event_enabled(struct mma9553_data *data,
253 bool check_type,
254 enum iio_chan_type type)
255{
256 int i;
257
258 for (i = 0; i < data->num_events; i++)
259 if ((check_type && data->events[i].info->type == type &&
260 data->events[i].enabled) ||
261 (!check_type && data->events[i].enabled))
262 return true;
263
264 return false;
265}
266
267static int mma9553_set_config(struct mma9553_data *data, u16 reg,
268 u16 *p_reg_val, u16 val, u16 mask)
269{
270 int ret, retries;
271 u16 reg_val, config;
272
273 reg_val = *p_reg_val;
274 if (val == mma9553_get_bits(reg_val, mask))
275 return 0;
276
277 reg_val = mma9553_set_bits(reg_val, val, mask);
278 ret = mma9551_write_config_word(data->client, MMA9551_APPID_PEDOMETER,
279 reg, reg_val);
280 if (ret < 0) {
281 dev_err(&data->client->dev,
282 "error writing config register 0x%x\n", reg);
283 return ret;
284 }
285
286 *p_reg_val = reg_val;
287
288 /* Reinitializes the pedometer with current configuration values */
289 config = mma9553_set_bits(data->conf.config, 1,
290 MMA9553_MASK_CONF_CONFIG);
291
292 ret = mma9551_write_config_word(data->client, MMA9551_APPID_PEDOMETER,
293 MMA9553_REG_CONF_CONF_STEPLEN, config);
294 if (ret < 0) {
295 dev_err(&data->client->dev,
296 "error writing config register 0x%x\n",
297 MMA9553_REG_CONF_CONF_STEPLEN);
298 return ret;
299 }
300
301 retries = MMA9553_CONFIG_RETRIES;
302 do {
303 mma9551_sleep(MMA9553_DEFAULT_SAMPLE_RATE);
304 ret = mma9551_read_config_word(data->client,
305 MMA9551_APPID_PEDOMETER,
306 MMA9553_REG_CONF_CONF_STEPLEN,
307 &config);
308 if (ret < 0)
309 return ret;
310 } while (mma9553_get_bits(config, MMA9553_MASK_CONF_CONFIG) &&
311 --retries > 0);
312
313 return 0;
314}
315
316static int mma9553_read_activity_stepcnt(struct mma9553_data *data,
317 u8 *activity, u16 *stepcnt)
318{
319 u32 status_stepcnt;
320 u16 status;
321 int ret;
322
323 ret = mma9551_read_status_words(data->client, MMA9551_APPID_PEDOMETER,
324 MMA9553_REG_STATUS, sizeof(u32),
325 (u16 *) &status_stepcnt);
326 if (ret < 0) {
327 dev_err(&data->client->dev,
328 "error reading status and stepcnt\n");
329 return ret;
330 }
331
332 status = status_stepcnt & MMA9553_MASK_CONF_WORD;
333 *activity = mma9553_get_bits(status, MMA9553_MASK_STATUS_ACTIVITY);
334 *stepcnt = status_stepcnt >> 16;
335
336 return 0;
337}
338
339static int mma9553_conf_gpio(struct mma9553_data *data)
340{
341 u8 bitnum = 0, appid = MMA9551_APPID_PEDOMETER;
342 int ret;
343 struct mma9553_event *ev_step_detect;
344 bool activity_enabled;
345
346 activity_enabled =
347 mma9553_is_any_event_enabled(data, true, IIO_ACTIVITY);
348 ev_step_detect =
349 mma9553_get_event(data, IIO_STEPS, IIO_NO_MOD, IIO_EV_DIR_NONE);
350
351 /*
352 * If both step detector and activity are enabled, use the MRGFL bit.
353 * This bit is the logical OR of the SUSPCHG, STEPCHG, and ACTCHG flags.
354 */
355 if (activity_enabled && ev_step_detect->enabled)
356 bitnum = STATUS_TO_BITNUM(MMA9553_MASK_STATUS_MRGFL);
357 else if (ev_step_detect->enabled)
358 bitnum = STATUS_TO_BITNUM(MMA9553_MASK_STATUS_STEPCHG);
359 else if (activity_enabled)
360 bitnum = STATUS_TO_BITNUM(MMA9553_MASK_STATUS_ACTCHG);
361 else /* Reset */
362 appid = MMA9551_APPID_NONE;
363
364 if (data->gpio_bitnum == bitnum)
365 return 0;
366
367 /* Save initial values for activity and stepcnt */
368 if (activity_enabled || ev_step_detect->enabled)
369 mma9553_read_activity_stepcnt(data, &data->activity,
370 &data->stepcnt);
371
372 ret = mma9551_gpio_config(data->client,
373 MMA9553_DEFAULT_GPIO_PIN,
374 appid, bitnum, MMA9553_DEFAULT_GPIO_POLARITY);
375 if (ret < 0)
376 return ret;
377 data->gpio_bitnum = bitnum;
378
379 return 0;
380}
381
382static int mma9553_init(struct mma9553_data *data)
383{
384 int ret;
385
386 ret = mma9551_read_version(data->client);
387 if (ret)
388 return ret;
389
390 /*
391 * Read all the pedometer configuration registers. This is used as
392 * a device identification command to differentiate the MMA9553L
393 * from the MMA9550L.
394 */
395 ret =
396 mma9551_read_config_words(data->client, MMA9551_APPID_PEDOMETER,
397 MMA9553_REG_CONF_SLEEPMIN,
398 sizeof(data->conf), (u16 *) &data->conf);
399 if (ret < 0) {
400 dev_err(&data->client->dev,
401 "device is not MMA9553L: failed to read cfg regs\n");
402 return ret;
403 }
404
405
406 /* Reset gpio */
407 data->gpio_bitnum = -1;
408 ret = mma9553_conf_gpio(data);
409 if (ret < 0)
410 return ret;
411
412 ret = mma9551_app_reset(data->client, MMA9551_RSC_PED);
413 if (ret < 0)
414 return ret;
415
416 /* Init config registers */
417 data->conf.sleepmin = MMA9553_DEFAULT_SLEEPMIN;
418 data->conf.sleepmax = MMA9553_DEFAULT_SLEEPMAX;
419 data->conf.sleepthd = MMA9553_DEFAULT_SLEEPTHD;
420 data->conf.config =
421 mma9553_set_bits(data->conf.config, 1, MMA9553_MASK_CONF_CONFIG);
422 /*
423 * Clear the activity debounce counter when the activity level changes,
424 * so that the confidence level applies for any activity level.
425 */
426 data->conf.config = mma9553_set_bits(data->conf.config, 1,
427 MMA9553_MASK_CONF_ACT_DBCNTM);
428 ret =
429 mma9551_write_config_words(data->client, MMA9551_APPID_PEDOMETER,
430 MMA9553_REG_CONF_SLEEPMIN,
431 sizeof(data->conf), (u16 *) &data->conf);
432 if (ret < 0) {
433 dev_err(&data->client->dev,
434 "failed to write configuration registers\n");
435 return ret;
436 }
437
438 return mma9551_set_device_state(data->client, true);
439}
440
441static int mma9553_read_raw(struct iio_dev *indio_dev,
442 struct iio_chan_spec const *chan,
443 int *val, int *val2, long mask)
444{
445 struct mma9553_data *data = iio_priv(indio_dev);
446 int ret;
447 u16 tmp;
448 u8 activity;
449 bool powered_on;
450
451 switch (mask) {
452 case IIO_CHAN_INFO_PROCESSED:
453 switch (chan->type) {
454 case IIO_STEPS:
455 /*
456 * The HW only counts steps and other dependent
457 * parameters (speed, distance, calories, activity)
458 * if power is on (from enabling an event or the
459 * step counter */
460 powered_on =
461 mma9553_is_any_event_enabled(data, false, 0) ||
462 data->stepcnt_enabled;
463 if (!powered_on) {
464 dev_err(&data->client->dev,
465 "No channels enabled\n");
466 return -EINVAL;
467 }
468 mutex_lock(&data->mutex);
469 ret = mma9551_read_status_word(data->client,
470 MMA9551_APPID_PEDOMETER,
471 MMA9553_REG_STEPCNT,
472 &tmp);
473 mutex_unlock(&data->mutex);
474 if (ret < 0)
475 return ret;
476 *val = tmp;
477 return IIO_VAL_INT;
478 case IIO_DISTANCE:
479 powered_on =
480 mma9553_is_any_event_enabled(data, false, 0) ||
481 data->stepcnt_enabled;
482 if (!powered_on) {
483 dev_err(&data->client->dev,
484 "No channels enabled\n");
485 return -EINVAL;
486 }
487 mutex_lock(&data->mutex);
488 ret = mma9551_read_status_word(data->client,
489 MMA9551_APPID_PEDOMETER,
490 MMA9553_REG_DISTANCE,
491 &tmp);
492 mutex_unlock(&data->mutex);
493 if (ret < 0)
494 return ret;
495 *val = tmp;
496 return IIO_VAL_INT;
497 case IIO_ACTIVITY:
498 powered_on =
499 mma9553_is_any_event_enabled(data, false, 0) ||
500 data->stepcnt_enabled;
501 if (!powered_on) {
502 dev_err(&data->client->dev,
503 "No channels enabled\n");
504 return -EINVAL;
505 }
506 mutex_lock(&data->mutex);
507 ret = mma9551_read_status_word(data->client,
508 MMA9551_APPID_PEDOMETER,
509 MMA9553_REG_STATUS,
510 &tmp);
511 mutex_unlock(&data->mutex);
512 if (ret < 0)
513 return ret;
514
515 activity =
516 mma9553_get_bits(tmp, MMA9553_MASK_STATUS_ACTIVITY);
517
518 /*
519 * The device does not support confidence value levels,
520 * so we will always have 100% for current activity and
521 * 0% for the others.
522 */
523 if (chan->channel2 == mma9553_activity_to_mod(activity))
524 *val = 100;
525 else
526 *val = 0;
527 return IIO_VAL_INT;
528 default:
529 return -EINVAL;
530 }
531 case IIO_CHAN_INFO_RAW:
532 switch (chan->type) {
533 case IIO_VELOCITY: /* m/h */
534 if (chan->channel2 != IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z)
535 return -EINVAL;
536 powered_on =
537 mma9553_is_any_event_enabled(data, false, 0) ||
538 data->stepcnt_enabled;
539 if (!powered_on) {
540 dev_err(&data->client->dev,
541 "No channels enabled\n");
542 return -EINVAL;
543 }
544 mutex_lock(&data->mutex);
545 ret = mma9551_read_status_word(data->client,
546 MMA9551_APPID_PEDOMETER,
547 MMA9553_REG_SPEED, &tmp);
548 mutex_unlock(&data->mutex);
549 if (ret < 0)
550 return ret;
551 *val = tmp;
552 return IIO_VAL_INT;
553 case IIO_ENERGY: /* Cal or kcal */
554 powered_on =
555 mma9553_is_any_event_enabled(data, false, 0) ||
556 data->stepcnt_enabled;
557 if (!powered_on) {
558 dev_err(&data->client->dev,
559 "No channels enabled\n");
560 return -EINVAL;
561 }
562 mutex_lock(&data->mutex);
563 ret = mma9551_read_status_word(data->client,
564 MMA9551_APPID_PEDOMETER,
565 MMA9553_REG_CALORIES,
566 &tmp);
567 mutex_unlock(&data->mutex);
568 if (ret < 0)
569 return ret;
570 *val = tmp;
571 return IIO_VAL_INT;
572 case IIO_ACCEL:
573 mutex_lock(&data->mutex);
574 ret = mma9551_read_accel_chan(data->client,
575 chan, val, val2);
576 mutex_unlock(&data->mutex);
577 return ret;
578 default:
579 return -EINVAL;
580 }
581 case IIO_CHAN_INFO_SCALE:
582 switch (chan->type) {
583 case IIO_VELOCITY: /* m/h to m/s */
584 if (chan->channel2 != IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z)
585 return -EINVAL;
586 *val = 0;
587 *val2 = 277; /* 0.000277 */
588 return IIO_VAL_INT_PLUS_MICRO;
589 case IIO_ENERGY: /* Cal or kcal to J */
590 *val = 4184;
591 return IIO_VAL_INT;
592 case IIO_ACCEL:
593 return mma9551_read_accel_scale(val, val2);
594 default:
595 return -EINVAL;
596 }
597 case IIO_CHAN_INFO_ENABLE:
598 *val = data->stepcnt_enabled;
599 return IIO_VAL_INT;
600 case IIO_CHAN_INFO_CALIBHEIGHT:
601 tmp = mma9553_get_bits(data->conf.height_weight,
602 MMA9553_MASK_CONF_HEIGHT);
603 *val = tmp / 100; /* cm to m */
604 *val2 = (tmp % 100) * 10000;
605 return IIO_VAL_INT_PLUS_MICRO;
606 case IIO_CHAN_INFO_CALIBWEIGHT:
607 *val = mma9553_get_bits(data->conf.height_weight,
608 MMA9553_MASK_CONF_WEIGHT);
609 return IIO_VAL_INT;
610 case IIO_CHAN_INFO_DEBOUNCE_COUNT:
611 switch (chan->type) {
612 case IIO_STEPS:
613 *val = mma9553_get_bits(data->conf.filter,
614 MMA9553_MASK_CONF_FILTSTEP);
615 return IIO_VAL_INT;
616 default:
617 return -EINVAL;
618 }
619 case IIO_CHAN_INFO_DEBOUNCE_TIME:
620 switch (chan->type) {
621 case IIO_STEPS:
622 *val = mma9553_get_bits(data->conf.filter,
623 MMA9553_MASK_CONF_FILTTIME);
624 return IIO_VAL_INT;
625 default:
626 return -EINVAL;
627 }
628 case IIO_CHAN_INFO_INT_TIME:
629 switch (chan->type) {
630 case IIO_VELOCITY:
631 if (chan->channel2 != IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z)
632 return -EINVAL;
633 *val = mma9553_get_bits(data->conf.speed_step,
634 MMA9553_MASK_CONF_SPDPRD);
635 return IIO_VAL_INT;
636 default:
637 return -EINVAL;
638 }
639 default:
640 return -EINVAL;
641 }
642}
643
644static int mma9553_write_raw(struct iio_dev *indio_dev,
645 struct iio_chan_spec const *chan,
646 int val, int val2, long mask)
647{
648 struct mma9553_data *data = iio_priv(indio_dev);
649 int ret, tmp;
650
651 switch (mask) {
652 case IIO_CHAN_INFO_ENABLE:
653 if (data->stepcnt_enabled == !!val)
654 return 0;
655 mutex_lock(&data->mutex);
656 ret = mma9551_set_power_state(data->client, val);
657 if (ret < 0) {
658 mutex_unlock(&data->mutex);
659 return ret;
660 }
661 data->stepcnt_enabled = val;
662 mutex_unlock(&data->mutex);
663 return 0;
664 case IIO_CHAN_INFO_CALIBHEIGHT:
665 /* m to cm */
666 tmp = val * 100 + val2 / 10000;
667 if (tmp < 0 || tmp > 255)
668 return -EINVAL;
669 mutex_lock(&data->mutex);
670 ret = mma9553_set_config(data,
671 MMA9553_REG_CONF_HEIGHT_WEIGHT,
672 &data->conf.height_weight,
673 tmp, MMA9553_MASK_CONF_HEIGHT);
674 mutex_unlock(&data->mutex);
675 return ret;
676 case IIO_CHAN_INFO_CALIBWEIGHT:
677 if (val < 0 || val > 255)
678 return -EINVAL;
679 mutex_lock(&data->mutex);
680 ret = mma9553_set_config(data,
681 MMA9553_REG_CONF_HEIGHT_WEIGHT,
682 &data->conf.height_weight,
683 val, MMA9553_MASK_CONF_WEIGHT);
684 mutex_unlock(&data->mutex);
685 return ret;
686 case IIO_CHAN_INFO_DEBOUNCE_COUNT:
687 switch (chan->type) {
688 case IIO_STEPS:
689 /*
690 * Set to 0 to disable step filtering. If the value
691 * specified is greater than 6, then 6 will be used.
692 */
693 if (val < 0)
694 return -EINVAL;
695 if (val > 6)
696 val = 6;
697 mutex_lock(&data->mutex);
698 ret = mma9553_set_config(data, MMA9553_REG_CONF_FILTER,
699 &data->conf.filter, val,
700 MMA9553_MASK_CONF_FILTSTEP);
701 mutex_unlock(&data->mutex);
702 return ret;
703 default:
704 return -EINVAL;
705 }
706 case IIO_CHAN_INFO_DEBOUNCE_TIME:
707 switch (chan->type) {
708 case IIO_STEPS:
709 if (val < 0 || val > 127)
710 return -EINVAL;
711 mutex_lock(&data->mutex);
712 ret = mma9553_set_config(data, MMA9553_REG_CONF_FILTER,
713 &data->conf.filter, val,
714 MMA9553_MASK_CONF_FILTTIME);
715 mutex_unlock(&data->mutex);
716 return ret;
717 default:
718 return -EINVAL;
719 }
720 case IIO_CHAN_INFO_INT_TIME:
721 switch (chan->type) {
722 case IIO_VELOCITY:
723 if (chan->channel2 != IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z)
724 return -EINVAL;
725 /*
726 * If set to a value greater than 5, then 5 will be
727 * used. Warning: Do not set SPDPRD to 0 or 1 as
728 * this may cause undesirable behavior.
729 */
730 if (val < 2)
731 return -EINVAL;
732 if (val > 5)
733 val = 5;
734 mutex_lock(&data->mutex);
735 ret = mma9553_set_config(data,
736 MMA9553_REG_CONF_SPEED_STEP,
737 &data->conf.speed_step, val,
738 MMA9553_MASK_CONF_SPDPRD);
739 mutex_unlock(&data->mutex);
740 return ret;
741 default:
742 return -EINVAL;
743 }
744 default:
745 return -EINVAL;
746 }
747}
748
749static int mma9553_read_event_config(struct iio_dev *indio_dev,
750 const struct iio_chan_spec *chan,
751 enum iio_event_type type,
752 enum iio_event_direction dir)
753{
754
755 struct mma9553_data *data = iio_priv(indio_dev);
756 struct mma9553_event *event;
757
758 event = mma9553_get_event(data, chan->type, chan->channel2, dir);
759 if (!event)
760 return -EINVAL;
761
762 return event->enabled;
763}
764
765static int mma9553_write_event_config(struct iio_dev *indio_dev,
766 const struct iio_chan_spec *chan,
767 enum iio_event_type type,
768 enum iio_event_direction dir, int state)
769{
770 struct mma9553_data *data = iio_priv(indio_dev);
771 struct mma9553_event *event;
772 int ret;
773
774 event = mma9553_get_event(data, chan->type, chan->channel2, dir);
775 if (!event)
776 return -EINVAL;
777
778 if (event->enabled == state)
779 return 0;
780
781 mutex_lock(&data->mutex);
782
783 ret = mma9551_set_power_state(data->client, state);
784 if (ret < 0)
785 goto err_out;
786 event->enabled = state;
787
788 ret = mma9553_conf_gpio(data);
789 if (ret < 0)
790 goto err_conf_gpio;
791
792 mutex_unlock(&data->mutex);
793
794 return ret;
795
796err_conf_gpio:
797 if (state) {
798 event->enabled = false;
799 mma9551_set_power_state(data->client, false);
800 }
801err_out:
802 mutex_unlock(&data->mutex);
803 return ret;
804}
805
806static int mma9553_read_event_value(struct iio_dev *indio_dev,
807 const struct iio_chan_spec *chan,
808 enum iio_event_type type,
809 enum iio_event_direction dir,
810 enum iio_event_info info,
811 int *val, int *val2)
812{
813 struct mma9553_data *data = iio_priv(indio_dev);
814
815 *val2 = 0;
816 switch (info) {
817 case IIO_EV_INFO_VALUE:
818 switch (chan->type) {
819 case IIO_STEPS:
820 *val = mma9553_get_bits(data->conf.speed_step,
821 MMA9553_MASK_CONF_STEPCOALESCE);
822 return IIO_VAL_INT;
823 case IIO_ACTIVITY:
824 /*
825 * The device does not support confidence value levels.
826 * We set an average of 50%.
827 */
828 *val = 50;
829 return IIO_VAL_INT;
830 default:
831 return -EINVAL;
832 }
833 case IIO_EV_INFO_PERIOD:
834 switch (chan->type) {
835 case IIO_ACTIVITY:
836 *val = MMA9553_ACTIVITY_THD_TO_SEC(data->conf.actthd);
837 return IIO_VAL_INT;
838 default:
839 return -EINVAL;
840 }
841 default:
842 return -EINVAL;
843 }
844}
845
846static int mma9553_write_event_value(struct iio_dev *indio_dev,
847 const struct iio_chan_spec *chan,
848 enum iio_event_type type,
849 enum iio_event_direction dir,
850 enum iio_event_info info,
851 int val, int val2)
852{
853 struct mma9553_data *data = iio_priv(indio_dev);
854 int ret;
855
856 switch (info) {
857 case IIO_EV_INFO_VALUE:
858 switch (chan->type) {
859 case IIO_STEPS:
860 if (val < 0 || val > 255)
861 return -EINVAL;
862 mutex_lock(&data->mutex);
863 ret = mma9553_set_config(data,
864 MMA9553_REG_CONF_SPEED_STEP,
865 &data->conf.speed_step, val,
866 MMA9553_MASK_CONF_STEPCOALESCE);
867 mutex_unlock(&data->mutex);
868 return ret;
869 default:
870 return -EINVAL;
871 }
872 case IIO_EV_INFO_PERIOD:
873 switch (chan->type) {
874 case IIO_ACTIVITY:
875 mutex_lock(&data->mutex);
876 ret = mma9553_set_config(data, MMA9553_REG_CONF_ACTTHD,
877 &data->conf.actthd,
878 MMA9553_ACTIVITY_SEC_TO_THD
879 (val), MMA9553_MASK_CONF_WORD);
880 mutex_unlock(&data->mutex);
881 return ret;
882 default:
883 return -EINVAL;
884 }
885 default:
886 return -EINVAL;
887 }
888}
889
890static int mma9553_get_calibgender_mode(struct iio_dev *indio_dev,
891 const struct iio_chan_spec *chan)
892{
893 struct mma9553_data *data = iio_priv(indio_dev);
894 u8 gender;
895
896 gender = mma9553_get_bits(data->conf.filter, MMA9553_MASK_CONF_MALE);
897 /*
898 * HW expects 0 for female and 1 for male,
899 * while iio index is 0 for male and 1 for female
900 */
901 return !gender;
902}
903
904static int mma9553_set_calibgender_mode(struct iio_dev *indio_dev,
905 const struct iio_chan_spec *chan,
906 unsigned int mode)
907{
908 struct mma9553_data *data = iio_priv(indio_dev);
909 u8 gender = !mode;
910 int ret;
911
912 if ((mode != 0) && (mode != 1))
913 return -EINVAL;
914 mutex_lock(&data->mutex);
915 ret = mma9553_set_config(data, MMA9553_REG_CONF_FILTER,
916 &data->conf.filter, gender,
917 MMA9553_MASK_CONF_MALE);
918 mutex_unlock(&data->mutex);
919
920 return ret;
921}
922
923static const struct iio_event_spec mma9553_step_event = {
924 .type = IIO_EV_TYPE_CHANGE,
925 .dir = IIO_EV_DIR_NONE,
926 .mask_separate = BIT(IIO_EV_INFO_ENABLE) | BIT(IIO_EV_INFO_VALUE),
927};
928
929static const struct iio_event_spec mma9553_activity_events[] = {
930 {
931 .type = IIO_EV_TYPE_THRESH,
932 .dir = IIO_EV_DIR_RISING,
933 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
934 BIT(IIO_EV_INFO_VALUE) |
935 BIT(IIO_EV_INFO_PERIOD),
936 },
937 {
938 .type = IIO_EV_TYPE_THRESH,
939 .dir = IIO_EV_DIR_FALLING,
940 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
941 BIT(IIO_EV_INFO_VALUE) |
942 BIT(IIO_EV_INFO_PERIOD),
943 },
944};
945
946static const char * const calibgender_modes[] = { "male", "female" };
947
948static const struct iio_enum mma9553_calibgender_enum = {
949 .items = calibgender_modes,
950 .num_items = ARRAY_SIZE(calibgender_modes),
951 .get = mma9553_get_calibgender_mode,
952 .set = mma9553_set_calibgender_mode,
953};
954
955static const struct iio_chan_spec_ext_info mma9553_ext_info[] = {
956 IIO_ENUM("calibgender", IIO_SHARED_BY_TYPE, &mma9553_calibgender_enum),
957 IIO_ENUM_AVAILABLE("calibgender", &mma9553_calibgender_enum),
958 {},
959};
960
961#define MMA9553_PEDOMETER_CHANNEL(_type, _mask) { \
962 .type = _type, \
963 .info_mask_separate = BIT(IIO_CHAN_INFO_ENABLE) | \
964 BIT(IIO_CHAN_INFO_CALIBHEIGHT) | \
965 _mask, \
966 .ext_info = mma9553_ext_info, \
967}
968
969#define MMA9553_ACTIVITY_CHANNEL(_chan2) { \
970 .type = IIO_ACTIVITY, \
971 .modified = 1, \
972 .channel2 = _chan2, \
973 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), \
974 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_CALIBHEIGHT), \
975 .event_spec = mma9553_activity_events, \
976 .num_event_specs = ARRAY_SIZE(mma9553_activity_events), \
977 .ext_info = mma9553_ext_info, \
978}
979
980static const struct iio_chan_spec mma9553_channels[] = {
981 MMA9551_ACCEL_CHANNEL(IIO_MOD_X),
982 MMA9551_ACCEL_CHANNEL(IIO_MOD_Y),
983 MMA9551_ACCEL_CHANNEL(IIO_MOD_Z),
984
985 {
986 .type = IIO_STEPS,
987 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
988 BIT(IIO_CHAN_INFO_ENABLE) |
989 BIT(IIO_CHAN_INFO_DEBOUNCE_COUNT) |
990 BIT(IIO_CHAN_INFO_DEBOUNCE_TIME),
991 .event_spec = &mma9553_step_event,
992 .num_event_specs = 1,
993 },
994
995 MMA9553_PEDOMETER_CHANNEL(IIO_DISTANCE, BIT(IIO_CHAN_INFO_PROCESSED)),
996 {
997 .type = IIO_VELOCITY,
998 .modified = 1,
999 .channel2 = IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z,
1000 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
1001 BIT(IIO_CHAN_INFO_SCALE) |
1002 BIT(IIO_CHAN_INFO_INT_TIME) |
1003 BIT(IIO_CHAN_INFO_ENABLE),
1004 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_CALIBHEIGHT),
1005 .ext_info = mma9553_ext_info,
1006 },
1007 MMA9553_PEDOMETER_CHANNEL(IIO_ENERGY, BIT(IIO_CHAN_INFO_RAW) |
1008 BIT(IIO_CHAN_INFO_SCALE) |
1009 BIT(IIO_CHAN_INFO_CALIBWEIGHT)),
1010
1011 MMA9553_ACTIVITY_CHANNEL(IIO_MOD_RUNNING),
1012 MMA9553_ACTIVITY_CHANNEL(IIO_MOD_JOGGING),
1013 MMA9553_ACTIVITY_CHANNEL(IIO_MOD_WALKING),
1014 MMA9553_ACTIVITY_CHANNEL(IIO_MOD_STILL),
1015};
1016
1017static const struct iio_info mma9553_info = {
1018 .driver_module = THIS_MODULE,
1019 .read_raw = mma9553_read_raw,
1020 .write_raw = mma9553_write_raw,
1021 .read_event_config = mma9553_read_event_config,
1022 .write_event_config = mma9553_write_event_config,
1023 .read_event_value = mma9553_read_event_value,
1024 .write_event_value = mma9553_write_event_value,
1025};
1026
1027static irqreturn_t mma9553_irq_handler(int irq, void *private)
1028{
1029 struct iio_dev *indio_dev = private;
1030 struct mma9553_data *data = iio_priv(indio_dev);
1031
1032 data->timestamp = iio_get_time_ns();
1033 /*
1034 * Since we only configure the interrupt pin when an
1035 * event is enabled, we are sure we have at least
1036 * one event enabled at this point.
1037 */
1038 return IRQ_WAKE_THREAD;
1039}
1040
1041static irqreturn_t mma9553_event_handler(int irq, void *private)
1042{
1043 struct iio_dev *indio_dev = private;
1044 struct mma9553_data *data = iio_priv(indio_dev);
1045 u16 stepcnt;
1046 u8 activity;
1047 struct mma9553_event *ev_activity, *ev_prev_activity, *ev_step_detect;
1048 int ret;
1049
1050 mutex_lock(&data->mutex);
1051 ret = mma9553_read_activity_stepcnt(data, &activity, &stepcnt);
1052 if (ret < 0) {
1053 mutex_unlock(&data->mutex);
1054 return IRQ_HANDLED;
1055 }
1056
1057 ev_prev_activity =
1058 mma9553_get_event(data, IIO_ACTIVITY,
1059 mma9553_activity_to_mod(data->activity),
1060 IIO_EV_DIR_FALLING);
1061 ev_activity =
1062 mma9553_get_event(data, IIO_ACTIVITY,
1063 mma9553_activity_to_mod(activity),
1064 IIO_EV_DIR_RISING);
1065 ev_step_detect =
1066 mma9553_get_event(data, IIO_STEPS, IIO_NO_MOD, IIO_EV_DIR_NONE);
1067
1068 if (ev_step_detect->enabled && (stepcnt != data->stepcnt)) {
1069 data->stepcnt = stepcnt;
1070 iio_push_event(indio_dev,
1071 IIO_EVENT_CODE(IIO_STEPS, 0, IIO_NO_MOD,
1072 IIO_EV_DIR_NONE, IIO_EV_TYPE_CHANGE, 0, 0, 0),
1073 data->timestamp);
1074 }
1075
1076 if (activity != data->activity) {
1077 data->activity = activity;
1078 /* ev_activity can be NULL if activity == ACTIVITY_UNKNOWN */
1079 if (ev_prev_activity && ev_prev_activity->enabled)
1080 iio_push_event(indio_dev,
1081 IIO_EVENT_CODE(IIO_ACTIVITY, 0,
1082 ev_prev_activity->info->mod,
1083 IIO_EV_DIR_FALLING,
1084 IIO_EV_TYPE_THRESH, 0, 0, 0),
1085 data->timestamp);
1086
1087 if (ev_activity && ev_activity->enabled)
1088 iio_push_event(indio_dev,
1089 IIO_EVENT_CODE(IIO_ACTIVITY, 0,
1090 ev_activity->info->mod,
1091 IIO_EV_DIR_RISING,
1092 IIO_EV_TYPE_THRESH, 0, 0, 0),
1093 data->timestamp);
1094 }
1095 mutex_unlock(&data->mutex);
1096
1097 return IRQ_HANDLED;
1098}
1099
1100static int mma9553_gpio_probe(struct i2c_client *client)
1101{
1102 struct device *dev;
1103 struct gpio_desc *gpio;
1104 int ret;
1105
1106 if (!client)
1107 return -EINVAL;
1108
1109 dev = &client->dev;
1110
1111 /* data ready gpio interrupt pin */
1112 gpio = devm_gpiod_get_index(dev, MMA9553_GPIO_NAME, 0);
1113 if (IS_ERR(gpio)) {
1114 dev_err(dev, "acpi gpio get index failed\n");
1115 return PTR_ERR(gpio);
1116 }
1117
1118 ret = gpiod_direction_input(gpio);
1119 if (ret)
1120 return ret;
1121
1122 ret = gpiod_to_irq(gpio);
1123
1124 dev_dbg(dev, "gpio resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
1125
1126 return ret;
1127}
1128
1129static const char *mma9553_match_acpi_device(struct device *dev)
1130{
1131 const struct acpi_device_id *id;
1132
1133 id = acpi_match_device(dev->driver->acpi_match_table, dev);
1134 if (!id)
1135 return NULL;
1136
1137 return dev_name(dev);
1138}
1139
1140static int mma9553_probe(struct i2c_client *client,
1141 const struct i2c_device_id *id)
1142{
1143 struct mma9553_data *data;
1144 struct iio_dev *indio_dev;
1145 const char *name = NULL;
1146 int ret;
1147
1148 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1149 if (!indio_dev)
1150 return -ENOMEM;
1151
1152 data = iio_priv(indio_dev);
1153 i2c_set_clientdata(client, indio_dev);
1154 data->client = client;
1155
1156 if (id)
1157 name = id->name;
1158 else if (ACPI_HANDLE(&client->dev))
1159 name = mma9553_match_acpi_device(&client->dev);
1160 else
1161 return -ENOSYS;
1162
1163 mutex_init(&data->mutex);
1164 mma9553_init_events(data);
1165
1166 ret = mma9553_init(data);
1167 if (ret < 0)
1168 return ret;
1169
1170 indio_dev->dev.parent = &client->dev;
1171 indio_dev->channels = mma9553_channels;
1172 indio_dev->num_channels = ARRAY_SIZE(mma9553_channels);
1173 indio_dev->name = name;
1174 indio_dev->modes = INDIO_DIRECT_MODE;
1175 indio_dev->info = &mma9553_info;
1176
1177 if (client->irq < 0)
1178 client->irq = mma9553_gpio_probe(client);
1179
1180 if (client->irq >= 0) {
1181 ret = devm_request_threaded_irq(&client->dev, client->irq,
1182 mma9553_irq_handler,
1183 mma9553_event_handler,
1184 IRQF_TRIGGER_RISING,
1185 MMA9553_IRQ_NAME, indio_dev);
1186 if (ret < 0) {
1187 dev_err(&client->dev, "request irq %d failed\n",
1188 client->irq);
1189 goto out_poweroff;
1190 }
1191
1192 }
1193
1194 ret = iio_device_register(indio_dev);
1195 if (ret < 0) {
1196 dev_err(&client->dev, "unable to register iio device\n");
1197 goto out_poweroff;
1198 }
1199
1200 ret = pm_runtime_set_active(&client->dev);
1201 if (ret < 0)
1202 goto out_iio_unregister;
1203
1204 pm_runtime_enable(&client->dev);
1205 pm_runtime_set_autosuspend_delay(&client->dev,
1206 MMA9551_AUTO_SUSPEND_DELAY_MS);
1207 pm_runtime_use_autosuspend(&client->dev);
1208
1209 dev_dbg(&indio_dev->dev, "Registered device %s\n", name);
1210
1211 return 0;
1212
1213out_iio_unregister:
1214 iio_device_unregister(indio_dev);
1215out_poweroff:
1216 mma9551_set_device_state(client, false);
1217 return ret;
1218}
1219
1220static int mma9553_remove(struct i2c_client *client)
1221{
1222 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1223 struct mma9553_data *data = iio_priv(indio_dev);
1224
1225 pm_runtime_disable(&client->dev);
1226 pm_runtime_set_suspended(&client->dev);
1227 pm_runtime_put_noidle(&client->dev);
1228
1229 iio_device_unregister(indio_dev);
1230 mutex_lock(&data->mutex);
1231 mma9551_set_device_state(data->client, false);
1232 mutex_unlock(&data->mutex);
1233
1234 return 0;
1235}
1236
1237#ifdef CONFIG_PM
1238static int mma9553_runtime_suspend(struct device *dev)
1239{
1240 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1241 struct mma9553_data *data = iio_priv(indio_dev);
1242 int ret;
1243
1244 mutex_lock(&data->mutex);
1245 ret = mma9551_set_device_state(data->client, false);
1246 mutex_unlock(&data->mutex);
1247 if (ret < 0) {
1248 dev_err(&data->client->dev, "powering off device failed\n");
1249 return -EAGAIN;
1250 }
1251
1252 return 0;
1253}
1254
1255static int mma9553_runtime_resume(struct device *dev)
1256{
1257 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1258 struct mma9553_data *data = iio_priv(indio_dev);
1259 int ret;
1260
1261 ret = mma9551_set_device_state(data->client, true);
1262 if (ret < 0)
1263 return ret;
1264
1265 mma9551_sleep(MMA9553_DEFAULT_SAMPLE_RATE);
1266
1267 return 0;
1268}
1269#endif
1270
1271#ifdef CONFIG_PM_SLEEP
1272static int mma9553_suspend(struct device *dev)
1273{
1274 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1275 struct mma9553_data *data = iio_priv(indio_dev);
1276 int ret;
1277
1278 mutex_lock(&data->mutex);
1279 ret = mma9551_set_device_state(data->client, false);
1280 mutex_unlock(&data->mutex);
1281
1282 return ret;
1283}
1284
1285static int mma9553_resume(struct device *dev)
1286{
1287 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1288 struct mma9553_data *data = iio_priv(indio_dev);
1289 int ret;
1290
1291 mutex_lock(&data->mutex);
1292 ret = mma9551_set_device_state(data->client, true);
1293 mutex_unlock(&data->mutex);
1294
1295 return ret;
1296}
1297#endif
1298
1299static const struct dev_pm_ops mma9553_pm_ops = {
1300 SET_SYSTEM_SLEEP_PM_OPS(mma9553_suspend, mma9553_resume)
1301 SET_RUNTIME_PM_OPS(mma9553_runtime_suspend,
1302 mma9553_runtime_resume, NULL)
1303};
1304
1305static const struct acpi_device_id mma9553_acpi_match[] = {
1306 {"MMA9553", 0},
1307 {},
1308};
1309
1310MODULE_DEVICE_TABLE(acpi, mma9553_acpi_match);
1311
1312static const struct i2c_device_id mma9553_id[] = {
1313 {"mma9553", 0},
1314 {},
1315};
1316
1317MODULE_DEVICE_TABLE(i2c, mma9553_id);
1318
1319static struct i2c_driver mma9553_driver = {
1320 .driver = {
1321 .name = MMA9553_DRV_NAME,
1322 .acpi_match_table = ACPI_PTR(mma9553_acpi_match),
1323 .pm = &mma9553_pm_ops,
1324 },
1325 .probe = mma9553_probe,
1326 .remove = mma9553_remove,
1327 .id_table = mma9553_id,
1328};
1329
1330module_i2c_driver(mma9553_driver);
1331
1332MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
1333MODULE_LICENSE("GPL v2");
1334MODULE_DESCRIPTION("MMA9553L pedometer platform driver");
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-23 14:48:24 -0500