lkml.org 
[lkml]   [2013]   [Sep]   [23]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
SubjectRe: [PATCH] iio: add Bosch BMG160 gyroscope sensor driver
From
Date
On Mon, 2013-09-23 at 13:35 +0800, jianlong wrote:
> This patch adds IIO driver for Bosch BMG160 triaxial gyroscope sensor.
> Thanks a lot.

Maybe some trivial, mostly whitespace, corrections before
modifying the bmg160_api.c and bmg_iio.h files...
---
drivers/iio/gyro/bmg160_core.c | 286 +++++++++++++++++++-------------------
drivers/iio/gyro/bmg160_ring.c | 19 +--
drivers/iio/gyro/bmg160_trigger.c | 75 +++++-----
3 files changed, 187 insertions(+), 193 deletions(-)

diff --git a/drivers/iio/gyro/bmg160_core.c b/drivers/iio/gyro/bmg160_core.c
index 0234348..73fd3b2 100644
--- a/drivers/iio/gyro/bmg160_core.c
+++ b/drivers/iio/gyro/bmg160_core.c
@@ -38,7 +38,7 @@
#define BUFF_SIZE 256

struct op_mode_map {
- char *op_mode_name;
+ const char *op_mode_name;
long op_mode;
};

@@ -59,7 +59,7 @@ static struct i2c_client *bmg_client;
* @gyro_fs_dps: sensor's full scale, the unit is degree pre second.
* @gyro_fs_rslt: sensor's resolution.
* example: 0(Reg val)----2000dps(full scale)----61000(resolution)
-*/
+ */
static struct bmg_fullscale_avl bmg_fs_avl_array[] = {
[0] = {
.gyro_fs_value = BMG_FSR_2000DPS_VAL,
@@ -106,42 +106,42 @@ static const struct bmg_hw bmg_hw_info[NUM_DEVICE_PARTS] = {
#define BMG_SENSORS_16_BITS 16
#define BMG_TEMP_SCALE 5000
#define BMG_TEMP_OFFSET 12000
-#define WATER_MARK_LEVEL 40
-
-#define BMG_GYRO_CHANNELS_CONFIG(device_type, si, mod, \
- endian, bits, addr) \
- { \
- .type = device_type, \
- .modified = 1, \
- .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
- .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
- .scan_index = si, \
- .channel2 = mod, \
- .address = addr, \
- .scan_type = { \
- .sign = 's', \
- .realbits = bits, \
- .shift = 16 - bits, \
- .storagebits = 16, \
- .endianness = endian, \
- }, \
+#define WATER_MARK_LEVEL 40
+
+#define BMG_GYRO_CHANNELS_CONFIG(device_type, si, mod, \
+ endian, bits, addr) \
+ { \
+ .type = device_type, \
+ .modified = 1, \
+ .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
+ .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+ .scan_index = si, \
+ .channel2 = mod, \
+ .address = addr, \
+ .scan_type = { \
+ .sign = 's', \
+ .realbits = bits, \
+ .shift = 16 - bits, \
+ .storagebits = 16, \
+ .endianness = endian, \
+ }, \
}
-#define BMG_DEV_ATTR_SAMP_FREQ() \
- IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO, \
- bmg_read_frequency, \
- bmg_write_frequency)
-
-#define BMG_DEV_ATTR_R_W(name) \
- IIO_DEVICE_ATTR(name, S_IRUGO | S_IWUSR , \
- bmg_show_##name, \
- bmg_store_##name, 0);
-
-#define BMG_DEV_ATTR_R(name) \
- IIO_DEVICE_ATTR(name, S_IRUGO, \
+#define BMG_DEV_ATTR_SAMP_FREQ() \
+ IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO, \
+ bmg_read_frequency, \
+ bmg_write_frequency)
+
+#define BMG_DEV_ATTR_R_W(name) \
+ IIO_DEVICE_ATTR(name, S_IRUGO | S_IWUSR , \
+ bmg_show_##name, \
+ bmg_store_##name, 0);
+
+#define BMG_DEV_ATTR_R(name) \
+ IIO_DEVICE_ATTR(name, S_IRUGO, \
bmg_show_##name, NULL , 0);

-#define BMG_DEV_ATTR_W(name) \
- IIO_DEVICE_ATTR(name, S_IWUSR, \
+#define BMG_DEV_ATTR_W(name) \
+ IIO_DEVICE_ATTR(name, S_IWUSR, \
NULL, bmg_store_##name, 0);

#define BMG_BYTE_FOR_PER_AXIS_CHANNEL 2
@@ -150,20 +150,28 @@ static const struct bmg_hw bmg_hw_info[NUM_DEVICE_PARTS] = {
static const struct iio_chan_spec bmg_12bit_raw_channels[] = {
{ .type = IIO_TEMP,
.channel = IIO_NO_MOD,
- .info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
- | BIT(IIO_CHAN_INFO_OFFSET)
- | BIT(IIO_CHAN_INFO_SCALE),
+ .info_mask_separate = (BIT(IIO_CHAN_INFO_RAW) |
+ BIT(IIO_CHAN_INFO_OFFSET) |
+ BIT(IIO_CHAN_INFO_SCALE)),
.address = BMG160_TEMP_ADDR,
.scan_index = -1,
- .scan_type = { .sign = 'u', .realbits = 8,
- .storagebits = 8, .shift = 0, .endianness = IIO_LE },
+ .scan_type = {
+ .sign = 'u',
+ .realbits = 8,
+ .storagebits = 8,
+ .shift = 0,
+ .endianness = IIO_LE
+ },
},
BMG_GYRO_CHANNELS_CONFIG(IIO_ANGL_VEL, BMG_SCAN_GYRO_X,
- IIO_MOD_X, IIO_LE, BMG_SENSORS_12_BITS, BMG160_RATE_X_LSB_VALUEX__REG),
+ IIO_MOD_X, IIO_LE, BMG_SENSORS_12_BITS,
+ BMG160_RATE_X_LSB_VALUEX__REG),
BMG_GYRO_CHANNELS_CONFIG(IIO_ANGL_VEL, BMG_SCAN_GYRO_Y,
- IIO_MOD_Y, IIO_LE, BMG_SENSORS_12_BITS, BMG160_RATE_Y_LSB_VALUEY__REG),
+ IIO_MOD_Y, IIO_LE, BMG_SENSORS_12_BITS,
+ BMG160_RATE_Y_LSB_VALUEY__REG),
BMG_GYRO_CHANNELS_CONFIG(IIO_ANGL_VEL, BMG_SCAN_GYRO_Z,
- IIO_MOD_Z, IIO_LE, BMG_SENSORS_12_BITS, BMG160_RATE_Z_LSB_VALUEZ__REG),
+ IIO_MOD_Z, IIO_LE, BMG_SENSORS_12_BITS,
+ BMG160_RATE_Z_LSB_VALUEZ__REG),
IIO_CHAN_SOFT_TIMESTAMP(BMG_SCAN_TIMESTAMP),

};
@@ -172,26 +180,34 @@ static const struct iio_chan_spec bmg_12bit_raw_channels[] = {
static const struct iio_chan_spec bmg_16bit_raw_channels[] = {
{ .type = IIO_TEMP,
.channel = IIO_NO_MOD,
- .info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
- | BIT(IIO_CHAN_INFO_OFFSET)
- | BIT(IIO_CHAN_INFO_SCALE),
+ .info_mask_separate = (BIT(IIO_CHAN_INFO_RAW) |
+ BIT(IIO_CHAN_INFO_OFFSET) |
+ BIT(IIO_CHAN_INFO_SCALE)),
.address = BMG160_TEMP_ADDR,
.scan_index = -1,
- .scan_type = { .sign = 'u', .realbits = 8,
- .storagebits = 8, .shift = 0, .endianness = IIO_LE },
+ .scan_type = {
+ .sign = 'u',
+ .realbits = 8,
+ .storagebits = 8,
+ .shift = 0,
+ .endianness = IIO_LE
+ },
},
BMG_GYRO_CHANNELS_CONFIG(IIO_ANGL_VEL, BMG_SCAN_GYRO_X,
- IIO_MOD_X, IIO_LE, BMG_SENSORS_16_BITS, BMG160_RATE_X_LSB_VALUEX__REG),
+ IIO_MOD_X, IIO_LE, BMG_SENSORS_16_BITS,
+ BMG160_RATE_X_LSB_VALUEX__REG),
BMG_GYRO_CHANNELS_CONFIG(IIO_ANGL_VEL, BMG_SCAN_GYRO_Y,
- IIO_MOD_Y, IIO_LE, BMG_SENSORS_16_BITS, BMG160_RATE_Y_LSB_VALUEY__REG),
+ IIO_MOD_Y, IIO_LE, BMG_SENSORS_16_BITS,
+ BMG160_RATE_Y_LSB_VALUEY__REG),
BMG_GYRO_CHANNELS_CONFIG(IIO_ANGL_VEL, BMG_SCAN_GYRO_Z,
- IIO_MOD_Z, IIO_LE, BMG_SENSORS_16_BITS, BMG160_RATE_Z_LSB_VALUEZ__REG),
+ IIO_MOD_Z, IIO_LE, BMG_SENSORS_16_BITS,
+ BMG160_RATE_Z_LSB_VALUEZ__REG),
IIO_CHAN_SOFT_TIMESTAMP(BMG_SCAN_TIMESTAMP),
};

/* bmg i2c routine read */
static char bmg_i2c_read(struct i2c_client *client, u8 reg_addr,
- u8 *data, u8 len)
+ u8 *data, u8 len)
{
#if !defined BMG_USE_BASIC_I2C_FUNC
s32 dummy;
@@ -202,7 +218,7 @@ static char bmg_i2c_read(struct i2c_client *client, u8 reg_addr,
#ifdef BMG_SMBUS
dummy = i2c_smbus_read_byte_data(client, reg_addr);
if (dummy < 0) {
- dev_err(&client->dev, "i2c bus read error");
+ dev_err(&client->dev, "i2c bus read error\n");
return -1;
}
*data = (u8)(dummy & 0xff);
@@ -224,18 +240,18 @@ static char bmg_i2c_read(struct i2c_client *client, u8 reg_addr,

struct i2c_msg msg[] = {
{
- .addr = client->addr,
- .flags = 0,
- .len = 1,
- .buf = &reg_addr,
+ .addr = client->addr,
+ .flags = 0,
+ .len = 1,
+ .buf = &reg_addr,
},

{
- .addr = client->addr,
- .flags = I2C_M_RD,
- .len = len,
- .buf = data,
- },
+ .addr = client->addr,
+ .flags = I2C_M_RD,
+ .len = len,
+ .buf = data,
+ },
};

for (retry = 0; retry < BMG_MAX_RETRY_I2C_XFER; retry++) {
@@ -246,7 +262,7 @@ static char bmg_i2c_read(struct i2c_client *client, u8 reg_addr,
}

if (BMG_MAX_RETRY_I2C_XFER <= retry) {
- dev_err(&client->dev, "I2C xfer error");
+ dev_err(&client->dev, "I2C xfer error\n");
return -EIO;
}

@@ -268,21 +284,20 @@ static void bmg_dump_reg(struct i2c_client *client)
for (i = 0; i < BYTES_PER_LINE; i++) {
dbg_buf[i] = i;
sprintf(dbg_buf_str + i * 3, "%02x%c",
- dbg_buf[i],
- (((i + 1) % BYTES_PER_LINE == 0) ? '\n' : ' '));
+ dbg_buf[i],
+ (((i + 1) % BYTES_PER_LINE == 0) ? '\n' : ' '));
}
dev_dbg(&client->dev, "%s\n", dbg_buf_str);

bmg_i2c_read(client, BMG_REG_NAME(CHIP_ID_ADDR), dbg_buf, 64);
for (i = 0; i < 64; i++) {
sprintf(dbg_buf_str + i * 3, "%02x%c",
- dbg_buf[i],
- (((i + 1) % BYTES_PER_LINE == 0) ? '\n' : ' '));
+ dbg_buf[i],
+ (((i + 1) % BYTES_PER_LINE == 0) ? '\n' : ' '));
}
dev_dbg(&client->dev, "%s\n", dbg_buf_str);
}

-
/* i2c operation for API */
static int bmg_check_chip_id(struct i2c_client *client)
{
@@ -290,7 +305,7 @@ static int bmg_check_chip_id(struct i2c_client *client)
u8 chip_id = 0;

bmg_i2c_read(client, BMG_REG_NAME(CHIP_ID_ADDR), &chip_id, 1);
- dev_info(&client->dev, "read chip id result: %#x", chip_id);
+ dev_info(&client->dev, "read chip id result: %#x\n", chip_id);

if ((chip_id & 0xff) != SENSOR_CHIP_ID_BMG)
err = -1;
@@ -300,11 +315,10 @@ static int bmg_check_chip_id(struct i2c_client *client)

/* i2c write routine*/
static char bmg_i2c_write(struct i2c_client *client, u8 reg_addr,
- u8 *data, u8 len)
+ u8 *data, u8 len)
{
#if !defined BMG_USE_BASIC_I2C_FUNC
s32 dummy;
-
#ifndef BMG_SMBUS
u8 buffer[2];
#endif
@@ -323,22 +337,22 @@ static char bmg_i2c_write(struct i2c_client *client, u8 reg_addr,
reg_addr++;
data++;
if (dummy < 0) {
- dev_err(&client->dev, "error writing i2c bus");
+ dev_err(&client->dev, "error writing i2c bus\n");
return -EPERM;
}
-
}
+
return 0;
#else
u8 buffer[2];
int retry;
struct i2c_msg msg[] = {
{
- .addr = client->addr,
- .flags = 0,
- .len = 2,
- .buf = buffer,
- },
+ .addr = client->addr,
+ .flags = 0,
+ .len = 2,
+ .buf = buffer,
+ },
};

while (0 != len--) {
@@ -346,14 +360,14 @@ static char bmg_i2c_write(struct i2c_client *client, u8 reg_addr,
buffer[1] = *data;
for (retry = 0; retry < BMG_MAX_RETRY_I2C_XFER; retry++) {
if (i2c_transfer(client->adapter, msg,
- ARRAY_SIZE(msg)) > 0) {
+ ARRAY_SIZE(msg)) > 0) {
break;
} else {
mdelay(BMG_I2C_WRITE_DELAY_TIME);
}
}
if (BMG_MAX_RETRY_I2C_XFER <= retry) {
- dev_err(&client->dev, "I2C xfer error");
+ dev_err(&client->dev, "I2C xfer error\n");
return -EIO;
}
reg_addr++;
@@ -378,16 +392,15 @@ static char bmg_i2c_write_wrapper(u8 dev_addr, u8 reg_addr, u8 *data, u8 len)
return err;
}

-
static int bmg_read_axis_data(struct iio_dev *indio_dev, u8 reg_address,
- int *data)
+ int *data)
{
int ret;
unsigned char axis_outdata[BMG_BYTE_FOR_PER_AXIS_CHANNEL];
struct bmg_client_data *client_data = iio_priv(indio_dev);

ret = bmg_i2c_read(client_data->client, reg_address,
- axis_outdata, BMG_BYTE_FOR_PER_AXIS_CHANNEL);
+ axis_outdata, BMG_BYTE_FOR_PER_AXIS_CHANNEL);
if (ret < 0)
return ret;

