xref: /openbmc/linux/drivers/iio/accel/mma9551_core.c (revision d7a3d85e)
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 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  */
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 	int len_words = len / sizeof(u16);
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 	}
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 }
409 EXPORT_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  */
427 int 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);
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 	}
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 }
449 EXPORT_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  */
467 int 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);
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 	}
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 }
485 EXPORT_SYMBOL(mma9551_write_config_words);
486 
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  */
503 int 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 }
521 EXPORT_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  */
542 int 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 }
600 EXPORT_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  */
614 int 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 }
630 EXPORT_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  */
649 int 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 }
660 EXPORT_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  */
672 int 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 }
696 EXPORT_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  */
706 void 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 }
715 EXPORT_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  */
732 int 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 
767 out_poweroff:
768 	mma9551_set_power_state(client, false);
769 	return ret;
770 }
771 EXPORT_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  */
782 int mma9551_read_accel_scale(int *val, int *val2)
783 {
784 	*val = 0;
785 	*val2 = 2440;
786 
787 	return IIO_VAL_INT_PLUS_MICRO;
788 }
789 EXPORT_SYMBOL(mma9551_read_accel_scale);
790 
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  */
801 int 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 }
808 EXPORT_SYMBOL(mma9551_app_reset);
809 
810 MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
811 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
812 MODULE_LICENSE("GPL v2");
813 MODULE_DESCRIPTION("MMA955xL sensors core");
814