Skip to contentSkip to conversation

iio: imu: Add support for Kionix KMX61 sensor

PATCH Superseded Daniel Baluta 3 participants 6 messages Nov 10, 2014 – Nov 22, 2014 IIO

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 iio: imu: Add support for Kionix KMX61 sensor

Minimal implementation for KMX61 6-axis accelerometer/magnetometer. It exports raw accel/magn readings together with scale and sampling frequency.

Datasheet will be available at:
http://www.kionix.com/6-axis-accelerometer-magnetometer/kmx61

---
Changes since v1:
* serialize non-atomic operations with a mutex (set_odr/get_odr, set_scale).
* no need to protect reading info scale because it reduces to reading an u8 which should be atomic on all arches
* *note* - read_measurment is an atomic operation

 drivers/iio/imu/Kconfig  |   9 +
 drivers/iio/imu/Makefile |   2 +
 drivers/iio/imu/kmx61.c  | 590 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 601 insertions(+)
 create mode 100644 drivers/iio/imu/kmx61.c
drivers/iio/imu/Kconfig +9 -0
index 2b0e451..d675f43 100644
@@ -25,6 +25,15 @@ config ADIS16480
 	  Say yes here to build support for Analog Devices ADIS16375, ADIS16480,
 	  ADIS16485, ADIS16488 inertial sensors.
 
+config KMX61
+	tristate "Kionix KMX61 6-axis accelerometer and magnetometer"
+	depends on I2C
+	help
+	  Say Y here if you want to build a driver for Kionix KMX61 6-axis accelerometer
+	  and magnetometer.
+	  To compile this driver as module, choose M here: the module will be called
+	  kmx61.
+
 source "drivers/iio/imu/inv_mpu6050/Kconfig"
 
 endmenu
drivers/iio/imu/Makefile +2 -0
index 114d2c1..e1e6e3d 100644
@@ -14,3 +14,5 @@ adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_buffer.o
 obj-$(CONFIG_IIO_ADIS_LIB) += adis_lib.o
 
 obj-y += inv_mpu6050/
+
+obj-$(CONFIG_KMX61) += kmx61.o
drivers/iio/imu/kmx61.c new file +590 -0

590 lines not on this page · raw message

Signature · 1 line
1.9.1
maintainer
#1 lore raw
Quoted 7 lines · Daniel Baluta

Minimal implementation for KMX61 6-axis accelerometer/magnetometer. It exports raw accel/magn readings together with scale and sampling frequency.

Datasheet will be available at:
http://www.kionix.com/6-axis-accelerometer-magnetometer/kmx61

Looking very nice. I made a few more comments inline but only
one was more than a comment - I added a check on val==0 in the obvious place. Please take a look at the testing branch of iio.git to make sure I didn't mess anything up!

Applied to the togreg branch of iio.git - initially pushed out as testing for the autobuilders to play with it.

Jonathan

Quoted 170 lines

---
Changes since v1:
* serialize non-atomic operations with a mutex (set_odr/get_odr, set_scale).
* no need to protect reading info scale because it reduces to reading an u8 which should be atomic on all arches
* *note* - read_measurment is an atomic operation

 drivers/iio/imu/Kconfig  |   9 +
 drivers/iio/imu/Makefile |   2 +
 drivers/iio/imu/kmx61.c  | 590 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 601 insertions(+)
 create mode 100644 drivers/iio/imu/kmx61.c
drivers/iio/imu/Kconfig +9 -0
index 2b0e451..d675f43 100644
@@ -25,6 +25,15 @@ config ADIS16480
 	  Say yes here to build support for Analog Devices ADIS16375, ADIS16480,
 	  ADIS16485, ADIS16488 inertial sensors.
 
+config KMX61
+	tristate "Kionix KMX61 6-axis accelerometer and magnetometer"
+	depends on I2C
+	help
+	  Say Y here if you want to build a driver for Kionix KMX61 6-axis accelerometer
+	  and magnetometer.
+	  To compile this driver as module, choose M here: the module will be called
+	  kmx61.
+
 source "drivers/iio/imu/inv_mpu6050/Kconfig"
 
 endmenu
drivers/iio/imu/Makefile +2 -0
index 114d2c1..e1e6e3d 100644
@@ -14,3 +14,5 @@ adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_buffer.o
 obj-$(CONFIG_IIO_ADIS_LIB) += adis_lib.o
 
 obj-y += inv_mpu6050/
+
+obj-$(CONFIG_KMX61) += kmx61.o
drivers/iio/imu/kmx61.c new file +121 -0
new file mode 100644
index 0000000..6135a16
@@ -0,0 +1,590 @@
+/*
+ * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
+ *
+ * Copyright (c) 2014, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
+ *
+ * TODO: buffer, interrupt, thresholds, acpi, temperature sensor
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define KMX61_DRV_NAME "kmx61"
+
+#define KMX61_REG_WHO_AM_I		0x00
+
+#define KMX61_ACC_XOUT_L		0x0A
+
+#define KMX61_ACC_XOUT_H		0x0B
+#define KMX61_ACC_YOUT_L		0x0C
+#define KMX61_ACC_YOUT_H		0x0D
+#define KMX61_ACC_ZOUT_L		0x0E
+#define KMX61_ACC_ZOUT_H		0x0F
+
+#define KMX61_MAG_XOUT_L		0x12
+
+#define KMX61_MAG_XOUT_H		0x13
+#define KMX61_MAG_YOUT_L		0x14
+#define KMX61_MAG_YOUT_H		0x15
+#define KMX61_MAG_ZOUT_L		0x16
+#define KMX61_MAG_ZOUT_H		0x17
+
+#define KMX61_REG_ODCNTL		0x2C
+
+#define KMX61_REG_STBY			0x29
+#define KMX61_REG_CTRL1			0x2A
+
+#define KMX61_REG_COTR			0x3C
+
+#define KMX61_ACC_STBY_BIT	BIT(0)
+#define KMX61_MAG_STBY_BIT	BIT(1)
+#define KMX61_ACT_STBY_BIT	BIT(7)
+
+#define KMX61_ALL_STBY		(KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
+
+#define KMX61_REG_CTRL1_GSEL0_SHIFT	0
+#define KMX61_REG_CTRL1_GSEL1_SHIFT	1
+#define KMX61_REG_CTRL1_GSEL0_MASK	0x01
+#define KMX61_REG_CTRL1_GSEL1_MASK	0x02
+
+#define KMX61_REG_CTRL1_BIT_RES		BIT(4)
+
+#define KMX61_ACC_ODR_SHIFT	0
+#define KMX61_MAG_ODR_SHIFT	4
+#define KMX61_ACC_ODR_MASK	0x0F
+#define KMX61_MAG_ODR_MASK	0xF0
+
+#define KMX61_CHIP_ID		0x12
+
+struct kmx61_data {
+	struct i2c_client *client;
+	/* serialize access to non-atomic ops, e.g set_mode */
+	struct mutex lock;
+	u8 range;
+	u8 odr_bits;
+};
+
+enum kmx61_range {
+	KMX61_RANGE_2G,
+	KMX61_RANGE_4G,
+	KMX61_RANGE_8G,
+};
+
+enum kmx61_scan {
+	KMX61_SCAN_ACC_X,
+	KMX61_SCAN_ACC_Y,
+	KMX61_SCAN_ACC_Z,
+	KMX61_SCAN_TEMP,
+	KMX61_SCAN_MAG_X,
+	KMX61_SCAN_MAG_Y,
+	KMX61_SCAN_MAG_Z,
+};
+
+static const struct {
+	u16 scale;
+	u8 gsel0;
+	u8 gsel1;
+} kmx61_scale_table[] = {
+	{9582, 0, 0},
+	{19163, 1, 0},
+	{38326, 0, 1},
+};
+
+/* KMX61 devices */
+#define KMX61_ACC	0x01
+#define KMX61_MAG	0x02
+
+static const struct {
+	int val;
+	int val2;
+	int odr_bits;
+} samp_freq_table[] = { {12, 500000, 0x00},
+			{25, 0, 0x01},
+			{50, 0, 0x02},
+			{100, 0, 0x03},
+			{200, 0, 0x04},
+			{400, 0, 0x05},
+			{800, 0, 0x06},
+			{1600, 0, 0x07},
+			{0, 781000, 0x08},
+			{1, 563000, 0x09},
+			{3, 125000, 0x0A},
+			{6, 250000, 0x0B} };

drivers/iio/imu/kmx61.c line 131

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+
+static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
+static IIO_CONST_ATTR(magn_scale_available, "0.001465");
+static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
+	"0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
+
+static struct attribute *kmx61_attributes[] = {
+	&iio_const_attr_accel_scale_available.dev_attr.attr,
+	&iio_const_attr_magn_scale_available.dev_attr.attr,
+	&iio_const_attr_sampling_frequency_available.dev_attr.attr,

Interesting. So sampling frequency is controllable seperately for the two sensing types, but uses a single set of values. This is a rare coherent looking bit of dual sensor type hardware ;)

Quoted 29 lines
drivers/iio/imu/kmx61.c new file +29 -0
+	NULL,
+};
+
+static const struct attribute_group kmx61_attribute_group = {
+	.attrs = kmx61_attributes,
+};
+
+#define KMX61_ACC_CHAN(_axis, _index) { \
+	.type = IIO_ACCEL, \
+	.modified = 1, \
+	.channel2 = IIO_MOD_ ## _axis, \
+	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+				BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+	.scan_index = _index, \
+	.scan_type = { \
+		.sign = 's', \
+		.realbits = 12, \
+		.storagebits = 16, \
+		.shift = 4, \
+		.endianness = IIO_BE, \
+	}, \
+}
+
+#define KMX61_MAG_CHAN(_axis, _index) { \
+	.type = IIO_MAGN, \
+	.modified = 1, \
+	.channel2 = IIO_MOD_ ## _axis, \
+	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \

drivers/iio/imu/kmx61.c line 170

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+				BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+	.scan_index = _index, \
+	.scan_type = { \
+		.sign = 's', \
+		.realbits = 14, \
+		.storagebits = 16, \
+		.shift = 2, \
+		.endianness = IIO_BE, \
+	}, \

Wouldn't normally expect scan_index and scan_type in a driver without buffered support, but you do make use of some of the elements elsewhere and state that buffered support is on the todo list so lets leave it here.

Quoted 159 lines
drivers/iio/imu/kmx61.c new file +159 -0
+}
+
+static const struct iio_chan_spec kmx61_channels[] = {
+	KMX61_ACC_CHAN(X, KMX61_SCAN_ACC_X),
+	KMX61_ACC_CHAN(Y, KMX61_SCAN_ACC_Y),
+	KMX61_ACC_CHAN(Z, KMX61_SCAN_ACC_Z),
+	KMX61_MAG_CHAN(X, KMX61_SCAN_MAG_X),
+	KMX61_MAG_CHAN(Y, KMX61_SCAN_MAG_Y),
+	KMX61_MAG_CHAN(Z, KMX61_SCAN_MAG_Z),
+};
+
+static int kmx61_convert_freq_to_bit(int val, int val2)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+		if (val == samp_freq_table[i].val &&
+		    val2 == samp_freq_table[i].val2)
+			return samp_freq_table[i].odr_bits;
+	return -EINVAL;
+}
+
+static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error reading reg_stby\n");
+		return ret;
+	}
+	if (device & KMX61_ACC) {
+		if (mode & KMX61_ACC_STBY_BIT)
+			ret |= KMX61_ACC_STBY_BIT;
+		else
+			ret &= ~KMX61_ACC_STBY_BIT;
+	}
+
+	if (device & KMX61_MAG) {
+		if (mode & KMX61_MAG_STBY_BIT)
+			ret |= KMX61_MAG_STBY_BIT;
+		else
+			ret &= ~KMX61_MAG_STBY_BIT;
+	}
+
+	ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error writing reg_stby\n");
+		return ret;
+	}
+
+	return ret;
+}
+
+static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error reading reg_stby\n");
+		return ret;
+	}
+	*mode = 0;
+
+	if (device & KMX61_ACC) {
+		if (ret & KMX61_ACC_STBY_BIT)
+			*mode |= KMX61_ACC_STBY_BIT;
+		else
+			*mode &= ~KMX61_ACC_STBY_BIT;
+	}
+
+	if (device & KMX61_MAG) {
+		if (ret & KMX61_MAG_STBY_BIT)
+			*mode |= KMX61_MAG_STBY_BIT;
+		else
+			*mode &= ~KMX61_MAG_STBY_BIT;
+	}
+
+	return 0;
+}
+
+static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
+{
+	int ret;
+	u8 mode;
+	int lodr_bits, odr_bits;
+
+	ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
+	if (ret < 0)
+		return ret;
+
+	lodr_bits = kmx61_convert_freq_to_bit(val, val2);
+	if (lodr_bits < 0)
+		return lodr_bits;
+
+	/* To change ODR, accel and magn must be in STDBY */
+	ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+	if (ret < 0)
+		return ret;
+
+	odr_bits = 0;
+	if (device & KMX61_ACC)
+		odr_bits |= lodr_bits;
+	if (device & KMX61_MAG)
+		odr_bits |= (lodr_bits << KMX61_MAG_ODR_SHIFT);
+
+	ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
+					odr_bits);
+	if (ret < 0)
+		return ret;
+
+	ret = kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG);
+	if (ret < 0)
+		return ret;
+
+	data->odr_bits = lodr_bits;
+
+	return 0;
+}
+
+static
+int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2, u8 device)
+{	int i;
+	u8 lodr_bits;
+
+	if (device & KMX61_ACC)
+		lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
+			     KMX61_ACC_ODR_MASK;
+	else if (device & KMX61_MAG)
+		lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
+			     KMX61_MAG_ODR_MASK;
+	else
+		return -EINVAL;
+
+	for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+		if (lodr_bits == samp_freq_table[i].odr_bits) {
+			*val = samp_freq_table[i].val;
+			*val2 = samp_freq_table[i].val2;
+			return 0;
+		}
+	return -EINVAL;
+}
+
+static int kmx61_set_range(struct kmx61_data *data, int range)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
+		return ret;
+	}
+
+	ret &= ~(KMX61_REG_CTRL1_GSEL0_MASK | KMX61_REG_CTRL1_GSEL1_MASK);
+	ret |= kmx61_scale_table[range].gsel0 << KMX61_REG_CTRL1_GSEL0_SHIFT;
+	ret |= kmx61_scale_table[range].gsel1 << KMX61_REG_CTRL1_GSEL1_SHIFT;
+
+	ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);

