GNU Linux-libre 4.9.282-gnu1
[releases.git] / 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         *val = be16_to_cpu(v);
308
309         return ret;
310 }
311 EXPORT_SYMBOL(mma9551_read_config_word);
312
313 /**
314  * mma9551_write_config_word() - write 1 config word
315  * @client:     I2C client
316  * @app_id:     Application ID
317  * @reg:        Application register
318  * @val:        Value to write
319  *
320  * Write one configuration word from the device using MMA955xL command format.
321  * Commands to the MMA955xL platform consist of a write followed by one or
322  * more reads.
323  *
324  * Locking note: This function must be called with the device lock held.
325  * Locking is not handled inside the function. Callers should ensure they
326  * serialize access to the HW.
327  *
328  * Returns: 0 on success, negative value on failure.
329  */
330 int mma9551_write_config_word(struct i2c_client *client, u8 app_id,
331                               u16 reg, u16 val)
332 {
333         __be16 v = cpu_to_be16(val);
334
335         return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg,
336                                 (u8 *)&v, 2, NULL, 0);
337 }
338 EXPORT_SYMBOL(mma9551_write_config_word);
339
340 /**
341  * mma9551_read_status_word() - read 1 status word
342  * @client:     I2C client
343  * @app_id:     Application ID
344  * @reg:        Application register
345  * @val:        Pointer to store value read
346  *
347  * Read one status word from the device using MMA955xL command format.
348  * Commands to the MMA955xL platform consist of a write followed by one or
349  * more reads.
350  *
351  * Locking note: This function must be called with the device lock held.
352  * Locking is not handled inside the function. Callers should ensure they
353  * serialize access to the HW.
354  *
355  * Returns: 0 on success, negative value on failure.
356  */
357 int mma9551_read_status_word(struct i2c_client *client, u8 app_id,
358                              u16 reg, u16 *val)
359 {
360         int ret;
361         __be16 v;
362
363         ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
364                                reg, NULL, 0, (u8 *)&v, 2);
365         *val = be16_to_cpu(v);
366
367         return ret;
368 }
369 EXPORT_SYMBOL(mma9551_read_status_word);
370
371 /**
372  * mma9551_read_config_words() - read multiple config words
373  * @client:     I2C client
374  * @app_id:     Application ID
375  * @reg:        Application register
376  * @len:        Length of array to read (in words)
377  * @buf:        Array of words to read
378  *
379  * Read multiple configuration registers (word-sized registers).
380  *
381  * Locking note: This function must be called with the device lock held.
382  * Locking is not handled inside the function. Callers should ensure they
383  * serialize access to the HW.
384  *
385  * Returns: 0 on success, negative value on failure.
386  */
387 int mma9551_read_config_words(struct i2c_client *client, u8 app_id,
388                               u16 reg, u8 len, u16 *buf)
389 {
390         int ret, i;
391         __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
392
393         if (len > ARRAY_SIZE(be_buf)) {
394                 dev_err(&client->dev, "Invalid buffer size %d\n", len);
395                 return -EINVAL;
396         }
397
398         ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
399                                reg, NULL, 0, (u8 *)be_buf, len * sizeof(u16));
400         if (ret < 0)
401                 return ret;
402
403         for (i = 0; i < len; i++)
404                 buf[i] = be16_to_cpu(be_buf[i]);
405
406         return 0;
407 }
408 EXPORT_SYMBOL(mma9551_read_config_words);
409
410 /**
411  * mma9551_read_status_words() - read multiple status words
412  * @client:     I2C client
413  * @app_id:     Application ID
414  * @reg:        Application register
415  * @len:        Length of array to read (in words)
416  * @buf:        Array of words to read
417  *
418  * Read multiple status registers (word-sized registers).
419  *
420  * Locking note: This function must be called with the device lock held.
421  * Locking is not handled inside the function. Callers should ensure they
422  * serialize access to the HW.
423  *
424  * Returns: 0 on success, negative value on failure.
425  */
426 int mma9551_read_status_words(struct i2c_client *client, u8 app_id,
427                               u16 reg, u8 len, u16 *buf)
428 {
429         int ret, i;
430         __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
431
432         if (len > ARRAY_SIZE(be_buf)) {
433                 dev_err(&client->dev, "Invalid buffer size %d\n", len);
434                 return -EINVAL;
435         }
436
437         ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
438                                reg, NULL, 0, (u8 *)be_buf, len * sizeof(u16));
439         if (ret < 0)
440                 return ret;
441
442         for (i = 0; i < len; i++)
443                 buf[i] = be16_to_cpu(be_buf[i]);
444
445         return 0;
446 }
447 EXPORT_SYMBOL(mma9551_read_status_words);
448
449 /**
450  * mma9551_write_config_words() - write multiple config words
451  * @client:     I2C client
452  * @app_id:     Application ID
453  * @reg:        Application register
454  * @len:        Length of array to write (in words)
455  * @buf:        Array of words to write
456  *
457  * Write multiple configuration registers (word-sized registers).
458  *
459  * Locking note: This function must be called with the device lock held.
460  * Locking is not handled inside the function. Callers should ensure they
461  * serialize access to the HW.
462  *
463  * Returns: 0 on success, negative value on failure.
464  */
465 int mma9551_write_config_words(struct i2c_client *client, u8 app_id,
466                                u16 reg, u8 len, u16 *buf)
467 {
468         int i;
469         __be16 be_buf[(MMA9551_MAX_MAILBOX_DATA_REGS - 1) / 2];
470
471         if (len > ARRAY_SIZE(be_buf)) {
472                 dev_err(&client->dev, "Invalid buffer size %d\n", len);
473                 return -EINVAL;
474         }
475
476         for (i = 0; i < len; i++)
477                 be_buf[i] = cpu_to_be16(buf[i]);
478
479         return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG,
480                                 reg, (u8 *)be_buf, len * sizeof(u16), NULL, 0);
481 }
482 EXPORT_SYMBOL(mma9551_write_config_words);
483
484 /**
485  * mma9551_update_config_bits() - update bits in register
486  * @client:     I2C client
487  * @app_id:     Application ID
488  * @reg:        Application register
489  * @mask:       Mask for the bits to update
490  * @val:        Value of the bits to update
491  *
492  * Update bits in the given register using a bit mask.
493  *
494  * Locking note: This function must be called with the device lock held.
495  * Locking is not handled inside the function. Callers should ensure they
496  * serialize access to the HW.
497  *
498  * Returns: 0 on success, negative value on failure.
499  */
500 int mma9551_update_config_bits(struct i2c_client *client, u8 app_id,
501                                u16 reg, u8 mask, u8 val)
502 {
503         int ret;
504         u8 tmp, orig;
505
506         ret = mma9551_read_config_byte(client, app_id, reg, &orig);
507         if (ret < 0)
508                 return ret;
509
510         tmp = orig & ~mask;
511         tmp |= val & mask;
512
513         if (tmp == orig)
514                 return 0;
515
516         return mma9551_write_config_byte(client, app_id, reg, tmp);
517 }
518 EXPORT_SYMBOL(mma9551_update_config_bits);
519
520 /**
521  * mma9551_gpio_config() - configure gpio
522  * @client:     I2C client
523  * @pin:        GPIO pin to configure
524  * @app_id:     Application ID
525  * @bitnum:     Bit number of status register being assigned to the GPIO pin.
526  * @polarity:   The polarity parameter is described in section 6.2.2, page 66,
527  *              of the Software Reference Manual.  Basically, polarity=0 means
528  *              the interrupt line has the same value as the selected bit,
529  *              while polarity=1 means the line is inverted.
530  *
531  * Assign a bit from an application’s status register to a specific GPIO pin.
532  *
533  * Locking note: This function must be called with the device lock held.
534  * Locking is not handled inside the function. Callers should ensure they
535  * serialize access to the HW.
536  *
537  * Returns: 0 on success, negative value on failure.
538  */
539 int mma9551_gpio_config(struct i2c_client *client, enum mma9551_gpio_pin pin,
540                         u8 app_id, u8 bitnum, int polarity)
541 {
542         u8 reg, pol_mask, pol_val;
543         int ret;
544
545         if (pin > mma9551_gpio_max) {
546                 dev_err(&client->dev, "bad GPIO pin\n");
547                 return -EINVAL;
548         }
549
550         /*
551          * Pin 6 is configured by regs 0x00 and 0x01, pin 7 by 0x02 and
552          * 0x03, and so on.
553          */
554         reg = pin * 2;
555
556         ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO,
557                                         reg, app_id);
558         if (ret < 0) {
559                 dev_err(&client->dev, "error setting GPIO app_id\n");
560                 return ret;
561         }
562
563         ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO,
564                                         reg + 1, bitnum);
565         if (ret < 0) {
566                 dev_err(&client->dev, "error setting GPIO bit number\n");
567                 return ret;
568         }
569
570         switch (pin) {
571         case mma9551_gpio6:
572                 reg = MMA9551_GPIO_POL_LSB;
573                 pol_mask = 1 << 6;
574                 break;
575         case mma9551_gpio7:
576                 reg = MMA9551_GPIO_POL_LSB;
577                 pol_mask = 1 << 7;
578                 break;
579         case mma9551_gpio8:
580                 reg = MMA9551_GPIO_POL_MSB;
581                 pol_mask = 1 << 0;
582                 break;
583         case mma9551_gpio9:
584                 reg = MMA9551_GPIO_POL_MSB;
585                 pol_mask = 1 << 1;
586                 break;
587         }
588         pol_val = polarity ? pol_mask : 0;
589
590         ret = mma9551_update_config_bits(client, MMA9551_APPID_GPIO, reg,
591                                          pol_mask, pol_val);
592         if (ret < 0)
593                 dev_err(&client->dev, "error setting GPIO polarity\n");
594
595         return ret;
596 }
597 EXPORT_SYMBOL(mma9551_gpio_config);
598
599 /**
600  * mma9551_read_version() - read device version information
601  * @client:     I2C client
602  *
603  * Read version information and print device id and firmware version.
604  *
605  * Locking note: This function must be called with the device lock held.
606  * Locking is not handled inside the function. Callers should ensure they
607  * serialize access to the HW.
608  *
609  * Returns: 0 on success, negative value on failure.
610  */
611 int mma9551_read_version(struct i2c_client *client)
612 {
613         struct mma9551_version_info info;
614         int ret;
615
616         ret = mma9551_transfer(client, MMA9551_APPID_VERSION, 0x00, 0x00,
617                                NULL, 0, (u8 *)&info, sizeof(info));
618         if (ret < 0)
619                 return ret;
620
621         dev_info(&client->dev, "device ID 0x%x, firmware version %02x.%02x\n",
622                  be32_to_cpu(info.device_id), info.fw_version[0],
623                  info.fw_version[1]);
624
625         return 0;
626 }
627 EXPORT_SYMBOL(mma9551_read_version);
628
629 /**
630  * mma9551_set_device_state() - sets HW power mode
631  * @client:     I2C client
632  * @enable:     Use true to power on device, false to cause the device
633  *              to enter sleep.
634  *
635  * Set power on/off for device using the Sleep/Wake Application.
636  * When enable is true, power on chip and enable doze mode.
637  * When enable is false, enter sleep mode (device remains in the
638  * lowest-power mode).
639  *
640  * Locking note: This function must be called with the device lock held.
641  * Locking is not handled inside the function. Callers should ensure they
642  * serialize access to the HW.
643  *
644  * Returns: 0 on success, negative value on failure.
645  */
646 int mma9551_set_device_state(struct i2c_client *client, bool enable)
647 {
648         return mma9551_update_config_bits(client, MMA9551_APPID_SLEEP_WAKE,
649                                           MMA9551_SLEEP_CFG,
650                                           MMA9551_SLEEP_CFG_SNCEN |
651                                           MMA9551_SLEEP_CFG_FLEEN |
652                                           MMA9551_SLEEP_CFG_SCHEN,
653                                           enable ? MMA9551_SLEEP_CFG_SCHEN |
654                                           MMA9551_SLEEP_CFG_FLEEN :
655                                           MMA9551_SLEEP_CFG_SNCEN);
656 }
657 EXPORT_SYMBOL(mma9551_set_device_state);
658
659 /**
660  * mma9551_set_power_state() - sets runtime PM state
661  * @client:     I2C client
662  * @on:         Use true to power on device, false to power off
663  *
664  * Resume or suspend the device using Runtime PM.
665  * The device will suspend after the autosuspend delay.
666  *
667  * Returns: 0 on success, negative value on failure.
668  */
669 int mma9551_set_power_state(struct i2c_client *client, bool on)
670 {
671 #ifdef CONFIG_PM
672         int ret;
673
674         if (on)
675                 ret = pm_runtime_get_sync(&client->dev);
676         else {
677                 pm_runtime_mark_last_busy(&client->dev);
678                 ret = pm_runtime_put_autosuspend(&client->dev);
679         }
680
681         if (ret < 0) {
682                 dev_err(&client->dev,
683                         "failed to change power state to %d\n", on);
684                 if (on)
685                         pm_runtime_put_noidle(&client->dev);
686
687                 return ret;
688         }
689 #endif
690
691         return 0;
692 }
693 EXPORT_SYMBOL(mma9551_set_power_state);
694
695 /**
696  * mma9551_sleep() - sleep
697  * @freq:       Application frequency
698  *
699  * Firmware applications run at a certain frequency on the
700  * device. Sleep for one application cycle to make sure the
701  * application had time to run once and initialize set values.
702  */
703 void mma9551_sleep(int freq)
704 {
705         int sleep_val = 1000 / freq;
706
707         if (sleep_val < 20)
708                 usleep_range(sleep_val * 1000, 20000);
709         else
710                 msleep_interruptible(sleep_val);
711 }
712 EXPORT_SYMBOL(mma9551_sleep);
713
714 /**
715  * mma9551_read_accel_chan() - read accelerometer channel
716  * @client:     I2C client
717  * @chan:       IIO channel
718  * @val:        Pointer to the accelerometer value read
719  * @val2:       Unused
720  *
721  * Read accelerometer value for the specified channel.
722  *
723  * Locking note: This function must be called with the device lock held.
724  * Locking is not handled inside the function. Callers should ensure they
725  * serialize access to the HW.
726  *
727  * Returns: IIO_VAL_INT on success, negative value on failure.
728  */
729 int mma9551_read_accel_chan(struct i2c_client *client,
730                             const struct iio_chan_spec *chan,
731                             int *val, int *val2)
732 {
733         u16 reg_addr;
734         s16 raw_accel;
735         int ret;
736
737         switch (chan->channel2) {
738         case IIO_MOD_X:
739                 reg_addr = MMA9551_AFE_X_ACCEL_REG;
740                 break;
741         case IIO_MOD_Y:
742                 reg_addr = MMA9551_AFE_Y_ACCEL_REG;
743                 break;
744         case IIO_MOD_Z:
745                 reg_addr = MMA9551_AFE_Z_ACCEL_REG;
746                 break;
747         default:
748                 return -EINVAL;
749         }
750
751         ret = mma9551_set_power_state(client, true);
752         if (ret < 0)
753                 return ret;
754
755         ret = mma9551_read_status_word(client, MMA9551_APPID_AFE,
756                                        reg_addr, &raw_accel);
757         if (ret < 0)
758                 goto out_poweroff;
759
760         *val = raw_accel;
761
762         ret = IIO_VAL_INT;
763
764 out_poweroff:
765         mma9551_set_power_state(client, false);
766         return ret;
767 }
768 EXPORT_SYMBOL(mma9551_read_accel_chan);
769
770 /**
771  * mma9551_read_accel_scale() - read accelerometer scale
772  * @val:        Pointer to the accelerometer scale (int value)
773  * @val2:       Pointer to the accelerometer scale (micro value)
774  *
775  * Read accelerometer scale.
776  *
777  * Returns: IIO_VAL_INT_PLUS_MICRO.
778  */
779 int mma9551_read_accel_scale(int *val, int *val2)
780 {
781         *val = 0;
782         *val2 = 2440;
783
784         return IIO_VAL_INT_PLUS_MICRO;
785 }
786 EXPORT_SYMBOL(mma9551_read_accel_scale);
787
788 /**
789  * mma9551_app_reset() - reset application
790  * @client:     I2C client
791  * @app_mask:   Application to reset
792  *
793  * Reset the given application (using the Reset/Suspend/Clear
794  * Control Application)
795  *
796  * Returns: 0 on success, negative value on failure.
797  */
798 int mma9551_app_reset(struct i2c_client *client, u32 app_mask)
799 {
800         return mma9551_write_config_byte(client, MMA9551_APPID_RSC,
801                                          MMA9551_RSC_RESET +
802                                          MMA9551_RSC_OFFSET(app_mask),
803                                          MMA9551_RSC_VAL(app_mask));
804 }
805 EXPORT_SYMBOL(mma9551_app_reset);
806
807 MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
808 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
809 MODULE_LICENSE("GPL v2");
810 MODULE_DESCRIPTION("MMA955xL sensors core");