drivers/iio/accel/mma9551_core.c

   1 /*
   2  * Common code for Freescale MMA955x Intelligent Sensor Platform drivers
   3  * Copyright (c) 2014, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/i2c.h>
  17 #include <linux/delay.h>
  18 #include <linux/iio/iio.h>
  19 #include <linux/pm_runtime.h>
  20 #include "mma9551_core.h"
  21
  22 /* Command masks for mailbox write command */
  23 #define MMA9551_CMD_READ_VERSION_INFO   0x00
  24 #define MMA9551_CMD_READ_CONFIG         0x10
  25 #define MMA9551_CMD_WRITE_CONFIG        0x20
  26 #define MMA9551_CMD_READ_STATUS         0x30
  27
  28 /* Mailbox read command */
  29 #define MMA9551_RESPONSE_COCO           BIT(7)
  30
  31 /* Error-Status codes returned in mailbox read command */
  32 #define MMA9551_MCI_ERROR_NONE                  0x00
  33 #define MMA9551_MCI_ERROR_PARAM                 0x04
  34 #define MMA9551_MCI_INVALID_COUNT               0x19
  35 #define MMA9551_MCI_ERROR_COMMAND               0x1C
  36 #define MMA9551_MCI_ERROR_INVALID_LENGTH        0x21
  37 #define MMA9551_MCI_ERROR_FIFO_BUSY             0x22
  38 #define MMA9551_MCI_ERROR_FIFO_ALLOCATED        0x23
  39 #define MMA9551_MCI_ERROR_FIFO_OVERSIZE         0x24
  40
  41 /* GPIO Application */
  42 #define MMA9551_GPIO_POL_MSB            0x08
  43 #define MMA9551_GPIO_POL_LSB            0x09
  44
  45 /* Sleep/Wake application */
  46 #define MMA9551_SLEEP_CFG               0x06
  47 #define MMA9551_SLEEP_CFG_SNCEN         BIT(0)
  48 #define MMA9551_SLEEP_CFG_FLEEN         BIT(1)
  49 #define MMA9551_SLEEP_CFG_SCHEN         BIT(2)
  50
  51 /* AFE application */
  52 #define MMA9551_AFE_X_ACCEL_REG         0x00
  53 #define MMA9551_AFE_Y_ACCEL_REG         0x02
  54 #define MMA9551_AFE_Z_ACCEL_REG         0x04
  55
  56 /* Reset/Suspend/Clear application */
  57 #define MMA9551_RSC_RESET               0x00
  58 #define MMA9551_RSC_OFFSET(mask)        (3 - (ffs(mask) - 1) / 8)
  59 #define MMA9551_RSC_VAL(mask)           (mask >> (((ffs(mask) - 1) / 8) * 8))
  60
  61 /*
  62  * A response is composed of:
  63  * - control registers: MB0-3
  64  * - data registers: MB4-31
  65  *
  66  * A request is composed of:
  67  * - mbox to write to (always 0)
  68  * - control registers: MB1-4
  69  * - data registers: MB5-31
  70  */
  71 #define MMA9551_MAILBOX_CTRL_REGS       4
  72 #define MMA9551_MAX_MAILBOX_DATA_REGS   28
  73 #define MMA9551_MAILBOX_REGS            32
  74
  75 #define MMA9551_I2C_READ_RETRIES        5
  76 #define MMA9551_I2C_READ_DELAY  50      /* us */
  77
  78 struct mma9551_mbox_request {
  79         u8 start_mbox;          /* Always 0. */
  80         u8 app_id;
  81         /*
  82          * See Section 5.3.1 of the MMA955xL Software Reference Manual.
  83          *
  84          * Bit 7: reserved, always 0
  85          * Bits 6-4: command
  86          * Bits 3-0: upper bits of register offset
  87          */
  88         u8 cmd_off;
  89         u8 lower_off;
  90         u8 nbytes;
  91         u8 buf[MMA9551_MAX_MAILBOX_DATA_REGS - 1];
  92 } __packed;
  93
  94 struct mma9551_mbox_response {
  95         u8 app_id;
  96         /*
  97          * See Section 5.3.3 of the MMA955xL Software Reference Manual.
  98          *
  99          * Bit 7: COCO
 100          * Bits 6-0: Error code.
 101          */
 102         u8 coco_err;
 103         u8 nbytes;
 104         u8 req_bytes;
 105         u8 buf[MMA9551_MAX_MAILBOX_DATA_REGS];
 106 } __packed;
 107
 108 struct mma9551_version_info {
 109         __be32 device_id;
 110         u8 rom_version[2];
 111         u8 fw_version[2];
 112         u8 hw_version[2];
 113         u8 fw_build[2];
 114 };
 115
 116 static int mma9551_transfer(struct i2c_client *client,
 117                             u8 app_id, u8 command, u16 offset,
 118                             u8 *inbytes, int num_inbytes,
 119                             u8 *outbytes, int num_outbytes)
 120 {
 121         struct mma9551_mbox_request req;
 122         struct mma9551_mbox_response rsp;
 123         struct i2c_msg in, out;
 124         u8 req_len, err_code;
 125         int ret, retries;
 126
 127         if (offset >= 1 << 12) {
 128                 dev_err(&client->dev, "register offset too large\n");
 129                 return -EINVAL;
 130         }
 131
 132         req_len = 1 + MMA9551_MAILBOX_CTRL_REGS + num_inbytes;
 133         req.start_mbox = 0;
 134         req.app_id = app_id;
 135         req.cmd_off = command | (offset >> 8);
 136         req.lower_off = offset;
 137
 138         if (command == MMA9551_CMD_WRITE_CONFIG)
 139                 req.nbytes = num_inbytes;
 140         else
 141                 req.nbytes = num_outbytes;
 142         if (num_inbytes)
 143                 memcpy(req.buf, inbytes, num_inbytes);
 144
 145         out.addr = client->addr;
 146         out.flags = 0;
 147         out.len = req_len;
 148         out.buf = (u8 *)&req;
 149
 150         ret = i2c_transfer(client->adapter, &out, 1);
 151         if (ret < 0) {
 152                 dev_err(&client->dev, "i2c write failed\n");
 153                 return ret;
 154         }
 155
 156         retries = MMA9551_I2C_READ_RETRIES;
 157         do {
 158                 udelay(MMA9551_I2C_READ_DELAY);
 159
 160                 in.addr = client->addr;
 161                 in.flags = I2C_M_RD;
 162                 in.len = sizeof(rsp);
 163                 in.buf = (u8 *)&rsp;
 164
 165                 ret = i2c_transfer(client->adapter, &in, 1);
 166                 if (ret < 0) {
 167                         dev_err(&client->dev, "i2c read failed\n");
 168                         return ret;
 169                 }
 170
 171                 if (rsp.coco_err & MMA9551_RESPONSE_COCO)
 172                         break;
 173         } while (--retries > 0);
 174
 175         if (retries == 0) {
 176                 dev_err(&client->dev,
 177                         "timed out while waiting for command response\n");
 178                 return -ETIMEDOUT;
 179         }
 180
 181         if (rsp.app_id != app_id) {
 182                 dev_err(&client->dev,
 183                         "app_id mismatch in response got %02x expected %02x\n",
 184                         rsp.app_id, app_id);
 185                 return -EINVAL;
 186         }
 187
 188         err_code = rsp.coco_err & ~MMA9551_RESPONSE_COCO;
 189         if (err_code != MMA9551_MCI_ERROR_NONE) {
 190                 dev_err(&client->dev, "read returned error %x\n", err_code);
 191                 return -EINVAL;
 192         }
 193
 194         if (rsp.nbytes != rsp.req_bytes) {
 195                 dev_err(&client->dev,
 196                         "output length mismatch got %d expected %d\n",
 197                         rsp.nbytes, rsp.req_bytes);
 198                 return -EINVAL;
 199         }
 200
 201         if (num_outbytes)
 202                 memcpy(outbytes, rsp.buf, num_outbytes);
 203
 204         return 0;
 205 }
 206
 207 /**
 208  * mma9551_read_config_byte() - read 1 configuration byte
 209  * @client:     I2C client
 210  * @app_id:     Application ID
 211  * @reg:        Application register
 212  * @val:        Pointer to store value read
 213  *
 214  * Read one configuration byte from the device using MMA955xL command format.
 215  * Commands to the MMA955xL platform consist of a write followed
 216  * by one or more reads.
 217  *
 218  * Locking note: This function must be called with the device lock held.
 219  * Locking is not handled inside the function. Callers should ensure they
 220  * serialize access to the HW.
 221  *
 222  * Returns: 0 on success, negative value on failure.
 223  */
 224 int mma9551_read_config_byte(struct i2c_client *client, u8 app_id,
 225                              u16 reg, u8 *val)
 226 {
 227         return mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
 228                                 reg, NULL, 0, val, 1);
 229 }
 230 EXPORT_SYMBOL(mma9551_read_config_byte);
 231
 232 /**
 233  * mma9551_write_config_byte() - write 1 configuration byte
 234  * @client:     I2C client
 235  * @app_id:     Application ID
 236  * @reg:        Application register
 237  * @val:        Value to write
 238  *
 239  * Write one configuration byte from the device using MMA955xL command format.
 240  * Commands to the MMA955xL platform consist of a write followed by one or
 241  * more reads.
 242  *
 243  * Locking note: This function must be called with the device lock held.
 244  * Locking is not handled inside the function. Callers should ensure they
 245  * serialize access to the HW.
 246  *
 247  * Returns: 0 on success, negative value on failure.
 248  */
 249 int mma9551_write_config_byte(struct i2c_client *client, u8 app_id,
 250                               u16 reg, u8 val)
 251 {
 252         return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg,
 253                                 &val, 1, NULL, 0);
 254 }
 255 EXPORT_SYMBOL(mma9551_write_config_byte);
 256
 257 /**
 258  * mma9551_read_status_byte() - read 1 status byte
 259  * @client:     I2C client
 260  * @app_id:     Application ID
 261  * @reg:        Application register
 262  * @val:        Pointer to store value read
 263  *
 264  * Read one status byte from the device using MMA955xL command format.
 265  * Commands to the MMA955xL platform consist of a write followed by one or
 266  * more reads.
 267  *
 268  * Locking note: This function must be called with the device lock held.
 269  * Locking is not handled inside the function. Callers should ensure they
 270  * serialize access to the HW.
 271  *
 272  * Returns: 0 on success, negative value on failure.
 273  */
 274 int mma9551_read_status_byte(struct i2c_client *client, u8 app_id,
 275                              u16 reg, u8 *val)
 276 {
 277         return mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
 278                                 reg, NULL, 0, val, 1);
 279 }
 280 EXPORT_SYMBOL(mma9551_read_status_byte);
 281
 282 /**
 283  * mma9551_read_config_word() - read 1 config word
 284  * @client:     I2C client
 285  * @app_id:     Application ID
 286  * @reg:        Application register
 287  * @val:        Pointer to store value read
 288  *
 289  * Read one configuration word from the device using MMA955xL command format.
 290  * Commands to the MMA955xL platform consist of a write followed by one or
 291  * more reads.
 292  *
 293  * Locking note: This function must be called with the device lock held.
 294  * Locking is not handled inside the function. Callers should ensure they
 295  * serialize access to the HW.
 296  *
 297  * Returns: 0 on success, negative value on failure.
 298  */
 299 int mma9551_read_config_word(struct i2c_client *client, u8 app_id,
 300                              u16 reg, u16 *val)
 301 {
 302         int ret;
 303         __be16 v;
 304
 305         ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
 306                                reg, NULL, 0, (u8 *)&v, 2);
 307         if (ret < 0)
 308                 return ret;
 309
 310         *val = be16_to_cpu(v);
 311
 312         return 0;
 313 }
 314 EXPORT_SYMBOL(mma9551_read_config_word);
 315
 316 /**
 317  * mma9551_write_config_word() - write 1 config word
 318  * @client:     I2C client
 319  * @app_id:     Application ID
 320  * @reg:        Application register
 321  * @val:        Value to write
 322  *
 323  * Write one configuration word from the device using MMA955xL command format.
 324  * Commands to the MMA955xL platform consist of a write followed by one or
 325  * more reads.
 326  *
 327  * Locking note: This function must be called with the device lock held.
 328  * Locking is not handled inside the function. Callers should ensure they
 329  * serialize access to the HW.
 330  *
 331  * Returns: 0 on success, negative value on failure.
 332  */
 333 int mma9551_write_config_word(struct i2c_client *client, u8 app_id,
 334                               u16 reg, u16 val)
 335 {
 336         __be16 v = cpu_to_be16(val);
 337
 338         return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg,
 339                                 (u8 *)&v, 2, NULL, 0);
 340 }
 341 EXPORT_SYMBOL(mma9551_write_config_word);
 342
 343 /**
 344  * mma9551_read_status_word() - read 1 status word
 345  * @client:     I2C client
 346  * @app_id:     Application ID
 347  * @reg:        Application register
 348  * @val:        Pointer to store value read
 349  *
 350  * Read one status word from the device using MMA955xL command format.
 351  * Commands to the MMA955xL platform consist of a write followed by one or
 352  * more reads.
 353  *
 354  * Locking note: This function must be called with the device lock held.
 355  * Locking is not handled inside the function. Callers should ensure they
 356  * serialize access to the HW.
 357  *
 358  * Returns: 0 on success, negative value on failure.
 359  */
 360 int mma9551_read_status_word(struct i2c_client *client, u8 app_id,
 361                              u16 reg, u16 *val)
 362 {
 363         int ret;
 364         __be16 v;
 365
 366         ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
 367                                reg, NULL, 0, (u8 *)&v, 2);
 368         if (ret < 0)
 369                 return ret;
 370
 371         *val = be16_to_cpu(v);
 372
 373         return 0;
 374 }
 375 EXPORT_SYMBOL(mma9551_read_status_word);
 376
 377 /**
 378  * mma9551_read_config_words() - read multiple config words
 379  * @client:     I2C client
 380  * @app_id:     Application ID
 381  * @reg:        Application register
 382  * @len:        Length of array to read (in words)
 383  * @buf:        Array of words to read
 384  *
 385  * Read multiple configuration registers (word-sized registers).
 386  *
 387  * Locking note: This function must be called with the device lock held.
 388  * Locking is not handled inside the function. Callers should ensure they
 389  * serialize access to the HW.
 390  *
 391  * Returns: 0 on success, negative value on failure.
 392  */
 393 int mma9551_read_config_words(struct i2c_client *client, u8 app_id,
 394                               u16 reg, u8 len, u16 *buf)
 395 {
 396         int ret, i;
 397         __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
 398
 399         if (len > ARRAY_SIZE(be_buf)) {
 400                 dev_err(&client->dev, "Invalid buffer size %d\n", len);
 401                 return -EINVAL;
 402         }
 403
 404         ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
 405                                reg, NULL, 0, (u8 *)be_buf, len * sizeof(u16));
 406         if (ret < 0)
 407                 return ret;
 408
 409         for (i = 0; i < len; i++)
 410                 buf[i] = be16_to_cpu(be_buf[i]);
 411
 412         return 0;
 413 }
 414 EXPORT_SYMBOL(mma9551_read_config_words);
 415
 416 /**
 417  * mma9551_read_status_words() - read multiple status words
 418  * @client:     I2C client
 419  * @app_id:     Application ID
 420  * @reg:        Application register
 421  * @len:        Length of array to read (in words)
 422  * @buf:        Array of words to read
 423  *
 424  * Read multiple status registers (word-sized registers).
 425  *
 426  * Locking note: This function must be called with the device lock held.
 427  * Locking is not handled inside the function. Callers should ensure they
 428  * serialize access to the HW.
 429  *
 430  * Returns: 0 on success, negative value on failure.
 431  */
 432 int mma9551_read_status_words(struct i2c_client *client, u8 app_id,
 433                               u16 reg, u8 len, u16 *buf)
 434 {
 435         int ret, i;
 436         __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
 437
 438         if (len > ARRAY_SIZE(be_buf)) {
 439                 dev_err(&client->dev, "Invalid buffer size %d\n", len);
 440                 return -EINVAL;
 441         }
 442
 443         ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
 444                                reg, NULL, 0, (u8 *)be_buf, len * sizeof(u16));
 445         if (ret < 0)
 446                 return ret;
 447
 448         for (i = 0; i < len; i++)
 449                 buf[i] = be16_to_cpu(be_buf[i]);
 450
 451         return 0;
 452 }
 453 EXPORT_SYMBOL(mma9551_read_status_words);
 454
 455 /**
 456  * mma9551_write_config_words() - write multiple config words
 457  * @client:     I2C client
 458  * @app_id:     Application ID
 459  * @reg:        Application register
 460  * @len:        Length of array to write (in words)
 461  * @buf:        Array of words to write
 462  *
 463  * Write multiple configuration registers (word-sized registers).
 464  *
 465  * Locking note: This function must be called with the device lock held.
 466  * Locking is not handled inside the function. Callers should ensure they
 467  * serialize access to the HW.
 468  *
 469  * Returns: 0 on success, negative value on failure.
 470  */
 471 int mma9551_write_config_words(struct i2c_client *client, u8 app_id,
 472                                u16 reg, u8 len, u16 *buf)
 473 {
 474         int i;
 475         __be16 be_buf[(MMA9551_MAX_MAILBOX_DATA_REGS - 1) / 2];
 476
 477         if (len > ARRAY_SIZE(be_buf)) {
 478                 dev_err(&client->dev, "Invalid buffer size %d\n", len);
 479                 return -EINVAL;
 480         }
 481
 482         for (i = 0; i < len; i++)
 483                 be_buf[i] = cpu_to_be16(buf[i]);
 484
 485         return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG,
 486                                 reg, (u8 *)be_buf, len * sizeof(u16), NULL, 0);
 487 }
 488 EXPORT_SYMBOL(mma9551_write_config_words);
 489
 490 /**
 491  * mma9551_update_config_bits() - update bits in register
 492  * @client:     I2C client
 493  * @app_id:     Application ID
 494  * @reg:        Application register
 495  * @mask:       Mask for the bits to update
 496  * @val:        Value of the bits to update
 497  *
 498  * Update bits in the given register using a bit mask.
 499  *
 500  * Locking note: This function must be called with the device lock held.
 501  * Locking is not handled inside the function. Callers should ensure they
 502  * serialize access to the HW.
 503  *
 504  * Returns: 0 on success, negative value on failure.
 505  */
 506 int mma9551_update_config_bits(struct i2c_client *client, u8 app_id,
 507                                u16 reg, u8 mask, u8 val)
 508 {
 509         int ret;
 510         u8 tmp, orig;
 511
 512         ret = mma9551_read_config_byte(client, app_id, reg, &orig);
 513         if (ret < 0)
 514                 return ret;
 515
 516         tmp = orig & ~mask;
 517         tmp |= val & mask;
 518
 519         if (tmp == orig)
 520                 return 0;
 521
 522         return mma9551_write_config_byte(client, app_id, reg, tmp);
 523 }
 524 EXPORT_SYMBOL(mma9551_update_config_bits);
 525
 526 /**
 527  * mma9551_gpio_config() - configure gpio
 528  * @client:     I2C client
 529  * @pin:        GPIO pin to configure
 530  * @app_id:     Application ID
 531  * @bitnum:     Bit number of status register being assigned to the GPIO pin.
 532  * @polarity:   The polarity parameter is described in section 6.2.2, page 66,
 533  *              of the Software Reference Manual.  Basically, polarity=0 means
 534  *              the interrupt line has the same value as the selected bit,
 535  *              while polarity=1 means the line is inverted.
 536  *
 537  * Assign a bit from an application’s status register to a specific GPIO pin.
 538  *
 539  * Locking note: This function must be called with the device lock held.
 540  * Locking is not handled inside the function. Callers should ensure they
 541  * serialize access to the HW.
 542  *
 543  * Returns: 0 on success, negative value on failure.
 544  */
 545 int mma9551_gpio_config(struct i2c_client *client, enum mma9551_gpio_pin pin,
 546                         u8 app_id, u8 bitnum, int polarity)
 547 {
 548         u8 reg, pol_mask, pol_val;
 549         int ret;
 550
 551         if (pin > mma9551_gpio_max) {
 552                 dev_err(&client->dev, "bad GPIO pin\n");
 553                 return -EINVAL;
 554         }
 555
 556         /*
 557          * Pin 6 is configured by regs 0x00 and 0x01, pin 7 by 0x02 and
 558          * 0x03, and so on.
 559          */
 560         reg = pin * 2;
 561
 562         ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO,
 563                                         reg, app_id);
 564         if (ret < 0) {
 565                 dev_err(&client->dev, "error setting GPIO app_id\n");
 566                 return ret;
 567         }
 568
 569         ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO,
 570                                         reg + 1, bitnum);
 571         if (ret < 0) {
 572                 dev_err(&client->dev, "error setting GPIO bit number\n");
 573                 return ret;
 574         }
 575
 576         switch (pin) {
 577         case mma9551_gpio6:
 578                 reg = MMA9551_GPIO_POL_LSB;
 579                 pol_mask = 1 << 6;
 580                 break;
 581         case mma9551_gpio7:
 582                 reg = MMA9551_GPIO_POL_LSB;
 583                 pol_mask = 1 << 7;
 584                 break;
 585         case mma9551_gpio8:
 586                 reg = MMA9551_GPIO_POL_MSB;
 587                 pol_mask = 1 << 0;
 588                 break;
 589         case mma9551_gpio9:
 590                 reg = MMA9551_GPIO_POL_MSB;
 591                 pol_mask = 1 << 1;
 592                 break;
 593         }
 594         pol_val = polarity ? pol_mask : 0;
 595
 596         ret = mma9551_update_config_bits(client, MMA9551_APPID_GPIO, reg,
 597                                          pol_mask, pol_val);
 598         if (ret < 0)
 599                 dev_err(&client->dev, "error setting GPIO polarity\n");
 600
 601         return ret;
 602 }
 603 EXPORT_SYMBOL(mma9551_gpio_config);
 604
 605 /**
 606  * mma9551_read_version() - read device version information
 607  * @client:     I2C client
 608  *
 609  * Read version information and print device id and firmware version.
 610  *
 611  * Locking note: This function must be called with the device lock held.
 612  * Locking is not handled inside the function. Callers should ensure they
 613  * serialize access to the HW.
 614  *
 615  * Returns: 0 on success, negative value on failure.
 616  */
 617 int mma9551_read_version(struct i2c_client *client)
 618 {
 619         struct mma9551_version_info info;
 620         int ret;
 621
 622         ret = mma9551_transfer(client, MMA9551_APPID_VERSION, 0x00, 0x00,
 623                                NULL, 0, (u8 *)&info, sizeof(info));
 624         if (ret < 0)
 625                 return ret;
 626
 627         dev_info(&client->dev, "device ID 0x%x, firmware version %02x.%02x\n",
 628                  be32_to_cpu(info.device_id), info.fw_version[0],
 629                  info.fw_version[1]);
 630
 631         return 0;
 632 }
 633 EXPORT_SYMBOL(mma9551_read_version);
 634
 635 /**
 636  * mma9551_set_device_state() - sets HW power mode
 637  * @client:     I2C client
 638  * @enable:     Use true to power on device, false to cause the device
 639  *              to enter sleep.
 640  *
 641  * Set power on/off for device using the Sleep/Wake Application.
 642  * When enable is true, power on chip and enable doze mode.
 643  * When enable is false, enter sleep mode (device remains in the
 644  * lowest-power mode).
 645  *
 646  * Locking note: This function must be called with the device lock held.
 647  * Locking is not handled inside the function. Callers should ensure they
 648  * serialize access to the HW.
 649  *
 650  * Returns: 0 on success, negative value on failure.
 651  */
 652 int mma9551_set_device_state(struct i2c_client *client, bool enable)
 653 {
 654         return mma9551_update_config_bits(client, MMA9551_APPID_SLEEP_WAKE,
 655                                           MMA9551_SLEEP_CFG,
 656                                           MMA9551_SLEEP_CFG_SNCEN |
 657                                           MMA9551_SLEEP_CFG_FLEEN |
 658                                           MMA9551_SLEEP_CFG_SCHEN,
 659                                           enable ? MMA9551_SLEEP_CFG_SCHEN |
 660                                           MMA9551_SLEEP_CFG_FLEEN :
 661                                           MMA9551_SLEEP_CFG_SNCEN);
 662 }
 663 EXPORT_SYMBOL(mma9551_set_device_state);
 664
 665 /**
 666  * mma9551_set_power_state() - sets runtime PM state
 667  * @client:     I2C client
 668  * @on:         Use true to power on device, false to power off
 669  *
 670  * Resume or suspend the device using Runtime PM.
 671  * The device will suspend after the autosuspend delay.
 672  *
 673  * Returns: 0 on success, negative value on failure.
 674  */
 675 int mma9551_set_power_state(struct i2c_client *client, bool on)
 676 {
 677 #ifdef CONFIG_PM
 678         int ret;
 679
 680         if (on)
 681                 ret = pm_runtime_get_sync(&client->dev);
 682         else {
 683                 pm_runtime_mark_last_busy(&client->dev);
 684                 ret = pm_runtime_put_autosuspend(&client->dev);
 685         }
 686
 687         if (ret < 0) {
 688                 dev_err(&client->dev,
 689                         "failed to change power state to %d\n", on);
 690                 if (on)
 691                         pm_runtime_put_noidle(&client->dev);
 692
 693                 return ret;
 694         }
 695 #endif
 696
 697         return 0;
 698 }
 699 EXPORT_SYMBOL(mma9551_set_power_state);
 700
 701 /**
 702  * mma9551_sleep() - sleep
 703  * @freq:       Application frequency
 704  *
 705  * Firmware applications run at a certain frequency on the
 706  * device. Sleep for one application cycle to make sure the
 707  * application had time to run once and initialize set values.
 708  */
 709 void mma9551_sleep(int freq)
 710 {
 711         int sleep_val = 1000 / freq;
 712
 713         if (sleep_val < 20)
 714                 usleep_range(sleep_val * 1000, 20000);
 715         else
 716                 msleep_interruptible(sleep_val);
 717 }
 718 EXPORT_SYMBOL(mma9551_sleep);
 719
 720 /**
 721  * mma9551_read_accel_chan() - read accelerometer channel
 722  * @client:     I2C client
 723  * @chan:       IIO channel
 724  * @val:        Pointer to the accelerometer value read
 725  * @val2:       Unused
 726  *
 727  * Read accelerometer value for the specified channel.
 728  *
 729  * Locking note: This function must be called with the device lock held.
 730  * Locking is not handled inside the function. Callers should ensure they
 731  * serialize access to the HW.
 732  *
 733  * Returns: IIO_VAL_INT on success, negative value on failure.
 734  */
 735 int mma9551_read_accel_chan(struct i2c_client *client,
 736                             const struct iio_chan_spec *chan,
 737                             int *val, int *val2)
 738 {
 739         u16 reg_addr;
 740         s16 raw_accel;
 741         int ret;
 742
 743         switch (chan->channel2) {
 744         case IIO_MOD_X:
 745                 reg_addr = MMA9551_AFE_X_ACCEL_REG;
 746                 break;
 747         case IIO_MOD_Y:
 748                 reg_addr = MMA9551_AFE_Y_ACCEL_REG;
 749                 break;
 750         case IIO_MOD_Z:
 751                 reg_addr = MMA9551_AFE_Z_ACCEL_REG;
 752                 break;
 753         default:
 754                 return -EINVAL;
 755         }
 756
 757         ret = mma9551_set_power_state(client, true);
 758         if (ret < 0)
 759                 return ret;
 760
 761         ret = mma9551_read_status_word(client, MMA9551_APPID_AFE,
 762                                        reg_addr, &raw_accel);
 763         if (ret < 0)
 764                 goto out_poweroff;
 765
 766         *val = raw_accel;
 767
 768         ret = IIO_VAL_INT;
 769
 770 out_poweroff:
 771         mma9551_set_power_state(client, false);
 772         return ret;
 773 }
 774 EXPORT_SYMBOL(mma9551_read_accel_chan);
 775
 776 /**
 777  * mma9551_read_accel_scale() - read accelerometer scale
 778  * @val:        Pointer to the accelerometer scale (int value)
 779  * @val2:       Pointer to the accelerometer scale (micro value)
 780  *
 781  * Read accelerometer scale.
 782  *
 783  * Returns: IIO_VAL_INT_PLUS_MICRO.
 784  */
 785 int mma9551_read_accel_scale(int *val, int *val2)
 786 {
 787         *val = 0;
 788         *val2 = 2440;
 789
 790         return IIO_VAL_INT_PLUS_MICRO;
 791 }
 792 EXPORT_SYMBOL(mma9551_read_accel_scale);
 793
 794 /**
 795  * mma9551_app_reset() - reset application
 796  * @client:     I2C client
 797  * @app_mask:   Application to reset
 798  *
 799  * Reset the given application (using the Reset/Suspend/Clear
 800  * Control Application)
 801  *
 802  * Returns: 0 on success, negative value on failure.
 803  */
 804 int mma9551_app_reset(struct i2c_client *client, u32 app_mask)
 805 {
 806         return mma9551_write_config_byte(client, MMA9551_APPID_RSC,
 807                                          MMA9551_RSC_RESET +
 808                                          MMA9551_RSC_OFFSET(app_mask),
 809                                          MMA9551_RSC_VAL(app_mask));
 810 }
 811 EXPORT_SYMBOL(mma9551_app_reset);
 812
 813 MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
 814 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
 815 MODULE_LICENSE("GPL v2");
 816 MODULE_DESCRIPTION("MMA955xL sensors core");