drivers/iio/imu/kmx61.c line 339

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
+		return ret;
+	}
+
+	data->range = range;
+
+	return 0;
+}
+

I'd be tempted to use a parameter name other than val as that tends to have a fairly specific meaning in iio drivers (afterall you pass val2 in here!) scale would work or maybe microscale or similar?

Quoted 153 lines
drivers/iio/imu/kmx61.c new file +153 -0
+static int kmx61_set_scale(struct kmx61_data *data, int val)
+{
+	int ret, i;
+	u8  mode;
+
+	for (i = 0; i < ARRAY_SIZE(kmx61_scale_table); i++) {
+		if (kmx61_scale_table[i].scale == val) {
+			ret = kmx61_get_mode(data, &mode,
+					     KMX61_ACC | KMX61_MAG);
+			if (ret < 0)
+				return ret;
+
+			ret = kmx61_set_mode(data, KMX61_ALL_STBY,
+					     KMX61_ACC | KMX61_MAG);
+			if (ret < 0)
+				return ret;
+
+			ret = kmx61_set_range(data, i);
+			if (ret < 0)
+				return ret;
+
+			ret = kmx61_set_mode(data, mode,
+					     KMX61_ACC | KMX61_MAG);
+			if (ret < 0)
+				return ret;
+
+			return 0;
+		}
+	}
+	return -EINVAL;
+}
+
+static int kmx61_chip_init(struct kmx61_data *data)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error reading who_am_i\n");
+		return ret;
+	}
+
+	if (ret != KMX61_CHIP_ID) {
+		dev_err(&data->client->dev,
+			"Wrong chip id, got %x expected %x\n",
+			 ret, KMX61_CHIP_ID);
+		return -EINVAL;
+	}
+
+	/* set accel 12bit, 4g range */
+	ret = kmx61_set_range(data, KMX61_RANGE_4G);
+	if (ret < 0)
+		return ret;
+
+	/* put accel and magnetometer in operating mode */
+	ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+static int kmx61_read_measurement(struct kmx61_data *data, int base, int offset)
+{
+	int ret;
+	u8 reg = base + offset * 2;
+
+	ret = i2c_smbus_read_word_data(data->client, reg);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
+		return ret;
+	}
+
+	return ret;
+}
+
+static int kmx61_read_raw(struct iio_dev *indio_dev,
+			      struct iio_chan_spec const *chan, int *val,
+			      int *val2, long mask)
+{
+	struct kmx61_data *data = iio_priv(indio_dev);
+	int ret;
+	u8 base_reg;
+	u8 device;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_RAW:
+		switch (chan->type) {
+		case IIO_ACCEL: case IIO_MAGN:
+			base_reg = KMX61_ACC_XOUT_L;
+			break;
+		default:
+			return -EINVAL;
+		}
+		ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
+		if (ret < 0)
+			return ret;
+		*val = sign_extend32(ret >> chan->scan_type.shift,
+				     chan->scan_type.realbits - 1);
+		return IIO_VAL_INT;
+	case IIO_CHAN_INFO_SCALE:
+		switch (chan->type) {
+		case IIO_ACCEL:
+			*val = 0;
+			*val2 = kmx61_scale_table[data->range].scale;
+			return IIO_VAL_INT_PLUS_MICRO;
+		case IIO_MAGN:
+			/* 14 bits res, 1465 microGauss per magn count */
+			*val = 0;
+			*val2 = 1465;
+			return IIO_VAL_INT_PLUS_MICRO;
+		default:
+			break;
+		}
+	case IIO_CHAN_INFO_SAMP_FREQ:
+		switch (chan->type) {
+		case IIO_ACCEL:
+			device = KMX61_ACC;
+			break;
+		case IIO_MAGN:
+			device = KMX61_MAG;
+			break;
+		default:
+			return -EINVAL;
+		}
+
+		mutex_lock(&data->lock);
+		ret = kmx61_get_odr(data, val, val2, device);
+		mutex_unlock(&data->lock);
+		if (ret)
+			return -EINVAL;
+		return IIO_VAL_INT_PLUS_MICRO;
+	}
+	return -EINVAL;
+}
+
+static int kmx61_write_raw(struct iio_dev *indio_dev,
+			       struct iio_chan_spec const *chan, int val,
+			       int val2, long mask)
+{
+	struct kmx61_data *data = iio_priv(indio_dev);
+	int ret;
+	u8 device;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_SAMP_FREQ:
+		switch (chan->type) {
+		case IIO_ACCEL:
+			device = KMX61_ACC;
+			break;
+		case IIO_MAGN:
+			device = KMX61_MAG;
+			break;

drivers/iio/imu/kmx61.c line 502

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+		default:
+			return -EINVAL;
+		}
+		mutex_lock(&data->lock);
+		ret = kmx61_set_odr(data, val, val2, device);
+		mutex_unlock(&data->lock);
+		break;
+	case IIO_CHAN_INFO_SCALE:
+		switch (chan->type) {
+		case IIO_ACCEL:

Should verify that val == 0 incase of crazy userspace input.

Quoted 89 lines
drivers/iio/imu/kmx61.c new file +88 -0
+			mutex_lock(&data->lock);
+			ret = kmx61_set_scale(data, val2);
+			mutex_unlock(&data->lock);
+			break;
+		default:
+			ret  = -EINVAL;
+		}
+		break;
+	default:
+		ret = -EINVAL;
+	}
+
+	return ret;
+}
+
+static const struct iio_info kmx61_info = {
+	.driver_module		= THIS_MODULE,
+	.read_raw		= kmx61_read_raw,
+	.write_raw		= kmx61_write_raw,
+	.attrs			= &kmx61_attribute_group,
+};
+
+static int kmx61_probe(struct i2c_client *client,
+		       const struct i2c_device_id *id)
+{
+	struct kmx61_data *data;
+	struct iio_dev *indio_dev;
+	int ret;
+
+	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+	if (!indio_dev)
+		return -ENOMEM;
+
+	data = iio_priv(indio_dev);
+	i2c_set_clientdata(client, indio_dev);
+	data->client = client;
+
+	indio_dev->dev.parent = &client->dev;
+	indio_dev->info = &kmx61_info;
+	indio_dev->channels = kmx61_channels;
+	indio_dev->num_channels = ARRAY_SIZE(kmx61_channels);
+	indio_dev->modes = INDIO_DIRECT_MODE;
+
+	mutex_init(&data->lock);
+
+	ret = kmx61_chip_init(data);
+	if (ret < 0)
+		return ret;
+
+	return iio_device_register(indio_dev);
+}
+
+static int kmx61_remove(struct i2c_client *client)
+{
+	struct iio_dev *indio_dev = i2c_get_clientdata(client);
+	struct kmx61_data *data = iio_priv(indio_dev);
+	int ret;
+
+	iio_device_unregister(indio_dev);
+
+	mutex_lock(&data->lock);
+	ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+	mutex_unlock(&data->lock);
+
+	return ret;
+}
+
+static const struct i2c_device_id kmx61_id[] = {
+	{"kmx61", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, kmx61_id);
+
+static struct i2c_driver kmx61_driver = {
+	.driver = {
+		.name = "kmx61",
+	},
+	.probe		= kmx61_probe,
+	.remove		= kmx61_remove,
+	.id_table	= kmx61_id,
+};
+
+module_i2c_driver(kmx61_driver);
+
+MODULE_AUTHOR("Daniel Baluta <[email protected]>");
+MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
+MODULE_LICENSE("GPL v2");
#2 lore raw
Quoted 4 lines · Jonathan Cameron
Quoted 3 lines · Daniel Baluta

Minimal implementation for KMX61 6-axis accelerometer/magnetometer. It exports raw accel/magn readings together with scale and sampling frequency.

Quoted 8 lines
Quoted 4 lines

Datasheet will be available at:
http://www.kionix.com/6-axis-accelerometer-magnetometer/kmx61

Looking very nice. I made a few more comments inline but only
one was more than a comment - I added a check on val==0 in the obvious place. Please take a look at the testing branch of iio.git to make sure I didn't mess anything up!

Thanks! It looks good.

Quoted 180 lines

Applied to the togreg branch of iio.git - initially pushed out as testing for the autobuilders to play with it.

Jonathan

Quoted 175 lines

---
Changes since v1:
* serialize non-atomic operations with a mutex (set_odr/get_odr, set_scale).
* no need to protect reading info scale because it reduces to reading an u8 which should be atomic on all arches
* *note* - read_measurment is an atomic operation

 drivers/iio/imu/Kconfig  |   9 +
 drivers/iio/imu/Makefile |   2 +
 drivers/iio/imu/kmx61.c  | 590 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 601 insertions(+)
 create mode 100644 drivers/iio/imu/kmx61.c
drivers/iio/imu/Kconfig +9 -0
index 2b0e451..d675f43 100644
@@ -25,6 +25,15 @@ config ADIS16480
        Say yes here to build support for Analog Devices ADIS16375, ADIS16480,
        ADIS16485, ADIS16488 inertial sensors.
 
+config KMX61
+     tristate "Kionix KMX61 6-axis accelerometer and magnetometer"
+     depends on I2C
+     help
+       Say Y here if you want to build a driver for Kionix KMX61 6-axis accelerometer
+       and magnetometer.
+       To compile this driver as module, choose M here: the module will be called
+       kmx61.
+
 source "drivers/iio/imu/inv_mpu6050/Kconfig"
 
 endmenu
drivers/iio/imu/Makefile +2 -0
index 114d2c1..e1e6e3d 100644
@@ -14,3 +14,5 @@ adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_buffer.o
 obj-$(CONFIG_IIO_ADIS_LIB) += adis_lib.o
 
 obj-y += inv_mpu6050/
+
+obj-$(CONFIG_KMX61) += kmx61.o
drivers/iio/imu/kmx61.c new file +126 -0
new file mode 100644
index 0000000..6135a16
@@ -0,0 +1,590 @@
+/*
+ * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
+ *
+ * Copyright (c) 2014, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
+ *
+ * TODO: buffer, interrupt, thresholds, acpi, temperature sensor
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define KMX61_DRV_NAME "kmx61"
+
+#define KMX61_REG_WHO_AM_I           0x00
+
+#define KMX61_ACC_XOUT_L             0x0A
+
+#define KMX61_ACC_XOUT_H             0x0B
+#define KMX61_ACC_YOUT_L             0x0C
+#define KMX61_ACC_YOUT_H             0x0D
+#define KMX61_ACC_ZOUT_L             0x0E
+#define KMX61_ACC_ZOUT_H             0x0F
+
+#define KMX61_MAG_XOUT_L             0x12
+
+#define KMX61_MAG_XOUT_H             0x13
+#define KMX61_MAG_YOUT_L             0x14
+#define KMX61_MAG_YOUT_H             0x15
+#define KMX61_MAG_ZOUT_L             0x16
+#define KMX61_MAG_ZOUT_H             0x17
+
+#define KMX61_REG_ODCNTL             0x2C
+
+#define KMX61_REG_STBY                       0x29
+#define KMX61_REG_CTRL1                      0x2A
+
+#define KMX61_REG_COTR                       0x3C
+
+#define KMX61_ACC_STBY_BIT   BIT(0)
+#define KMX61_MAG_STBY_BIT   BIT(1)
+#define KMX61_ACT_STBY_BIT   BIT(7)
+
+#define KMX61_ALL_STBY               (KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
+
+#define KMX61_REG_CTRL1_GSEL0_SHIFT  0
+#define KMX61_REG_CTRL1_GSEL1_SHIFT  1
+#define KMX61_REG_CTRL1_GSEL0_MASK   0x01
+#define KMX61_REG_CTRL1_GSEL1_MASK   0x02
+
+#define KMX61_REG_CTRL1_BIT_RES              BIT(4)
+
+#define KMX61_ACC_ODR_SHIFT  0
+#define KMX61_MAG_ODR_SHIFT  4
+#define KMX61_ACC_ODR_MASK   0x0F
+#define KMX61_MAG_ODR_MASK   0xF0
+
+#define KMX61_CHIP_ID                0x12
+
+struct kmx61_data {
+     struct i2c_client *client;
+     /* serialize access to non-atomic ops, e.g set_mode */
+     struct mutex lock;
+     u8 range;
+     u8 odr_bits;
+};
+
+enum kmx61_range {
+     KMX61_RANGE_2G,
+     KMX61_RANGE_4G,
+     KMX61_RANGE_8G,
+};
+
+enum kmx61_scan {
+     KMX61_SCAN_ACC_X,
+     KMX61_SCAN_ACC_Y,
+     KMX61_SCAN_ACC_Z,
+     KMX61_SCAN_TEMP,
+     KMX61_SCAN_MAG_X,
+     KMX61_SCAN_MAG_Y,
+     KMX61_SCAN_MAG_Z,
+};
+
+static const struct {
+     u16 scale;
+     u8 gsel0;
+     u8 gsel1;
+} kmx61_scale_table[] = {
+     {9582, 0, 0},
+     {19163, 1, 0},
+     {38326, 0, 1},
+};
+
+/* KMX61 devices */
+#define KMX61_ACC    0x01
+#define KMX61_MAG    0x02
+
+static const struct {
+     int val;
+     int val2;
+     int odr_bits;
+} samp_freq_table[] = { {12, 500000, 0x00},
+                     {25, 0, 0x01},
+                     {50, 0, 0x02},
+                     {100, 0, 0x03},
+                     {200, 0, 0x04},
+                     {400, 0, 0x05},
+                     {800, 0, 0x06},
+                     {1600, 0, 0x07},
+                     {0, 781000, 0x08},
+                     {1, 563000, 0x09},
+                     {3, 125000, 0x0A},
+                     {6, 250000, 0x0B} };
+
+static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
+static IIO_CONST_ATTR(magn_scale_available, "0.001465");
+static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
+     "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
Quoted 8 lines