@@ -396,7 +409,7 @@ static int bmg_read_axis_data(struct iio_dev *indio_dev, u8 reg_address,
}

static int bmg_read_temp_data(struct iio_dev *indio_dev, u8 reg_address,
- int *data)
+ int *data)
{
int ret;
signed char temp_outdata;
@@ -410,7 +423,7 @@ static int bmg_read_temp_data(struct iio_dev *indio_dev, u8 reg_address,
}

static ssize_t bmg_read_frequency(struct device *dev,
- struct device_attribute *attr, char *buf)
+ struct device_attribute *attr, char *buf)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
int ret;
@@ -425,8 +438,8 @@ static ssize_t bmg_read_frequency(struct device *dev,
}

static ssize_t bmg_write_frequency(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count)
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
struct iio_dev *indio_dev = dev_get_drvdata(dev);
int err;
@@ -443,7 +456,7 @@ static ssize_t bmg_write_frequency(struct device *dev,
}

static ssize_t bmg_show_op_mode(struct device *dev,
- struct device_attribute *attr, char *buf)
+ struct device_attribute *attr, char *buf)
{
int ret;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
@@ -459,8 +472,8 @@ static ssize_t bmg_show_op_mode(struct device *dev,
}

static ssize_t bmg_store_op_mode(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count)
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
int err;
struct iio_dev *indio_dev = dev_get_drvdata(dev);
@@ -470,8 +483,8 @@ static ssize_t bmg_store_op_mode(struct device *dev,
if (err)
return err;

- dev_notice(indio_dev->dev.parent, "%s:set op-mode[%ld]",
- __func__, op_mode);
+ dev_notice(indio_dev->dev.parent, "%s:set op-mode[%ld]\n",
+ __func__, op_mode);

mutex_lock(&indio_dev->mlock);
err = BMG_CALL_API(set_mode)(op_mode);
@@ -479,12 +492,12 @@ static ssize_t bmg_store_op_mode(struct device *dev,

if (err)
return err;
- else
- return count;
+
+ return count;
}

static ssize_t bmg_show_bandwidth(struct device *dev,
- struct device_attribute *attr, char *buf)
+ struct device_attribute *attr, char *buf)
{
int err;
unsigned char bandwidth = 0;
@@ -499,8 +512,8 @@ static ssize_t bmg_show_bandwidth(struct device *dev,
}

static ssize_t bmg_store_bandwidth(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count)
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
int err;
unsigned long bandwidth;
@@ -517,7 +530,7 @@ static ssize_t bmg_store_bandwidth(struct device *dev,
}

static ssize_t bmg_show_selftest(struct device *dev,
- struct device_attribute *attr, char *buf)
+ struct device_attribute *attr, char *buf)
{
int err;
unsigned char selftest;
@@ -539,10 +552,10 @@ static ssize_t bmg_show_selftest(struct device *dev,
datay_check = abs(1000 * client_data->value.datay / 16384);
dataz_check = abs(1000 * client_data->value.dataz / 16384);
mutex_unlock(&indio_dev->mlock);
- if ((datax_check <= 5) && (datay_check <= 5) && (dataz_check <= 5))
+ if ((datax_check <= 5) && (datay_check <= 5) && (dataz_check <= 5)) {
dev_notice(&indio_dev->dev, "Self test successfully!\n");
- else {
- dev_err(&indio_dev->dev, "Self test checking value failed!");
+ } else {
+ dev_err(&indio_dev->dev, "Self test checking value failed!\n");
dev_err(&indio_dev->dev, "x y z axis values:%d,%d,%d\n",
datax_check, datay_check, dataz_check);
selftest |= C_BMG160_FAILURE;
@@ -559,51 +572,49 @@ static int bmg_set_fullscale(struct bmg_client_data *client_data, int val)
for (i = 0; i < NUM_BMG_FSR_VAL; i++) {
if (val == bmg_fs_avl_array[i].gyro_fs_value) {
BMG_CALL_API(set_range_reg)(val);
- client_data->current_fullscale =
- (struct bmg_fullscale_avl *)&bmg_fs_avl_array[i];
+ client_data->current_fullscale = &bmg_fs_avl_array[i];
return 0;
- } else if (i == NUM_BMG_FSR_VAL)
+ } else if (i == NUM_BMG_FSR_VAL) {
return -EINVAL;
+ }
}
return -EINVAL;
}

static int bmg_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *ch, int *val,
- int *val2, long mask)
+ int *val2, long mask)
{
int ret, result;
struct bmg_client_data *client_data = iio_priv(indio_dev);

switch (mask) {
- case IIO_CHAN_INFO_RAW:
- {
+ case IIO_CHAN_INFO_RAW: {
result = 0;
ret = IIO_VAL_INT;
mutex_lock(&indio_dev->mlock);
switch (ch->type) {
case IIO_ANGL_VEL:
result = bmg_read_axis_data(indio_dev,
- ch->address, val);
+ ch->address, val);
*val = *val >> ch->scan_type.shift;
break;
case IIO_TEMP:
result = bmg_read_temp_data(indio_dev,
- ch->address, val);
+ ch->address, val);
*val = *val >> ch->scan_type.shift;
break;
default:
ret = -EINVAL;
break;
}
- mutex_unlock(&indio_dev->mlock);
- if (result < 0)
- return result;
- return ret;
+ mutex_unlock(&indio_dev->mlock);
+ if (result < 0)
+ return result;
+ return ret;
}

- case IIO_CHAN_INFO_SCALE:
- {
+ case IIO_CHAN_INFO_SCALE: {
switch (ch->type) {
case IIO_ANGL_VEL:
*val = 0;
@@ -618,8 +629,7 @@ static int bmg_read_raw(struct iio_dev *indio_dev,
}
}

- case IIO_CHAN_INFO_OFFSET:
- {
+ case IIO_CHAN_INFO_OFFSET: {
switch (ch->type) {
case IIO_TEMP:
*val = BMG_TEMP_OFFSET;
@@ -632,12 +642,11 @@ static int bmg_read_raw(struct iio_dev *indio_dev,
default:
return -EINVAL;
}
-
}

static int bmg_wirte_raw(struct iio_dev *indio_dev,
- struct iio_chan_spec const *ch, int val,
- int val2, long mask)
+ struct iio_chan_spec const *ch, int val,
+ int val2, long mask)
{
int ret;
struct bmg_client_data *client_data = iio_priv(indio_dev);
@@ -689,19 +698,16 @@ static const struct iio_info bmg_iio_info = {
.write_raw = &bmg_wirte_raw,
};

-
-
-
static int bmg_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int err = 0;
struct iio_dev *indio_dev;
struct bmg_client_data *client_data = NULL;
struct device_node *np = client->dev.of_node;
- dev_info(&client->dev, "function entrance");
+ dev_info(&client->dev, "function entrance\n");

if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
- dev_err(&client->dev, "i2c_check_functionality error!");
+ dev_err(&client->dev, "i2c_check_functionality error!\n");
err = -EIO;
goto exit_err_clean;
}
@@ -710,7 +716,7 @@ static int bmg_probe(struct i2c_client *client, const struct i2c_device_id *id)
bmg_client = client;
} else {
dev_err(&client->dev,
- "this driver does not support multiple clients");
+ "this driver does not support multiple clients\n");
err = -EINVAL;
goto exit_err_clean;
}
@@ -718,10 +724,10 @@ static int bmg_probe(struct i2c_client *client, const struct i2c_device_id *id)
err = bmg_check_chip_id(client);
if (!err) {
dev_notice(&client->dev,
- "Bosch Sensortec Device %s detected", SENSOR_NAME);
+ "Bosch Sensortec Device %s detected\n", SENSOR_NAME);
} else {
dev_err(&client_data->client->dev,
- "Bosch Sensortec Device not found, chip id mismatch");
+ "Bosch Sensortec Device not found, chip id mismatch\n");
err = -ENXIO;
goto exit_err_clean;
}
@@ -729,7 +735,7 @@ static int bmg_probe(struct i2c_client *client, const struct i2c_device_id *id)
indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*client_data));
if (indio_dev == NULL) {
dev_err(indio_dev->dev.parent,
- "IIO device alloc err %d\n", err);
+ "IIO device alloc err %d\n", err);
return -ENOMEM;
}

