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