drivers/iio/imu/kmx61.c line 131

Quoted 5 lines
drivers/iio/imu/kmx61.c new file +5 -0
+
+static struct attribute *kmx61_attributes[] = {
+     &iio_const_attr_accel_scale_available.dev_attr.attr,
+     &iio_const_attr_magn_scale_available.dev_attr.attr,
+     &iio_const_attr_sampling_frequency_available.dev_attr.attr,

Interesting. So sampling frequency is controllable seperately for the two sensing types, but uses a single set of values. This is a rare coherent looking bit of dual sensor type hardware ;)

Yes.

Anyway, when the FIFO hardware buffer is used, it will be updated at the faster of the two output data rates

Quoted 208 lines
Quoted 29 lines
drivers/iio/imu/kmx61.c new file +29 -0
+     NULL,
+};
+
+static const struct attribute_group kmx61_attribute_group = {
+     .attrs = kmx61_attributes,
+};
+
+#define KMX61_ACC_CHAN(_axis, _index) { \
+     .type = IIO_ACCEL, \
+     .modified = 1, \
+     .channel2 = IIO_MOD_ ## _axis, \
+     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+                             BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+     .scan_index = _index, \
+     .scan_type = { \
+             .sign = 's', \
+             .realbits = 12, \
+             .storagebits = 16, \
+             .shift = 4, \
+             .endianness = IIO_BE, \
+     }, \
+}
+
+#define KMX61_MAG_CHAN(_axis, _index) { \
+     .type = IIO_MAGN, \
+     .modified = 1, \
+     .channel2 = IIO_MOD_ ## _axis, \
+     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \

drivers/iio/imu/kmx61.c line 170

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+                             BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+     .scan_index = _index, \
+     .scan_type = { \
+             .sign = 's', \
+             .realbits = 14, \
+             .storagebits = 16, \
+             .shift = 2, \
+             .endianness = IIO_BE, \
+     }, \

Wouldn't normally expect scan_index and scan_type in a driver without buffered support, but you do make use of some of the elements elsewhere and state that buffered support is on the todo list so lets leave it here.

Quoted 165 lines
drivers/iio/imu/kmx61.c new file +165 -0
+}
+
+static const struct iio_chan_spec kmx61_channels[] = {
+     KMX61_ACC_CHAN(X, KMX61_SCAN_ACC_X),
+     KMX61_ACC_CHAN(Y, KMX61_SCAN_ACC_Y),
+     KMX61_ACC_CHAN(Z, KMX61_SCAN_ACC_Z),
+     KMX61_MAG_CHAN(X, KMX61_SCAN_MAG_X),
+     KMX61_MAG_CHAN(Y, KMX61_SCAN_MAG_Y),
+     KMX61_MAG_CHAN(Z, KMX61_SCAN_MAG_Z),
+};
+
+static int kmx61_convert_freq_to_bit(int val, int val2)
+{
+     int i;
+
+     for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+             if (val == samp_freq_table[i].val &&
+                 val2 == samp_freq_table[i].val2)
+                     return samp_freq_table[i].odr_bits;
+     return -EINVAL;
+}
+
+static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading reg_stby\n");
+             return ret;
+     }
+     if (device & KMX61_ACC) {
+             if (mode & KMX61_ACC_STBY_BIT)
+                     ret |= KMX61_ACC_STBY_BIT;
+             else
+                     ret &= ~KMX61_ACC_STBY_BIT;
+     }
+
+     if (device & KMX61_MAG) {
+             if (mode & KMX61_MAG_STBY_BIT)
+                     ret |= KMX61_MAG_STBY_BIT;
+             else
+                     ret &= ~KMX61_MAG_STBY_BIT;
+     }
+
+     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error writing reg_stby\n");
+             return ret;
+     }
+
+     return ret;
+}
+
+static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading reg_stby\n");
+             return ret;
+     }
+     *mode = 0;
+
+     if (device & KMX61_ACC) {
+             if (ret & KMX61_ACC_STBY_BIT)
+                     *mode |= KMX61_ACC_STBY_BIT;
+             else
+                     *mode &= ~KMX61_ACC_STBY_BIT;
+     }
+
+     if (device & KMX61_MAG) {
+             if (ret & KMX61_MAG_STBY_BIT)
+                     *mode |= KMX61_MAG_STBY_BIT;
+             else
+                     *mode &= ~KMX61_MAG_STBY_BIT;
+     }
+
+     return 0;
+}
+
+static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
+{
+     int ret;
+     u8 mode;
+     int lodr_bits, odr_bits;
+
+     ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     lodr_bits = kmx61_convert_freq_to_bit(val, val2);
+     if (lodr_bits < 0)
+             return lodr_bits;
+
+     /* To change ODR, accel and magn must be in STDBY */
+     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     odr_bits = 0;
+     if (device & KMX61_ACC)
+             odr_bits |= lodr_bits;
+     if (device & KMX61_MAG)
+             odr_bits |= (lodr_bits << KMX61_MAG_ODR_SHIFT);
+
+     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
+                                     odr_bits);
+     if (ret < 0)
+             return ret;
+
+     ret = kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     data->odr_bits = lodr_bits;
+
+     return 0;
+}
+
+static
+int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2, u8 device)
+{    int i;
+     u8 lodr_bits;
+
+     if (device & KMX61_ACC)
+             lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
+                          KMX61_ACC_ODR_MASK;
+     else if (device & KMX61_MAG)
+             lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
+                          KMX61_MAG_ODR_MASK;
+     else
+             return -EINVAL;
+
+     for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+             if (lodr_bits == samp_freq_table[i].odr_bits) {
+                     *val = samp_freq_table[i].val;
+                     *val2 = samp_freq_table[i].val2;
+                     return 0;
+             }
+     return -EINVAL;
+}
+
+static int kmx61_set_range(struct kmx61_data *data, int range)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
+             return ret;
+     }
+
+     ret &= ~(KMX61_REG_CTRL1_GSEL0_MASK | KMX61_REG_CTRL1_GSEL1_MASK);
+     ret |= kmx61_scale_table[range].gsel0 << KMX61_REG_CTRL1_GSEL0_SHIFT;
+     ret |= kmx61_scale_table[range].gsel1 << KMX61_REG_CTRL1_GSEL1_SHIFT;
+
+     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
+             return ret;
+     }
+
+     data->range = range;
Quoted 8 lines

drivers/iio/imu/kmx61.c line 252

Quoted 4 lines
drivers/iio/imu/kmx61.c new file +4 -0
+
+     return 0;
+}
+

I'd be tempted to use a parameter name other than val as that tends to have a fairly specific meaning in iio drivers (afterall you pass val2 in here!) scale would work or maybe microscale or similar?

'scale' works for me. I will send a cleanup patch.

Quoted 157 lines
Quoted 157 lines
drivers/iio/imu/kmx61.c new file +157 -0
+static int kmx61_set_scale(struct kmx61_data *data, int val)
+{
+     int ret, i;
+     u8  mode;
+
+     for (i = 0; i < ARRAY_SIZE(kmx61_scale_table); i++) {
+             if (kmx61_scale_table[i].scale == val) {
+                     ret = kmx61_get_mode(data, &mode,
+                                          KMX61_ACC | KMX61_MAG);
+                     if (ret < 0)
+                             return ret;
+
+                     ret = kmx61_set_mode(data, KMX61_ALL_STBY,
+                                          KMX61_ACC | KMX61_MAG);
+                     if (ret < 0)
+                             return ret;
+
+                     ret = kmx61_set_range(data, i);
+                     if (ret < 0)
+                             return ret;
+
+                     ret = kmx61_set_mode(data, mode,
+                                          KMX61_ACC | KMX61_MAG);
+                     if (ret < 0)
+                             return ret;
+
+                     return 0;
+             }
+     }
+     return -EINVAL;
+}
+
+static int kmx61_chip_init(struct kmx61_data *data)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading who_am_i\n");
+             return ret;
+     }
+
+     if (ret != KMX61_CHIP_ID) {
+             dev_err(&data->client->dev,
+                     "Wrong chip id, got %x expected %x\n",
+                      ret, KMX61_CHIP_ID);
+             return -EINVAL;
+     }
+
+     /* set accel 12bit, 4g range */
+     ret = kmx61_set_range(data, KMX61_RANGE_4G);
+     if (ret < 0)
+             return ret;
+
+     /* put accel and magnetometer in operating mode */
+     ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     return 0;
+}
+
+static int kmx61_read_measurement(struct kmx61_data *data, int base, int offset)
+{
+     int ret;
+     u8 reg = base + offset * 2;
+
+     ret = i2c_smbus_read_word_data(data->client, reg);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
+             return ret;
+     }
+
+     return ret;
+}
+
+static int kmx61_read_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan, int *val,
+                           int *val2, long mask)
+{
+     struct kmx61_data *data = iio_priv(indio_dev);
+     int ret;
+     u8 base_reg;
+     u8 device;
+
+     switch (mask) {
+     case IIO_CHAN_INFO_RAW:
+             switch (chan->type) {
+             case IIO_ACCEL: case IIO_MAGN:
+                     base_reg = KMX61_ACC_XOUT_L;
+                     break;
+             default:
+                     return -EINVAL;
+             }
+             ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
+             if (ret < 0)
+                     return ret;
+             *val = sign_extend32(ret >> chan->scan_type.shift,
+                                  chan->scan_type.realbits - 1);
+             return IIO_VAL_INT;
+     case IIO_CHAN_INFO_SCALE:
+             switch (chan->type) {
+             case IIO_ACCEL:
+                     *val = 0;
+                     *val2 = kmx61_scale_table[data->range].scale;
+                     return IIO_VAL_INT_PLUS_MICRO;
+             case IIO_MAGN:
+                     /* 14 bits res, 1465 microGauss per magn count */
+                     *val = 0;
+                     *val2 = 1465;
+                     return IIO_VAL_INT_PLUS_MICRO;
+             default:
+                     break;
+             }
+     case IIO_CHAN_INFO_SAMP_FREQ:
+             switch (chan->type) {
+             case IIO_ACCEL:
+                     device = KMX61_ACC;
+                     break;
+             case IIO_MAGN:
+                     device = KMX61_MAG;
+                     break;
+             default:
+                     return -EINVAL;
+             }
+
+             mutex_lock(&data->lock);
+             ret = kmx61_get_odr(data, val, val2, device);
+             mutex_unlock(&data->lock);
+             if (ret)
+                     return -EINVAL;
+             return IIO_VAL_INT_PLUS_MICRO;
+     }
+     return -EINVAL;
+}
+
+static int kmx61_write_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan, int val,
+                            int val2, long mask)
+{
+     struct kmx61_data *data = iio_priv(indio_dev);
+     int ret;
+     u8 device;
+
+     switch (mask) {
+     case IIO_CHAN_INFO_SAMP_FREQ:
+             switch (chan->type) {
+             case IIO_ACCEL:
+                     device = KMX61_ACC;
+                     break;
+             case IIO_MAGN:
+                     device = KMX61_MAG;
+                     break;
+             default:
+                     return -EINVAL;
+             }
+             mutex_lock(&data->lock);
Quoted 8 lines

drivers/iio/imu/kmx61.c line 502

Quoted 6 lines
drivers/iio/imu/kmx61.c new file +6 -0
+             ret = kmx61_set_odr(data, val, val2, device);
+             mutex_unlock(&data->lock);
+             break;
+     case IIO_CHAN_INFO_SCALE:
+             switch (chan->type) {
+             case IIO_ACCEL:

Should verify that val == 0 incase of crazy userspace input.

Looks good. Thanks for updating the patch.

Quoted 94 lines
Quoted 79 lines
drivers/iio/imu/kmx61.c new file +78 -0
+                     mutex_lock(&data->lock);
+                     ret = kmx61_set_scale(data, val2);
+                     mutex_unlock(&data->lock);
+                     break;
+             default:
+                     ret  = -EINVAL;
+             }
+             break;
+     default:
+             ret = -EINVAL;
+     }
+
+     return ret;
+}
+
+static const struct iio_info kmx61_info = {
+     .driver_module          = THIS_MODULE,
+     .read_raw               = kmx61_read_raw,
+     .write_raw              = kmx61_write_raw,
+     .attrs                  = &kmx61_attribute_group,
+};
+
+static int kmx61_probe(struct i2c_client *client,
+                    const struct i2c_device_id *id)
+{
+     struct kmx61_data *data;
+     struct iio_dev *indio_dev;
+     int ret;
+
+     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+     if (!indio_dev)
+             return -ENOMEM;
+
+     data = iio_priv(indio_dev);
+     i2c_set_clientdata(client, indio_dev);
+     data->client = client;
+
+     indio_dev->dev.parent = &client->dev;
+     indio_dev->info = &kmx61_info;
+     indio_dev->channels = kmx61_channels;
+     indio_dev->num_channels = ARRAY_SIZE(kmx61_channels);
+     indio_dev->modes = INDIO_DIRECT_MODE;
+
+     mutex_init(&data->lock);
+
+     ret = kmx61_chip_init(data);
+     if (ret < 0)
+             return ret;
+
+     return iio_device_register(indio_dev);
+}
+
+static int kmx61_remove(struct i2c_client *client)
+{
+     struct iio_dev *indio_dev = i2c_get_clientdata(client);
+     struct kmx61_data *data = iio_priv(indio_dev);
+     int ret;
+
+     iio_device_unregister(indio_dev);
+
+     mutex_lock(&data->lock);
+     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+     mutex_unlock(&data->lock);
+
+     return ret;
+}
+
+static const struct i2c_device_id kmx61_id[] = {
+     {"kmx61", 0},
+     {}
+};
+
+MODULE_DEVICE_TABLE(i2c, kmx61_id);
+
+static struct i2c_driver kmx61_driver = {
+     .driver = {
+             .name = "kmx61",
+     },

drivers/iio/imu/kmx61.c line 590

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+     .probe          = kmx61_probe,
+     .remove         = kmx61_remove,
+     .id_table       = kmx61_id,
+};
+
+module_i2c_driver(kmx61_driver);
+
+MODULE_AUTHOR("Daniel Baluta <[email protected]>");
+MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
+MODULE_LICENSE("GPL v2");