@@ -740,7 +746,7 @@ static int bmg_probe(struct i2c_client *client, const struct i2c_device_id *id)
* need to set in the dts file by using "gpio_int" key word.
*/
err = of_property_read_u32(np, "gpio_int",
- &client_data->gpio_interrupt_pin);
+ &client_data->gpio_interrupt_pin);
if (err) {
dev_err(&client_data->client->dev,
"Not found usable gpio interrupt pin!\n");
@@ -751,8 +757,7 @@ static int bmg_probe(struct i2c_client *client, const struct i2c_device_id *id)
indio_dev->channels = bmg_16bit_raw_channels;
indio_dev->num_channels = ARRAY_SIZE(bmg_16bit_raw_channels);
indio_dev->info = &bmg_iio_info;
- client_data->current_fullscale = (struct bmg_fullscale_avl *)
- &bmg_fs_avl_array[0];
+ client_data->current_fullscale = bmg_fs_avl_array;
indio_dev->modes = INDIO_DIRECT_MODE;
/* h/w init */
client_data->device.bus_read = bmg_i2c_read_wrapper;
@@ -777,38 +782,37 @@ static int bmg_probe(struct i2c_client *client, const struct i2c_device_id *id)
#endif

memcpy(&client_data->chip_config,
- bmg_hw_info[client_data->chip_type].config,
- sizeof(struct bmg_chip_config));
+ bmg_hw_info[client_data->chip_type].config,
+ sizeof(struct bmg_chip_config));
client_data->IRQ = client->irq;

