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