--
To unsubscribe from this list: send the line "unsubscribe linux-iio" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

maintainer
#3 lore raw
Quoted 8 lines · Daniel Baluta
Quoted 7 lines · Jonathan Cameron
Quoted 6 lines · Daniel Baluta

Minimal implementation for KMX61 6-axis accelerometer/magnetometer. It exports raw accel/magn readings together with scale and sampling frequency.

Datasheet will be available at:
http://www.kionix.com/6-axis-accelerometer-magnetometer/kmx61

Quoted 7 lines
Quoted 5 lines
Quoted 1 line

Looking very nice. I made a few more comments inline but only
one was more than a comment - I added a check on val==0 in the obvious place. Please take a look at the testing branch of iio.git to make sure I didn't mess anything up!

Thanks! It looks good.

Dropped this version as discussed. Will take a look at V3 in a few mins.

Quoted 681 lines
Quoted 181 lines

Applied to the togreg branch of iio.git - initially pushed out as testing for the autobuilders to play with it.

Jonathan

Quoted 175 lines

---
Changes since v1:
* serialize non-atomic operations with a mutex (set_odr/get_odr, set_scale).
* no need to protect reading info scale because it reduces to reading an u8 which should be atomic on all arches
* *note* - read_measurment is an atomic operation

 drivers/iio/imu/Kconfig  |   9 +
 drivers/iio/imu/Makefile |   2 +
 drivers/iio/imu/kmx61.c  | 590 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 601 insertions(+)
 create mode 100644 drivers/iio/imu/kmx61.c
drivers/iio/imu/Kconfig +9 -0
index 2b0e451..d675f43 100644
@@ -25,6 +25,15 @@ config ADIS16480
        Say yes here to build support for Analog Devices ADIS16375, ADIS16480,
        ADIS16485, ADIS16488 inertial sensors.
 
+config KMX61
+     tristate "Kionix KMX61 6-axis accelerometer and magnetometer"
+     depends on I2C
+     help
+       Say Y here if you want to build a driver for Kionix KMX61 6-axis accelerometer
+       and magnetometer.
+       To compile this driver as module, choose M here: the module will be called
+       kmx61.
+
 source "drivers/iio/imu/inv_mpu6050/Kconfig"
 
 endmenu
drivers/iio/imu/Makefile +2 -0
index 114d2c1..e1e6e3d 100644
@@ -14,3 +14,5 @@ adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_buffer.o
 obj-$(CONFIG_IIO_ADIS_LIB) += adis_lib.o
 
 obj-y += inv_mpu6050/
+
+obj-$(CONFIG_KMX61) += kmx61.o
drivers/iio/imu/kmx61.c new file +126 -0
new file mode 100644
index 0000000..6135a16
@@ -0,0 +1,590 @@
+/*
+ * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
+ *
+ * Copyright (c) 2014, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
+ *
+ * TODO: buffer, interrupt, thresholds, acpi, temperature sensor
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define KMX61_DRV_NAME "kmx61"
+
+#define KMX61_REG_WHO_AM_I           0x00
+
+#define KMX61_ACC_XOUT_L             0x0A
+
+#define KMX61_ACC_XOUT_H             0x0B
+#define KMX61_ACC_YOUT_L             0x0C
+#define KMX61_ACC_YOUT_H             0x0D
+#define KMX61_ACC_ZOUT_L             0x0E
+#define KMX61_ACC_ZOUT_H             0x0F
+
+#define KMX61_MAG_XOUT_L             0x12
+
+#define KMX61_MAG_XOUT_H             0x13
+#define KMX61_MAG_YOUT_L             0x14
+#define KMX61_MAG_YOUT_H             0x15
+#define KMX61_MAG_ZOUT_L             0x16
+#define KMX61_MAG_ZOUT_H             0x17
+
+#define KMX61_REG_ODCNTL             0x2C
+
+#define KMX61_REG_STBY                       0x29
+#define KMX61_REG_CTRL1                      0x2A
+
+#define KMX61_REG_COTR                       0x3C
+
+#define KMX61_ACC_STBY_BIT   BIT(0)
+#define KMX61_MAG_STBY_BIT   BIT(1)
+#define KMX61_ACT_STBY_BIT   BIT(7)
+
+#define KMX61_ALL_STBY               (KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
+
+#define KMX61_REG_CTRL1_GSEL0_SHIFT  0
+#define KMX61_REG_CTRL1_GSEL1_SHIFT  1
+#define KMX61_REG_CTRL1_GSEL0_MASK   0x01
+#define KMX61_REG_CTRL1_GSEL1_MASK   0x02
+
+#define KMX61_REG_CTRL1_BIT_RES              BIT(4)
+
+#define KMX61_ACC_ODR_SHIFT  0
+#define KMX61_MAG_ODR_SHIFT  4
+#define KMX61_ACC_ODR_MASK   0x0F
+#define KMX61_MAG_ODR_MASK   0xF0
+
+#define KMX61_CHIP_ID                0x12
+
+struct kmx61_data {
+     struct i2c_client *client;
+     /* serialize access to non-atomic ops, e.g set_mode */
+     struct mutex lock;
+     u8 range;
+     u8 odr_bits;
+};
+
+enum kmx61_range {
+     KMX61_RANGE_2G,
+     KMX61_RANGE_4G,
+     KMX61_RANGE_8G,
+};
+
+enum kmx61_scan {
+     KMX61_SCAN_ACC_X,
+     KMX61_SCAN_ACC_Y,
+     KMX61_SCAN_ACC_Z,
+     KMX61_SCAN_TEMP,
+     KMX61_SCAN_MAG_X,
+     KMX61_SCAN_MAG_Y,
+     KMX61_SCAN_MAG_Z,
+};
+
+static const struct {
+     u16 scale;
+     u8 gsel0;
+     u8 gsel1;
+} kmx61_scale_table[] = {
+     {9582, 0, 0},
+     {19163, 1, 0},
+     {38326, 0, 1},
+};
+
+/* KMX61 devices */
+#define KMX61_ACC    0x01
+#define KMX61_MAG    0x02
+
+static const struct {
+     int val;
+     int val2;
+     int odr_bits;
+} samp_freq_table[] = { {12, 500000, 0x00},
+                     {25, 0, 0x01},
+                     {50, 0, 0x02},
+                     {100, 0, 0x03},
+                     {200, 0, 0x04},
+                     {400, 0, 0x05},
+                     {800, 0, 0x06},
+                     {1600, 0, 0x07},
+                     {0, 781000, 0x08},
+                     {1, 563000, 0x09},
+                     {3, 125000, 0x0A},
+                     {6, 250000, 0x0B} };
+
+static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
+static IIO_CONST_ATTR(magn_scale_available, "0.001465");
+static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
+     "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
Quoted 8 lines

drivers/iio/imu/kmx61.c line 131

Quoted 5 lines
drivers/iio/imu/kmx61.c new file +5 -0
+
+static struct attribute *kmx61_attributes[] = {
+     &iio_const_attr_accel_scale_available.dev_attr.attr,
+     &iio_const_attr_magn_scale_available.dev_attr.attr,
+     &iio_const_attr_sampling_frequency_available.dev_attr.attr,

Interesting. So sampling frequency is controllable seperately for the two sensing types, but uses a single set of values. This is a rare coherent looking bit of dual sensor type hardware ;)

Yes.

Anyway, when the FIFO hardware buffer is used, it will be updated at the faster of the two output data rates

Quoted 208 lines
Quoted 29 lines
drivers/iio/imu/kmx61.c new file +29 -0
+     NULL,
+};
+
+static const struct attribute_group kmx61_attribute_group = {
+     .attrs = kmx61_attributes,
+};
+
+#define KMX61_ACC_CHAN(_axis, _index) { \
+     .type = IIO_ACCEL, \
+     .modified = 1, \
+     .channel2 = IIO_MOD_ ## _axis, \
+     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+                             BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+     .scan_index = _index, \
+     .scan_type = { \
+             .sign = 's', \
+             .realbits = 12, \
+             .storagebits = 16, \
+             .shift = 4, \
+             .endianness = IIO_BE, \
+     }, \
+}
+
+#define KMX61_MAG_CHAN(_axis, _index) { \
+     .type = IIO_MAGN, \
+     .modified = 1, \
+     .channel2 = IIO_MOD_ ## _axis, \
+     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \

drivers/iio/imu/kmx61.c line 170

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+                             BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+     .scan_index = _index, \
+     .scan_type = { \
+             .sign = 's', \
+             .realbits = 14, \
+             .storagebits = 16, \
+             .shift = 2, \
+             .endianness = IIO_BE, \
+     }, \

Wouldn't normally expect scan_index and scan_type in a driver without buffered support, but you do make use of some of the elements elsewhere and state that buffered support is on the todo list so lets leave it here.