err = bmg_allocate_ring(indio_dev);
if (err < 0) {
dev_err(indio_dev->dev.parent,
- "bmg configure buffer fail %d\n", err);
+ "bmg configure buffer fail %d\n", err);
return err;
}
err = bmg_probe_trigger(indio_dev);
if (err) {
dev_err(indio_dev->dev.parent,
- "bmg trigger probe fail %d\n", err);
+ "bmg trigger probe fail %d\n", err);
goto bmg_probe_trigger_error;
}
BMG_CALL_API(set_bw)(3); /*set bandwidth to 47Hz*/
err = iio_device_register(indio_dev);
if (err) {
dev_err(indio_dev->dev.parent,
- "bmg IIO device register failed %d\n", err);
+ "bmg IIO device register failed %d\n", err);
goto bmg_probe_error;
}


BMG_CALL_API(set_data_enable)(INT_ENABLE);
/* now it's power on which is considered as resuming from suspend */
- err = BMG_CALL_API(set_mode)(
- BMG_VAL_NAME(MODE_SUSPEND));
+ err = BMG_CALL_API(set_mode)(BMG_VAL_NAME(MODE_SUSPEND));

dev_notice(indio_dev->dev.parent,
- "IIO device sensor %s probed successfully", SENSOR_NAME);
+ "IIO device sensor %s probed successfully\n", SENSOR_NAME);

