drivers/iio/accel/mma9553.c

   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(reg_val, mask))
 271                 return 0;
 272
 273         reg_val = mma9553_set_bits(reg_val, val, mask);
 274         ret = mma9551_write_config_word(data->client, MMA9551_APPID_PEDOMETER,
 275                                         reg, 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(data->conf.config, 1,
 286                                   MMA9553_MASK_CONF_CONFIG);
 287
 288         ret = mma9551_write_config_word(data->client, MMA9551_APPID_PEDOMETER,
 289                                         MMA9553_REG_CONF_CONF_STEPLEN, 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(data->client,
 301                                                MMA9551_APPID_PEDOMETER,
 302                                                MMA9553_REG_CONF_CONF_STEPLEN,
 303                                                &config);
 304                 if (ret < 0)
 305                         return ret;
 306         } while (mma9553_get_bits(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(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(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, true,
 341                                                         IIO_ACTIVITY);
 342         ev_step_detect = mma9553_get_event(data, IIO_STEPS, IIO_NO_MOD,
 343                                            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, &data->activity,
 364                                                     &data->stepcnt);
 365                 if (ret < 0)
 366                         return ret;
 367         }
 368
 369         ret = mma9551_gpio_config(data->client, MMA9553_DEFAULT_GPIO_PIN, 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(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(data->client, MMA9551_APPID_PEDOMETER,
 392                                         MMA9553_REG_CONF_SLEEPMIN,
 393                                         sizeof(data->conf) / sizeof(u16),
 394                                         (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(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(data->conf.config, 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(data->conf.config, 1,
 422                                              MMA9553_MASK_CONF_ACT_DBCNTM);
 423         ret = mma9551_write_config_words(data->client, MMA9551_APPID_PEDOMETER,
 424                                          MMA9553_REG_CONF_SLEEPMIN,
 425                                          sizeof(data->conf) / sizeof(u16),
 426                                          (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(data->client, 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, false, 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(data->client, MMA9551_APPID_PEDOMETER,
 457                                        reg, tmp);
 458         mutex_unlock(&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);
 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);
 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);
 494                         if (ret < 0)
 495                                 return ret;
 496
 497                         activity =
 498                             mma9553_get_bits(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);
 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);
 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(data->client,
 536                                                       chan, val, val2);
 537                         mutex_unlock(&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(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(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(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(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(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(data->client, val);
 618                 if (ret < 0) {
 619                         mutex_unlock(&data->mutex);
 620                         return ret;
 621                 }
 622                 data->stepcnt_enabled = val;
 623                 mutex_unlock(&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                                          &data->conf.height_weight,
 634                                          tmp, MMA9553_MASK_CONF_HEIGHT);
 635                 mutex_unlock(&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                                          &data->conf.height_weight,
 644                                          val, MMA9553_MASK_CONF_WEIGHT);
 645                 mutex_unlock(&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                                                  &data->conf.filter, val,
 661                                                  MMA9553_MASK_CONF_FILTSTEP);
 662                         mutex_unlock(&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                                                  &data->conf.filter, val,
 675                                                  MMA9553_MASK_CONF_FILTTIME);
 676                         mutex_unlock(&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                                                  &data->conf.speed_step, val,
 699                                                  MMA9553_MASK_CONF_SPDPRD);
 700                         mutex_unlock(&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, chan->type, 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, chan->type, 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(data->client, 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(&data->mutex);
 753
 754         return 0;
 755
 756 err_conf_gpio:
 757         if (state) {
 758                 event->enabled = false;
 759                 mma9551_set_power_state(data->client, false);
 760         }
 761 err_out:
 762         mutex_unlock(&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(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                                                 &data->conf.speed_step, val,
 826                                                 MMA9553_MASK_CONF_STEPCOALESCE);
 827                         mutex_unlock(&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                                                  &data->conf.actthd,
 841                                                  MMA9553_ACTIVITY_SEC_TO_THD
 842                                                  (val), MMA9553_MASK_CONF_WORD);
 843                         mutex_unlock(&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(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                                  &data->conf.filter, gender,
 880                                  MMA9553_MASK_CONF_MALE);
 881         mutex_unlock(&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, &stepcnt);
1015         if (ret < 0) {
1016                 mutex_unlock(&data->mutex);
1017                 return IRQ_HANDLED;
1018         }
1019
1020         ev_prev_activity = mma9553_get_event(data, IIO_ACTIVITY,
1021                                              mma9553_activity_to_mod(
1022                                              data->activity),
1023                                              IIO_EV_DIR_FALLING);
1024         ev_activity = mma9553_get_event(data, IIO_ACTIVITY,
1025                                         mma9553_activity_to_mod(activity),
1026                                         IIO_EV_DIR_RISING);
1027         ev_step_detect = mma9553_get_event(data, IIO_STEPS, IIO_NO_MOD,
1028                                            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                                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                                        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                                        data->timestamp);
1059         }
1060         mutex_unlock(&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(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                          const struct i2c_device_id *id)
1078 {
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(&client->dev, sizeof(*data));
1085         if (!indio_dev)
1086                 return -ENOMEM;
1087
1088         data = iio_priv(indio_dev);
1089         i2c_set_clientdata(client, 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(&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(&client->dev, client->irq,
1114                                                 mma9553_irq_handler,
1115                                                 mma9553_event_handler,
1116                                                 IRQF_TRIGGER_RISING,
1117                                                 MMA9553_IRQ_NAME, 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(&client->dev);
1126         if (ret < 0)
1127                 goto out_poweroff;
1128
1129         pm_runtime_enable(&client->dev);
1130         pm_runtime_set_autosuspend_delay(&client->dev,
1131                                          MMA9551_AUTO_SUSPEND_DELAY_MS);
1132         pm_runtime_use_autosuspend(&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 out_poweroff;
1138         }
1139
1140         dev_dbg(&indio_dev->dev, "Registered device %s\n", name);
1141         return 0;
1142
1143 out_poweroff:
1144         mma9551_set_device_state(client, false);
1145         return ret;
1146 }
1147
1148 static int mma9553_remove(struct i2c_client *client)
1149 {
1150         struct iio_dev *indio_dev = i2c_get_clientdata(client);
1151         struct mma9553_data *data = iio_priv(indio_dev);
1152
1153         iio_device_unregister(indio_dev);
1154
1155         pm_runtime_disable(&client->dev);
1156         pm_runtime_set_suspended(&client->dev);
1157
1158         mutex_lock(&data->mutex);
1159         mma9551_set_device_state(data->client, false);
1160         mutex_unlock(&data->mutex);
1161
1162         return 0;
1163 }
1164
1165 #ifdef CONFIG_PM
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(data->client, false);
1174         mutex_unlock(&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(data->client, true);
1190         if (ret < 0)
1191                 return ret;
1192
1193         mma9551_sleep(MMA9553_DEFAULT_SAMPLE_RATE);
1194
1195         return 0;
1196 }
1197 #endif
1198
1199 #ifdef CONFIG_PM_SLEEP
1200 static int mma9553_suspend(struct device *dev)
1201 {
1202         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1203         struct mma9553_data *data = iio_priv(indio_dev);
1204         int ret;
1205
1206         mutex_lock(&data->mutex);
1207         ret = mma9551_set_device_state(data->client, false);
1208         mutex_unlock(&data->mutex);
1209
1210         return ret;
1211 }
1212
1213 static int mma9553_resume(struct device *dev)
1214 {
1215         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1216         struct mma9553_data *data = iio_priv(indio_dev);
1217         int ret;
1218
1219         mutex_lock(&data->mutex);
1220         ret = mma9551_set_device_state(data->client, true);
1221         mutex_unlock(&data->mutex);
1222
1223         return ret;
1224 }
1225 #endif
1226
1227 static const struct dev_pm_ops mma9553_pm_ops = {
1228         SET_SYSTEM_SLEEP_PM_OPS(mma9553_suspend, mma9553_resume)
1229         SET_RUNTIME_PM_OPS(mma9553_runtime_suspend,
1230                            mma9553_runtime_resume, NULL)
1231 };
1232
1233 static const struct acpi_device_id mma9553_acpi_match[] = {
1234         {"MMA9553", 0},
1235         {},
1236 };
1237
1238 MODULE_DEVICE_TABLE(acpi, mma9553_acpi_match);
1239
1240 static const struct i2c_device_id mma9553_id[] = {
1241         {"mma9553", 0},
1242         {},
1243 };
1244
1245 MODULE_DEVICE_TABLE(i2c, mma9553_id);
1246
1247 static struct i2c_driver mma9553_driver = {
1248         .driver = {
1249                    .name = MMA9553_DRV_NAME,
1250                    .acpi_match_table = ACPI_PTR(mma9553_acpi_match),
1251                    .pm = &mma9553_pm_ops,
1252                    },
1253         .probe = mma9553_probe,
1254         .remove = mma9553_remove,
1255         .id_table = mma9553_id,
1256 };
1257
1258 module_i2c_driver(mma9553_driver);
1259
1260 MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
1261 MODULE_LICENSE("GPL v2");
1262 MODULE_DESCRIPTION("MMA9553L pedometer platform driver");