Quoted 165 lines
drivers/iio/imu/kmx61.c new file +165 -0
+}
+
+static const struct iio_chan_spec kmx61_channels[] = {
+     KMX61_ACC_CHAN(X, KMX61_SCAN_ACC_X),
+     KMX61_ACC_CHAN(Y, KMX61_SCAN_ACC_Y),
+     KMX61_ACC_CHAN(Z, KMX61_SCAN_ACC_Z),
+     KMX61_MAG_CHAN(X, KMX61_SCAN_MAG_X),
+     KMX61_MAG_CHAN(Y, KMX61_SCAN_MAG_Y),
+     KMX61_MAG_CHAN(Z, KMX61_SCAN_MAG_Z),
+};
+
+static int kmx61_convert_freq_to_bit(int val, int val2)
+{
+     int i;
+
+     for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+             if (val == samp_freq_table[i].val &&
+                 val2 == samp_freq_table[i].val2)
+                     return samp_freq_table[i].odr_bits;
+     return -EINVAL;
+}
+
+static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading reg_stby\n");
+             return ret;
+     }
+     if (device & KMX61_ACC) {
+             if (mode & KMX61_ACC_STBY_BIT)
+                     ret |= KMX61_ACC_STBY_BIT;
+             else
+                     ret &= ~KMX61_ACC_STBY_BIT;
+     }
+
+     if (device & KMX61_MAG) {
+             if (mode & KMX61_MAG_STBY_BIT)
+                     ret |= KMX61_MAG_STBY_BIT;
+             else
+                     ret &= ~KMX61_MAG_STBY_BIT;
+     }
+
+     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error writing reg_stby\n");
+             return ret;
+     }
+
+     return ret;
+}
+
+static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading reg_stby\n");
+             return ret;
+     }
+     *mode = 0;
+
+     if (device & KMX61_ACC) {
+             if (ret & KMX61_ACC_STBY_BIT)
+                     *mode |= KMX61_ACC_STBY_BIT;
+             else
+                     *mode &= ~KMX61_ACC_STBY_BIT;
+     }
+
+     if (device & KMX61_MAG) {
+             if (ret & KMX61_MAG_STBY_BIT)
+                     *mode |= KMX61_MAG_STBY_BIT;
+             else
+                     *mode &= ~KMX61_MAG_STBY_BIT;
+     }
+
+     return 0;
+}
+
+static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
+{
+     int ret;
+     u8 mode;
+     int lodr_bits, odr_bits;
+
+     ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     lodr_bits = kmx61_convert_freq_to_bit(val, val2);
+     if (lodr_bits < 0)
+             return lodr_bits;
+
+     /* To change ODR, accel and magn must be in STDBY */
+     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     odr_bits = 0;
+     if (device & KMX61_ACC)
+             odr_bits |= lodr_bits;
+     if (device & KMX61_MAG)
+             odr_bits |= (lodr_bits << KMX61_MAG_ODR_SHIFT);
+
+     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
+                                     odr_bits);
+     if (ret < 0)
+             return ret;
+
+     ret = kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     data->odr_bits = lodr_bits;
+
+     return 0;
+}
+
+static
+int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2, u8 device)
+{    int i;
+     u8 lodr_bits;
+
+     if (device & KMX61_ACC)
+             lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
+                          KMX61_ACC_ODR_MASK;
+     else if (device & KMX61_MAG)
+             lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
+                          KMX61_MAG_ODR_MASK;
+     else
+             return -EINVAL;
+
+     for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+             if (lodr_bits == samp_freq_table[i].odr_bits) {
+                     *val = samp_freq_table[i].val;
+                     *val2 = samp_freq_table[i].val2;
+                     return 0;
+             }
+     return -EINVAL;
+}
+
+static int kmx61_set_range(struct kmx61_data *data, int range)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
+             return ret;
+     }
+
+     ret &= ~(KMX61_REG_CTRL1_GSEL0_MASK | KMX61_REG_CTRL1_GSEL1_MASK);
+     ret |= kmx61_scale_table[range].gsel0 << KMX61_REG_CTRL1_GSEL0_SHIFT;
+     ret |= kmx61_scale_table[range].gsel1 << KMX61_REG_CTRL1_GSEL1_SHIFT;
+
+     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
+             return ret;
+     }
+
+     data->range = range;
Quoted 8 lines

drivers/iio/imu/kmx61.c line 252

Quoted 4 lines
drivers/iio/imu/kmx61.c new file +4 -0
+
+     return 0;
+}
+

I'd be tempted to use a parameter name other than val as that tends to have a fairly specific meaning in iio drivers (afterall you pass val2 in here!) scale would work or maybe microscale or similar?

'scale' works for me. I will send a cleanup patch.

Quoted 157 lines
Quoted 157 lines
drivers/iio/imu/kmx61.c new file +157 -0
+static int kmx61_set_scale(struct kmx61_data *data, int val)
+{
+     int ret, i;
+     u8  mode;
+
+     for (i = 0; i < ARRAY_SIZE(kmx61_scale_table); i++) {
+             if (kmx61_scale_table[i].scale == val) {
+                     ret = kmx61_get_mode(data, &mode,
+                                          KMX61_ACC | KMX61_MAG);
+                     if (ret < 0)
+                             return ret;
+
+                     ret = kmx61_set_mode(data, KMX61_ALL_STBY,
+                                          KMX61_ACC | KMX61_MAG);
+                     if (ret < 0)
+                             return ret;
+
+                     ret = kmx61_set_range(data, i);
+                     if (ret < 0)
+                             return ret;
+
+                     ret = kmx61_set_mode(data, mode,
+                                          KMX61_ACC | KMX61_MAG);
+                     if (ret < 0)
+                             return ret;
+
+                     return 0;
+             }
+     }
+     return -EINVAL;
+}
+
+static int kmx61_chip_init(struct kmx61_data *data)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading who_am_i\n");
+             return ret;
+     }
+
+     if (ret != KMX61_CHIP_ID) {
+             dev_err(&data->client->dev,
+                     "Wrong chip id, got %x expected %x\n",
+                      ret, KMX61_CHIP_ID);
+             return -EINVAL;
+     }
+
+     /* set accel 12bit, 4g range */
+     ret = kmx61_set_range(data, KMX61_RANGE_4G);
+     if (ret < 0)
+             return ret;
+
+     /* put accel and magnetometer in operating mode */
+     ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     return 0;
+}
+
+static int kmx61_read_measurement(struct kmx61_data *data, int base, int offset)
+{
+     int ret;
+     u8 reg = base + offset * 2;
+
+     ret = i2c_smbus_read_word_data(data->client, reg);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
+             return ret;
+     }
+
+     return ret;
+}
+
+static int kmx61_read_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan, int *val,
+                           int *val2, long mask)
+{
+     struct kmx61_data *data = iio_priv(indio_dev);
+     int ret;
+     u8 base_reg;
+     u8 device;
+
+     switch (mask) {
+     case IIO_CHAN_INFO_RAW:
+             switch (chan->type) {
+             case IIO_ACCEL: case IIO_MAGN:
+                     base_reg = KMX61_ACC_XOUT_L;
+                     break;
+             default:
+                     return -EINVAL;
+             }
+             ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
+             if (ret < 0)
+                     return ret;
+             *val = sign_extend32(ret >> chan->scan_type.shift,
+                                  chan->scan_type.realbits - 1);
+             return IIO_VAL_INT;
+     case IIO_CHAN_INFO_SCALE:
+             switch (chan->type) {
+             case IIO_ACCEL:
+                     *val = 0;
+                     *val2 = kmx61_scale_table[data->range].scale;
+                     return IIO_VAL_INT_PLUS_MICRO;
+             case IIO_MAGN:
+                     /* 14 bits res, 1465 microGauss per magn count */
+                     *val = 0;
+                     *val2 = 1465;
+                     return IIO_VAL_INT_PLUS_MICRO;
+             default:
+                     break;
+             }
+     case IIO_CHAN_INFO_SAMP_FREQ:
+             switch (chan->type) {
+             case IIO_ACCEL:
+                     device = KMX61_ACC;
+                     break;
+             case IIO_MAGN:
+                     device = KMX61_MAG;
+                     break;
+             default:
+                     return -EINVAL;
+             }
+
+             mutex_lock(&data->lock);
+             ret = kmx61_get_odr(data, val, val2, device);
+             mutex_unlock(&data->lock);
+             if (ret)
+                     return -EINVAL;
+             return IIO_VAL_INT_PLUS_MICRO;
+     }
+     return -EINVAL;
+}
+
+static int kmx61_write_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan, int val,
+                            int val2, long mask)
+{
+     struct kmx61_data *data = iio_priv(indio_dev);
+     int ret;
+     u8 device;
+
+     switch (mask) {
+     case IIO_CHAN_INFO_SAMP_FREQ:
+             switch (chan->type) {
+             case IIO_ACCEL:
+                     device = KMX61_ACC;
+                     break;
+             case IIO_MAGN:
+                     device = KMX61_MAG;
+                     break;
+             default:
+                     return -EINVAL;
+             }
+             mutex_lock(&data->lock);
Quoted 8 lines

drivers/iio/imu/kmx61.c line 502

Quoted 6 lines
drivers/iio/imu/kmx61.c new file +6 -0
+             ret = kmx61_set_odr(data, val, val2, device);
+             mutex_unlock(&data->lock);
+             break;
+     case IIO_CHAN_INFO_SCALE:
+             switch (chan->type) {
+             case IIO_ACCEL:

Should verify that val == 0 incase of crazy userspace input.

Looks good. Thanks for updating the patch.

Quoted 86 lines
Quoted 86 lines
drivers/iio/imu/kmx61.c new file +86 -0
+                     mutex_lock(&data->lock);
+                     ret = kmx61_set_scale(data, val2);
+                     mutex_unlock(&data->lock);
+                     break;
+             default:
+                     ret  = -EINVAL;
+             }
+             break;
+     default:
+             ret = -EINVAL;
+     }
+
+     return ret;
+}
+
+static const struct iio_info kmx61_info = {
+     .driver_module          = THIS_MODULE,
+     .read_raw               = kmx61_read_raw,
+     .write_raw              = kmx61_write_raw,
+     .attrs                  = &kmx61_attribute_group,
+};
+
+static int kmx61_probe(struct i2c_client *client,
+                    const struct i2c_device_id *id)
+{
+     struct kmx61_data *data;
+     struct iio_dev *indio_dev;
+     int ret;
+
+     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+     if (!indio_dev)
+             return -ENOMEM;
+
+     data = iio_priv(indio_dev);
+     i2c_set_clientdata(client, indio_dev);
+     data->client = client;
+
+     indio_dev->dev.parent = &client->dev;
+     indio_dev->info = &kmx61_info;
+     indio_dev->channels = kmx61_channels;
+     indio_dev->num_channels = ARRAY_SIZE(kmx61_channels);
+     indio_dev->modes = INDIO_DIRECT_MODE;
+
+     mutex_init(&data->lock);
+
+     ret = kmx61_chip_init(data);
+     if (ret < 0)
+             return ret;
+
+     return iio_device_register(indio_dev);
+}
+
+static int kmx61_remove(struct i2c_client *client)
+{
+     struct iio_dev *indio_dev = i2c_get_clientdata(client);
+     struct kmx61_data *data = iio_priv(indio_dev);
+     int ret;
+
+     iio_device_unregister(indio_dev);
+
+     mutex_lock(&data->lock);
+     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+     mutex_unlock(&data->lock);
+
+     return ret;
+}
+
+static const struct i2c_device_id kmx61_id[] = {
+     {"kmx61", 0},
+     {}
+};
+
+MODULE_DEVICE_TABLE(i2c, kmx61_id);
+
+static struct i2c_driver kmx61_driver = {
+     .driver = {
+             .name = "kmx61",
+     },
+     .probe          = kmx61_probe,
+     .remove         = kmx61_remove,
+     .id_table       = kmx61_id,
+};
+
+module_i2c_driver(kmx61_driver);
+
+MODULE_AUTHOR("Daniel Baluta <[email protected]>");
Quoted 8 lines

drivers/iio/imu/kmx61.c line 590

Quoted 3 lines
drivers/iio/imu/kmx61.c new file +2 -0
+MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
+MODULE_LICENSE("GPL v2");

--
To unsubscribe from this list: send the line "unsubscribe linux-iio" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

--
To unsubscribe from this list: send the line "unsubscribe linux-iio" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html

#4 lore raw
In reply to Daniel Baluta
Quoted 6 lines

Minimal implementation for KMX61 6-axis accelerometer/magnetometer. It exports raw accel/magn readings together with scale and sampling frequency.

Datasheet will be available at:
http://www.kionix.com/6-axis-accelerometer-magnetometer/kmx61

some trivial comments below

Quoted 79 lines

---
Changes since v1:
* serialize non-atomic operations with a mutex (set_odr/get_odr, set_scale).
* no need to protect reading info scale because it reduces to reading an u8 which should be atomic on all arches
* *note* - read_measurment is an atomic operation

 drivers/iio/imu/Kconfig  |   9 +
 drivers/iio/imu/Makefile |   2 +
 drivers/iio/imu/kmx61.c  | 590 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 601 insertions(+)
 create mode 100644 drivers/iio/imu/kmx61.c
drivers/iio/imu/Kconfig +9 -0
index 2b0e451..d675f43 100644
@@ -25,6 +25,15 @@ config ADIS16480
 	  Say yes here to build support for Analog Devices ADIS16375, ADIS16480,
 	  ADIS16485, ADIS16488 inertial sensors.
 
+config KMX61
+	tristate "Kionix KMX61 6-axis accelerometer and magnetometer"
+	depends on I2C
+	help
+	  Say Y here if you want to build a driver for Kionix KMX61 6-axis accelerometer
+	  and magnetometer.
+	  To compile this driver as module, choose M here: the module will be called
+	  kmx61.
+
 source "drivers/iio/imu/inv_mpu6050/Kconfig"
 
 endmenu
drivers/iio/imu/Makefile +2 -0
index 114d2c1..e1e6e3d 100644
@@ -14,3 +14,5 @@ adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_buffer.o
 obj-$(CONFIG_IIO_ADIS_LIB) += adis_lib.o
 
 obj-y += inv_mpu6050/