return 0;

@@ -819,10 +823,8 @@ bmg_probe_trigger_error:
exit_err_clean:
bmg_client = NULL;
return err;
-
}

-
static int bmg_remove(struct i2c_client *client)
{
struct iio_dev *indio_dev = i2c_get_clientdata(client);
diff --git a/drivers/iio/gyro/bmg160_ring.c b/drivers/iio/gyro/bmg160_ring.c
index ffc51d1..0dadd97 100644
--- a/drivers/iio/gyro/bmg160_ring.c
+++ b/drivers/iio/gyro/bmg160_ring.c
@@ -10,7 +10,7 @@
#include "bmg_iio.h"

extern char bmg_i2c_burst_read(struct i2c_client *client, u8 reg_addr,
- u8 *data, u16 len);
+ u8 *data, u16 len);

static irqreturn_t bmg_buffer_handler(int irq, void *p)
{
@@ -30,9 +30,9 @@ static irqreturn_t bmg_buffer_handler(int irq, void *p)
if (client_data->chip_config.gyro_fifo_enable)
bytes_per_datum = BMG160_BYTES_PER_3AXIS_SENSOR;
/*
-* There is new data to push to IIO ring buffer
-* please give attentions to the data format
-*/
+ * There is new data to push to IIO ring buffer
+ * please give attentions to the data format
+ */
BMG_CALL_API(get_dataxyz)(&client_data->value);

buffer_data_out[0] = client_data->value.datax & 0xff;
@@ -42,28 +42,23 @@ static irqreturn_t bmg_buffer_handler(int irq, void *p)
buffer_data_out[4] = client_data->value.dataz & 0xff;
buffer_data_out[5] = (client_data->value.dataz >> 8) & 0xff;
/*for every frame, need 8 bytes to axis data storage*/
- iio_push_to_buffers_with_timestamp(indio_dev, buffer_data_out, timestamp);
-
+ iio_push_to_buffers_with_timestamp(indio_dev, buffer_data_out,
+ timestamp);

bmg_buffer_handler_error:
mutex_unlock(&indio_dev->mlock);
iio_trigger_notify_done(indio_dev->trig);

return IRQ_HANDLED;
-
}

