1 // SPDX-License-Identifier: GPL-2.0-only
3 * Common code for Freescale MMA955x Intelligent Sensor Platform drivers
4 * Copyright (c) 2014, Intel Corporation.
7 #include <linux/module.h>
9 #include <linux/delay.h>
10 #include <linux/iio/iio.h>
11 #include <linux/pm_runtime.h>
12 #include "mma9551_core.h"
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
20 /* Mailbox read command */
21 #define MMA9551_RESPONSE_COCO BIT(7)
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
33 /* GPIO Application */
34 #define MMA9551_GPIO_POL_MSB 0x08
35 #define MMA9551_GPIO_POL_LSB 0x09
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)
44 #define MMA9551_AFE_X_ACCEL_REG 0x00
45 #define MMA9551_AFE_Y_ACCEL_REG 0x02
46 #define MMA9551_AFE_Z_ACCEL_REG 0x04
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))
54 * A response is composed of:
55 * - control registers: MB0-3
56 * - data registers: MB4-31
58 * A request is composed of:
59 * - mbox to write to (always 0)
60 * - control registers: MB1-4
61 * - data registers: MB5-31
63 #define MMA9551_MAILBOX_CTRL_REGS 4
64 #define MMA9551_MAX_MAILBOX_DATA_REGS 28
65 #define MMA9551_MAILBOX_REGS 32
67 #define MMA9551_I2C_READ_RETRIES 5
68 #define MMA9551_I2C_READ_DELAY 50 /* us */
70 struct mma9551_mbox_request {
71 u8 start_mbox; /* Always 0. */
74 * See Section 5.3.1 of the MMA955xL Software Reference Manual.
76 * Bit 7: reserved, always 0
78 * Bits 3-0: upper bits of register offset
83 u8 buf[MMA9551_MAX_MAILBOX_DATA_REGS - 1];
86 struct mma9551_mbox_response {
89 * See Section 5.3.3 of the MMA955xL Software Reference Manual.
92 * Bits 6-0: Error code.
97 u8 buf[MMA9551_MAX_MAILBOX_DATA_REGS];
100 struct mma9551_version_info {
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)
113 struct mma9551_mbox_request req;
114 struct mma9551_mbox_response rsp;
115 struct i2c_msg in, out;
116 u8 req_len, err_code;
119 if (offset >= 1 << 12) {
120 dev_err(&client->dev, "register offset too large\n");
124 req_len = 1 + MMA9551_MAILBOX_CTRL_REGS + num_inbytes;
127 req.cmd_off = command | (offset >> 8);
128 req.lower_off = offset;
130 if (command == MMA9551_CMD_WRITE_CONFIG)
131 req.nbytes = num_inbytes;
133 req.nbytes = num_outbytes;
135 memcpy(req.buf, inbytes, num_inbytes);
137 out.addr = client->addr;
140 out.buf = (u8 *)&req;
142 ret = i2c_transfer(client->adapter, &out, 1);
144 dev_err(&client->dev, "i2c write failed\n");
148 retries = MMA9551_I2C_READ_RETRIES;
150 udelay(MMA9551_I2C_READ_DELAY);
152 in.addr = client->addr;
154 in.len = sizeof(rsp);
157 ret = i2c_transfer(client->adapter, &in, 1);
159 dev_err(&client->dev, "i2c read failed\n");
163 if (rsp.coco_err & MMA9551_RESPONSE_COCO)
165 } while (--retries > 0);
168 dev_err(&client->dev,
169 "timed out while waiting for command response\n");
173 if (rsp.app_id != app_id) {
174 dev_err(&client->dev,
175 "app_id mismatch in response got %02x expected %02x\n",
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);
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);
194 memcpy(outbytes, rsp.buf, num_outbytes);
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
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.
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.
214 * Returns: 0 on success, negative value on failure.
216 int mma9551_read_config_byte(struct i2c_client *client, u8 app_id,
219 return mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
220 reg, NULL, 0, val, 1);
222 EXPORT_SYMBOL_NS(mma9551_read_config_byte, IIO_MMA9551);
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
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
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.
239 * Returns: 0 on success, negative value on failure.
241 int mma9551_write_config_byte(struct i2c_client *client, u8 app_id,
244 return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg,
247 EXPORT_SYMBOL_NS(mma9551_write_config_byte, IIO_MMA9551);
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
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
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.
264 * Returns: 0 on success, negative value on failure.
266 int mma9551_read_status_byte(struct i2c_client *client, u8 app_id,
269 return mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
270 reg, NULL, 0, val, 1);
272 EXPORT_SYMBOL_NS(mma9551_read_status_byte, IIO_MMA9551);
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
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
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.
289 * Returns: 0 on success, negative value on failure.
291 int mma9551_read_config_word(struct i2c_client *client, u8 app_id,
297 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
298 reg, NULL, 0, (u8 *)&v, 2);
299 *val = be16_to_cpu(v);
303 EXPORT_SYMBOL_NS(mma9551_read_config_word, IIO_MMA9551);
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
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
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.
320 * Returns: 0 on success, negative value on failure.
322 int mma9551_write_config_word(struct i2c_client *client, u8 app_id,
325 __be16 v = cpu_to_be16(val);
327 return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg,
328 (u8 *)&v, 2, NULL, 0);
330 EXPORT_SYMBOL_NS(mma9551_write_config_word, IIO_MMA9551);
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
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
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.
347 * Returns: 0 on success, negative value on failure.
349 int mma9551_read_status_word(struct i2c_client *client, u8 app_id,
355 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
356 reg, NULL, 0, (u8 *)&v, 2);
357 *val = be16_to_cpu(v);
361 EXPORT_SYMBOL_NS(mma9551_read_status_word, IIO_MMA9551);
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
371 * Read multiple configuration registers (word-sized registers).
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.
377 * Returns: 0 on success, negative value on failure.
379 int mma9551_read_config_words(struct i2c_client *client, u8 app_id,
380 u16 reg, u8 len, u16 *buf)
383 __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
385 if (len > ARRAY_SIZE(be_buf)) {
386 dev_err(&client->dev, "Invalid buffer size %d\n", len);
390 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
391 reg, NULL, 0, (u8 *)be_buf, len * sizeof(u16));
395 for (i = 0; i < len; i++)
396 buf[i] = be16_to_cpu(be_buf[i]);
400 EXPORT_SYMBOL_NS(mma9551_read_config_words, IIO_MMA9551);
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
410 * Read multiple status registers (word-sized registers).
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.
416 * Returns: 0 on success, negative value on failure.
418 int mma9551_read_status_words(struct i2c_client *client, u8 app_id,
419 u16 reg, u8 len, u16 *buf)
422 __be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
424 if (len > ARRAY_SIZE(be_buf)) {
425 dev_err(&client->dev, "Invalid buffer size %d\n", len);
429 ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
430 reg, NULL, 0, (u8 *)be_buf, len * sizeof(u16));
434 for (i = 0; i < len; i++)
435 buf[i] = be16_to_cpu(be_buf[i]);
439 EXPORT_SYMBOL_NS(mma9551_read_status_words, IIO_MMA9551);
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
449 * Write multiple configuration registers (word-sized registers).
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.
455 * Returns: 0 on success, negative value on failure.
457 int mma9551_write_config_words(struct i2c_client *client, u8 app_id,
458 u16 reg, u8 len, u16 *buf)
461 __be16 be_buf[(MMA9551_MAX_MAILBOX_DATA_REGS - 1) / 2];
463 if (len > ARRAY_SIZE(be_buf)) {
464 dev_err(&client->dev, "Invalid buffer size %d\n", len);
468 for (i = 0; i < len; i++)
469 be_buf[i] = cpu_to_be16(buf[i]);
471 return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG,
472 reg, (u8 *)be_buf, len * sizeof(u16), NULL, 0);
474 EXPORT_SYMBOL_NS(mma9551_write_config_words, IIO_MMA9551);
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
484 * Update bits in the given register using a bit mask.
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.
490 * Returns: 0 on success, negative value on failure.
492 int mma9551_update_config_bits(struct i2c_client *client, u8 app_id,
493 u16 reg, u8 mask, u8 val)
498 ret = mma9551_read_config_byte(client, app_id, reg, &orig);
508 return mma9551_write_config_byte(client, app_id, reg, tmp);
510 EXPORT_SYMBOL_NS(mma9551_update_config_bits, IIO_MMA9551);
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.
523 * Assign a bit from an application’s status register to a specific GPIO pin.
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.
529 * Returns: 0 on success, negative value on failure.
531 int mma9551_gpio_config(struct i2c_client *client, enum mma9551_gpio_pin pin,
532 u8 app_id, u8 bitnum, int polarity)
534 u8 reg, pol_mask, pol_val;
537 if (pin > mma9551_gpio_max) {
538 dev_err(&client->dev, "bad GPIO pin\n");
543 * Pin 6 is configured by regs 0x00 and 0x01, pin 7 by 0x02 and
548 ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO,
551 dev_err(&client->dev, "error setting GPIO app_id\n");
555 ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO,
558 dev_err(&client->dev, "error setting GPIO bit number\n");
564 reg = MMA9551_GPIO_POL_LSB;
568 reg = MMA9551_GPIO_POL_LSB;
572 reg = MMA9551_GPIO_POL_MSB;
576 reg = MMA9551_GPIO_POL_MSB;
580 pol_val = polarity ? pol_mask : 0;
582 ret = mma9551_update_config_bits(client, MMA9551_APPID_GPIO, reg,
585 dev_err(&client->dev, "error setting GPIO polarity\n");
589 EXPORT_SYMBOL_NS(mma9551_gpio_config, IIO_MMA9551);
592 * mma9551_read_version() - read device version information
593 * @client: I2C client
595 * Read version information and print device id and firmware version.
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.
601 * Returns: 0 on success, negative value on failure.
603 int mma9551_read_version(struct i2c_client *client)
605 struct mma9551_version_info info;
608 ret = mma9551_transfer(client, MMA9551_APPID_VERSION, 0x00, 0x00,
609 NULL, 0, (u8 *)&info, sizeof(info));
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],
619 EXPORT_SYMBOL_NS(mma9551_read_version, IIO_MMA9551);
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
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).
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.
636 * Returns: 0 on success, negative value on failure.
638 int mma9551_set_device_state(struct i2c_client *client, bool enable)
640 return mma9551_update_config_bits(client, MMA9551_APPID_SLEEP_WAKE,
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);
649 EXPORT_SYMBOL_NS(mma9551_set_device_state, IIO_MMA9551);
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
656 * Resume or suspend the device using Runtime PM.
657 * The device will suspend after the autosuspend delay.
659 * Returns: 0 on success, negative value on failure.
661 int mma9551_set_power_state(struct i2c_client *client, bool on)
667 ret = pm_runtime_resume_and_get(&client->dev);
669 pm_runtime_mark_last_busy(&client->dev);
670 ret = pm_runtime_put_autosuspend(&client->dev);
674 dev_err(&client->dev,
675 "failed to change power state to %d\n", on);
683 EXPORT_SYMBOL_NS(mma9551_set_power_state, IIO_MMA9551);
686 * mma9551_sleep() - sleep
687 * @freq: Application frequency
689 * Firmware applications run at a certain frequency on the
690 * device. Sleep for one application cycle to make sure the
691 * application had time to run once and initialize set values.
693 void mma9551_sleep(int freq)
695 int sleep_val = 1000 / freq;
698 usleep_range(sleep_val * 1000, 20000);
700 msleep_interruptible(sleep_val);
702 EXPORT_SYMBOL_NS(mma9551_sleep, IIO_MMA9551);
705 * mma9551_read_accel_chan() - read accelerometer channel
706 * @client: I2C client
708 * @val: Pointer to the accelerometer value read
711 * Read accelerometer value for the specified channel.
713 * Locking note: This function must be called with the device lock held.
714 * Locking is not handled inside the function. Callers should ensure they
715 * serialize access to the HW.
717 * Returns: IIO_VAL_INT on success, negative value on failure.
719 int mma9551_read_accel_chan(struct i2c_client *client,
720 const struct iio_chan_spec *chan,
727 switch (chan->channel2) {
729 reg_addr = MMA9551_AFE_X_ACCEL_REG;
732 reg_addr = MMA9551_AFE_Y_ACCEL_REG;
735 reg_addr = MMA9551_AFE_Z_ACCEL_REG;
741 ret = mma9551_set_power_state(client, true);
745 ret = mma9551_read_status_word(client, MMA9551_APPID_AFE,
746 reg_addr, &raw_accel);
755 mma9551_set_power_state(client, false);
758 EXPORT_SYMBOL_NS(mma9551_read_accel_chan, IIO_MMA9551);
761 * mma9551_read_accel_scale() - read accelerometer scale
762 * @val: Pointer to the accelerometer scale (int value)
763 * @val2: Pointer to the accelerometer scale (micro value)
765 * Read accelerometer scale.
767 * Returns: IIO_VAL_INT_PLUS_MICRO.
769 int mma9551_read_accel_scale(int *val, int *val2)
774 return IIO_VAL_INT_PLUS_MICRO;
776 EXPORT_SYMBOL_NS(mma9551_read_accel_scale, IIO_MMA9551);
779 * mma9551_app_reset() - reset application
780 * @client: I2C client
781 * @app_mask: Application to reset
783 * Reset the given application (using the Reset/Suspend/Clear
784 * Control Application)
786 * Returns: 0 on success, negative value on failure.
788 int mma9551_app_reset(struct i2c_client *client, u32 app_mask)
790 return mma9551_write_config_byte(client, MMA9551_APPID_RSC,
792 MMA9551_RSC_OFFSET(app_mask),
793 MMA9551_RSC_VAL(app_mask));
795 EXPORT_SYMBOL_NS(mma9551_app_reset, IIO_MMA9551);
797 MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
798 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
799 MODULE_LICENSE("GPL v2");
800 MODULE_DESCRIPTION("MMA955xL sensors core");