![Thomas Gleixner](/assets/img/avatar_default.png)
Based on 1 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms and conditions of the gnu general public license version 2 as published by the free software foundation this program is distributed in the hope it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details extracted by the scancode license scanner the SPDX license identifier GPL-2.0-only has been chosen to replace the boilerplate/reference in 263 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Alexios Zavras <alexios.zavras@intel.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190529141901.208660670@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
803 lines
21 KiB
C
803 lines
21 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
||
/*
|
||
* Common code for Freescale MMA955x Intelligent Sensor Platform drivers
|
||
* Copyright (c) 2014, Intel Corporation.
|
||
*/
|
||
|
||
#include <linux/module.h>
|
||
#include <linux/i2c.h>
|
||
#include <linux/delay.h>
|
||
#include <linux/iio/iio.h>
|
||
#include <linux/pm_runtime.h>
|
||
#include "mma9551_core.h"
|
||
|
||
/* Command masks for mailbox write command */
|
||
#define MMA9551_CMD_READ_VERSION_INFO 0x00
|
||
#define MMA9551_CMD_READ_CONFIG 0x10
|
||
#define MMA9551_CMD_WRITE_CONFIG 0x20
|
||
#define MMA9551_CMD_READ_STATUS 0x30
|
||
|
||
/* Mailbox read command */
|
||
#define MMA9551_RESPONSE_COCO BIT(7)
|
||
|
||
/* Error-Status codes returned in mailbox read command */
|
||
#define MMA9551_MCI_ERROR_NONE 0x00
|
||
#define MMA9551_MCI_ERROR_PARAM 0x04
|
||
#define MMA9551_MCI_INVALID_COUNT 0x19
|
||
#define MMA9551_MCI_ERROR_COMMAND 0x1C
|
||
#define MMA9551_MCI_ERROR_INVALID_LENGTH 0x21
|
||
#define MMA9551_MCI_ERROR_FIFO_BUSY 0x22
|
||
#define MMA9551_MCI_ERROR_FIFO_ALLOCATED 0x23
|
||
#define MMA9551_MCI_ERROR_FIFO_OVERSIZE 0x24
|
||
|
||
/* GPIO Application */
|
||
#define MMA9551_GPIO_POL_MSB 0x08
|
||
#define MMA9551_GPIO_POL_LSB 0x09
|
||
|
||
/* Sleep/Wake application */
|
||
#define MMA9551_SLEEP_CFG 0x06
|
||
#define MMA9551_SLEEP_CFG_SNCEN BIT(0)
|
||
#define MMA9551_SLEEP_CFG_FLEEN BIT(1)
|
||
#define MMA9551_SLEEP_CFG_SCHEN BIT(2)
|
||
|
||
/* AFE application */
|
||
#define MMA9551_AFE_X_ACCEL_REG 0x00
|
||
#define MMA9551_AFE_Y_ACCEL_REG 0x02
|
||
#define MMA9551_AFE_Z_ACCEL_REG 0x04
|
||
|
||
/* Reset/Suspend/Clear application */
|
||
#define MMA9551_RSC_RESET 0x00
|
||
#define MMA9551_RSC_OFFSET(mask) (3 - (ffs(mask) - 1) / 8)
|
||
#define MMA9551_RSC_VAL(mask) (mask >> (((ffs(mask) - 1) / 8) * 8))
|
||
|
||
/*
|
||
* A response is composed of:
|
||
* - control registers: MB0-3
|
||
* - data registers: MB4-31
|
||
*
|
||
* A request is composed of:
|
||
* - mbox to write to (always 0)
|
||
* - control registers: MB1-4
|
||
* - data registers: MB5-31
|
||
*/
|
||
#define MMA9551_MAILBOX_CTRL_REGS 4
|
||
#define MMA9551_MAX_MAILBOX_DATA_REGS 28
|
||
#define MMA9551_MAILBOX_REGS 32
|
||
|
||
#define MMA9551_I2C_READ_RETRIES 5
|
||
#define MMA9551_I2C_READ_DELAY 50 /* us */
|
||
|
||
struct mma9551_mbox_request {
|
||
u8 start_mbox; /* Always 0. */
|
||
u8 app_id;
|
||
/*
|
||
* See Section 5.3.1 of the MMA955xL Software Reference Manual.
|
||
*
|
||
* Bit 7: reserved, always 0
|
||
* Bits 6-4: command
|
||
* Bits 3-0: upper bits of register offset
|
||
*/
|
||
u8 cmd_off;
|
||
u8 lower_off;
|
||
u8 nbytes;
|
||
u8 buf[MMA9551_MAX_MAILBOX_DATA_REGS - 1];
|
||
} __packed;
|
||
|
||
struct mma9551_mbox_response {
|
||
u8 app_id;
|
||
/*
|
||
* See Section 5.3.3 of the MMA955xL Software Reference Manual.
|
||
*
|
||
* Bit 7: COCO
|
||
* Bits 6-0: Error code.
|
||
*/
|
||
u8 coco_err;
|
||
u8 nbytes;
|
||
u8 req_bytes;
|
||
u8 buf[MMA9551_MAX_MAILBOX_DATA_REGS];
|
||
} __packed;
|
||
|
||
struct mma9551_version_info {
|
||
__be32 device_id;
|
||
u8 rom_version[2];
|
||
u8 fw_version[2];
|
||
u8 hw_version[2];
|
||
u8 fw_build[2];
|
||
};
|
||
|
||
static int mma9551_transfer(struct i2c_client *client,
|
||
u8 app_id, u8 command, u16 offset,
|
||
u8 *inbytes, int num_inbytes,
|
||
u8 *outbytes, int num_outbytes)
|
||
{
|
||
struct mma9551_mbox_request req;
|
||
struct mma9551_mbox_response rsp;
|
||
struct i2c_msg in, out;
|
||
u8 req_len, err_code;
|
||
int ret, retries;
|
||
|
||
if (offset >= 1 << 12) {
|
||
dev_err(&client->dev, "register offset too large\n");
|
||
return -EINVAL;
|
||
}
|
||
|
||
req_len = 1 + MMA9551_MAILBOX_CTRL_REGS + num_inbytes;
|
||
req.start_mbox = 0;
|
||
req.app_id = app_id;
|
||
req.cmd_off = command | (offset >> 8);
|
||
req.lower_off = offset;
|
||
|
||
if (command == MMA9551_CMD_WRITE_CONFIG)
|
||
req.nbytes = num_inbytes;
|
||
else
|
||
req.nbytes = num_outbytes;
|
||
if (num_inbytes)
|
||
memcpy(req.buf, inbytes, num_inbytes);
|
||
|
||
out.addr = client->addr;
|
||
out.flags = 0;
|
||
out.len = req_len;
|
||
out.buf = (u8 *)&req;
|
||
|
||
ret = i2c_transfer(client->adapter, &out, 1);
|
||
if (ret < 0) {
|
||
dev_err(&client->dev, "i2c write failed\n");
|
||
return ret;
|
||
}
|
||
|
||
retries = MMA9551_I2C_READ_RETRIES;
|
||
do {
|
||
udelay(MMA9551_I2C_READ_DELAY);
|
||
|
||
in.addr = client->addr;
|
||
in.flags = I2C_M_RD;
|
||
in.len = sizeof(rsp);
|
||
in.buf = (u8 *)&rsp;
|
||
|
||
ret = i2c_transfer(client->adapter, &in, 1);
|
||
if (ret < 0) {
|
||
dev_err(&client->dev, "i2c read failed\n");
|
||
return ret;
|
||
}
|
||
|
||
if (rsp.coco_err & MMA9551_RESPONSE_COCO)
|
||
break;
|
||
} while (--retries > 0);
|
||
|
||
if (retries == 0) {
|
||
dev_err(&client->dev,
|
||
"timed out while waiting for command response\n");
|
||
return -ETIMEDOUT;
|
||
}
|
||
|
||
if (rsp.app_id != app_id) {
|
||
dev_err(&client->dev,
|
||
"app_id mismatch in response got %02x expected %02x\n",
|
||
rsp.app_id, app_id);
|
||
return -EINVAL;
|
||
}
|
||
|
||
err_code = rsp.coco_err & ~MMA9551_RESPONSE_COCO;
|
||
if (err_code != MMA9551_MCI_ERROR_NONE) {
|
||
dev_err(&client->dev, "read returned error %x\n", err_code);
|
||
return -EINVAL;
|
||
}
|
||
|
||
if (rsp.nbytes != rsp.req_bytes) {
|
||
dev_err(&client->dev,
|
||
"output length mismatch got %d expected %d\n",
|
||
rsp.nbytes, rsp.req_bytes);
|
||
return -EINVAL;
|
||
}
|
||
|
||
if (num_outbytes)
|
||
memcpy(outbytes, rsp.buf, num_outbytes);
|
||
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* mma9551_read_config_byte() - read 1 configuration byte
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @val: Pointer to store value read
|
||
*
|
||
* Read one configuration byte from the device using MMA955xL command format.
|
||
* Commands to the MMA955xL platform consist of a write followed
|
||
* by one or more reads.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_read_config_byte(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u8 *val)
|
||
{
|
||
return mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
|
||
reg, NULL, 0, val, 1);
|
||
}
|
||
EXPORT_SYMBOL(mma9551_read_config_byte);
|
||
|
||
/**
|
||
* mma9551_write_config_byte() - write 1 configuration byte
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @val: Value to write
|
||
*
|
||
* Write one configuration byte from the device using MMA955xL command format.
|
||
* Commands to the MMA955xL platform consist of a write followed by one or
|
||
* more reads.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_write_config_byte(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u8 val)
|
||
{
|
||
return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg,
|
||
&val, 1, NULL, 0);
|
||
}
|
||
EXPORT_SYMBOL(mma9551_write_config_byte);
|
||
|
||
/**
|
||
* mma9551_read_status_byte() - read 1 status byte
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @val: Pointer to store value read
|
||
*
|
||
* Read one status byte from the device using MMA955xL command format.
|
||
* Commands to the MMA955xL platform consist of a write followed by one or
|
||
* more reads.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_read_status_byte(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u8 *val)
|
||
{
|
||
return mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
|
||
reg, NULL, 0, val, 1);
|
||
}
|
||
EXPORT_SYMBOL(mma9551_read_status_byte);
|
||
|
||
/**
|
||
* mma9551_read_config_word() - read 1 config word
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @val: Pointer to store value read
|
||
*
|
||
* Read one configuration word from the device using MMA955xL command format.
|
||
* Commands to the MMA955xL platform consist of a write followed by one or
|
||
* more reads.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_read_config_word(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u16 *val)
|
||
{
|
||
int ret;
|
||
__be16 v;
|
||
|
||
ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
|
||
reg, NULL, 0, (u8 *)&v, 2);
|
||
*val = be16_to_cpu(v);
|
||
|
||
return ret;
|
||
}
|
||
EXPORT_SYMBOL(mma9551_read_config_word);
|
||
|
||
/**
|
||
* mma9551_write_config_word() - write 1 config word
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @val: Value to write
|
||
*
|
||
* Write one configuration word from the device using MMA955xL command format.
|
||
* Commands to the MMA955xL platform consist of a write followed by one or
|
||
* more reads.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_write_config_word(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u16 val)
|
||
{
|
||
__be16 v = cpu_to_be16(val);
|
||
|
||
return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG, reg,
|
||
(u8 *)&v, 2, NULL, 0);
|
||
}
|
||
EXPORT_SYMBOL(mma9551_write_config_word);
|
||
|
||
/**
|
||
* mma9551_read_status_word() - read 1 status word
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @val: Pointer to store value read
|
||
*
|
||
* Read one status word from the device using MMA955xL command format.
|
||
* Commands to the MMA955xL platform consist of a write followed by one or
|
||
* more reads.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_read_status_word(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u16 *val)
|
||
{
|
||
int ret;
|
||
__be16 v;
|
||
|
||
ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
|
||
reg, NULL, 0, (u8 *)&v, 2);
|
||
*val = be16_to_cpu(v);
|
||
|
||
return ret;
|
||
}
|
||
EXPORT_SYMBOL(mma9551_read_status_word);
|
||
|
||
/**
|
||
* mma9551_read_config_words() - read multiple config words
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @len: Length of array to read (in words)
|
||
* @buf: Array of words to read
|
||
*
|
||
* Read multiple configuration registers (word-sized registers).
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_read_config_words(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u8 len, u16 *buf)
|
||
{
|
||
int ret, i;
|
||
__be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
|
||
|
||
if (len > ARRAY_SIZE(be_buf)) {
|
||
dev_err(&client->dev, "Invalid buffer size %d\n", len);
|
||
return -EINVAL;
|
||
}
|
||
|
||
ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_CONFIG,
|
||
reg, NULL, 0, (u8 *)be_buf, len * sizeof(u16));
|
||
if (ret < 0)
|
||
return ret;
|
||
|
||
for (i = 0; i < len; i++)
|
||
buf[i] = be16_to_cpu(be_buf[i]);
|
||
|
||
return 0;
|
||
}
|
||
EXPORT_SYMBOL(mma9551_read_config_words);
|
||
|
||
/**
|
||
* mma9551_read_status_words() - read multiple status words
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @len: Length of array to read (in words)
|
||
* @buf: Array of words to read
|
||
*
|
||
* Read multiple status registers (word-sized registers).
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_read_status_words(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u8 len, u16 *buf)
|
||
{
|
||
int ret, i;
|
||
__be16 be_buf[MMA9551_MAX_MAILBOX_DATA_REGS / 2];
|
||
|
||
if (len > ARRAY_SIZE(be_buf)) {
|
||
dev_err(&client->dev, "Invalid buffer size %d\n", len);
|
||
return -EINVAL;
|
||
}
|
||
|
||
ret = mma9551_transfer(client, app_id, MMA9551_CMD_READ_STATUS,
|
||
reg, NULL, 0, (u8 *)be_buf, len * sizeof(u16));
|
||
if (ret < 0)
|
||
return ret;
|
||
|
||
for (i = 0; i < len; i++)
|
||
buf[i] = be16_to_cpu(be_buf[i]);
|
||
|
||
return 0;
|
||
}
|
||
EXPORT_SYMBOL(mma9551_read_status_words);
|
||
|
||
/**
|
||
* mma9551_write_config_words() - write multiple config words
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @len: Length of array to write (in words)
|
||
* @buf: Array of words to write
|
||
*
|
||
* Write multiple configuration registers (word-sized registers).
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_write_config_words(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u8 len, u16 *buf)
|
||
{
|
||
int i;
|
||
__be16 be_buf[(MMA9551_MAX_MAILBOX_DATA_REGS - 1) / 2];
|
||
|
||
if (len > ARRAY_SIZE(be_buf)) {
|
||
dev_err(&client->dev, "Invalid buffer size %d\n", len);
|
||
return -EINVAL;
|
||
}
|
||
|
||
for (i = 0; i < len; i++)
|
||
be_buf[i] = cpu_to_be16(buf[i]);
|
||
|
||
return mma9551_transfer(client, app_id, MMA9551_CMD_WRITE_CONFIG,
|
||
reg, (u8 *)be_buf, len * sizeof(u16), NULL, 0);
|
||
}
|
||
EXPORT_SYMBOL(mma9551_write_config_words);
|
||
|
||
/**
|
||
* mma9551_update_config_bits() - update bits in register
|
||
* @client: I2C client
|
||
* @app_id: Application ID
|
||
* @reg: Application register
|
||
* @mask: Mask for the bits to update
|
||
* @val: Value of the bits to update
|
||
*
|
||
* Update bits in the given register using a bit mask.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_update_config_bits(struct i2c_client *client, u8 app_id,
|
||
u16 reg, u8 mask, u8 val)
|
||
{
|
||
int ret;
|
||
u8 tmp, orig;
|
||
|
||
ret = mma9551_read_config_byte(client, app_id, reg, &orig);
|
||
if (ret < 0)
|
||
return ret;
|
||
|
||
tmp = orig & ~mask;
|
||
tmp |= val & mask;
|
||
|
||
if (tmp == orig)
|
||
return 0;
|
||
|
||
return mma9551_write_config_byte(client, app_id, reg, tmp);
|
||
}
|
||
EXPORT_SYMBOL(mma9551_update_config_bits);
|
||
|
||
/**
|
||
* mma9551_gpio_config() - configure gpio
|
||
* @client: I2C client
|
||
* @pin: GPIO pin to configure
|
||
* @app_id: Application ID
|
||
* @bitnum: Bit number of status register being assigned to the GPIO pin.
|
||
* @polarity: The polarity parameter is described in section 6.2.2, page 66,
|
||
* of the Software Reference Manual. Basically, polarity=0 means
|
||
* the interrupt line has the same value as the selected bit,
|
||
* while polarity=1 means the line is inverted.
|
||
*
|
||
* Assign a bit from an application’s status register to a specific GPIO pin.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_gpio_config(struct i2c_client *client, enum mma9551_gpio_pin pin,
|
||
u8 app_id, u8 bitnum, int polarity)
|
||
{
|
||
u8 reg, pol_mask, pol_val;
|
||
int ret;
|
||
|
||
if (pin > mma9551_gpio_max) {
|
||
dev_err(&client->dev, "bad GPIO pin\n");
|
||
return -EINVAL;
|
||
}
|
||
|
||
/*
|
||
* Pin 6 is configured by regs 0x00 and 0x01, pin 7 by 0x02 and
|
||
* 0x03, and so on.
|
||
*/
|
||
reg = pin * 2;
|
||
|
||
ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO,
|
||
reg, app_id);
|
||
if (ret < 0) {
|
||
dev_err(&client->dev, "error setting GPIO app_id\n");
|
||
return ret;
|
||
}
|
||
|
||
ret = mma9551_write_config_byte(client, MMA9551_APPID_GPIO,
|
||
reg + 1, bitnum);
|
||
if (ret < 0) {
|
||
dev_err(&client->dev, "error setting GPIO bit number\n");
|
||
return ret;
|
||
}
|
||
|
||
switch (pin) {
|
||
case mma9551_gpio6:
|
||
reg = MMA9551_GPIO_POL_LSB;
|
||
pol_mask = 1 << 6;
|
||
break;
|
||
case mma9551_gpio7:
|
||
reg = MMA9551_GPIO_POL_LSB;
|
||
pol_mask = 1 << 7;
|
||
break;
|
||
case mma9551_gpio8:
|
||
reg = MMA9551_GPIO_POL_MSB;
|
||
pol_mask = 1 << 0;
|
||
break;
|
||
case mma9551_gpio9:
|
||
reg = MMA9551_GPIO_POL_MSB;
|
||
pol_mask = 1 << 1;
|
||
break;
|
||
}
|
||
pol_val = polarity ? pol_mask : 0;
|
||
|
||
ret = mma9551_update_config_bits(client, MMA9551_APPID_GPIO, reg,
|
||
pol_mask, pol_val);
|
||
if (ret < 0)
|
||
dev_err(&client->dev, "error setting GPIO polarity\n");
|
||
|
||
return ret;
|
||
}
|
||
EXPORT_SYMBOL(mma9551_gpio_config);
|
||
|
||
/**
|
||
* mma9551_read_version() - read device version information
|
||
* @client: I2C client
|
||
*
|
||
* Read version information and print device id and firmware version.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_read_version(struct i2c_client *client)
|
||
{
|
||
struct mma9551_version_info info;
|
||
int ret;
|
||
|
||
ret = mma9551_transfer(client, MMA9551_APPID_VERSION, 0x00, 0x00,
|
||
NULL, 0, (u8 *)&info, sizeof(info));
|
||
if (ret < 0)
|
||
return ret;
|
||
|
||
dev_info(&client->dev, "device ID 0x%x, firmware version %02x.%02x\n",
|
||
be32_to_cpu(info.device_id), info.fw_version[0],
|
||
info.fw_version[1]);
|
||
|
||
return 0;
|
||
}
|
||
EXPORT_SYMBOL(mma9551_read_version);
|
||
|
||
/**
|
||
* mma9551_set_device_state() - sets HW power mode
|
||
* @client: I2C client
|
||
* @enable: Use true to power on device, false to cause the device
|
||
* to enter sleep.
|
||
*
|
||
* Set power on/off for device using the Sleep/Wake Application.
|
||
* When enable is true, power on chip and enable doze mode.
|
||
* When enable is false, enter sleep mode (device remains in the
|
||
* lowest-power mode).
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_set_device_state(struct i2c_client *client, bool enable)
|
||
{
|
||
return mma9551_update_config_bits(client, MMA9551_APPID_SLEEP_WAKE,
|
||
MMA9551_SLEEP_CFG,
|
||
MMA9551_SLEEP_CFG_SNCEN |
|
||
MMA9551_SLEEP_CFG_FLEEN |
|
||
MMA9551_SLEEP_CFG_SCHEN,
|
||
enable ? MMA9551_SLEEP_CFG_SCHEN |
|
||
MMA9551_SLEEP_CFG_FLEEN :
|
||
MMA9551_SLEEP_CFG_SNCEN);
|
||
}
|
||
EXPORT_SYMBOL(mma9551_set_device_state);
|
||
|
||
/**
|
||
* mma9551_set_power_state() - sets runtime PM state
|
||
* @client: I2C client
|
||
* @on: Use true to power on device, false to power off
|
||
*
|
||
* Resume or suspend the device using Runtime PM.
|
||
* The device will suspend after the autosuspend delay.
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_set_power_state(struct i2c_client *client, bool on)
|
||
{
|
||
#ifdef CONFIG_PM
|
||
int ret;
|
||
|
||
if (on)
|
||
ret = pm_runtime_get_sync(&client->dev);
|
||
else {
|
||
pm_runtime_mark_last_busy(&client->dev);
|
||
ret = pm_runtime_put_autosuspend(&client->dev);
|
||
}
|
||
|
||
if (ret < 0) {
|
||
dev_err(&client->dev,
|
||
"failed to change power state to %d\n", on);
|
||
if (on)
|
||
pm_runtime_put_noidle(&client->dev);
|
||
|
||
return ret;
|
||
}
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
EXPORT_SYMBOL(mma9551_set_power_state);
|
||
|
||
/**
|
||
* mma9551_sleep() - sleep
|
||
* @freq: Application frequency
|
||
*
|
||
* Firmware applications run at a certain frequency on the
|
||
* device. Sleep for one application cycle to make sure the
|
||
* application had time to run once and initialize set values.
|
||
*/
|
||
void mma9551_sleep(int freq)
|
||
{
|
||
int sleep_val = 1000 / freq;
|
||
|
||
if (sleep_val < 20)
|
||
usleep_range(sleep_val * 1000, 20000);
|
||
else
|
||
msleep_interruptible(sleep_val);
|
||
}
|
||
EXPORT_SYMBOL(mma9551_sleep);
|
||
|
||
/**
|
||
* mma9551_read_accel_chan() - read accelerometer channel
|
||
* @client: I2C client
|
||
* @chan: IIO channel
|
||
* @val: Pointer to the accelerometer value read
|
||
* @val2: Unused
|
||
*
|
||
* Read accelerometer value for the specified channel.
|
||
*
|
||
* Locking note: This function must be called with the device lock held.
|
||
* Locking is not handled inside the function. Callers should ensure they
|
||
* serialize access to the HW.
|
||
*
|
||
* Returns: IIO_VAL_INT on success, negative value on failure.
|
||
*/
|
||
int mma9551_read_accel_chan(struct i2c_client *client,
|
||
const struct iio_chan_spec *chan,
|
||
int *val, int *val2)
|
||
{
|
||
u16 reg_addr;
|
||
s16 raw_accel;
|
||
int ret;
|
||
|
||
switch (chan->channel2) {
|
||
case IIO_MOD_X:
|
||
reg_addr = MMA9551_AFE_X_ACCEL_REG;
|
||
break;
|
||
case IIO_MOD_Y:
|
||
reg_addr = MMA9551_AFE_Y_ACCEL_REG;
|
||
break;
|
||
case IIO_MOD_Z:
|
||
reg_addr = MMA9551_AFE_Z_ACCEL_REG;
|
||
break;
|
||
default:
|
||
return -EINVAL;
|
||
}
|
||
|
||
ret = mma9551_set_power_state(client, true);
|
||
if (ret < 0)
|
||
return ret;
|
||
|
||
ret = mma9551_read_status_word(client, MMA9551_APPID_AFE,
|
||
reg_addr, &raw_accel);
|
||
if (ret < 0)
|
||
goto out_poweroff;
|
||
|
||
*val = raw_accel;
|
||
|
||
ret = IIO_VAL_INT;
|
||
|
||
out_poweroff:
|
||
mma9551_set_power_state(client, false);
|
||
return ret;
|
||
}
|
||
EXPORT_SYMBOL(mma9551_read_accel_chan);
|
||
|
||
/**
|
||
* mma9551_read_accel_scale() - read accelerometer scale
|
||
* @val: Pointer to the accelerometer scale (int value)
|
||
* @val2: Pointer to the accelerometer scale (micro value)
|
||
*
|
||
* Read accelerometer scale.
|
||
*
|
||
* Returns: IIO_VAL_INT_PLUS_MICRO.
|
||
*/
|
||
int mma9551_read_accel_scale(int *val, int *val2)
|
||
{
|
||
*val = 0;
|
||
*val2 = 2440;
|
||
|
||
return IIO_VAL_INT_PLUS_MICRO;
|
||
}
|
||
EXPORT_SYMBOL(mma9551_read_accel_scale);
|
||
|
||
/**
|
||
* mma9551_app_reset() - reset application
|
||
* @client: I2C client
|
||
* @app_mask: Application to reset
|
||
*
|
||
* Reset the given application (using the Reset/Suspend/Clear
|
||
* Control Application)
|
||
*
|
||
* Returns: 0 on success, negative value on failure.
|
||
*/
|
||
int mma9551_app_reset(struct i2c_client *client, u32 app_mask)
|
||
{
|
||
return mma9551_write_config_byte(client, MMA9551_APPID_RSC,
|
||
MMA9551_RSC_RESET +
|
||
MMA9551_RSC_OFFSET(app_mask),
|
||
MMA9551_RSC_VAL(app_mask));
|
||
}
|
||
EXPORT_SYMBOL(mma9551_app_reset);
|
||
|
||
MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
|
||
MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
|
||
MODULE_LICENSE("GPL v2");
|
||
MODULE_DESCRIPTION("MMA955xL sensors core");
|