-
int bmg_allocate_ring(struct iio_dev *indio_dev)
{
return iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
- &bmg_buffer_handler, NULL);
+ &bmg_buffer_handler, NULL);
}

void bmg_deallocate_ring(struct iio_dev *indio_dev)
{
iio_triggered_buffer_cleanup(indio_dev);
}
-
-
-
diff --git a/drivers/iio/gyro/bmg160_trigger.c b/drivers/iio/gyro/bmg160_trigger.c
index a374c72..b749c94 100644
--- a/drivers/iio/gyro/bmg160_trigger.c
+++ b/drivers/iio/gyro/bmg160_trigger.c
@@ -13,58 +13,56 @@
#include <linux/gpio.h>
#include <linux/of_irq.h>

-
static void bmg_scan_query(struct iio_dev *indio_dev)
{
- struct bmg_client_data *client_data = iio_priv(indio_dev);
+ struct bmg_client_data *client_data = iio_priv(indio_dev);

- client_data->chip_config.gyro_fifo_enable =
+ client_data->chip_config.gyro_fifo_enable =
test_bit(BMG_SCAN_GYRO_X, indio_dev->active_scan_mask) ||
test_bit(BMG_SCAN_GYRO_Y, indio_dev->active_scan_mask) ||
test_bit(BMG_SCAN_GYRO_Z, indio_dev->active_scan_mask);
}