+
+obj-$(CONFIG_KMX61) += kmx61.o
drivers/iio/imu/kmx61.c new file +29 -0
new file mode 100644
index 0000000..6135a16
@@ -0,0 +1,590 @@
+/*
+ * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
+ *
+ * Copyright (c) 2014, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
+ *
+ * TODO: buffer, interrupt, thresholds, acpi, temperature sensor
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define KMX61_DRV_NAME "kmx61"
+
+#define KMX61_REG_WHO_AM_I		0x00
+
+#define KMX61_ACC_XOUT_L		0x0A
+
+#define KMX61_ACC_XOUT_H		0x0B
+#define KMX61_ACC_YOUT_L		0x0C
+#define KMX61_ACC_YOUT_H		0x0D

drivers/iio/imu/kmx61.c line 39

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+#define KMX61_ACC_ZOUT_L		0x0E
+#define KMX61_ACC_ZOUT_H		0x0F
+
+#define KMX61_MAG_XOUT_L		0x12
+
+#define KMX61_MAG_XOUT_H		0x13
+#define KMX61_MAG_YOUT_L		0x14
+#define KMX61_MAG_YOUT_H		0x15
+#define KMX61_MAG_ZOUT_L		0x16
+#define KMX61_MAG_ZOUT_H		0x17

only the XOUT_L #defines are actually used, there is extra whitespace

I'd suggest to drop the other defines and maybe add a comment saying that we have 3 16-bit LSB values for X/Y/Z

Quoted 60 lines
drivers/iio/imu/kmx61.c new file +60 -0
+
+#define KMX61_REG_ODCNTL		0x2C
+
+#define KMX61_REG_STBY			0x29
+#define KMX61_REG_CTRL1			0x2A
+
+#define KMX61_REG_COTR			0x3C
+
+#define KMX61_ACC_STBY_BIT	BIT(0)
+#define KMX61_MAG_STBY_BIT	BIT(1)
+#define KMX61_ACT_STBY_BIT	BIT(7)
+
+#define KMX61_ALL_STBY		(KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
+
+#define KMX61_REG_CTRL1_GSEL0_SHIFT	0
+#define KMX61_REG_CTRL1_GSEL1_SHIFT	1
+#define KMX61_REG_CTRL1_GSEL0_MASK	0x01
+#define KMX61_REG_CTRL1_GSEL1_MASK	0x02
+
+#define KMX61_REG_CTRL1_BIT_RES		BIT(4)
+
+#define KMX61_ACC_ODR_SHIFT	0
+#define KMX61_MAG_ODR_SHIFT	4
+#define KMX61_ACC_ODR_MASK	0x0F
+#define KMX61_MAG_ODR_MASK	0xF0
+
+#define KMX61_CHIP_ID		0x12
+
+struct kmx61_data {
+	struct i2c_client *client;
+	/* serialize access to non-atomic ops, e.g set_mode */
+	struct mutex lock;
+	u8 range;
+	u8 odr_bits;
+};
+
+enum kmx61_range {
+	KMX61_RANGE_2G,
+	KMX61_RANGE_4G,
+	KMX61_RANGE_8G,
+};
+
+enum kmx61_scan {
+	KMX61_SCAN_ACC_X,
+	KMX61_SCAN_ACC_Y,
+	KMX61_SCAN_ACC_Z,
+	KMX61_SCAN_TEMP,
+	KMX61_SCAN_MAG_X,
+	KMX61_SCAN_MAG_Y,
+	KMX61_SCAN_MAG_Z,
+};
+
+static const struct {
+	u16 scale;
+	u8 gsel0;
+	u8 gsel1;
+} kmx61_scale_table[] = {
+	{9582, 0, 0},
+	{19163, 1, 0},
+	{38326, 0, 1},

drivers/iio/imu/kmx61.c line 109

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+};
+
+/* KMX61 devices */
+#define KMX61_ACC	0x01
+#define KMX61_MAG	0x02
+
+static const struct {
+	int val;
+	int val2;
+	int odr_bits;

odr_bits should probably be u8

drivers/iio/imu/kmx61.c line 110

Quoted 1 line
drivers/iio/imu/kmx61.c new file +1 -0
+} samp_freq_table[] = { {12, 500000, 0x00},

no kmx16_ prefix

Quoted 32 lines
drivers/iio/imu/kmx61.c new file +32 -0
+			{25, 0, 0x01},
+			{50, 0, 0x02},
+			{100, 0, 0x03},
+			{200, 0, 0x04},
+			{400, 0, 0x05},
+			{800, 0, 0x06},
+			{1600, 0, 0x07},
+			{0, 781000, 0x08},
+			{1, 563000, 0x09},
+			{3, 125000, 0x0A},
+			{6, 250000, 0x0B} };
+
+static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
+static IIO_CONST_ATTR(magn_scale_available, "0.001465");
+static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
+	"0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
+
+static struct attribute *kmx61_attributes[] = {
+	&iio_const_attr_accel_scale_available.dev_attr.attr,
+	&iio_const_attr_magn_scale_available.dev_attr.attr,
+	&iio_const_attr_sampling_frequency_available.dev_attr.attr,
+	NULL,
+};
+
+static const struct attribute_group kmx61_attribute_group = {
+	.attrs = kmx61_attributes,
+};
+
+#define KMX61_ACC_CHAN(_axis, _index) { \
+	.type = IIO_ACCEL, \
+	.modified = 1, \
+	.channel2 = IIO_MOD_ ## _axis, \

drivers/iio/imu/kmx61.c line 152

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+				BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+	.scan_index = _index, \
+	.scan_type = { \
+		.sign = 's', \
+		.realbits = 12, \
+		.storagebits = 16, \
+		.shift = 4, \
+		.endianness = IIO_BE, \

the data registers are LSB, so it should be IIO_LE buffering is not implemented, so it doesn't matter; but IIO_BE is definitely wrong

Quoted 200 lines
drivers/iio/imu/kmx61.c new file +200 -0
+	}, \
+}
+
+#define KMX61_MAG_CHAN(_axis, _index) { \
+	.type = IIO_MAGN, \
+	.modified = 1, \
+	.channel2 = IIO_MOD_ ## _axis, \
+	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+				BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+	.scan_index = _index, \
+	.scan_type = { \
+		.sign = 's', \
+		.realbits = 14, \
+		.storagebits = 16, \
+		.shift = 2, \
+		.endianness = IIO_BE, \
+	}, \
+}
+
+static const struct iio_chan_spec kmx61_channels[] = {
+	KMX61_ACC_CHAN(X, KMX61_SCAN_ACC_X),
+	KMX61_ACC_CHAN(Y, KMX61_SCAN_ACC_Y),
+	KMX61_ACC_CHAN(Z, KMX61_SCAN_ACC_Z),
+	KMX61_MAG_CHAN(X, KMX61_SCAN_MAG_X),
+	KMX61_MAG_CHAN(Y, KMX61_SCAN_MAG_Y),
+	KMX61_MAG_CHAN(Z, KMX61_SCAN_MAG_Z),
+};
+
+static int kmx61_convert_freq_to_bit(int val, int val2)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+		if (val == samp_freq_table[i].val &&
+		    val2 == samp_freq_table[i].val2)
+			return samp_freq_table[i].odr_bits;
+	return -EINVAL;
+}
+
+static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error reading reg_stby\n");
+		return ret;
+	}
+	if (device & KMX61_ACC) {
+		if (mode & KMX61_ACC_STBY_BIT)
+			ret |= KMX61_ACC_STBY_BIT;
+		else
+			ret &= ~KMX61_ACC_STBY_BIT;
+	}
+
+	if (device & KMX61_MAG) {
+		if (mode & KMX61_MAG_STBY_BIT)
+			ret |= KMX61_MAG_STBY_BIT;
+		else
+			ret &= ~KMX61_MAG_STBY_BIT;
+	}
+
+	ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error writing reg_stby\n");
+		return ret;
+	}
+
+	return ret;
+}
+
+static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error reading reg_stby\n");
+		return ret;
+	}
+	*mode = 0;
+
+	if (device & KMX61_ACC) {
+		if (ret & KMX61_ACC_STBY_BIT)
+			*mode |= KMX61_ACC_STBY_BIT;
+		else
+			*mode &= ~KMX61_ACC_STBY_BIT;
+	}
+
+	if (device & KMX61_MAG) {
+		if (ret & KMX61_MAG_STBY_BIT)
+			*mode |= KMX61_MAG_STBY_BIT;
+		else
+			*mode &= ~KMX61_MAG_STBY_BIT;
+	}
+
+	return 0;
+}
+
+static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
+{
+	int ret;
+	u8 mode;
+	int lodr_bits, odr_bits;
+
+	ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
+	if (ret < 0)
+		return ret;
+
+	lodr_bits = kmx61_convert_freq_to_bit(val, val2);
+	if (lodr_bits < 0)
+		return lodr_bits;
+
+	/* To change ODR, accel and magn must be in STDBY */
+	ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+	if (ret < 0)
+		return ret;
+
+	odr_bits = 0;
+	if (device & KMX61_ACC)
+		odr_bits |= lodr_bits;
+	if (device & KMX61_MAG)
+		odr_bits |= (lodr_bits << KMX61_MAG_ODR_SHIFT);
+
+	ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
+					odr_bits);
+	if (ret < 0)
+		return ret;
+
+	ret = kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG);
+	if (ret < 0)
+		return ret;
+
+	data->odr_bits = lodr_bits;
+
+	return 0;
+}
+
+static
+int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2, u8 device)
+{	int i;
+	u8 lodr_bits;
+
+	if (device & KMX61_ACC)
+		lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
+			     KMX61_ACC_ODR_MASK;
+	else if (device & KMX61_MAG)
+		lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
+			     KMX61_MAG_ODR_MASK;
+	else
+		return -EINVAL;
+
+	for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+		if (lodr_bits == samp_freq_table[i].odr_bits) {
+			*val = samp_freq_table[i].val;
+			*val2 = samp_freq_table[i].val2;
+			return 0;
+		}
+	return -EINVAL;
+}
+
+static int kmx61_set_range(struct kmx61_data *data, int range)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
+		return ret;
+	}
+
+	ret &= ~(KMX61_REG_CTRL1_GSEL0_MASK | KMX61_REG_CTRL1_GSEL1_MASK);
+	ret |= kmx61_scale_table[range].gsel0 << KMX61_REG_CTRL1_GSEL0_SHIFT;
+	ret |= kmx61_scale_table[range].gsel1 << KMX61_REG_CTRL1_GSEL1_SHIFT;
+
+	ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
+		return ret;
+	}
+
+	data->range = range;
+
+	return 0;
+}
+
+static int kmx61_set_scale(struct kmx61_data *data, int val)
+{
+	int ret, i;
+	u8  mode;
+
+	for (i = 0; i < ARRAY_SIZE(kmx61_scale_table); i++) {
+		if (kmx61_scale_table[i].scale == val) {
+			ret = kmx61_get_mode(data, &mode,
+					     KMX61_ACC | KMX61_MAG);
+			if (ret < 0)
+				return ret;
+
+			ret = kmx61_set_mode(data, KMX61_ALL_STBY,

drivers/iio/imu/kmx61.c line 362

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+					     KMX61_ACC | KMX61_MAG);
+			if (ret < 0)
+				return ret;
+
+			ret = kmx61_set_range(data, i);
+			if (ret < 0)
+				return ret;
+
+			ret = kmx61_set_mode(data, mode,
+					     KMX61_ACC | KMX61_MAG);

simply return here

Quoted 56 lines
drivers/iio/imu/kmx61.c new file +56 -0
+			if (ret < 0)
+				return ret;
+
+			return 0;
+		}
+	}
+	return -EINVAL;
+}
+
+static int kmx61_chip_init(struct kmx61_data *data)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "Error reading who_am_i\n");
+		return ret;
+	}
+
+	if (ret != KMX61_CHIP_ID) {
+		dev_err(&data->client->dev,
+			"Wrong chip id, got %x expected %x\n",
+			 ret, KMX61_CHIP_ID);
+		return -EINVAL;
+	}
+
+	/* set accel 12bit, 4g range */
+	ret = kmx61_set_range(data, KMX61_RANGE_4G);
+	if (ret < 0)
+		return ret;
+
+	/* put accel and magnetometer in operating mode */
+	ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+static int kmx61_read_measurement(struct kmx61_data *data, int base, int offset)
+{
+	int ret;
+	u8 reg = base + offset * 2;
+
+	ret = i2c_smbus_read_word_data(data->client, reg);
+	if (ret < 0) {
+		dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
+		return ret;
+	}
+
+	return ret;
+}
+
+static int kmx61_read_raw(struct iio_dev *indio_dev,
+			      struct iio_chan_spec const *chan, int *val,
+			      int *val2, long mask)

drivers/iio/imu/kmx61.c line 428

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+{
+	struct kmx61_data *data = iio_priv(indio_dev);
+	int ret;
+	u8 base_reg;
+	u8 device;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_RAW:
+		switch (chan->type) {
+		case IIO_ACCEL: case IIO_MAGN:

cases on separate lines would be more readable

Quoted 13 lines
drivers/iio/imu/kmx61.c new file +13 -0
+			base_reg = KMX61_ACC_XOUT_L;
+			break;
+		default:
+			return -EINVAL;
+		}
+		ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
+		if (ret < 0)
+			return ret;
+		*val = sign_extend32(ret >> chan->scan_type.shift,
+				     chan->scan_type.realbits - 1);
+		return IIO_VAL_INT;
+	case IIO_CHAN_INFO_SCALE:
+		switch (chan->type) {

drivers/iio/imu/kmx61.c line 451

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+		case IIO_ACCEL:
+			*val = 0;
+			*val2 = kmx61_scale_table[data->range].scale;
+			return IIO_VAL_INT_PLUS_MICRO;
+		case IIO_MAGN:
+			/* 14 bits res, 1465 microGauss per magn count */
+			*val = 0;
+			*val2 = 1465;
+			return IIO_VAL_INT_PLUS_MICRO;
+		default:

could just return -EINVAL here

Quoted 24 lines
drivers/iio/imu/kmx61.c new file +24 -0
+			break;
+		}
+	case IIO_CHAN_INFO_SAMP_FREQ:
+		switch (chan->type) {
+		case IIO_ACCEL:
+			device = KMX61_ACC;
+			break;
+		case IIO_MAGN:
+			device = KMX61_MAG;
+			break;
+		default:
+			return -EINVAL;
+		}
+
+		mutex_lock(&data->lock);
+		ret = kmx61_get_odr(data, val, val2, device);
+		mutex_unlock(&data->lock);
+		if (ret)
+			return -EINVAL;
+		return IIO_VAL_INT_PLUS_MICRO;
+	}
+	return -EINVAL;
+}
+

