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