- /**
- * bmg_set_trig_ready_enable() - enable related functions such as new data mode.
- * @indio_dev: Device driver instance.
- * @enable: enable/disable
- */
+/**
+ * bmg_set_trig_ready_enable() - enable related functions such as new data mode.
+ * @indio_dev: Device driver instance.
+ * @enable: enable/disable
+ */
static int bmg_set_trig_ready_enable(struct iio_dev *indio_dev, bool enable)
{
- struct bmg_client_data *client_data = iio_priv(indio_dev);
+ struct bmg_client_data *client_data = iio_priv(indio_dev);

if (enable) {
bmg_scan_query(indio_dev);
if (client_data->chip_config.gyro_fifo_enable)
- dev_notice(indio_dev->dev.parent, "bmg scan query active enable.\n");
+ dev_notice(indio_dev->dev.parent, "bmg scan query active enable\n");
#if defined(BMG160_ENABLE_INT1) || defined(BMG160_ENABLE_INT2)
- BMG_CALL_API(set_data_enable)(INT_ENABLE);
- dev_notice(indio_dev->dev.parent, "bmg new data ready enable.\n");
+ BMG_CALL_API(set_data_enable)(INT_ENABLE);
+ dev_notice(indio_dev->dev.parent, "bmg new data ready enable\n");
#endif
} else {
- BMG_CALL_API(set_reset_int)(1);
+ BMG_CALL_API(set_reset_int)(1);
#if defined(BMG160_ENABLE_INT1) || defined(BMG160_ENABLE_INT2)
- BMG_CALL_API(set_data_enable)(INT_DISABLE);
- dev_notice(indio_dev->dev.parent, "bmg new data ready disabled.\n");
+ BMG_CALL_API(set_data_enable)(INT_DISABLE);
+ dev_notice(indio_dev->dev.parent, "bmg new data ready disabled\n");
#endif
}
- return 0;
+ return 0;
}