drivers/iio/imu/kmx61.c line 485

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+static int kmx61_write_raw(struct iio_dev *indio_dev,
+			       struct iio_chan_spec const *chan, int val,
+			       int val2, long mask)
+{
+	struct kmx61_data *data = iio_priv(indio_dev);
+	int ret;
+	u8 device;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_SAMP_FREQ:

you could use chan->address to store the device type (ACC or MAG) and save the switch block (here and in other places)

drivers/iio/imu/kmx61.c line 498

Quoted 13 lines
drivers/iio/imu/kmx61.c new file +13 -0
+		switch (chan->type) {
+		case IIO_ACCEL:
+			device = KMX61_ACC;
+			break;
+		case IIO_MAGN:
+			device = KMX61_MAG;
+			break;
+		default:
+			return -EINVAL;
+		}
+		mutex_lock(&data->lock);
+		ret = kmx61_set_odr(data, val, val2, device);
+		mutex_unlock(&data->lock);

follow edits are a matter of taste :)

return ret;

drivers/iio/imu/kmx61.c line 508

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+		break;
+	case IIO_CHAN_INFO_SCALE:
+		switch (chan->type) {
+		case IIO_ACCEL:
+			mutex_lock(&data->lock);
+			ret = kmx61_set_scale(data, val2);
+			mutex_unlock(&data->lock);
+			break;
+		default:
+			ret  = -EINVAL;

return -EINVAL

drivers/iio/imu/kmx61.c line 509

Quoted 1 line
drivers/iio/imu/kmx61.c new file +1 -0
+		}

return ret;

drivers/iio/imu/kmx61.c line 511

Quoted 2 lines
drivers/iio/imu/kmx61.c new file +2 -0
+		break;
+	default:

return -EINVAL;

Quoted 20 lines
drivers/iio/imu/kmx61.c new file +20 -0
+		ret = -EINVAL;
+	}
+
+	return ret;
+}
+
+static const struct iio_info kmx61_info = {
+	.driver_module		= THIS_MODULE,
+	.read_raw		= kmx61_read_raw,
+	.write_raw		= kmx61_write_raw,
+	.attrs			= &kmx61_attribute_group,
+};
+
+static int kmx61_probe(struct i2c_client *client,
+		       const struct i2c_device_id *id)
+{
+	struct kmx61_data *data;
+	struct iio_dev *indio_dev;
+	int ret;
+

drivers/iio/imu/kmx61.c line 541

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+	if (!indio_dev)
+		return -ENOMEM;
+
+	data = iio_priv(indio_dev);
+	i2c_set_clientdata(client, indio_dev);
+	data->client = client;
+
+	indio_dev->dev.parent = &client->dev;
+	indio_dev->info = &kmx61_info;

set indio_dev->name?

Quoted 50 lines
drivers/iio/imu/kmx61.c new file +49 -0
+	indio_dev->channels = kmx61_channels;
+	indio_dev->num_channels = ARRAY_SIZE(kmx61_channels);
+	indio_dev->modes = INDIO_DIRECT_MODE;
+
+	mutex_init(&data->lock);
+
+	ret = kmx61_chip_init(data);
+	if (ret < 0)
+		return ret;
+
+	return iio_device_register(indio_dev);
+}
+
+static int kmx61_remove(struct i2c_client *client)
+{
+	struct iio_dev *indio_dev = i2c_get_clientdata(client);
+	struct kmx61_data *data = iio_priv(indio_dev);
+	int ret;
+
+	iio_device_unregister(indio_dev);
+
+	mutex_lock(&data->lock);
+	ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+	mutex_unlock(&data->lock);
+
+	return ret;
+}
+
+static const struct i2c_device_id kmx61_id[] = {
+	{"kmx61", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, kmx61_id);
+
+static struct i2c_driver kmx61_driver = {
+	.driver = {
+		.name = "kmx61",
+	},
+	.probe		= kmx61_probe,
+	.remove		= kmx61_remove,
+	.id_table	= kmx61_id,
+};
+
+module_i2c_driver(kmx61_driver);
+
+MODULE_AUTHOR("Daniel Baluta <[email protected]>");
+MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
+MODULE_LICENSE("GPL v2");
Signature · 2 lines
Peter Meerwald
+43-664-2444418 (mobile)
#5 lore raw
Quoted 101 lines · Peter Meerwald
Quoted 6 lines

Minimal implementation for KMX61 6-axis accelerometer/magnetometer. It exports raw accel/magn readings together with scale and sampling frequency.

Datasheet will be available at:
http://www.kionix.com/6-axis-accelerometer-magnetometer/kmx61

some trivial comments below

Quoted 79 lines

---
Changes since v1:
* serialize non-atomic operations with a mutex (set_odr/get_odr, set_scale).
* no need to protect reading info scale because it reduces to reading an u8 which should be atomic on all arches
* *note* - read_measurment is an atomic operation

 drivers/iio/imu/Kconfig  |   9 +
 drivers/iio/imu/Makefile |   2 +
 drivers/iio/imu/kmx61.c  | 590 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 601 insertions(+)
 create mode 100644 drivers/iio/imu/kmx61.c
drivers/iio/imu/Kconfig +9 -0
index 2b0e451..d675f43 100644
@@ -25,6 +25,15 @@ config ADIS16480
        Say yes here to build support for Analog Devices ADIS16375, ADIS16480,
        ADIS16485, ADIS16488 inertial sensors.
 
+config KMX61
+     tristate "Kionix KMX61 6-axis accelerometer and magnetometer"
+     depends on I2C
+     help
+       Say Y here if you want to build a driver for Kionix KMX61 6-axis accelerometer
+       and magnetometer.
+       To compile this driver as module, choose M here: the module will be called
+       kmx61.
+
 source "drivers/iio/imu/inv_mpu6050/Kconfig"
 
 endmenu
drivers/iio/imu/Makefile +2 -0
index 114d2c1..e1e6e3d 100644
@@ -14,3 +14,5 @@ adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_buffer.o
 obj-$(CONFIG_IIO_ADIS_LIB) += adis_lib.o
 
 obj-y += inv_mpu6050/
+
+obj-$(CONFIG_KMX61) += kmx61.o
drivers/iio/imu/kmx61.c new file +29 -0
new file mode 100644
index 0000000..6135a16
@@ -0,0 +1,590 @@
+/*
+ * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
+ *
+ * Copyright (c) 2014, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
+ *
+ * TODO: buffer, interrupt, thresholds, acpi, temperature sensor
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+
+#define KMX61_DRV_NAME "kmx61"
+
+#define KMX61_REG_WHO_AM_I           0x00
+
+#define KMX61_ACC_XOUT_L             0x0A
+
+#define KMX61_ACC_XOUT_H             0x0B
+#define KMX61_ACC_YOUT_L             0x0C
+#define KMX61_ACC_YOUT_H             0x0D

drivers/iio/imu/kmx61.c line 39

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+#define KMX61_ACC_ZOUT_L             0x0E
+#define KMX61_ACC_ZOUT_H             0x0F
+
+#define KMX61_MAG_XOUT_L             0x12
+
+#define KMX61_MAG_XOUT_H             0x13
+#define KMX61_MAG_YOUT_L             0x14
+#define KMX61_MAG_YOUT_H             0x15
+#define KMX61_MAG_ZOUT_L             0x16
+#define KMX61_MAG_ZOUT_H             0x17

only the XOUT_L #defines are actually used, there is extra whitespace

Quoted 2 lines

I'd suggest to drop the other defines and maybe add a comment saying that we have 3 16-bit LSB values for X/Y/Z

I added all these defines for documentation, in the same way accel/kxcjk-1013.c did.

I think its better to add a comment making this clear.

Quoted 74 lines
Quoted 61 lines
drivers/iio/imu/kmx61.c new file +60 -0
+
+#define KMX61_REG_ODCNTL             0x2C
+
+#define KMX61_REG_STBY                       0x29
+#define KMX61_REG_CTRL1                      0x2A
+
+#define KMX61_REG_COTR                       0x3C
+
+#define KMX61_ACC_STBY_BIT   BIT(0)
+#define KMX61_MAG_STBY_BIT   BIT(1)
+#define KMX61_ACT_STBY_BIT   BIT(7)
+
+#define KMX61_ALL_STBY               (KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
+
+#define KMX61_REG_CTRL1_GSEL0_SHIFT  0
+#define KMX61_REG_CTRL1_GSEL1_SHIFT  1
+#define KMX61_REG_CTRL1_GSEL0_MASK   0x01
+#define KMX61_REG_CTRL1_GSEL1_MASK   0x02
+
+#define KMX61_REG_CTRL1_BIT_RES              BIT(4)
+
+#define KMX61_ACC_ODR_SHIFT  0
+#define KMX61_MAG_ODR_SHIFT  4
+#define KMX61_ACC_ODR_MASK   0x0F
+#define KMX61_MAG_ODR_MASK   0xF0
+
+#define KMX61_CHIP_ID                0x12
+
+struct kmx61_data {
+     struct i2c_client *client;
+     /* serialize access to non-atomic ops, e.g set_mode */
+     struct mutex lock;
+     u8 range;
+     u8 odr_bits;
+};
+
+enum kmx61_range {
+     KMX61_RANGE_2G,
+     KMX61_RANGE_4G,
+     KMX61_RANGE_8G,
+};
+
+enum kmx61_scan {
+     KMX61_SCAN_ACC_X,
+     KMX61_SCAN_ACC_Y,
+     KMX61_SCAN_ACC_Z,
+     KMX61_SCAN_TEMP,
+     KMX61_SCAN_MAG_X,
+     KMX61_SCAN_MAG_Y,
+     KMX61_SCAN_MAG_Z,
+};
+
+static const struct {
+     u16 scale;
+     u8 gsel0;
+     u8 gsel1;
+} kmx61_scale_table[] = {
+     {9582, 0, 0},
+     {19163, 1, 0},
+     {38326, 0, 1},

drivers/iio/imu/kmx61.c line 109

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+};
+
+/* KMX61 devices */
+#define KMX61_ACC    0x01
+#define KMX61_MAG    0x02
+
+static const struct {
+     int val;
+     int val2;
+     int odr_bits;

odr_bits should probably be u8

Quoted 3 lines

drivers/iio/imu/kmx61.c line 110

Quoted 1 line
drivers/iio/imu/kmx61.c new file +1 -0
+} samp_freq_table[] = { {12, 500000, 0x00},

no kmx16_ prefix

Correct. Will fix.

Quoted 39 lines
Quoted 39 lines
drivers/iio/imu/kmx61.c new file +38 -0
+                     {25, 0, 0x01},
+                     {50, 0, 0x02},
+                     {100, 0, 0x03},
+                     {200, 0, 0x04},
+                     {400, 0, 0x05},
+                     {800, 0, 0x06},
+                     {1600, 0, 0x07},
+                     {0, 781000, 0x08},
+                     {1, 563000, 0x09},
+                     {3, 125000, 0x0A},
+                     {6, 250000, 0x0B} };
+
+static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
+static IIO_CONST_ATTR(magn_scale_available, "0.001465");
+static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
+     "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
+
+static struct attribute *kmx61_attributes[] = {
+     &iio_const_attr_accel_scale_available.dev_attr.attr,
+     &iio_const_attr_magn_scale_available.dev_attr.attr,
+     &iio_const_attr_sampling_frequency_available.dev_attr.attr,
+     NULL,
+};
+
+static const struct attribute_group kmx61_attribute_group = {
+     .attrs = kmx61_attributes,
+};
+
+#define KMX61_ACC_CHAN(_axis, _index) { \
+     .type = IIO_ACCEL, \
+     .modified = 1, \
+     .channel2 = IIO_MOD_ ## _axis, \
+     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+                             BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+     .scan_index = _index, \
+     .scan_type = { \
+             .sign = 's', \
Quoted 9 lines

drivers/iio/imu/kmx61.c line 152

Quoted 4 lines
drivers/iio/imu/kmx61.c new file +4 -0
+             .realbits = 12, \
+             .storagebits = 16, \
+             .shift = 4, \
+             .endianness = IIO_BE, \

the data registers are LSB, so it should be IIO_LE buffering is not implemented, so it doesn't matter; but IIO_BE is definitely wrong

Ok. Will fix.

Quoted 204 lines
Quoted 204 lines
drivers/iio/imu/kmx61.c new file +204 -0
+     }, \
+}
+
+#define KMX61_MAG_CHAN(_axis, _index) { \
+     .type = IIO_MAGN, \
+     .modified = 1, \
+     .channel2 = IIO_MOD_ ## _axis, \
+     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
+     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
+                             BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+     .scan_index = _index, \
+     .scan_type = { \
+             .sign = 's', \
+             .realbits = 14, \
+             .storagebits = 16, \
+             .shift = 2, \
+             .endianness = IIO_BE, \
+     }, \
+}
+
+static const struct iio_chan_spec kmx61_channels[] = {
+     KMX61_ACC_CHAN(X, KMX61_SCAN_ACC_X),
+     KMX61_ACC_CHAN(Y, KMX61_SCAN_ACC_Y),
+     KMX61_ACC_CHAN(Z, KMX61_SCAN_ACC_Z),
+     KMX61_MAG_CHAN(X, KMX61_SCAN_MAG_X),
+     KMX61_MAG_CHAN(Y, KMX61_SCAN_MAG_Y),
+     KMX61_MAG_CHAN(Z, KMX61_SCAN_MAG_Z),
+};
+
+static int kmx61_convert_freq_to_bit(int val, int val2)
+{
+     int i;
+
+     for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+             if (val == samp_freq_table[i].val &&
+                 val2 == samp_freq_table[i].val2)
+                     return samp_freq_table[i].odr_bits;
+     return -EINVAL;
+}
+
+static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading reg_stby\n");
+             return ret;
+     }
+     if (device & KMX61_ACC) {
+             if (mode & KMX61_ACC_STBY_BIT)
+                     ret |= KMX61_ACC_STBY_BIT;
+             else
+                     ret &= ~KMX61_ACC_STBY_BIT;
+     }
+
+     if (device & KMX61_MAG) {
+             if (mode & KMX61_MAG_STBY_BIT)
+                     ret |= KMX61_MAG_STBY_BIT;
+             else
+                     ret &= ~KMX61_MAG_STBY_BIT;
+     }
+
+     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error writing reg_stby\n");
+             return ret;
+     }
+
+     return ret;
+}
+
+static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading reg_stby\n");
+             return ret;
+     }
+     *mode = 0;
+
+     if (device & KMX61_ACC) {
+             if (ret & KMX61_ACC_STBY_BIT)
+                     *mode |= KMX61_ACC_STBY_BIT;
+             else
+                     *mode &= ~KMX61_ACC_STBY_BIT;
+     }
+
+     if (device & KMX61_MAG) {
+             if (ret & KMX61_MAG_STBY_BIT)
+                     *mode |= KMX61_MAG_STBY_BIT;
+             else
+                     *mode &= ~KMX61_MAG_STBY_BIT;
+     }
+
+     return 0;
+}
+
+static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
+{
+     int ret;
+     u8 mode;
+     int lodr_bits, odr_bits;
+
+     ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     lodr_bits = kmx61_convert_freq_to_bit(val, val2);
+     if (lodr_bits < 0)
+             return lodr_bits;
+
+     /* To change ODR, accel and magn must be in STDBY */
+     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     odr_bits = 0;
+     if (device & KMX61_ACC)
+             odr_bits |= lodr_bits;
+     if (device & KMX61_MAG)
+             odr_bits |= (lodr_bits << KMX61_MAG_ODR_SHIFT);
+
+     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
+                                     odr_bits);
+     if (ret < 0)
+             return ret;
+
+     ret = kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     data->odr_bits = lodr_bits;
+
+     return 0;
+}
+
+static
+int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2, u8 device)
+{    int i;
+     u8 lodr_bits;
+
+     if (device & KMX61_ACC)
+             lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
+                          KMX61_ACC_ODR_MASK;
+     else if (device & KMX61_MAG)
+             lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
+                          KMX61_MAG_ODR_MASK;
+     else
+             return -EINVAL;
+
+     for (i = 0; i < ARRAY_SIZE(samp_freq_table); i++)
+             if (lodr_bits == samp_freq_table[i].odr_bits) {
+                     *val = samp_freq_table[i].val;
+                     *val2 = samp_freq_table[i].val2;
+                     return 0;
+             }
+     return -EINVAL;
+}
+
+static int kmx61_set_range(struct kmx61_data *data, int range)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
+             return ret;
+     }
+
+     ret &= ~(KMX61_REG_CTRL1_GSEL0_MASK | KMX61_REG_CTRL1_GSEL1_MASK);
+     ret |= kmx61_scale_table[range].gsel0 << KMX61_REG_CTRL1_GSEL0_SHIFT;
+     ret |= kmx61_scale_table[range].gsel1 << KMX61_REG_CTRL1_GSEL1_SHIFT;
+
+     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
+             return ret;
+     }
+
+     data->range = range;
+
+     return 0;
+}
+
+static int kmx61_set_scale(struct kmx61_data *data, int val)
+{
+     int ret, i;
+     u8  mode;
+
+     for (i = 0; i < ARRAY_SIZE(kmx61_scale_table); i++) {
+             if (kmx61_scale_table[i].scale == val) {
+                     ret = kmx61_get_mode(data, &mode,
+                                          KMX61_ACC | KMX61_MAG);
+                     if (ret < 0)
+                             return ret;
+
+                     ret = kmx61_set_mode(data, KMX61_ALL_STBY,
+                                          KMX61_ACC | KMX61_MAG);
+                     if (ret < 0)
+                             return ret;
+
Quoted 8 lines

drivers/iio/imu/kmx61.c line 362

Quoted 6 lines
drivers/iio/imu/kmx61.c new file +6 -0
+                     ret = kmx61_set_range(data, i);
+                     if (ret < 0)
+                             return ret;
+
+                     ret = kmx61_set_mode(data, mode,
+                                          KMX61_ACC | KMX61_MAG);

simply return here

Agree. Will fix.

Quoted 61 lines
Quoted 61 lines
drivers/iio/imu/kmx61.c new file +60 -0
+                     if (ret < 0)
+                             return ret;
+
+                     return 0;
+             }
+     }
+     return -EINVAL;
+}
+
+static int kmx61_chip_init(struct kmx61_data *data)
+{
+     int ret;
+
+     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "Error reading who_am_i\n");
+             return ret;
+     }
+
+     if (ret != KMX61_CHIP_ID) {
+             dev_err(&data->client->dev,
+                     "Wrong chip id, got %x expected %x\n",
+                      ret, KMX61_CHIP_ID);
+             return -EINVAL;
+     }
+
+     /* set accel 12bit, 4g range */
+     ret = kmx61_set_range(data, KMX61_RANGE_4G);
+     if (ret < 0)
+             return ret;
+
+     /* put accel and magnetometer in operating mode */
+     ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG);
+     if (ret < 0)
+             return ret;
+
+     return 0;
+}
+
+static int kmx61_read_measurement(struct kmx61_data *data, int base, int offset)
+{
+     int ret;
+     u8 reg = base + offset * 2;
+
+     ret = i2c_smbus_read_word_data(data->client, reg);
+     if (ret < 0) {
+             dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
+             return ret;
+     }
+
+     return ret;
+}
+
+static int kmx61_read_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan, int *val,
+                           int *val2, long mask)
+{
+     struct kmx61_data *data = iio_priv(indio_dev);
+     int ret;
+     u8 base_reg;
Quoted 8 lines

drivers/iio/imu/kmx61.c line 428

Quoted 6 lines
drivers/iio/imu/kmx61.c new file +6 -0
+     u8 device;
+
+     switch (mask) {
+     case IIO_CHAN_INFO_RAW:
+             switch (chan->type) {
+             case IIO_ACCEL: case IIO_MAGN:

cases on separate lines would be more readable

Ok.

Quoted 130 lines
Quoted 14 lines
drivers/iio/imu/kmx61.c new file +13 -0
+                     base_reg = KMX61_ACC_XOUT_L;
+                     break;
+             default:
+                     return -EINVAL;
+             }
+             ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
+             if (ret < 0)
+                     return ret;
+             *val = sign_extend32(ret >> chan->scan_type.shift,
+                                  chan->scan_type.realbits - 1);
+             return IIO_VAL_INT;
+     case IIO_CHAN_INFO_SCALE:
+             switch (chan->type) {

drivers/iio/imu/kmx61.c line 451

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+             case IIO_ACCEL:
+                     *val = 0;
+                     *val2 = kmx61_scale_table[data->range].scale;
+                     return IIO_VAL_INT_PLUS_MICRO;
+             case IIO_MAGN:
+                     /* 14 bits res, 1465 microGauss per magn count */
+                     *val = 0;
+                     *val2 = 1465;
+                     return IIO_VAL_INT_PLUS_MICRO;
+             default:

could just return -EINVAL here

Quoted 24 lines
drivers/iio/imu/kmx61.c new file +24 -0
+                     break;
+             }
+     case IIO_CHAN_INFO_SAMP_FREQ:
+             switch (chan->type) {
+             case IIO_ACCEL:
+                     device = KMX61_ACC;
+                     break;
+             case IIO_MAGN:
+                     device = KMX61_MAG;
+                     break;
+             default:
+                     return -EINVAL;
+             }
+
+             mutex_lock(&data->lock);
+             ret = kmx61_get_odr(data, val, val2, device);
+             mutex_unlock(&data->lock);
+             if (ret)
+                     return -EINVAL;
+             return IIO_VAL_INT_PLUS_MICRO;
+     }
+     return -EINVAL;
+}
+

