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