- /**
- * bmg_data_rdy_trigger_set_state() - set data ready state
- * @trig: Trigger instance
- * @state: Desired trigger state
- */
-static int bmg_data_rdy_trigger_set_state(struct iio_trigger *trig,
- bool state)
+/**
+ * bmg_data_rdy_trigger_set_state() - set data ready state
+ * @trig: Trigger instance
+ * @state: Desired trigger state
+ */
+static int bmg_data_rdy_trigger_set_state(struct iio_trigger *trig, bool state)
{
return bmg_set_trig_ready_enable(iio_trigger_get_drvdata(trig), state);
}

static const struct iio_trigger_ops bmg_trigger_ops = {
- .owner = THIS_MODULE,
- .set_trigger_state = &bmg_data_rdy_trigger_set_state,
+ .owner = THIS_MODULE,
+ .set_trigger_state = &bmg_data_rdy_trigger_set_state,
};

int bmg_probe_trigger(struct iio_dev *indio_dev)
@@ -73,8 +71,8 @@ int bmg_probe_trigger(struct iio_dev *indio_dev)
struct bmg_client_data *client_data = iio_priv(indio_dev);
int irq_num = 0;
client_data->trig = iio_trigger_alloc("%s-dev%d",
- indio_dev->name,
- indio_dev->id);
+ indio_dev->name,
+ indio_dev->id);
if (client_data->trig == NULL) {
ret = -ENOMEM;
dev_err(&indio_dev->dev, "bmg failed to allocate iio trigger.\n");
@@ -84,10 +82,10 @@ int bmg_probe_trigger(struct iio_dev *indio_dev)
gpio_direction_input(client_data->gpio_interrupt_pin);
irq_num = gpio_to_irq(client_data->gpio_interrupt_pin);
ret = devm_request_irq(irq_num, &iio_trigger_generic_data_rdy_poll, 0,
- "bmg_iio_int", client_data->trig);
+ "bmg_iio_int", client_data->trig);
if (ret) {
dev_err(&client_data->client->dev,
- "bmg could not request irq! err = %d\n", ret);
+ "bmg could not request irq! err = %d\n", ret);
goto error_irq_request;
}
/*gpio interrupt trig type*/
@@ -96,20 +94,20 @@ int bmg_probe_trigger(struct iio_dev *indio_dev)
client_data->trig->dev.parent = &client_data->client->dev;
client_data->trig->ops = &bmg_trigger_ops;
ret = iio_trigger_register(client_data->trig);
- if (ret < 0) {
- dev_err(&indio_dev->dev, "bmg iio trigger failed to register.\n");
+ if (ret < 0) {
+ dev_err(&indio_dev->dev, "bmg iio trigger failed to register\n");
goto erro_iio_trigger_register;
- }
- indio_dev->trig = client_data->trig;
+ }
+ indio_dev->trig = client_data->trig;

- return 0;
+ return 0;

erro_iio_trigger_register:
free_irq(gpio_to_irq(client_data->client->irq), client_data->trig);
- error_irq_request:
- iio_trigger_free(client_data->trig);
- error_alloc_trigger:
- return ret;
+error_irq_request:
+ iio_trigger_free(client_data->trig);
+error_alloc_trigger:
+ return ret;
}

void bmg_remove_trigger(struct iio_dev *indio_dev)
@@ -119,4 +117,3 @@ void bmg_remove_trigger(struct iio_dev *indio_dev)
free_irq(client_data->client->irq, client_data->trig);
iio_trigger_free(client_data->trig);
}
-



\
 
 \ /
  Last update: 2013-09-23 21:21    [W:0.132 / U:1.692 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site