drivers/iio/imu/kmx61.c line 485

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+static int kmx61_write_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan, int val,
+                            int val2, long mask)
+{
+     struct kmx61_data *data = iio_priv(indio_dev);
+     int ret;
+     u8 device;
+
+     switch (mask) {
+     case IIO_CHAN_INFO_SAMP_FREQ:

you could use chan->address to store the device type (ACC or MAG) and save the switch block (here and in other places)

drivers/iio/imu/kmx61.c line 498

Quoted 13 lines
drivers/iio/imu/kmx61.c new file +13 -0
+             switch (chan->type) {
+             case IIO_ACCEL:
+                     device = KMX61_ACC;
+                     break;
+             case IIO_MAGN:
+                     device = KMX61_MAG;
+                     break;
+             default:
+                     return -EINVAL;
+             }
+             mutex_lock(&data->lock);
+             ret = kmx61_set_odr(data, val, val2, device);
+             mutex_unlock(&data->lock);

follow edits are a matter of taste :)

return ret;

drivers/iio/imu/kmx61.c line 508

Quoted 10 lines
drivers/iio/imu/kmx61.c new file +10 -0
+             break;
+     case IIO_CHAN_INFO_SCALE:
+             switch (chan->type) {
+             case IIO_ACCEL:
+                     mutex_lock(&data->lock);
+                     ret = kmx61_set_scale(data, val2);
+                     mutex_unlock(&data->lock);
+                     break;
+             default:
+                     ret  = -EINVAL;

return -EINVAL

drivers/iio/imu/kmx61.c line 509

Quoted 1 line
drivers/iio/imu/kmx61.c new file +1 -0
+             }

return ret;

drivers/iio/imu/kmx61.c line 511

Quoted 2 lines
drivers/iio/imu/kmx61.c new file +2 -0
+             break;
+     default:

return -EINVAL;

Quoted 24 lines
drivers/iio/imu/kmx61.c new file +24 -0
+             ret = -EINVAL;
+     }
+
+     return ret;
+}
+
+static const struct iio_info kmx61_info = {
+     .driver_module          = THIS_MODULE,
+     .read_raw               = kmx61_read_raw,
+     .write_raw              = kmx61_write_raw,
+     .attrs                  = &kmx61_attribute_group,
+};
+
+static int kmx61_probe(struct i2c_client *client,
+                    const struct i2c_device_id *id)
+{
+     struct kmx61_data *data;
+     struct iio_dev *indio_dev;
+     int ret;
+
+     indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+     if (!indio_dev)
+             return -ENOMEM;
+
Quoted 8 lines

drivers/iio/imu/kmx61.c line 541

Quoted 6 lines
drivers/iio/imu/kmx61.c new file +6 -0
+     data = iio_priv(indio_dev);
+     i2c_set_clientdata(client, indio_dev);
+     data->client = client;
+
+     indio_dev->dev.parent = &client->dev;
+     indio_dev->info = &kmx61_info;

set indio_dev->name?

Will fix. What is this used for anyway? :)

Quoted 43 lines
Quoted 43 lines
drivers/iio/imu/kmx61.c new file +42 -0
+     indio_dev->channels = kmx61_channels;
+     indio_dev->num_channels = ARRAY_SIZE(kmx61_channels);
+     indio_dev->modes = INDIO_DIRECT_MODE;
+
+     mutex_init(&data->lock);
+
+     ret = kmx61_chip_init(data);
+     if (ret < 0)
+             return ret;
+
+     return iio_device_register(indio_dev);
+}
+
+static int kmx61_remove(struct i2c_client *client)
+{
+     struct iio_dev *indio_dev = i2c_get_clientdata(client);
+     struct kmx61_data *data = iio_priv(indio_dev);
+     int ret;
+
+     iio_device_unregister(indio_dev);
+
+     mutex_lock(&data->lock);
+     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG);
+     mutex_unlock(&data->lock);
+
+     return ret;
+}
+
+static const struct i2c_device_id kmx61_id[] = {
+     {"kmx61", 0},
+     {}
+};
+
+MODULE_DEVICE_TABLE(i2c, kmx61_id);
+
+static struct i2c_driver kmx61_driver = {
+     .driver = {
+             .name = "kmx61",
+     },
+     .probe          = kmx61_probe,
+     .remove         = kmx61_remove,
+     .id_table       = kmx61_id,
Quoted 8 lines

drivers/iio/imu/kmx61.c line 590

Quoted 8 lines
drivers/iio/imu/kmx61.c new file +7 -0
+};
+
+module_i2c_driver(kmx61_driver);
+
+MODULE_AUTHOR("Daniel Baluta <[email protected]>");
+MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
+MODULE_LICENSE("GPL v2");

Thanks a lot Peter!

Daniel.