All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH v2 0/6] iio: bmg160: Add SPI connection
@ 2015-08-04 11:02 Markus Pargmann
  2015-08-04 11:02 ` [PATCH v2 1/6] iio: bmg160: Use i2c regmap instead of direct i2c access Markus Pargmann
                   ` (6 more replies)
  0 siblings, 7 replies; 12+ messages in thread
From: Markus Pargmann @ 2015-08-04 11:02 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel, Markus Pargmann

Hi,

bmg160 and bmi055 can be used via I2C and SPI. This series converts the driver
to regmap and splits core driver and I2C/SPI.

Changes in v2:
 - Added the id->name from the SPI driver to be used as iio device name
 - Fixed Kconfig in patch 2 to add selects for REGMAP_I2C
 - Fixed regmap configs to be static const

Best regards,

Markus


Markus Pargmann (6):
  iio: bmg160: Use i2c regmap instead of direct i2c access
  iio: bmg160: Remove i2c_client from data struct
  iio: bmg160: Use generic dev_drvdata
  iio: bmg160: Remove remaining uses of i2c_client
  iio: bmg160: Separate i2c and core driver
  iio: bmg160: Add SPI driver

 drivers/iio/gyro/Kconfig                     |  29 ++-
 drivers/iio/gyro/Makefile                    |   4 +-
 drivers/iio/gyro/bmg160.h                    |  10 +
 drivers/iio/gyro/{bmg160.c => bmg160_core.c} | 356 +++++++++++----------------
 drivers/iio/gyro/bmg160_i2c.c                |  73 ++++++
 drivers/iio/gyro/bmg160_spi.c                |  60 +++++
 6 files changed, 311 insertions(+), 221 deletions(-)
 create mode 100644 drivers/iio/gyro/bmg160.h
 rename drivers/iio/gyro/{bmg160.c => bmg160_core.c} (74%)
 create mode 100644 drivers/iio/gyro/bmg160_i2c.c
 create mode 100644 drivers/iio/gyro/bmg160_spi.c

-- 
2.1.4


^ permalink raw reply	[flat|nested] 12+ messages in thread
* [PATCH v2 1/6] iio: bmg160: Use i2c regmap instead of direct i2c access
  2015-08-04 11:02 [PATCH v2 0/6] iio: bmg160: Add SPI connection Markus Pargmann
@ 2015-08-04 11:02 ` Markus Pargmann
  2015-08-09  6:47   ` Markus Pargmann
  2015-08-04 11:02 ` [PATCH v2 2/6] iio: bmg160: Remove i2c_client from data struct Markus Pargmann
                   ` (5 subsequent siblings)
  6 siblings, 1 reply; 12+ messages in thread
From: Markus Pargmann @ 2015-08-04 11:02 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel, Markus Pargmann

This patch introduces regmap usage into the driver. This is done to
later easily support the SPI interface of this chip.

Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
---
 drivers/iio/gyro/Kconfig  |   2 +
 drivers/iio/gyro/bmg160.c | 200 +++++++++++++++++++++-------------------------
 2 files changed, 91 insertions(+), 111 deletions(-)

diff --git a/drivers/iio/gyro/Kconfig b/drivers/iio/gyro/Kconfig
index 8d2439345673..b44984b3bb24 100644
--- a/drivers/iio/gyro/Kconfig
+++ b/drivers/iio/gyro/Kconfig
@@ -55,6 +55,8 @@ config BMG160
 	depends on I2C
 	select IIO_BUFFER
 	select IIO_TRIGGERED_BUFFER
+	select REGMAP
+	select REGMAP_I2C
 	help
 	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
 	  driver. This driver also supports BMI055 gyroscope.
diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160.c
index 460bf715d541..626f5c98dde8 100644
--- a/drivers/iio/gyro/bmg160.c
+++ b/drivers/iio/gyro/bmg160.c
@@ -28,6 +28,7 @@
 #include <linux/iio/events.h>
 #include <linux/iio/trigger_consumer.h>
 #include <linux/iio/triggered_buffer.h>
+#include <linux/regmap.h>
 
 #define BMG160_DRV_NAME		"bmg160"
 #define BMG160_IRQ_NAME		"bmg160_event"
@@ -98,6 +99,7 @@
 
 struct bmg160_data {
 	struct i2c_client *client;
+	struct regmap *regmap;
 	struct iio_trigger *dready_trig;
 	struct iio_trigger *motion_trig;
 	struct mutex mutex;
@@ -134,12 +136,19 @@ static const struct {
 			   { 133, BMG160_RANGE_250DPS},
 			   { 66, BMG160_RANGE_125DPS} };
 
+struct regmap_config bmg160_regmap_i2c_conf = {
+	.reg_bits = 8,
+	.val_bits = 8,
+
+	.use_single_rw = true,
+	.cache_type = REGCACHE_NONE,
+};
+
 static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
 {
 	int ret;
 
-	ret = i2c_smbus_write_byte_data(data->client,
-					BMG160_REG_PMU_LPW, mode);
+	ret = regmap_write(data->regmap, BMG160_REG_PMU_LPW, mode);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_pmu_lpw\n");
 		return ret;
@@ -169,8 +178,7 @@ static int bmg160_set_bw(struct bmg160_data *data, int val)
 	if (bw_bits < 0)
 		return bw_bits;
 
-	ret = i2c_smbus_write_byte_data(data->client, BMG160_REG_PMU_BW,
-					bw_bits);
+	ret = regmap_write(data->regmap, BMG160_REG_PMU_BW, bw_bits);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_pmu_bw\n");
 		return ret;
@@ -184,16 +192,17 @@ static int bmg160_set_bw(struct bmg160_data *data, int val)
 static int bmg160_chip_init(struct bmg160_data *data)
 {
 	int ret;
+	unsigned int val;
 
-	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_CHIP_ID);
+	ret = regmap_read(data->regmap, BMG160_REG_CHIP_ID, &val);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_chip_id\n");
 		return ret;
 	}
 
-	dev_dbg(&data->client->dev, "Chip Id %x\n", ret);
-	if (ret != BMG160_CHIP_ID_VAL) {
-		dev_err(&data->client->dev, "invalid chip %x\n", ret);
+	dev_dbg(&data->client->dev, "Chip Id %x\n", val);
+	if (val != BMG160_CHIP_ID_VAL) {
+		dev_err(&data->client->dev, "invalid chip %x\n", val);
 		return -ENODEV;
 	}
 
@@ -210,40 +219,31 @@ static int bmg160_chip_init(struct bmg160_data *data)
 		return ret;
 
 	/* Set Default Range */
-	ret = i2c_smbus_write_byte_data(data->client,
-					BMG160_REG_RANGE,
-					BMG160_RANGE_500DPS);
+	ret = regmap_write(data->regmap, BMG160_REG_RANGE, BMG160_RANGE_500DPS);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_range\n");
 		return ret;
 	}
 	data->dps_range = BMG160_RANGE_500DPS;
 
-	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_SLOPE_THRES);
+	ret = regmap_read(data->regmap, BMG160_REG_SLOPE_THRES, &val);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_slope_thres\n");
 		return ret;
 	}
-	data->slope_thres = ret;
+	data->slope_thres = val;
 
 	/* Set default interrupt mode */
-	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_EN_1);
-	if (ret < 0) {
-		dev_err(&data->client->dev, "Error reading reg_int_en_1\n");
-		return ret;
-	}
-	ret &= ~BMG160_INT1_BIT_OD;
-	ret = i2c_smbus_write_byte_data(data->client,
-					BMG160_REG_INT_EN_1, ret);
+	ret = regmap_update_bits(data->regmap, BMG160_REG_INT_EN_1,
+				 BMG160_INT1_BIT_OD, 0);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error writing reg_int_en_1\n");
+		dev_err(&data->client->dev, "Error updating bits in reg_int_en_1\n");
 		return ret;
 	}
 
-	ret = i2c_smbus_write_byte_data(data->client,
-					BMG160_REG_INT_RST_LATCH,
-					BMG160_INT_MODE_LATCH_INT |
-					BMG160_INT_MODE_LATCH_RESET);
+	ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
+			   BMG160_INT_MODE_LATCH_INT |
+			   BMG160_INT_MODE_LATCH_RESET);
 	if (ret < 0) {
 		dev_err(&data->client->dev,
 			"Error writing reg_motion_intr\n");
@@ -284,41 +284,28 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 	int ret;
 
 	/* Enable/Disable INT_MAP0 mapping */
-	ret = i2c_smbus_read_byte_data(data->client,  BMG160_REG_INT_MAP_0);
-	if (ret < 0) {
-		dev_err(&data->client->dev, "Error reading reg_int_map0\n");
-		return ret;
-	}
-	if (status)
-		ret |= BMG160_INT_MAP_0_BIT_ANY;
-	else
-		ret &= ~BMG160_INT_MAP_0_BIT_ANY;
-
-	ret = i2c_smbus_write_byte_data(data->client,
-					BMG160_REG_INT_MAP_0,
-					ret);
+	ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_0,
+				 BMG160_INT_MAP_0_BIT_ANY,
+				 (status ? BMG160_INT_MAP_0_BIT_ANY : 0));
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error writing reg_int_map0\n");
+		dev_err(&data->client->dev, "Error updating bits reg_int_map0\n");
 		return ret;
 	}
 
 	/* Enable/Disable slope interrupts */
 	if (status) {
 		/* Update slope thres */
-		ret = i2c_smbus_write_byte_data(data->client,
-						BMG160_REG_SLOPE_THRES,
-						data->slope_thres);
+		ret = regmap_write(data->regmap, BMG160_REG_SLOPE_THRES,
+				   data->slope_thres);
 		if (ret < 0) {
 			dev_err(&data->client->dev,
 				"Error writing reg_slope_thres\n");
 			return ret;
 		}
 
-		ret = i2c_smbus_write_byte_data(data->client,
-						BMG160_REG_MOTION_INTR,
-						BMG160_INT_MOTION_X |
-						BMG160_INT_MOTION_Y |
-						BMG160_INT_MOTION_Z);
+		ret = regmap_write(data->regmap, BMG160_REG_MOTION_INTR,
+				   BMG160_INT_MOTION_X | BMG160_INT_MOTION_Y |
+				   BMG160_INT_MOTION_Z);
 		if (ret < 0) {
 			dev_err(&data->client->dev,
 				"Error writing reg_motion_intr\n");
@@ -331,10 +318,10 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 		 * to set latched mode, we will be flooded anyway with INTR
 		 */
 		if (!data->dready_trigger_on) {
-			ret = i2c_smbus_write_byte_data(data->client,
-						BMG160_REG_INT_RST_LATCH,
-						BMG160_INT_MODE_LATCH_INT |
-						BMG160_INT_MODE_LATCH_RESET);
+			ret = regmap_write(data->regmap,
+					   BMG160_REG_INT_RST_LATCH,
+					   BMG160_INT_MODE_LATCH_INT |
+					   BMG160_INT_MODE_LATCH_RESET);
 			if (ret < 0) {
 				dev_err(&data->client->dev,
 					"Error writing reg_rst_latch\n");
@@ -342,14 +329,12 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 			}
 		}
 
-		ret = i2c_smbus_write_byte_data(data->client,
-						BMG160_REG_INT_EN_0,
-						BMG160_DATA_ENABLE_INT);
+		ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
+				   BMG160_DATA_ENABLE_INT);
 
-	} else
-		ret = i2c_smbus_write_byte_data(data->client,
-						BMG160_REG_INT_EN_0,
-						0);
+	} else {
+		ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
+	}
 
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_int_en0\n");
@@ -365,55 +350,39 @@ static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
 	int ret;
 
 	/* Enable/Disable INT_MAP1 mapping */
-	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_MAP_1);
-	if (ret < 0) {
-		dev_err(&data->client->dev, "Error reading reg_int_map1\n");
-		return ret;
-	}
-
-	if (status)
-		ret |= BMG160_INT_MAP_1_BIT_NEW_DATA;
-	else
-		ret &= ~BMG160_INT_MAP_1_BIT_NEW_DATA;
-
-	ret = i2c_smbus_write_byte_data(data->client,
-					BMG160_REG_INT_MAP_1,
-					ret);
+	ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_1,
+				 BMG160_INT_MAP_1_BIT_NEW_DATA,
+				 (status ? BMG160_INT_MAP_1_BIT_NEW_DATA : 0));
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error writing reg_int_map1\n");
+		dev_err(&data->client->dev, "Error updating bits in reg_int_map1\n");
 		return ret;
 	}
 
 	if (status) {
-		ret = i2c_smbus_write_byte_data(data->client,
-						BMG160_REG_INT_RST_LATCH,
-						BMG160_INT_MODE_NON_LATCH_INT |
-						BMG160_INT_MODE_LATCH_RESET);
+		ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
+				   BMG160_INT_MODE_NON_LATCH_INT |
+				   BMG160_INT_MODE_LATCH_RESET);
 		if (ret < 0) {
 			dev_err(&data->client->dev,
 				"Error writing reg_rst_latch\n");
 				return ret;
 		}
 
-		ret = i2c_smbus_write_byte_data(data->client,
-						BMG160_REG_INT_EN_0,
-						BMG160_DATA_ENABLE_INT);
+		ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
+				   BMG160_DATA_ENABLE_INT);
 
 	} else {
 		/* Restore interrupt mode */
-		ret = i2c_smbus_write_byte_data(data->client,
-						BMG160_REG_INT_RST_LATCH,
-						BMG160_INT_MODE_LATCH_INT |
-						BMG160_INT_MODE_LATCH_RESET);
+		ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
+				   BMG160_INT_MODE_LATCH_INT |
+				   BMG160_INT_MODE_LATCH_RESET);
 		if (ret < 0) {
 			dev_err(&data->client->dev,
 				"Error writing reg_rst_latch\n");
 				return ret;
 		}
 
-		ret = i2c_smbus_write_byte_data(data->client,
-						BMG160_REG_INT_EN_0,
-						0);
+		ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
 	}
 
 	if (ret < 0) {
@@ -444,10 +413,8 @@ static int bmg160_set_scale(struct bmg160_data *data, int val)
 
 	for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
 		if (bmg160_scale_table[i].scale == val) {
-			ret = i2c_smbus_write_byte_data(
-					data->client,
-					BMG160_REG_RANGE,
-					bmg160_scale_table[i].dps_range);
+			ret = regmap_write(data->regmap, BMG160_REG_RANGE,
+					   bmg160_scale_table[i].dps_range);
 			if (ret < 0) {
 				dev_err(&data->client->dev,
 					"Error writing reg_range\n");
@@ -464,6 +431,7 @@ static int bmg160_set_scale(struct bmg160_data *data, int val)
 static int bmg160_get_temp(struct bmg160_data *data, int *val)
 {
 	int ret;
+	unsigned int raw_val;
 
 	mutex_lock(&data->mutex);
 	ret = bmg160_set_power_state(data, true);
@@ -472,7 +440,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
 		return ret;
 	}
 
-	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_TEMP);
+	ret = regmap_read(data->regmap, BMG160_REG_TEMP, &raw_val);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_temp\n");
 		bmg160_set_power_state(data, false);
@@ -480,7 +448,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
 		return ret;
 	}
 
-	*val = sign_extend32(ret, 7);
+	*val = sign_extend32(raw_val, 7);
 	ret = bmg160_set_power_state(data, false);
 	mutex_unlock(&data->mutex);
 	if (ret < 0)
@@ -492,6 +460,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
 static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
 {
 	int ret;
+	unsigned int raw_val;
 
 	mutex_lock(&data->mutex);
 	ret = bmg160_set_power_state(data, true);
@@ -500,7 +469,8 @@ static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
 		return ret;
 	}
 
-	ret = i2c_smbus_read_word_data(data->client, BMG160_AXIS_TO_REG(axis));
+	ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(axis), &raw_val,
+			       2);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading axis %d\n", axis);
 		bmg160_set_power_state(data, false);
@@ -508,7 +478,7 @@ static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
 		return ret;
 	}
 
-	*val = sign_extend32(ret, 15);
+	*val = sign_extend32(raw_val, 15);
 	ret = bmg160_set_power_state(data, false);
 	mutex_unlock(&data->mutex);
 	if (ret < 0)
@@ -807,12 +777,13 @@ static irqreturn_t bmg160_trigger_handler(int irq, void *p)
 	struct iio_dev *indio_dev = pf->indio_dev;
 	struct bmg160_data *data = iio_priv(indio_dev);
 	int bit, ret, i = 0;
+	unsigned int val;
 
 	mutex_lock(&data->mutex);
 	for_each_set_bit(bit, indio_dev->active_scan_mask,
 			 indio_dev->masklength) {
-		ret = i2c_smbus_read_word_data(data->client,
-					       BMG160_AXIS_TO_REG(bit));
+		ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(bit),
+				       &val, 2);
 		if (ret < 0) {
 			mutex_unlock(&data->mutex);
 			goto err;
@@ -840,10 +811,9 @@ static int bmg160_trig_try_reen(struct iio_trigger *trig)
 		return 0;
 
 	/* Set latched mode interrupt and clear any latched interrupt */
-	ret = i2c_smbus_write_byte_data(data->client,
-					BMG160_REG_INT_RST_LATCH,
-					BMG160_INT_MODE_LATCH_INT |
-					BMG160_INT_MODE_LATCH_RESET);
+	ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
+			   BMG160_INT_MODE_LATCH_INT |
+			   BMG160_INT_MODE_LATCH_RESET);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error writing reg_rst_latch\n");
 		return ret;
@@ -907,33 +877,34 @@ static irqreturn_t bmg160_event_handler(int irq, void *private)
 	struct bmg160_data *data = iio_priv(indio_dev);
 	int ret;
 	int dir;
+	unsigned int val;
 
-	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_STATUS_2);
+	ret = regmap_read(data->regmap, BMG160_REG_INT_STATUS_2, &val);
 	if (ret < 0) {
 		dev_err(&data->client->dev, "Error reading reg_int_status2\n");
 		goto ack_intr_status;
 	}
 
-	if (ret & 0x08)
+	if (val & 0x08)
 		dir = IIO_EV_DIR_RISING;
 	else
 		dir = IIO_EV_DIR_FALLING;
 
-	if (ret & BMG160_ANY_MOTION_BIT_X)
+	if (val & BMG160_ANY_MOTION_BIT_X)
 		iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
 							0,
 							IIO_MOD_X,
 							IIO_EV_TYPE_ROC,
 							dir),
 							iio_get_time_ns());
-	if (ret & BMG160_ANY_MOTION_BIT_Y)
+	if (val & BMG160_ANY_MOTION_BIT_Y)
 		iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
 							0,
 							IIO_MOD_Y,
 							IIO_EV_TYPE_ROC,
 							dir),
 							iio_get_time_ns());
-	if (ret & BMG160_ANY_MOTION_BIT_Z)
+	if (val & BMG160_ANY_MOTION_BIT_Z)
 		iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
 							0,
 							IIO_MOD_Z,
@@ -943,10 +914,9 @@ static irqreturn_t bmg160_event_handler(int irq, void *private)
 
 ack_intr_status:
 	if (!data->dready_trigger_on) {
-		ret = i2c_smbus_write_byte_data(data->client,
-					BMG160_REG_INT_RST_LATCH,
-					BMG160_INT_MODE_LATCH_INT |
-					BMG160_INT_MODE_LATCH_RESET);
+		ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
+				   BMG160_INT_MODE_LATCH_INT |
+				   BMG160_INT_MODE_LATCH_RESET);
 		if (ret < 0)
 			dev_err(&data->client->dev,
 				"Error writing reg_rst_latch\n");
@@ -1038,6 +1008,14 @@ static int bmg160_probe(struct i2c_client *client,
 	struct iio_dev *indio_dev;
 	int ret;
 	const char *name = NULL;
+	struct regmap *regmap;
+
+	regmap = devm_regmap_init_i2c(client, &bmg160_regmap_i2c_conf);
+	if (IS_ERR(regmap)) {
+		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
+			(int)PTR_ERR(regmap));
+		return PTR_ERR(regmap);
+	}
 
 	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 	if (!indio_dev)
-- 
2.1.4


^ permalink raw reply related	[flat|nested] 12+ messages in thread
* [PATCH v2 2/6] iio: bmg160: Remove i2c_client from data struct
  2015-08-04 11:02 [PATCH v2 0/6] iio: bmg160: Add SPI connection Markus Pargmann
  2015-08-04 11:02 ` [PATCH v2 1/6] iio: bmg160: Use i2c regmap instead of direct i2c access Markus Pargmann
@ 2015-08-04 11:02 ` Markus Pargmann
  2015-08-04 11:02 ` [PATCH v2 3/6] iio: bmg160: Use generic dev_drvdata Markus Pargmann
                   ` (4 subsequent siblings)
  6 siblings, 0 replies; 12+ messages in thread
From: Markus Pargmann @ 2015-08-04 11:02 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel, Markus Pargmann

i2c_client variable is not really used anymore in the core driver. It is
only used to get the device to make proper outputs.

This patch replaces all i2c_client usage through direct usage of the
device pointer.

Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
---
 drivers/iio/gyro/bmg160.c | 64 +++++++++++++++++++++++------------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160.c
index 626f5c98dde8..71c605ea85ad 100644
--- a/drivers/iio/gyro/bmg160.c
+++ b/drivers/iio/gyro/bmg160.c
@@ -98,7 +98,7 @@
 #define BMG160_AUTO_SUSPEND_DELAY_MS	2000
 
 struct bmg160_data {
-	struct i2c_client *client;
+	struct device *dev;
 	struct regmap *regmap;
 	struct iio_trigger *dready_trig;
 	struct iio_trigger *motion_trig;
@@ -150,7 +150,7 @@ static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
 
 	ret = regmap_write(data->regmap, BMG160_REG_PMU_LPW, mode);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error writing reg_pmu_lpw\n");
+		dev_err(data->dev, "Error writing reg_pmu_lpw\n");
 		return ret;
 	}
 
@@ -180,7 +180,7 @@ static int bmg160_set_bw(struct bmg160_data *data, int val)
 
 	ret = regmap_write(data->regmap, BMG160_REG_PMU_BW, bw_bits);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error writing reg_pmu_bw\n");
+		dev_err(data->dev, "Error writing reg_pmu_bw\n");
 		return ret;
 	}
 
@@ -196,13 +196,13 @@ static int bmg160_chip_init(struct bmg160_data *data)
 
 	ret = regmap_read(data->regmap, BMG160_REG_CHIP_ID, &val);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error reading reg_chip_id\n");
+		dev_err(data->dev, "Error reading reg_chip_id\n");
 		return ret;
 	}
 
-	dev_dbg(&data->client->dev, "Chip Id %x\n", val);
+	dev_dbg(data->dev, "Chip Id %x\n", val);
 	if (val != BMG160_CHIP_ID_VAL) {
-		dev_err(&data->client->dev, "invalid chip %x\n", val);
+		dev_err(data->dev, "invalid chip %x\n", val);
 		return -ENODEV;
 	}
 
@@ -221,14 +221,14 @@ static int bmg160_chip_init(struct bmg160_data *data)
 	/* Set Default Range */
 	ret = regmap_write(data->regmap, BMG160_REG_RANGE, BMG160_RANGE_500DPS);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error writing reg_range\n");
+		dev_err(data->dev, "Error writing reg_range\n");
 		return ret;
 	}
 	data->dps_range = BMG160_RANGE_500DPS;
 
 	ret = regmap_read(data->regmap, BMG160_REG_SLOPE_THRES, &val);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error reading reg_slope_thres\n");
+		dev_err(data->dev, "Error reading reg_slope_thres\n");
 		return ret;
 	}
 	data->slope_thres = val;
@@ -237,7 +237,7 @@ static int bmg160_chip_init(struct bmg160_data *data)
 	ret = regmap_update_bits(data->regmap, BMG160_REG_INT_EN_1,
 				 BMG160_INT1_BIT_OD, 0);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error updating bits in reg_int_en_1\n");
+		dev_err(data->dev, "Error updating bits in reg_int_en_1\n");
 		return ret;
 	}
 
@@ -245,7 +245,7 @@ static int bmg160_chip_init(struct bmg160_data *data)
 			   BMG160_INT_MODE_LATCH_INT |
 			   BMG160_INT_MODE_LATCH_RESET);
 	if (ret < 0) {
-		dev_err(&data->client->dev,
+		dev_err(data->dev,
 			"Error writing reg_motion_intr\n");
 		return ret;
 	}
@@ -259,17 +259,17 @@ static int bmg160_set_power_state(struct bmg160_data *data, bool on)
 	int ret;
 
 	if (on)
-		ret = pm_runtime_get_sync(&data->client->dev);
+		ret = pm_runtime_get_sync(data->dev);
 	else {
-		pm_runtime_mark_last_busy(&data->client->dev);
-		ret = pm_runtime_put_autosuspend(&data->client->dev);
+		pm_runtime_mark_last_busy(data->dev);
+		ret = pm_runtime_put_autosuspend(data->dev);
 	}
 
 	if (ret < 0) {
-		dev_err(&data->client->dev,
+		dev_err(data->dev,
 			"Failed: bmg160_set_power_state for %d\n", on);
 		if (on)
-			pm_runtime_put_noidle(&data->client->dev);
+			pm_runtime_put_noidle(data->dev);
 
 		return ret;
 	}
@@ -288,7 +288,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 				 BMG160_INT_MAP_0_BIT_ANY,
 				 (status ? BMG160_INT_MAP_0_BIT_ANY : 0));
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error updating bits reg_int_map0\n");
+		dev_err(data->dev, "Error updating bits reg_int_map0\n");
 		return ret;
 	}
 
@@ -298,7 +298,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 		ret = regmap_write(data->regmap, BMG160_REG_SLOPE_THRES,
 				   data->slope_thres);
 		if (ret < 0) {
-			dev_err(&data->client->dev,
+			dev_err(data->dev,
 				"Error writing reg_slope_thres\n");
 			return ret;
 		}
@@ -307,7 +307,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 				   BMG160_INT_MOTION_X | BMG160_INT_MOTION_Y |
 				   BMG160_INT_MOTION_Z);
 		if (ret < 0) {
-			dev_err(&data->client->dev,
+			dev_err(data->dev,
 				"Error writing reg_motion_intr\n");
 			return ret;
 		}
@@ -323,7 +323,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 					   BMG160_INT_MODE_LATCH_INT |
 					   BMG160_INT_MODE_LATCH_RESET);
 			if (ret < 0) {
-				dev_err(&data->client->dev,
+				dev_err(data->dev,
 					"Error writing reg_rst_latch\n");
 				return ret;
 			}
@@ -337,7 +337,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 	}
 
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error writing reg_int_en0\n");
+		dev_err(data->dev, "Error writing reg_int_en0\n");
 		return ret;
 	}
 
@@ -354,7 +354,7 @@ static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
 				 BMG160_INT_MAP_1_BIT_NEW_DATA,
 				 (status ? BMG160_INT_MAP_1_BIT_NEW_DATA : 0));
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error updating bits in reg_int_map1\n");
+		dev_err(data->dev, "Error updating bits in reg_int_map1\n");
 		return ret;
 	}
 
@@ -363,7 +363,7 @@ static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
 				   BMG160_INT_MODE_NON_LATCH_INT |
 				   BMG160_INT_MODE_LATCH_RESET);
 		if (ret < 0) {
-			dev_err(&data->client->dev,
+			dev_err(data->dev,
 				"Error writing reg_rst_latch\n");
 				return ret;
 		}
@@ -377,7 +377,7 @@ static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
 				   BMG160_INT_MODE_LATCH_INT |
 				   BMG160_INT_MODE_LATCH_RESET);
 		if (ret < 0) {
-			dev_err(&data->client->dev,
+			dev_err(data->dev,
 				"Error writing reg_rst_latch\n");
 				return ret;
 		}
@@ -386,7 +386,7 @@ static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
 	}
 
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error writing reg_int_en0\n");
+		dev_err(data->dev, "Error writing reg_int_en0\n");
 		return ret;
 	}
 
@@ -416,7 +416,7 @@ static int bmg160_set_scale(struct bmg160_data *data, int val)
 			ret = regmap_write(data->regmap, BMG160_REG_RANGE,
 					   bmg160_scale_table[i].dps_range);
 			if (ret < 0) {
-				dev_err(&data->client->dev,
+				dev_err(data->dev,
 					"Error writing reg_range\n");
 				return ret;
 			}
@@ -442,7 +442,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
 
 	ret = regmap_read(data->regmap, BMG160_REG_TEMP, &raw_val);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error reading reg_temp\n");
+		dev_err(data->dev, "Error reading reg_temp\n");
 		bmg160_set_power_state(data, false);
 		mutex_unlock(&data->mutex);
 		return ret;
@@ -472,7 +472,7 @@ static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
 	ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(axis), &raw_val,
 			       2);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error reading axis %d\n", axis);
+		dev_err(data->dev, "Error reading axis %d\n", axis);
 		bmg160_set_power_state(data, false);
 		mutex_unlock(&data->mutex);
 		return ret;
@@ -815,7 +815,7 @@ static int bmg160_trig_try_reen(struct iio_trigger *trig)
 			   BMG160_INT_MODE_LATCH_INT |
 			   BMG160_INT_MODE_LATCH_RESET);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error writing reg_rst_latch\n");
+		dev_err(data->dev, "Error writing reg_rst_latch\n");
 		return ret;
 	}
 
@@ -881,7 +881,7 @@ static irqreturn_t bmg160_event_handler(int irq, void *private)
 
 	ret = regmap_read(data->regmap, BMG160_REG_INT_STATUS_2, &val);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "Error reading reg_int_status2\n");
+		dev_err(data->dev, "Error reading reg_int_status2\n");
 		goto ack_intr_status;
 	}
 
@@ -918,7 +918,7 @@ ack_intr_status:
 				   BMG160_INT_MODE_LATCH_INT |
 				   BMG160_INT_MODE_LATCH_RESET);
 		if (ret < 0)
-			dev_err(&data->client->dev,
+			dev_err(data->dev,
 				"Error writing reg_rst_latch\n");
 	}
 
@@ -1023,7 +1023,7 @@ static int bmg160_probe(struct i2c_client *client,
 
 	data = iio_priv(indio_dev);
 	i2c_set_clientdata(client, indio_dev);
-	data->client = client;
+	data->dev = &client->dev;
 
 	ret = bmg160_chip_init(data);
 	if (ret < 0)
@@ -1190,7 +1190,7 @@ static int bmg160_runtime_suspend(struct device *dev)
 
 	ret = bmg160_set_mode(data, BMG160_MODE_SUSPEND);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "set mode failed\n");
+		dev_err(data->dev, "set mode failed\n");
 		return -EAGAIN;
 	}
 
-- 
2.1.4


^ permalink raw reply related	[flat|nested] 12+ messages in thread
* [PATCH v2 3/6] iio: bmg160: Use generic dev_drvdata
  2015-08-04 11:02 [PATCH v2 0/6] iio: bmg160: Add SPI connection Markus Pargmann
  2015-08-04 11:02 ` [PATCH v2 1/6] iio: bmg160: Use i2c regmap instead of direct i2c access Markus Pargmann
  2015-08-04 11:02 ` [PATCH v2 2/6] iio: bmg160: Remove i2c_client from data struct Markus Pargmann
@ 2015-08-04 11:02 ` Markus Pargmann
  2015-08-04 11:02 ` [PATCH v2 4/6] iio: bmg160: Remove remaining uses of i2c_client Markus Pargmann
                   ` (3 subsequent siblings)
  6 siblings, 0 replies; 12+ messages in thread
From: Markus Pargmann @ 2015-08-04 11:02 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel, Markus Pargmann

i2c_get_clientdata() is specifically for i2c. Replace it with the
generic dev_get/set_drvdata() to support different protocols.

Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
---
 drivers/iio/gyro/bmg160.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160.c
index 71c605ea85ad..b47b7af19e32 100644
--- a/drivers/iio/gyro/bmg160.c
+++ b/drivers/iio/gyro/bmg160.c
@@ -1022,7 +1022,7 @@ static int bmg160_probe(struct i2c_client *client,
 		return -ENOMEM;
 
 	data = iio_priv(indio_dev);
-	i2c_set_clientdata(client, indio_dev);
+	dev_set_drvdata(&client->dev, indio_dev);
 	data->dev = &client->dev;
 
 	ret = bmg160_chip_init(data);
@@ -1156,7 +1156,7 @@ static int bmg160_remove(struct i2c_client *client)
 #ifdef CONFIG_PM_SLEEP
 static int bmg160_suspend(struct device *dev)
 {
-	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	struct bmg160_data *data = iio_priv(indio_dev);
 
 	mutex_lock(&data->mutex);
@@ -1168,7 +1168,7 @@ static int bmg160_suspend(struct device *dev)
 
 static int bmg160_resume(struct device *dev)
 {
-	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	struct bmg160_data *data = iio_priv(indio_dev);
 
 	mutex_lock(&data->mutex);
@@ -1184,7 +1184,7 @@ static int bmg160_resume(struct device *dev)
 #ifdef CONFIG_PM
 static int bmg160_runtime_suspend(struct device *dev)
 {
-	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	struct bmg160_data *data = iio_priv(indio_dev);
 	int ret;
 
@@ -1199,7 +1199,7 @@ static int bmg160_runtime_suspend(struct device *dev)
 
 static int bmg160_runtime_resume(struct device *dev)
 {
-	struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	struct bmg160_data *data = iio_priv(indio_dev);
 	int ret;
 
-- 
2.1.4


^ permalink raw reply related	[flat|nested] 12+ messages in thread
* [PATCH v2 4/6] iio: bmg160: Remove remaining uses of i2c_client
  2015-08-04 11:02 [PATCH v2 0/6] iio: bmg160: Add SPI connection Markus Pargmann
                   ` (2 preceding siblings ...)
  2015-08-04 11:02 ` [PATCH v2 3/6] iio: bmg160: Use generic dev_drvdata Markus Pargmann
@ 2015-08-04 11:02 ` Markus Pargmann
  2015-08-04 11:02 ` [PATCH v2 5/6] iio: bmg160: Separate i2c and core driver Markus Pargmann
                   ` (2 subsequent siblings)
  6 siblings, 0 replies; 12+ messages in thread
From: Markus Pargmann @ 2015-08-04 11:02 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel, Markus Pargmann

Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
---
 drivers/iio/gyro/bmg160.c | 55 +++++++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 28 deletions(-)

diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160.c
index b47b7af19e32..865ef4c1c43f 100644
--- a/drivers/iio/gyro/bmg160.c
+++ b/drivers/iio/gyro/bmg160.c
@@ -110,6 +110,7 @@ struct bmg160_data {
 	int slope_thres;
 	bool dready_trigger_on;
 	bool motion_trigger_on;
+	int irq;
 };
 
 enum bmg160_axis {
@@ -963,18 +964,14 @@ static const struct iio_buffer_setup_ops bmg160_buffer_setup_ops = {
 	.postdisable = bmg160_buffer_postdisable,
 };
 
-static int bmg160_gpio_probe(struct i2c_client *client,
-			     struct bmg160_data *data)
+static int bmg160_gpio_probe(struct bmg160_data *data)
 
 {
 	struct device *dev;
 	struct gpio_desc *gpio;
 	int ret;
 
-	if (!client)
-		return -EINVAL;
-
-	dev = &client->dev;
+	dev = data->dev;
 
 	/* data ready gpio interrupt pin */
 	gpio = devm_gpiod_get_index(dev, BMG160_GPIO_NAME, 0, GPIOD_IN);
@@ -983,11 +980,11 @@ static int bmg160_gpio_probe(struct i2c_client *client,
 		return PTR_ERR(gpio);
 	}
 
-	ret = gpiod_to_irq(gpio);
+	data->irq = gpiod_to_irq(gpio);
 
 	dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
 
-	return ret;
+	return 0;
 }
 
 static const char *bmg160_match_acpi_device(struct device *dev)
@@ -1009,6 +1006,7 @@ static int bmg160_probe(struct i2c_client *client,
 	int ret;
 	const char *name = NULL;
 	struct regmap *regmap;
+	struct device *dev = &client->dev;
 
 	regmap = devm_regmap_init_i2c(client, &bmg160_regmap_i2c_conf);
 	if (IS_ERR(regmap)) {
@@ -1022,8 +1020,9 @@ static int bmg160_probe(struct i2c_client *client,
 		return -ENOMEM;
 
 	data = iio_priv(indio_dev);
-	dev_set_drvdata(&client->dev, indio_dev);
-	data->dev = &client->dev;
+	dev_set_drvdata(dev, indio_dev);
+	data->dev = dev;
+	data->irq = client->irq;
 
 	ret = bmg160_chip_init(data);
 	if (ret < 0)
@@ -1034,22 +1033,22 @@ static int bmg160_probe(struct i2c_client *client,
 	if (id)
 		name = id->name;
 
-	if (ACPI_HANDLE(&client->dev))
-		name = bmg160_match_acpi_device(&client->dev);
+	if (ACPI_HANDLE(dev))
+		name = bmg160_match_acpi_device(dev);
 
-	indio_dev->dev.parent = &client->dev;
+	indio_dev->dev.parent = dev;
 	indio_dev->channels = bmg160_channels;
 	indio_dev->num_channels = ARRAY_SIZE(bmg160_channels);
 	indio_dev->name = name;
 	indio_dev->modes = INDIO_DIRECT_MODE;
 	indio_dev->info = &bmg160_info;
 
-	if (client->irq <= 0)
-		client->irq = bmg160_gpio_probe(client, data);
+	if (data->irq <= 0)
+		bmg160_gpio_probe(data);
 
-	if (client->irq > 0) {
-		ret = devm_request_threaded_irq(&client->dev,
-						client->irq,
+	if (data->irq > 0) {
+		ret = devm_request_threaded_irq(dev,
+						data->irq,
 						bmg160_data_rdy_trig_poll,
 						bmg160_event_handler,
 						IRQF_TRIGGER_RISING,
@@ -1058,28 +1057,28 @@ static int bmg160_probe(struct i2c_client *client,
 		if (ret)
 			return ret;
 
-		data->dready_trig = devm_iio_trigger_alloc(&client->dev,
+		data->dready_trig = devm_iio_trigger_alloc(dev,
 							   "%s-dev%d",
 							   indio_dev->name,
 							   indio_dev->id);
 		if (!data->dready_trig)
 			return -ENOMEM;
 
-		data->motion_trig = devm_iio_trigger_alloc(&client->dev,
+		data->motion_trig = devm_iio_trigger_alloc(dev,
 							  "%s-any-motion-dev%d",
 							  indio_dev->name,
 							  indio_dev->id);
 		if (!data->motion_trig)
 			return -ENOMEM;
 
-		data->dready_trig->dev.parent = &client->dev;
+		data->dready_trig->dev.parent = dev;
 		data->dready_trig->ops = &bmg160_trigger_ops;
 		iio_trigger_set_drvdata(data->dready_trig, indio_dev);
 		ret = iio_trigger_register(data->dready_trig);
 		if (ret)
 			return ret;
 
-		data->motion_trig->dev.parent = &client->dev;
+		data->motion_trig->dev.parent = dev;
 		data->motion_trig->ops = &bmg160_trigger_ops;
 		iio_trigger_set_drvdata(data->motion_trig, indio_dev);
 		ret = iio_trigger_register(data->motion_trig);
@@ -1094,25 +1093,25 @@ static int bmg160_probe(struct i2c_client *client,
 					 bmg160_trigger_handler,
 					 &bmg160_buffer_setup_ops);
 	if (ret < 0) {
-		dev_err(&client->dev,
+		dev_err(dev,
 			"iio triggered buffer setup failed\n");
 		goto err_trigger_unregister;
 	}
 
 	ret = iio_device_register(indio_dev);
 	if (ret < 0) {
-		dev_err(&client->dev, "unable to register iio device\n");
+		dev_err(dev, "unable to register iio device\n");
 		goto err_buffer_cleanup;
 	}
 
-	ret = pm_runtime_set_active(&client->dev);
+	ret = pm_runtime_set_active(dev);
 	if (ret)
 		goto err_iio_unregister;
 
-	pm_runtime_enable(&client->dev);
-	pm_runtime_set_autosuspend_delay(&client->dev,
+	pm_runtime_enable(dev);
+	pm_runtime_set_autosuspend_delay(dev,
 					 BMG160_AUTO_SUSPEND_DELAY_MS);
-	pm_runtime_use_autosuspend(&client->dev);
+	pm_runtime_use_autosuspend(dev);
 
 	return 0;
 
-- 
2.1.4


^ permalink raw reply related	[flat|nested] 12+ messages in thread
* [PATCH v2 5/6] iio: bmg160: Separate i2c and core driver
  2015-08-04 11:02 [PATCH v2 0/6] iio: bmg160: Add SPI connection Markus Pargmann
                   ` (3 preceding siblings ...)
  2015-08-04 11:02 ` [PATCH v2 4/6] iio: bmg160: Remove remaining uses of i2c_client Markus Pargmann
@ 2015-08-04 11:02 ` Markus Pargmann
  2015-08-08 16:11   ` Jonathan Cameron
  2015-08-04 11:02 ` [PATCH v2 6/6] iio: bmg160: Add SPI driver Markus Pargmann
  2015-08-08 16:12 ` [PATCH v2 0/6] iio: bmg160: Add SPI connection Jonathan Cameron
  6 siblings, 1 reply; 12+ messages in thread
From: Markus Pargmann @ 2015-08-04 11:02 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel, Markus Pargmann

This patch separates the core driver using regmap and the i2c driver
which creates the i2c regmap. Also in the Kconfig file BMG160 and
BMG160_I2C are separate now.

Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
---
 drivers/iio/gyro/Kconfig                     | 18 +++++--
 drivers/iio/gyro/Makefile                    |  3 +-
 drivers/iio/gyro/bmg160.h                    | 10 ++++
 drivers/iio/gyro/{bmg160.c => bmg160_core.c} | 77 ++++------------------------
 drivers/iio/gyro/bmg160_i2c.c                | 73 ++++++++++++++++++++++++++
 5 files changed, 110 insertions(+), 71 deletions(-)
 create mode 100644 drivers/iio/gyro/bmg160.h
 rename drivers/iio/gyro/{bmg160.c => bmg160_core.c} (94%)
 create mode 100644 drivers/iio/gyro/bmg160_i2c.c

diff --git a/drivers/iio/gyro/Kconfig b/drivers/iio/gyro/Kconfig
index b44984b3bb24..1e6cfff5546f 100644
--- a/drivers/iio/gyro/Kconfig
+++ b/drivers/iio/gyro/Kconfig
@@ -51,18 +51,28 @@ config ADXRS450
 	  will be called adxrs450.
 
 config BMG160
-	tristate "BOSCH BMG160 Gyro Sensor"
-	depends on I2C
+	bool "BOSCH BMG160 Gyro Sensor"
 	select IIO_BUFFER
 	select IIO_TRIGGERED_BUFFER
 	select REGMAP
-	select REGMAP_I2C
 	help
 	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
 	  driver. This driver also supports BMI055 gyroscope.
 
+if BMG160
+
+config BMG160_I2C
+	tristate "Driver for connection via I2C"
+	depends on I2C
+	select REGMAP_I2C
+	help
+	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
+	  driver connected via I2C. This driver also supports BMI055 gyroscope.
+
 	  This driver can also be built as a module.  If so, the module
-	  will be called bmg160.
+	  will be called bmg160_i2c.
+
+endif
 
 config HID_SENSOR_GYRO_3D
 	depends on HID_SENSOR_HUB
diff --git a/drivers/iio/gyro/Makefile b/drivers/iio/gyro/Makefile
index f46341b39139..608401041550 100644
--- a/drivers/iio/gyro/Makefile
+++ b/drivers/iio/gyro/Makefile
@@ -8,7 +8,8 @@ obj-$(CONFIG_ADIS16130) += adis16130.o
 obj-$(CONFIG_ADIS16136) += adis16136.o
 obj-$(CONFIG_ADIS16260) += adis16260.o
 obj-$(CONFIG_ADXRS450) += adxrs450.o
-obj-$(CONFIG_BMG160) += bmg160.o
+obj-$(CONFIG_BMG160) += bmg160_core.o
+obj-$(CONFIG_BMG160_I2C) += bmg160_i2c.o
 
 obj-$(CONFIG_HID_SENSOR_GYRO_3D) += hid-sensor-gyro-3d.o
 
diff --git a/drivers/iio/gyro/bmg160.h b/drivers/iio/gyro/bmg160.h
new file mode 100644
index 000000000000..72db723c8fb6
--- /dev/null
+++ b/drivers/iio/gyro/bmg160.h
@@ -0,0 +1,10 @@
+#ifndef BMG160_H_
+#define BMG160_H_
+
+extern const struct dev_pm_ops bmg160_pm_ops;
+
+int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
+		      const char *name);
+void bmg160_core_remove(struct device *dev);
+
+#endif  /* BMG160_H_ */
diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160_core.c
similarity index 94%
rename from drivers/iio/gyro/bmg160.c
rename to drivers/iio/gyro/bmg160_core.c
index 865ef4c1c43f..ba37db5d491a 100644
--- a/drivers/iio/gyro/bmg160.c
+++ b/drivers/iio/gyro/bmg160_core.c
@@ -13,7 +13,6 @@
  */
 
 #include <linux/module.h>
-#include <linux/i2c.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
@@ -30,7 +29,6 @@
 #include <linux/iio/triggered_buffer.h>
 #include <linux/regmap.h>
 
-#define BMG160_DRV_NAME		"bmg160"
 #define BMG160_IRQ_NAME		"bmg160_event"
 #define BMG160_GPIO_NAME		"gpio_int"
 
@@ -137,14 +135,6 @@ static const struct {
 			   { 133, BMG160_RANGE_250DPS},
 			   { 66, BMG160_RANGE_125DPS} };
 
-struct regmap_config bmg160_regmap_i2c_conf = {
-	.reg_bits = 8,
-	.val_bits = 8,
-
-	.use_single_rw = true,
-	.cache_type = REGCACHE_NONE,
-};
-
 static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
 {
 	int ret;
@@ -998,31 +988,22 @@ static const char *bmg160_match_acpi_device(struct device *dev)
 	return dev_name(dev);
 }
 
-static int bmg160_probe(struct i2c_client *client,
-			const struct i2c_device_id *id)
+int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
+		      const char *name)
 {
 	struct bmg160_data *data;
 	struct iio_dev *indio_dev;
 	int ret;
-	const char *name = NULL;
-	struct regmap *regmap;
-	struct device *dev = &client->dev;
-
-	regmap = devm_regmap_init_i2c(client, &bmg160_regmap_i2c_conf);
-	if (IS_ERR(regmap)) {
-		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
-			(int)PTR_ERR(regmap));
-		return PTR_ERR(regmap);
-	}
 
-	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
 	if (!indio_dev)
 		return -ENOMEM;
 
 	data = iio_priv(indio_dev);
 	dev_set_drvdata(dev, indio_dev);
 	data->dev = dev;
-	data->irq = client->irq;
+	data->irq = irq;
+	data->regmap = regmap;
 
 	ret = bmg160_chip_init(data);
 	if (ret < 0)
@@ -1030,9 +1011,6 @@ static int bmg160_probe(struct i2c_client *client,
 
 	mutex_init(&data->mutex);
 
-	if (id)
-		name = id->name;
-
 	if (ACPI_HANDLE(dev))
 		name = bmg160_match_acpi_device(dev);
 
@@ -1128,14 +1106,14 @@ err_trigger_unregister:
 	return ret;
 }
 
-static int bmg160_remove(struct i2c_client *client)
+void bmg160_core_remove(struct device *dev)
 {
-	struct iio_dev *indio_dev = i2c_get_clientdata(client);
+	struct iio_dev *indio_dev = dev_get_drvdata(dev);
 	struct bmg160_data *data = iio_priv(indio_dev);
 
-	pm_runtime_disable(&client->dev);
-	pm_runtime_set_suspended(&client->dev);
-	pm_runtime_put_noidle(&client->dev);
+	pm_runtime_disable(dev);
+	pm_runtime_set_suspended(dev);
+	pm_runtime_put_noidle(dev);
 
 	iio_device_unregister(indio_dev);
 	iio_triggered_buffer_cleanup(indio_dev);
@@ -1148,8 +1126,6 @@ static int bmg160_remove(struct i2c_client *client)
 	mutex_lock(&data->mutex);
 	bmg160_set_mode(data, BMG160_MODE_DEEP_SUSPEND);
 	mutex_unlock(&data->mutex);
-
-	return 0;
 }
 
 #ifdef CONFIG_PM_SLEEP
@@ -1212,40 +1188,9 @@ static int bmg160_runtime_resume(struct device *dev)
 }
 #endif
 
-static const struct dev_pm_ops bmg160_pm_ops = {
+const struct dev_pm_ops bmg160_pm_ops = {
 	SET_SYSTEM_SLEEP_PM_OPS(bmg160_suspend, bmg160_resume)
 	SET_RUNTIME_PM_OPS(bmg160_runtime_suspend,
 			   bmg160_runtime_resume, NULL)
 };
 
-static const struct acpi_device_id bmg160_acpi_match[] = {
-	{"BMG0160", 0},
-	{"BMI055B", 0},
-	{},
-};
-
-MODULE_DEVICE_TABLE(acpi, bmg160_acpi_match);
-
-static const struct i2c_device_id bmg160_id[] = {
-	{"bmg160", 0},
-	{"bmi055_gyro", 0},
-	{}
-};
-
-MODULE_DEVICE_TABLE(i2c, bmg160_id);
-
-static struct i2c_driver bmg160_driver = {
-	.driver = {
-		.name	= BMG160_DRV_NAME,
-		.acpi_match_table = ACPI_PTR(bmg160_acpi_match),
-		.pm	= &bmg160_pm_ops,
-	},
-	.probe		= bmg160_probe,
-	.remove		= bmg160_remove,
-	.id_table	= bmg160_id,
-};
-module_i2c_driver(bmg160_driver);
-
-MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
-MODULE_LICENSE("GPL v2");
-MODULE_DESCRIPTION("BMG160 Gyro driver");
diff --git a/drivers/iio/gyro/bmg160_i2c.c b/drivers/iio/gyro/bmg160_i2c.c
new file mode 100644
index 000000000000..4a39dff13cf2
--- /dev/null
+++ b/drivers/iio/gyro/bmg160_i2c.c
@@ -0,0 +1,73 @@
+#include <linux/i2c.h>
+#include <linux/regmap.h>
+#include <linux/iio/iio.h>
+#include <linux/module.h>
+#include <linux/acpi.h>
+
+#include "bmg160.h"
+
+static const struct regmap_config bmg160_regmap_i2c_conf = {
+	.reg_bits = 8,
+	.val_bits = 8,
+
+	.use_single_rw = true,
+	.cache_type = REGCACHE_NONE,
+};
+
+static int bmg160_i2c_probe(struct i2c_client *client,
+			    const struct i2c_device_id *id)
+{
+	struct regmap *regmap;
+	const char *name = NULL;
+
+	regmap = devm_regmap_init_i2c(client, &bmg160_regmap_i2c_conf);
+	if (IS_ERR(regmap)) {
+		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
+			(int)PTR_ERR(regmap));
+		return PTR_ERR(regmap);
+	}
+
+	if (id)
+		name = id->name;
+
+	return bmg160_core_probe(&client->dev, regmap, client->irq, name);
+}
+
+static int bmg160_i2c_remove(struct i2c_client *client)
+{
+	bmg160_core_remove(&client->dev);
+
+	return 0;
+}
+
+static const struct acpi_device_id bmg160_acpi_match[] = {
+	{"BMG0160", 0},
+	{"BMI055B", 0},
+	{},
+};
+
+MODULE_DEVICE_TABLE(acpi, bmg160_acpi_match);
+
+static const struct i2c_device_id bmg160_i2c_id[] = {
+	{"bmg160", 0},
+	{"bmi055_gyro", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, bmg160_i2c_id);
+
+static struct i2c_driver bmg160_i2c_driver = {
+	.driver = {
+		.name	= "bmg160_i2c",
+		.acpi_match_table = ACPI_PTR(bmg160_acpi_match),
+		.pm	= &bmg160_pm_ops,
+	},
+	.probe		= bmg160_i2c_probe,
+	.remove		= bmg160_i2c_remove,
+	.id_table	= bmg160_i2c_id,
+};
+module_i2c_driver(bmg160_i2c_driver);
+
+MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("BMG160 I2C Gyro driver");
-- 
2.1.4


^ permalink raw reply related	[flat|nested] 12+ messages in thread
* [PATCH v2 6/6] iio: bmg160: Add SPI driver
  2015-08-04 11:02 [PATCH v2 0/6] iio: bmg160: Add SPI connection Markus Pargmann
                   ` (4 preceding siblings ...)
  2015-08-04 11:02 ` [PATCH v2 5/6] iio: bmg160: Separate i2c and core driver Markus Pargmann
@ 2015-08-04 11:02 ` Markus Pargmann
  2015-08-10 13:38   ` Markus Pargmann
  2015-08-08 16:12 ` [PATCH v2 0/6] iio: bmg160: Add SPI connection Jonathan Cameron
  6 siblings, 1 reply; 12+ messages in thread
From: Markus Pargmann @ 2015-08-04 11:02 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel, Markus Pargmann

Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
---
 drivers/iio/gyro/Kconfig      | 11 ++++++++
 drivers/iio/gyro/Makefile     |  1 +
 drivers/iio/gyro/bmg160_spi.c | 60 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 72 insertions(+)
 create mode 100644 drivers/iio/gyro/bmg160_spi.c

diff --git a/drivers/iio/gyro/Kconfig b/drivers/iio/gyro/Kconfig
index 1e6cfff5546f..420aea844216 100644
--- a/drivers/iio/gyro/Kconfig
+++ b/drivers/iio/gyro/Kconfig
@@ -72,6 +72,17 @@ config BMG160_I2C
 	  This driver can also be built as a module.  If so, the module
 	  will be called bmg160_i2c.
 
+config BMG160_SPI
+	tristate "Driver for connection via SPI"
+	depends on SPI
+	select REGMAP_SPI
+	help
+	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
+	  driver connected via SPI. This driver also supports BMI055 gyroscope.
+
+	  This driver can also be built as a module.  If so, the module
+	  will be called bmg160_spi.
+
 endif
 
 config HID_SENSOR_GYRO_3D
diff --git a/drivers/iio/gyro/Makefile b/drivers/iio/gyro/Makefile
index 608401041550..f866a4be0667 100644
--- a/drivers/iio/gyro/Makefile
+++ b/drivers/iio/gyro/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_ADIS16260) += adis16260.o
 obj-$(CONFIG_ADXRS450) += adxrs450.o
 obj-$(CONFIG_BMG160) += bmg160_core.o
 obj-$(CONFIG_BMG160_I2C) += bmg160_i2c.o
+obj-$(CONFIG_BMG160_SPI) += bmg160_spi.o
 
 obj-$(CONFIG_HID_SENSOR_GYRO_3D) += hid-sensor-gyro-3d.o
 
diff --git a/drivers/iio/gyro/bmg160_spi.c b/drivers/iio/gyro/bmg160_spi.c
new file mode 100644
index 000000000000..4dcef65f3476
--- /dev/null
+++ b/drivers/iio/gyro/bmg160_spi.c
@@ -0,0 +1,60 @@
+#include <linux/spi/spi.h>
+#include <linux/regmap.h>
+#include <linux/iio/iio.h>
+#include <linux/module.h>
+
+#include <bmg160.h>
+
+static const struct regmap_config bmg160_regmap_spi_conf = {
+	.reg_bits = 8,
+	.val_bits = 8,
+	.read_flag_mask = 0x80,
+
+	.use_single_rw = true,
+	.cache_type = REGCACHE_NONE,
+};
+
+static int bmg160_spi_probe(struct spi_device *spi)
+{
+	struct regmap *regmap;
+	const struct spi_device_id *id = spi_get_device_id(spi);
+
+	regmap = devm_regmap_init_spi(spi, &bmg160_regmap_spi_conf);
+	if (IS_ERR(regmap)) {
+		dev_err(&spi->dev, "Failed to register spi regmap %d\n",
+			(int)PTR_ERR(regmap));
+		return PTR_ERR(regmap);
+	}
+
+	return bmg160_core_probe(&spi->dev, regmap, spi->irq, id->name);
+}
+
+static int bmg160_spi_remove(struct spi_device *spi)
+{
+	bmg160_core_remove(&spi->dev);
+
+	return 0;
+}
+
+static const struct spi_device_id bmg160_spi_id[] = {
+	{"bmg160", 0},
+	{"bmi055_gyro", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(spi, bmg160_spi_id);
+
+static struct spi_driver bmg160_spi_driver = {
+	.driver = {
+		.name	= "bmg160_spi",
+		.pm	= &bmg160_pm_ops,
+	},
+	.probe		= bmg160_spi_probe,
+	.remove		= bmg160_spi_remove,
+	.id_table	= bmg160_spi_id,
+};
+module_spi_driver(bmg160_spi_driver);
+
+MODULE_AUTHOR("Markus Pargmann <mpa@pengutronix.de>");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("BMG160 SPI Gyro driver");
-- 
2.1.4


^ permalink raw reply related	[flat|nested] 12+ messages in thread
* Re: [PATCH v2 5/6] iio: bmg160: Separate i2c and core driver
  2015-08-04 11:02 ` [PATCH v2 5/6] iio: bmg160: Separate i2c and core driver Markus Pargmann
@ 2015-08-08 16:11   ` Jonathan Cameron
  2015-08-09  6:45     ` Markus Pargmann
  0 siblings, 1 reply; 12+ messages in thread
From: Jonathan Cameron @ 2015-08-08 16:11 UTC (permalink / raw)
  To: Markus Pargmann
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel

On 04/08/15 12:02, Markus Pargmann wrote:
> This patch separates the core driver using regmap and the i2c driver
> which creates the i2c regmap. Also in the Kconfig file BMG160 and
> BMG160_I2C are separate now.
> 
> Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
Don't you need to EXPORT the various functions to be used
across the modules?
> ---
>  drivers/iio/gyro/Kconfig                     | 18 +++++--
>  drivers/iio/gyro/Makefile                    |  3 +-
>  drivers/iio/gyro/bmg160.h                    | 10 ++++
>  drivers/iio/gyro/{bmg160.c => bmg160_core.c} | 77 ++++------------------------
>  drivers/iio/gyro/bmg160_i2c.c                | 73 ++++++++++++++++++++++++++
>  5 files changed, 110 insertions(+), 71 deletions(-)
>  create mode 100644 drivers/iio/gyro/bmg160.h
>  rename drivers/iio/gyro/{bmg160.c => bmg160_core.c} (94%)
>  create mode 100644 drivers/iio/gyro/bmg160_i2c.c
> 
> diff --git a/drivers/iio/gyro/Kconfig b/drivers/iio/gyro/Kconfig
> index b44984b3bb24..1e6cfff5546f 100644
> --- a/drivers/iio/gyro/Kconfig
> +++ b/drivers/iio/gyro/Kconfig
> @@ -51,18 +51,28 @@ config ADXRS450
>  	  will be called adxrs450.
>  
>  config BMG160
> -	tristate "BOSCH BMG160 Gyro Sensor"
> -	depends on I2C
> +	bool "BOSCH BMG160 Gyro Sensor"
>  	select IIO_BUFFER
>  	select IIO_TRIGGERED_BUFFER
>  	select REGMAP
> -	select REGMAP_I2C
>  	help
>  	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
>  	  driver. This driver also supports BMI055 gyroscope.
>  
> +if BMG160
> +
> +config BMG160_I2C
> +	tristate "Driver for connection via I2C"
> +	depends on I2C
> +	select REGMAP_I2C
> +	help
> +	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
> +	  driver connected via I2C. This driver also supports BMI055 gyroscope.
> +
>  	  This driver can also be built as a module.  If so, the module
> -	  will be called bmg160.
> +	  will be called bmg160_i2c.
> +
> +endif
>  
>  config HID_SENSOR_GYRO_3D
>  	depends on HID_SENSOR_HUB
> diff --git a/drivers/iio/gyro/Makefile b/drivers/iio/gyro/Makefile
> index f46341b39139..608401041550 100644
> --- a/drivers/iio/gyro/Makefile
> +++ b/drivers/iio/gyro/Makefile
> @@ -8,7 +8,8 @@ obj-$(CONFIG_ADIS16130) += adis16130.o
>  obj-$(CONFIG_ADIS16136) += adis16136.o
>  obj-$(CONFIG_ADIS16260) += adis16260.o
>  obj-$(CONFIG_ADXRS450) += adxrs450.o
> -obj-$(CONFIG_BMG160) += bmg160.o
> +obj-$(CONFIG_BMG160) += bmg160_core.o
> +obj-$(CONFIG_BMG160_I2C) += bmg160_i2c.o
>  
>  obj-$(CONFIG_HID_SENSOR_GYRO_3D) += hid-sensor-gyro-3d.o
>  
> diff --git a/drivers/iio/gyro/bmg160.h b/drivers/iio/gyro/bmg160.h
> new file mode 100644
> index 000000000000..72db723c8fb6
> --- /dev/null
> +++ b/drivers/iio/gyro/bmg160.h
> @@ -0,0 +1,10 @@
> +#ifndef BMG160_H_
> +#define BMG160_H_
> +
> +extern const struct dev_pm_ops bmg160_pm_ops;
> +
> +int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
> +		      const char *name);
> +void bmg160_core_remove(struct device *dev);
> +
> +#endif  /* BMG160_H_ */
> diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160_core.c
> similarity index 94%
> rename from drivers/iio/gyro/bmg160.c
> rename to drivers/iio/gyro/bmg160_core.c
> index 865ef4c1c43f..ba37db5d491a 100644
> --- a/drivers/iio/gyro/bmg160.c
> +++ b/drivers/iio/gyro/bmg160_core.c
> @@ -13,7 +13,6 @@
>   */
>  
>  #include <linux/module.h>
> -#include <linux/i2c.h>
>  #include <linux/interrupt.h>
>  #include <linux/delay.h>
>  #include <linux/slab.h>
> @@ -30,7 +29,6 @@
>  #include <linux/iio/triggered_buffer.h>
>  #include <linux/regmap.h>
>  
> -#define BMG160_DRV_NAME		"bmg160"
>  #define BMG160_IRQ_NAME		"bmg160_event"
>  #define BMG160_GPIO_NAME		"gpio_int"
>  
> @@ -137,14 +135,6 @@ static const struct {
>  			   { 133, BMG160_RANGE_250DPS},
>  			   { 66, BMG160_RANGE_125DPS} };
>  
> -struct regmap_config bmg160_regmap_i2c_conf = {
> -	.reg_bits = 8,
> -	.val_bits = 8,
> -
> -	.use_single_rw = true,
> -	.cache_type = REGCACHE_NONE,
> -};
> -
>  static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
>  {
>  	int ret;
> @@ -998,31 +988,22 @@ static const char *bmg160_match_acpi_device(struct device *dev)
>  	return dev_name(dev);
>  }
>  
> -static int bmg160_probe(struct i2c_client *client,
> -			const struct i2c_device_id *id)
> +int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
> +		      const char *name)
>  {
>  	struct bmg160_data *data;
>  	struct iio_dev *indio_dev;
>  	int ret;
> -	const char *name = NULL;
> -	struct regmap *regmap;
> -	struct device *dev = &client->dev;
> -
> -	regmap = devm_regmap_init_i2c(client, &bmg160_regmap_i2c_conf);
> -	if (IS_ERR(regmap)) {
> -		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
> -			(int)PTR_ERR(regmap));
> -		return PTR_ERR(regmap);
> -	}
>  
> -	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
> +	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
>  	if (!indio_dev)
>  		return -ENOMEM;
>  
>  	data = iio_priv(indio_dev);
>  	dev_set_drvdata(dev, indio_dev);
>  	data->dev = dev;
> -	data->irq = client->irq;
> +	data->irq = irq;
> +	data->regmap = regmap;
>  
>  	ret = bmg160_chip_init(data);
>  	if (ret < 0)
> @@ -1030,9 +1011,6 @@ static int bmg160_probe(struct i2c_client *client,
>  
>  	mutex_init(&data->mutex);
>  
> -	if (id)
> -		name = id->name;
> -
>  	if (ACPI_HANDLE(dev))
>  		name = bmg160_match_acpi_device(dev);
>  
> @@ -1128,14 +1106,14 @@ err_trigger_unregister:
>  	return ret;
>  }
>  
> -static int bmg160_remove(struct i2c_client *client)
> +void bmg160_core_remove(struct device *dev)
>  {
> -	struct iio_dev *indio_dev = i2c_get_clientdata(client);
> +	struct iio_dev *indio_dev = dev_get_drvdata(dev);
>  	struct bmg160_data *data = iio_priv(indio_dev);
>  
> -	pm_runtime_disable(&client->dev);
> -	pm_runtime_set_suspended(&client->dev);
> -	pm_runtime_put_noidle(&client->dev);
> +	pm_runtime_disable(dev);
> +	pm_runtime_set_suspended(dev);
> +	pm_runtime_put_noidle(dev);
>  
>  	iio_device_unregister(indio_dev);
>  	iio_triggered_buffer_cleanup(indio_dev);
> @@ -1148,8 +1126,6 @@ static int bmg160_remove(struct i2c_client *client)
>  	mutex_lock(&data->mutex);
>  	bmg160_set_mode(data, BMG160_MODE_DEEP_SUSPEND);
>  	mutex_unlock(&data->mutex);
> -
> -	return 0;
>  }
GIven use across a module boundary I'd have thought an EXPORT was needed.
>  
>  #ifdef CONFIG_PM_SLEEP
> @@ -1212,40 +1188,9 @@ static int bmg160_runtime_resume(struct device *dev)
>  }
>  #endif
>  
> -static const struct dev_pm_ops bmg160_pm_ops = {
> +const struct dev_pm_ops bmg160_pm_ops = {
>  	SET_SYSTEM_SLEEP_PM_OPS(bmg160_suspend, bmg160_resume)
>  	SET_RUNTIME_PM_OPS(bmg160_runtime_suspend,
>  			   bmg160_runtime_resume, NULL)
>  };
>  
> -static const struct acpi_device_id bmg160_acpi_match[] = {
> -	{"BMG0160", 0},
> -	{"BMI055B", 0},
> -	{},
> -};
> -
> -MODULE_DEVICE_TABLE(acpi, bmg160_acpi_match);
> -
> -static const struct i2c_device_id bmg160_id[] = {
> -	{"bmg160", 0},
> -	{"bmi055_gyro", 0},
> -	{}
> -};
> -
> -MODULE_DEVICE_TABLE(i2c, bmg160_id);
> -
> -static struct i2c_driver bmg160_driver = {
> -	.driver = {
> -		.name	= BMG160_DRV_NAME,
> -		.acpi_match_table = ACPI_PTR(bmg160_acpi_match),
> -		.pm	= &bmg160_pm_ops,
> -	},
> -	.probe		= bmg160_probe,
> -	.remove		= bmg160_remove,
> -	.id_table	= bmg160_id,
> -};
> -module_i2c_driver(bmg160_driver);
> -
> -MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
> -MODULE_LICENSE("GPL v2");
> -MODULE_DESCRIPTION("BMG160 Gyro driver");
> diff --git a/drivers/iio/gyro/bmg160_i2c.c b/drivers/iio/gyro/bmg160_i2c.c
> new file mode 100644
> index 000000000000..4a39dff13cf2
> --- /dev/null
> +++ b/drivers/iio/gyro/bmg160_i2c.c
> @@ -0,0 +1,73 @@
> +#include <linux/i2c.h>
> +#include <linux/regmap.h>
> +#include <linux/iio/iio.h>
> +#include <linux/module.h>
> +#include <linux/acpi.h>
> +
> +#include "bmg160.h"
> +
> +static const struct regmap_config bmg160_regmap_i2c_conf = {
> +	.reg_bits = 8,
> +	.val_bits = 8,
> +
> +	.use_single_rw = true,
> +	.cache_type = REGCACHE_NONE,
> +};
> +
> +static int bmg160_i2c_probe(struct i2c_client *client,
> +			    const struct i2c_device_id *id)
> +{
> +	struct regmap *regmap;
> +	const char *name = NULL;
> +
> +	regmap = devm_regmap_init_i2c(client, &bmg160_regmap_i2c_conf);
> +	if (IS_ERR(regmap)) {
> +		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
> +			(int)PTR_ERR(regmap));
> +		return PTR_ERR(regmap);
> +	}
> +
> +	if (id)
> +		name = id->name;
> +
> +	return bmg160_core_probe(&client->dev, regmap, client->irq, name);
> +}
> +
> +static int bmg160_i2c_remove(struct i2c_client *client)
> +{
> +	bmg160_core_remove(&client->dev);
> +
> +	return 0;
> +}
> +
> +static const struct acpi_device_id bmg160_acpi_match[] = {
> +	{"BMG0160", 0},
> +	{"BMI055B", 0},
> +	{},
> +};
> +
> +MODULE_DEVICE_TABLE(acpi, bmg160_acpi_match);
> +
> +static const struct i2c_device_id bmg160_i2c_id[] = {
> +	{"bmg160", 0},
> +	{"bmi055_gyro", 0},
> +	{}
> +};
> +
> +MODULE_DEVICE_TABLE(i2c, bmg160_i2c_id);
> +
> +static struct i2c_driver bmg160_i2c_driver = {
> +	.driver = {
> +		.name	= "bmg160_i2c",
> +		.acpi_match_table = ACPI_PTR(bmg160_acpi_match),
> +		.pm	= &bmg160_pm_ops,
> +	},
> +	.probe		= bmg160_i2c_probe,
> +	.remove		= bmg160_i2c_remove,
> +	.id_table	= bmg160_i2c_id,
> +};
> +module_i2c_driver(bmg160_i2c_driver);
> +
> +MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
> +MODULE_LICENSE("GPL v2");
> +MODULE_DESCRIPTION("BMG160 I2C Gyro driver");
> 


^ permalink raw reply	[flat|nested] 12+ messages in thread
* Re: [PATCH v2 0/6] iio: bmg160: Add SPI connection
  2015-08-04 11:02 [PATCH v2 0/6] iio: bmg160: Add SPI connection Markus Pargmann
                   ` (5 preceding siblings ...)
  2015-08-04 11:02 ` [PATCH v2 6/6] iio: bmg160: Add SPI driver Markus Pargmann
@ 2015-08-08 16:12 ` Jonathan Cameron
  6 siblings, 0 replies; 12+ messages in thread
From: Jonathan Cameron @ 2015-08-08 16:12 UTC (permalink / raw)
  To: Markus Pargmann
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel

On 04/08/15 12:02, Markus Pargmann wrote:
> Hi,
> 
> bmg160 and bmi055 can be used via I2C and SPI. This series converts the driver
> to regmap and splits core driver and I2C/SPI.
> 
> Changes in v2:
>  - Added the id->name from the SPI driver to be used as iio device name
>  - Fixed Kconfig in patch 2 to add selects for REGMAP_I2C
>  - Fixed regmap configs to be static const
> 
> Best regards,
> 
> Markus
I am more or less happy with these, but want a reviewed-by/acked-by from
Srinivas.
> 
> 
> Markus Pargmann (6):
>   iio: bmg160: Use i2c regmap instead of direct i2c access
>   iio: bmg160: Remove i2c_client from data struct
>   iio: bmg160: Use generic dev_drvdata
>   iio: bmg160: Remove remaining uses of i2c_client
>   iio: bmg160: Separate i2c and core driver
>   iio: bmg160: Add SPI driver
> 
>  drivers/iio/gyro/Kconfig                     |  29 ++-
>  drivers/iio/gyro/Makefile                    |   4 +-
>  drivers/iio/gyro/bmg160.h                    |  10 +
>  drivers/iio/gyro/{bmg160.c => bmg160_core.c} | 356 +++++++++++----------------
>  drivers/iio/gyro/bmg160_i2c.c                |  73 ++++++
>  drivers/iio/gyro/bmg160_spi.c                |  60 +++++
>  6 files changed, 311 insertions(+), 221 deletions(-)
>  create mode 100644 drivers/iio/gyro/bmg160.h
>  rename drivers/iio/gyro/{bmg160.c => bmg160_core.c} (74%)
>  create mode 100644 drivers/iio/gyro/bmg160_i2c.c
>  create mode 100644 drivers/iio/gyro/bmg160_spi.c
> 


^ permalink raw reply	[flat|nested] 12+ messages in thread
* Re: [PATCH v2 5/6] iio: bmg160: Separate i2c and core driver
  2015-08-08 16:11   ` Jonathan Cameron
@ 2015-08-09  6:45     ` Markus Pargmann
  0 siblings, 0 replies; 12+ messages in thread
From: Markus Pargmann @ 2015-08-09  6:45 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Srinivas Pandruvada, Vlad Dogaru, Paul Bolle, linux-iio,
	linux-kernel, kernel

[-- Attachment #1: Type: text/plain, Size: 10989 bytes --]

On Sat, Aug 08, 2015 at 05:11:02PM +0100, Jonathan Cameron wrote:
> On 04/08/15 12:02, Markus Pargmann wrote:
> > This patch separates the core driver using regmap and the i2c driver
> > which creates the i2c regmap. Also in the Kconfig file BMG160 and
> > BMG160_I2C are separate now.
> > 
> > Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
> Don't you need to EXPORT the various functions to be used
> across the modules?

Yes, thanks. Will fix it.

Best Regards,

Markus

> > ---
> >  drivers/iio/gyro/Kconfig                     | 18 +++++--
> >  drivers/iio/gyro/Makefile                    |  3 +-
> >  drivers/iio/gyro/bmg160.h                    | 10 ++++
> >  drivers/iio/gyro/{bmg160.c => bmg160_core.c} | 77 ++++------------------------
> >  drivers/iio/gyro/bmg160_i2c.c                | 73 ++++++++++++++++++++++++++
> >  5 files changed, 110 insertions(+), 71 deletions(-)
> >  create mode 100644 drivers/iio/gyro/bmg160.h
> >  rename drivers/iio/gyro/{bmg160.c => bmg160_core.c} (94%)
> >  create mode 100644 drivers/iio/gyro/bmg160_i2c.c
> > 
> > diff --git a/drivers/iio/gyro/Kconfig b/drivers/iio/gyro/Kconfig
> > index b44984b3bb24..1e6cfff5546f 100644
> > --- a/drivers/iio/gyro/Kconfig
> > +++ b/drivers/iio/gyro/Kconfig
> > @@ -51,18 +51,28 @@ config ADXRS450
> >  	  will be called adxrs450.
> >  
> >  config BMG160
> > -	tristate "BOSCH BMG160 Gyro Sensor"
> > -	depends on I2C
> > +	bool "BOSCH BMG160 Gyro Sensor"
> >  	select IIO_BUFFER
> >  	select IIO_TRIGGERED_BUFFER
> >  	select REGMAP
> > -	select REGMAP_I2C
> >  	help
> >  	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
> >  	  driver. This driver also supports BMI055 gyroscope.
> >  
> > +if BMG160
> > +
> > +config BMG160_I2C
> > +	tristate "Driver for connection via I2C"
> > +	depends on I2C
> > +	select REGMAP_I2C
> > +	help
> > +	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
> > +	  driver connected via I2C. This driver also supports BMI055 gyroscope.
> > +
> >  	  This driver can also be built as a module.  If so, the module
> > -	  will be called bmg160.
> > +	  will be called bmg160_i2c.
> > +
> > +endif
> >  
> >  config HID_SENSOR_GYRO_3D
> >  	depends on HID_SENSOR_HUB
> > diff --git a/drivers/iio/gyro/Makefile b/drivers/iio/gyro/Makefile
> > index f46341b39139..608401041550 100644
> > --- a/drivers/iio/gyro/Makefile
> > +++ b/drivers/iio/gyro/Makefile
> > @@ -8,7 +8,8 @@ obj-$(CONFIG_ADIS16130) += adis16130.o
> >  obj-$(CONFIG_ADIS16136) += adis16136.o
> >  obj-$(CONFIG_ADIS16260) += adis16260.o
> >  obj-$(CONFIG_ADXRS450) += adxrs450.o
> > -obj-$(CONFIG_BMG160) += bmg160.o
> > +obj-$(CONFIG_BMG160) += bmg160_core.o
> > +obj-$(CONFIG_BMG160_I2C) += bmg160_i2c.o
> >  
> >  obj-$(CONFIG_HID_SENSOR_GYRO_3D) += hid-sensor-gyro-3d.o
> >  
> > diff --git a/drivers/iio/gyro/bmg160.h b/drivers/iio/gyro/bmg160.h
> > new file mode 100644
> > index 000000000000..72db723c8fb6
> > --- /dev/null
> > +++ b/drivers/iio/gyro/bmg160.h
> > @@ -0,0 +1,10 @@
> > +#ifndef BMG160_H_
> > +#define BMG160_H_
> > +
> > +extern const struct dev_pm_ops bmg160_pm_ops;
> > +
> > +int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
> > +		      const char *name);
> > +void bmg160_core_remove(struct device *dev);
> > +
> > +#endif  /* BMG160_H_ */
> > diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160_core.c
> > similarity index 94%
> > rename from drivers/iio/gyro/bmg160.c
> > rename to drivers/iio/gyro/bmg160_core.c
> > index 865ef4c1c43f..ba37db5d491a 100644
> > --- a/drivers/iio/gyro/bmg160.c
> > +++ b/drivers/iio/gyro/bmg160_core.c
> > @@ -13,7 +13,6 @@
> >   */
> >  
> >  #include <linux/module.h>
> > -#include <linux/i2c.h>
> >  #include <linux/interrupt.h>
> >  #include <linux/delay.h>
> >  #include <linux/slab.h>
> > @@ -30,7 +29,6 @@
> >  #include <linux/iio/triggered_buffer.h>
> >  #include <linux/regmap.h>
> >  
> > -#define BMG160_DRV_NAME		"bmg160"
> >  #define BMG160_IRQ_NAME		"bmg160_event"
> >  #define BMG160_GPIO_NAME		"gpio_int"
> >  
> > @@ -137,14 +135,6 @@ static const struct {
> >  			   { 133, BMG160_RANGE_250DPS},
> >  			   { 66, BMG160_RANGE_125DPS} };
> >  
> > -struct regmap_config bmg160_regmap_i2c_conf = {
> > -	.reg_bits = 8,
> > -	.val_bits = 8,
> > -
> > -	.use_single_rw = true,
> > -	.cache_type = REGCACHE_NONE,
> > -};
> > -
> >  static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
> >  {
> >  	int ret;
> > @@ -998,31 +988,22 @@ static const char *bmg160_match_acpi_device(struct device *dev)
> >  	return dev_name(dev);
> >  }
> >  
> > -static int bmg160_probe(struct i2c_client *client,
> > -			const struct i2c_device_id *id)
> > +int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
> > +		      const char *name)
> >  {
> >  	struct bmg160_data *data;
> >  	struct iio_dev *indio_dev;
> >  	int ret;
> > -	const char *name = NULL;
> > -	struct regmap *regmap;
> > -	struct device *dev = &client->dev;
> > -
> > -	regmap = devm_regmap_init_i2c(client, &bmg160_regmap_i2c_conf);
> > -	if (IS_ERR(regmap)) {
> > -		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
> > -			(int)PTR_ERR(regmap));
> > -		return PTR_ERR(regmap);
> > -	}
> >  
> > -	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
> > +	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
> >  	if (!indio_dev)
> >  		return -ENOMEM;
> >  
> >  	data = iio_priv(indio_dev);
> >  	dev_set_drvdata(dev, indio_dev);
> >  	data->dev = dev;
> > -	data->irq = client->irq;
> > +	data->irq = irq;
> > +	data->regmap = regmap;
> >  
> >  	ret = bmg160_chip_init(data);
> >  	if (ret < 0)
> > @@ -1030,9 +1011,6 @@ static int bmg160_probe(struct i2c_client *client,
> >  
> >  	mutex_init(&data->mutex);
> >  
> > -	if (id)
> > -		name = id->name;
> > -
> >  	if (ACPI_HANDLE(dev))
> >  		name = bmg160_match_acpi_device(dev);
> >  
> > @@ -1128,14 +1106,14 @@ err_trigger_unregister:
> >  	return ret;
> >  }
> >  
> > -static int bmg160_remove(struct i2c_client *client)
> > +void bmg160_core_remove(struct device *dev)
> >  {
> > -	struct iio_dev *indio_dev = i2c_get_clientdata(client);
> > +	struct iio_dev *indio_dev = dev_get_drvdata(dev);
> >  	struct bmg160_data *data = iio_priv(indio_dev);
> >  
> > -	pm_runtime_disable(&client->dev);
> > -	pm_runtime_set_suspended(&client->dev);
> > -	pm_runtime_put_noidle(&client->dev);
> > +	pm_runtime_disable(dev);
> > +	pm_runtime_set_suspended(dev);
> > +	pm_runtime_put_noidle(dev);
> >  
> >  	iio_device_unregister(indio_dev);
> >  	iio_triggered_buffer_cleanup(indio_dev);
> > @@ -1148,8 +1126,6 @@ static int bmg160_remove(struct i2c_client *client)
> >  	mutex_lock(&data->mutex);
> >  	bmg160_set_mode(data, BMG160_MODE_DEEP_SUSPEND);
> >  	mutex_unlock(&data->mutex);
> > -
> > -	return 0;
> >  }
> GIven use across a module boundary I'd have thought an EXPORT was needed.
> >  
> >  #ifdef CONFIG_PM_SLEEP
> > @@ -1212,40 +1188,9 @@ static int bmg160_runtime_resume(struct device *dev)
> >  }
> >  #endif
> >  
> > -static const struct dev_pm_ops bmg160_pm_ops = {
> > +const struct dev_pm_ops bmg160_pm_ops = {
> >  	SET_SYSTEM_SLEEP_PM_OPS(bmg160_suspend, bmg160_resume)
> >  	SET_RUNTIME_PM_OPS(bmg160_runtime_suspend,
> >  			   bmg160_runtime_resume, NULL)
> >  };
> >  
> > -static const struct acpi_device_id bmg160_acpi_match[] = {
> > -	{"BMG0160", 0},
> > -	{"BMI055B", 0},
> > -	{},
> > -};
> > -
> > -MODULE_DEVICE_TABLE(acpi, bmg160_acpi_match);
> > -
> > -static const struct i2c_device_id bmg160_id[] = {
> > -	{"bmg160", 0},
> > -	{"bmi055_gyro", 0},
> > -	{}
> > -};
> > -
> > -MODULE_DEVICE_TABLE(i2c, bmg160_id);
> > -
> > -static struct i2c_driver bmg160_driver = {
> > -	.driver = {
> > -		.name	= BMG160_DRV_NAME,
> > -		.acpi_match_table = ACPI_PTR(bmg160_acpi_match),
> > -		.pm	= &bmg160_pm_ops,
> > -	},
> > -	.probe		= bmg160_probe,
> > -	.remove		= bmg160_remove,
> > -	.id_table	= bmg160_id,
> > -};
> > -module_i2c_driver(bmg160_driver);
> > -
> > -MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
> > -MODULE_LICENSE("GPL v2");
> > -MODULE_DESCRIPTION("BMG160 Gyro driver");
> > diff --git a/drivers/iio/gyro/bmg160_i2c.c b/drivers/iio/gyro/bmg160_i2c.c
> > new file mode 100644
> > index 000000000000..4a39dff13cf2
> > --- /dev/null
> > +++ b/drivers/iio/gyro/bmg160_i2c.c
> > @@ -0,0 +1,73 @@
> > +#include <linux/i2c.h>
> > +#include <linux/regmap.h>
> > +#include <linux/iio/iio.h>
> > +#include <linux/module.h>
> > +#include <linux/acpi.h>
> > +
> > +#include "bmg160.h"
> > +
> > +static const struct regmap_config bmg160_regmap_i2c_conf = {
> > +	.reg_bits = 8,
> > +	.val_bits = 8,
> > +
> > +	.use_single_rw = true,
> > +	.cache_type = REGCACHE_NONE,
> > +};
> > +
> > +static int bmg160_i2c_probe(struct i2c_client *client,
> > +			    const struct i2c_device_id *id)
> > +{
> > +	struct regmap *regmap;
> > +	const char *name = NULL;
> > +
> > +	regmap = devm_regmap_init_i2c(client, &bmg160_regmap_i2c_conf);
> > +	if (IS_ERR(regmap)) {
> > +		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
> > +			(int)PTR_ERR(regmap));
> > +		return PTR_ERR(regmap);
> > +	}
> > +
> > +	if (id)
> > +		name = id->name;
> > +
> > +	return bmg160_core_probe(&client->dev, regmap, client->irq, name);
> > +}
> > +
> > +static int bmg160_i2c_remove(struct i2c_client *client)
> > +{
> > +	bmg160_core_remove(&client->dev);
> > +
> > +	return 0;
> > +}
> > +
> > +static const struct acpi_device_id bmg160_acpi_match[] = {
> > +	{"BMG0160", 0},
> > +	{"BMI055B", 0},
> > +	{},
> > +};
> > +
> > +MODULE_DEVICE_TABLE(acpi, bmg160_acpi_match);
> > +
> > +static const struct i2c_device_id bmg160_i2c_id[] = {
> > +	{"bmg160", 0},
> > +	{"bmi055_gyro", 0},
> > +	{}
> > +};
> > +
> > +MODULE_DEVICE_TABLE(i2c, bmg160_i2c_id);
> > +
> > +static struct i2c_driver bmg160_i2c_driver = {
> > +	.driver = {
> > +		.name	= "bmg160_i2c",
> > +		.acpi_match_table = ACPI_PTR(bmg160_acpi_match),
> > +		.pm	= &bmg160_pm_ops,
> > +	},
> > +	.probe		= bmg160_i2c_probe,
> > +	.remove		= bmg160_i2c_remove,
> > +	.id_table	= bmg160_i2c_id,
> > +};
> > +module_i2c_driver(bmg160_i2c_driver);
> > +
> > +MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
> > +MODULE_LICENSE("GPL v2");
> > +MODULE_DESCRIPTION("BMG160 I2C Gyro driver");
> > 
> 
> 

-- 
Pengutronix e.K.                           |                             |
Industrial Linux Solutions                 | http://www.pengutronix.de/  |
Peiner Str. 6-8, 31137 Hildesheim, Germany | Phone: +49-5121-206917-0    |
Amtsgericht Hildesheim, HRA 2686           | Fax:   +49-5121-206917-5555 |

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

^ permalink raw reply	[flat|nested] 12+ messages in thread
* Re: [PATCH v2 1/6] iio: bmg160: Use i2c regmap instead of direct i2c access
  2015-08-04 11:02 ` [PATCH v2 1/6] iio: bmg160: Use i2c regmap instead of direct i2c access Markus Pargmann
@ 2015-08-09  6:47   ` Markus Pargmann
  0 siblings, 0 replies; 12+ messages in thread
From: Markus Pargmann @ 2015-08-09  6:47 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Vlad Dogaru, Paul Bolle, linux-iio, linux-kernel, kernel,
	Srinivas Pandruvada

[-- Attachment #1: Type: text/plain, Size: 17144 bytes --]

On Tue, Aug 04, 2015 at 01:02:54PM +0200, Markus Pargmann wrote:
> This patch introduces regmap usage into the driver. This is done to
> later easily support the SPI interface of this chip.
> 
> Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
> ---
>  drivers/iio/gyro/Kconfig  |   2 +
>  drivers/iio/gyro/bmg160.c | 200 +++++++++++++++++++++-------------------------
>  2 files changed, 91 insertions(+), 111 deletions(-)
> 
> diff --git a/drivers/iio/gyro/Kconfig b/drivers/iio/gyro/Kconfig
> index 8d2439345673..b44984b3bb24 100644
> --- a/drivers/iio/gyro/Kconfig
> +++ b/drivers/iio/gyro/Kconfig
> @@ -55,6 +55,8 @@ config BMG160
>  	depends on I2C
>  	select IIO_BUFFER
>  	select IIO_TRIGGERED_BUFFER
> +	select REGMAP
> +	select REGMAP_I2C
>  	help
>  	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
>  	  driver. This driver also supports BMI055 gyroscope.
> diff --git a/drivers/iio/gyro/bmg160.c b/drivers/iio/gyro/bmg160.c
> index 460bf715d541..626f5c98dde8 100644
> --- a/drivers/iio/gyro/bmg160.c
> +++ b/drivers/iio/gyro/bmg160.c
> @@ -28,6 +28,7 @@
>  #include <linux/iio/events.h>
>  #include <linux/iio/trigger_consumer.h>
>  #include <linux/iio/triggered_buffer.h>
> +#include <linux/regmap.h>
>  
>  #define BMG160_DRV_NAME		"bmg160"
>  #define BMG160_IRQ_NAME		"bmg160_event"
> @@ -98,6 +99,7 @@
>  
>  struct bmg160_data {
>  	struct i2c_client *client;
> +	struct regmap *regmap;
>  	struct iio_trigger *dready_trig;
>  	struct iio_trigger *motion_trig;
>  	struct mutex mutex;
> @@ -134,12 +136,19 @@ static const struct {
>  			   { 133, BMG160_RANGE_250DPS},
>  			   { 66, BMG160_RANGE_125DPS} };
>  
> +struct regmap_config bmg160_regmap_i2c_conf = {
> +	.reg_bits = 8,
> +	.val_bits = 8,
> +
> +	.use_single_rw = true,

This should not be necessary, we should be able to read multiple
registers at once. This is the same for the spi regmap config.

Also a max_register is missing. Will fix it.

Regards,

Markus

> +	.cache_type = REGCACHE_NONE,
> +};
> +
>  static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
>  {
>  	int ret;
>  
> -	ret = i2c_smbus_write_byte_data(data->client,
> -					BMG160_REG_PMU_LPW, mode);
> +	ret = regmap_write(data->regmap, BMG160_REG_PMU_LPW, mode);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error writing reg_pmu_lpw\n");
>  		return ret;
> @@ -169,8 +178,7 @@ static int bmg160_set_bw(struct bmg160_data *data, int val)
>  	if (bw_bits < 0)
>  		return bw_bits;
>  
> -	ret = i2c_smbus_write_byte_data(data->client, BMG160_REG_PMU_BW,
> -					bw_bits);
> +	ret = regmap_write(data->regmap, BMG160_REG_PMU_BW, bw_bits);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error writing reg_pmu_bw\n");
>  		return ret;
> @@ -184,16 +192,17 @@ static int bmg160_set_bw(struct bmg160_data *data, int val)
>  static int bmg160_chip_init(struct bmg160_data *data)
>  {
>  	int ret;
> +	unsigned int val;
>  
> -	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_CHIP_ID);
> +	ret = regmap_read(data->regmap, BMG160_REG_CHIP_ID, &val);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error reading reg_chip_id\n");
>  		return ret;
>  	}
>  
> -	dev_dbg(&data->client->dev, "Chip Id %x\n", ret);
> -	if (ret != BMG160_CHIP_ID_VAL) {
> -		dev_err(&data->client->dev, "invalid chip %x\n", ret);
> +	dev_dbg(&data->client->dev, "Chip Id %x\n", val);
> +	if (val != BMG160_CHIP_ID_VAL) {
> +		dev_err(&data->client->dev, "invalid chip %x\n", val);
>  		return -ENODEV;
>  	}
>  
> @@ -210,40 +219,31 @@ static int bmg160_chip_init(struct bmg160_data *data)
>  		return ret;
>  
>  	/* Set Default Range */
> -	ret = i2c_smbus_write_byte_data(data->client,
> -					BMG160_REG_RANGE,
> -					BMG160_RANGE_500DPS);
> +	ret = regmap_write(data->regmap, BMG160_REG_RANGE, BMG160_RANGE_500DPS);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error writing reg_range\n");
>  		return ret;
>  	}
>  	data->dps_range = BMG160_RANGE_500DPS;
>  
> -	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_SLOPE_THRES);
> +	ret = regmap_read(data->regmap, BMG160_REG_SLOPE_THRES, &val);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error reading reg_slope_thres\n");
>  		return ret;
>  	}
> -	data->slope_thres = ret;
> +	data->slope_thres = val;
>  
>  	/* Set default interrupt mode */
> -	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_EN_1);
> -	if (ret < 0) {
> -		dev_err(&data->client->dev, "Error reading reg_int_en_1\n");
> -		return ret;
> -	}
> -	ret &= ~BMG160_INT1_BIT_OD;
> -	ret = i2c_smbus_write_byte_data(data->client,
> -					BMG160_REG_INT_EN_1, ret);
> +	ret = regmap_update_bits(data->regmap, BMG160_REG_INT_EN_1,
> +				 BMG160_INT1_BIT_OD, 0);
>  	if (ret < 0) {
> -		dev_err(&data->client->dev, "Error writing reg_int_en_1\n");
> +		dev_err(&data->client->dev, "Error updating bits in reg_int_en_1\n");
>  		return ret;
>  	}
>  
> -	ret = i2c_smbus_write_byte_data(data->client,
> -					BMG160_REG_INT_RST_LATCH,
> -					BMG160_INT_MODE_LATCH_INT |
> -					BMG160_INT_MODE_LATCH_RESET);
> +	ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
> +			   BMG160_INT_MODE_LATCH_INT |
> +			   BMG160_INT_MODE_LATCH_RESET);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev,
>  			"Error writing reg_motion_intr\n");
> @@ -284,41 +284,28 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
>  	int ret;
>  
>  	/* Enable/Disable INT_MAP0 mapping */
> -	ret = i2c_smbus_read_byte_data(data->client,  BMG160_REG_INT_MAP_0);
> -	if (ret < 0) {
> -		dev_err(&data->client->dev, "Error reading reg_int_map0\n");
> -		return ret;
> -	}
> -	if (status)
> -		ret |= BMG160_INT_MAP_0_BIT_ANY;
> -	else
> -		ret &= ~BMG160_INT_MAP_0_BIT_ANY;
> -
> -	ret = i2c_smbus_write_byte_data(data->client,
> -					BMG160_REG_INT_MAP_0,
> -					ret);
> +	ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_0,
> +				 BMG160_INT_MAP_0_BIT_ANY,
> +				 (status ? BMG160_INT_MAP_0_BIT_ANY : 0));
>  	if (ret < 0) {
> -		dev_err(&data->client->dev, "Error writing reg_int_map0\n");
> +		dev_err(&data->client->dev, "Error updating bits reg_int_map0\n");
>  		return ret;
>  	}
>  
>  	/* Enable/Disable slope interrupts */
>  	if (status) {
>  		/* Update slope thres */
> -		ret = i2c_smbus_write_byte_data(data->client,
> -						BMG160_REG_SLOPE_THRES,
> -						data->slope_thres);
> +		ret = regmap_write(data->regmap, BMG160_REG_SLOPE_THRES,
> +				   data->slope_thres);
>  		if (ret < 0) {
>  			dev_err(&data->client->dev,
>  				"Error writing reg_slope_thres\n");
>  			return ret;
>  		}
>  
> -		ret = i2c_smbus_write_byte_data(data->client,
> -						BMG160_REG_MOTION_INTR,
> -						BMG160_INT_MOTION_X |
> -						BMG160_INT_MOTION_Y |
> -						BMG160_INT_MOTION_Z);
> +		ret = regmap_write(data->regmap, BMG160_REG_MOTION_INTR,
> +				   BMG160_INT_MOTION_X | BMG160_INT_MOTION_Y |
> +				   BMG160_INT_MOTION_Z);
>  		if (ret < 0) {
>  			dev_err(&data->client->dev,
>  				"Error writing reg_motion_intr\n");
> @@ -331,10 +318,10 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
>  		 * to set latched mode, we will be flooded anyway with INTR
>  		 */
>  		if (!data->dready_trigger_on) {
> -			ret = i2c_smbus_write_byte_data(data->client,
> -						BMG160_REG_INT_RST_LATCH,
> -						BMG160_INT_MODE_LATCH_INT |
> -						BMG160_INT_MODE_LATCH_RESET);
> +			ret = regmap_write(data->regmap,
> +					   BMG160_REG_INT_RST_LATCH,
> +					   BMG160_INT_MODE_LATCH_INT |
> +					   BMG160_INT_MODE_LATCH_RESET);
>  			if (ret < 0) {
>  				dev_err(&data->client->dev,
>  					"Error writing reg_rst_latch\n");
> @@ -342,14 +329,12 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
>  			}
>  		}
>  
> -		ret = i2c_smbus_write_byte_data(data->client,
> -						BMG160_REG_INT_EN_0,
> -						BMG160_DATA_ENABLE_INT);
> +		ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
> +				   BMG160_DATA_ENABLE_INT);
>  
> -	} else
> -		ret = i2c_smbus_write_byte_data(data->client,
> -						BMG160_REG_INT_EN_0,
> -						0);
> +	} else {
> +		ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
> +	}
>  
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error writing reg_int_en0\n");
> @@ -365,55 +350,39 @@ static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
>  	int ret;
>  
>  	/* Enable/Disable INT_MAP1 mapping */
> -	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_MAP_1);
> -	if (ret < 0) {
> -		dev_err(&data->client->dev, "Error reading reg_int_map1\n");
> -		return ret;
> -	}
> -
> -	if (status)
> -		ret |= BMG160_INT_MAP_1_BIT_NEW_DATA;
> -	else
> -		ret &= ~BMG160_INT_MAP_1_BIT_NEW_DATA;
> -
> -	ret = i2c_smbus_write_byte_data(data->client,
> -					BMG160_REG_INT_MAP_1,
> -					ret);
> +	ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_1,
> +				 BMG160_INT_MAP_1_BIT_NEW_DATA,
> +				 (status ? BMG160_INT_MAP_1_BIT_NEW_DATA : 0));
>  	if (ret < 0) {
> -		dev_err(&data->client->dev, "Error writing reg_int_map1\n");
> +		dev_err(&data->client->dev, "Error updating bits in reg_int_map1\n");
>  		return ret;
>  	}
>  
>  	if (status) {
> -		ret = i2c_smbus_write_byte_data(data->client,
> -						BMG160_REG_INT_RST_LATCH,
> -						BMG160_INT_MODE_NON_LATCH_INT |
> -						BMG160_INT_MODE_LATCH_RESET);
> +		ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
> +				   BMG160_INT_MODE_NON_LATCH_INT |
> +				   BMG160_INT_MODE_LATCH_RESET);
>  		if (ret < 0) {
>  			dev_err(&data->client->dev,
>  				"Error writing reg_rst_latch\n");
>  				return ret;
>  		}
>  
> -		ret = i2c_smbus_write_byte_data(data->client,
> -						BMG160_REG_INT_EN_0,
> -						BMG160_DATA_ENABLE_INT);
> +		ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
> +				   BMG160_DATA_ENABLE_INT);
>  
>  	} else {
>  		/* Restore interrupt mode */
> -		ret = i2c_smbus_write_byte_data(data->client,
> -						BMG160_REG_INT_RST_LATCH,
> -						BMG160_INT_MODE_LATCH_INT |
> -						BMG160_INT_MODE_LATCH_RESET);
> +		ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
> +				   BMG160_INT_MODE_LATCH_INT |
> +				   BMG160_INT_MODE_LATCH_RESET);
>  		if (ret < 0) {
>  			dev_err(&data->client->dev,
>  				"Error writing reg_rst_latch\n");
>  				return ret;
>  		}
>  
> -		ret = i2c_smbus_write_byte_data(data->client,
> -						BMG160_REG_INT_EN_0,
> -						0);
> +		ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
>  	}
>  
>  	if (ret < 0) {
> @@ -444,10 +413,8 @@ static int bmg160_set_scale(struct bmg160_data *data, int val)
>  
>  	for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
>  		if (bmg160_scale_table[i].scale == val) {
> -			ret = i2c_smbus_write_byte_data(
> -					data->client,
> -					BMG160_REG_RANGE,
> -					bmg160_scale_table[i].dps_range);
> +			ret = regmap_write(data->regmap, BMG160_REG_RANGE,
> +					   bmg160_scale_table[i].dps_range);
>  			if (ret < 0) {
>  				dev_err(&data->client->dev,
>  					"Error writing reg_range\n");
> @@ -464,6 +431,7 @@ static int bmg160_set_scale(struct bmg160_data *data, int val)
>  static int bmg160_get_temp(struct bmg160_data *data, int *val)
>  {
>  	int ret;
> +	unsigned int raw_val;
>  
>  	mutex_lock(&data->mutex);
>  	ret = bmg160_set_power_state(data, true);
> @@ -472,7 +440,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
>  		return ret;
>  	}
>  
> -	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_TEMP);
> +	ret = regmap_read(data->regmap, BMG160_REG_TEMP, &raw_val);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error reading reg_temp\n");
>  		bmg160_set_power_state(data, false);
> @@ -480,7 +448,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
>  		return ret;
>  	}
>  
> -	*val = sign_extend32(ret, 7);
> +	*val = sign_extend32(raw_val, 7);
>  	ret = bmg160_set_power_state(data, false);
>  	mutex_unlock(&data->mutex);
>  	if (ret < 0)
> @@ -492,6 +460,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
>  static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
>  {
>  	int ret;
> +	unsigned int raw_val;
>  
>  	mutex_lock(&data->mutex);
>  	ret = bmg160_set_power_state(data, true);
> @@ -500,7 +469,8 @@ static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
>  		return ret;
>  	}
>  
> -	ret = i2c_smbus_read_word_data(data->client, BMG160_AXIS_TO_REG(axis));
> +	ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(axis), &raw_val,
> +			       2);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error reading axis %d\n", axis);
>  		bmg160_set_power_state(data, false);
> @@ -508,7 +478,7 @@ static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
>  		return ret;
>  	}
>  
> -	*val = sign_extend32(ret, 15);
> +	*val = sign_extend32(raw_val, 15);
>  	ret = bmg160_set_power_state(data, false);
>  	mutex_unlock(&data->mutex);
>  	if (ret < 0)
> @@ -807,12 +777,13 @@ static irqreturn_t bmg160_trigger_handler(int irq, void *p)
>  	struct iio_dev *indio_dev = pf->indio_dev;
>  	struct bmg160_data *data = iio_priv(indio_dev);
>  	int bit, ret, i = 0;
> +	unsigned int val;
>  
>  	mutex_lock(&data->mutex);
>  	for_each_set_bit(bit, indio_dev->active_scan_mask,
>  			 indio_dev->masklength) {
> -		ret = i2c_smbus_read_word_data(data->client,
> -					       BMG160_AXIS_TO_REG(bit));
> +		ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(bit),
> +				       &val, 2);
>  		if (ret < 0) {
>  			mutex_unlock(&data->mutex);
>  			goto err;
> @@ -840,10 +811,9 @@ static int bmg160_trig_try_reen(struct iio_trigger *trig)
>  		return 0;
>  
>  	/* Set latched mode interrupt and clear any latched interrupt */
> -	ret = i2c_smbus_write_byte_data(data->client,
> -					BMG160_REG_INT_RST_LATCH,
> -					BMG160_INT_MODE_LATCH_INT |
> -					BMG160_INT_MODE_LATCH_RESET);
> +	ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
> +			   BMG160_INT_MODE_LATCH_INT |
> +			   BMG160_INT_MODE_LATCH_RESET);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error writing reg_rst_latch\n");
>  		return ret;
> @@ -907,33 +877,34 @@ static irqreturn_t bmg160_event_handler(int irq, void *private)
>  	struct bmg160_data *data = iio_priv(indio_dev);
>  	int ret;
>  	int dir;
> +	unsigned int val;
>  
> -	ret = i2c_smbus_read_byte_data(data->client, BMG160_REG_INT_STATUS_2);
> +	ret = regmap_read(data->regmap, BMG160_REG_INT_STATUS_2, &val);
>  	if (ret < 0) {
>  		dev_err(&data->client->dev, "Error reading reg_int_status2\n");
>  		goto ack_intr_status;
>  	}
>  
> -	if (ret & 0x08)
> +	if (val & 0x08)
>  		dir = IIO_EV_DIR_RISING;
>  	else
>  		dir = IIO_EV_DIR_FALLING;
>  
> -	if (ret & BMG160_ANY_MOTION_BIT_X)
> +	if (val & BMG160_ANY_MOTION_BIT_X)
>  		iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
>  							0,
>  							IIO_MOD_X,
>  							IIO_EV_TYPE_ROC,
>  							dir),
>  							iio_get_time_ns());
> -	if (ret & BMG160_ANY_MOTION_BIT_Y)
> +	if (val & BMG160_ANY_MOTION_BIT_Y)
>  		iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
>  							0,
>  							IIO_MOD_Y,
>  							IIO_EV_TYPE_ROC,
>  							dir),
>  							iio_get_time_ns());
> -	if (ret & BMG160_ANY_MOTION_BIT_Z)
> +	if (val & BMG160_ANY_MOTION_BIT_Z)
>  		iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
>  							0,
>  							IIO_MOD_Z,
> @@ -943,10 +914,9 @@ static irqreturn_t bmg160_event_handler(int irq, void *private)
>  
>  ack_intr_status:
>  	if (!data->dready_trigger_on) {
> -		ret = i2c_smbus_write_byte_data(data->client,
> -					BMG160_REG_INT_RST_LATCH,
> -					BMG160_INT_MODE_LATCH_INT |
> -					BMG160_INT_MODE_LATCH_RESET);
> +		ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
> +				   BMG160_INT_MODE_LATCH_INT |
> +				   BMG160_INT_MODE_LATCH_RESET);
>  		if (ret < 0)
>  			dev_err(&data->client->dev,
>  				"Error writing reg_rst_latch\n");
> @@ -1038,6 +1008,14 @@ static int bmg160_probe(struct i2c_client *client,
>  	struct iio_dev *indio_dev;
>  	int ret;
>  	const char *name = NULL;
> +	struct regmap *regmap;
> +
> +	regmap = devm_regmap_init_i2c(client, &bmg160_regmap_i2c_conf);
> +	if (IS_ERR(regmap)) {
> +		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
> +			(int)PTR_ERR(regmap));
> +		return PTR_ERR(regmap);
> +	}
>  
>  	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
>  	if (!indio_dev)
> -- 
> 2.1.4
> 
> 
> 

-- 
Pengutronix e.K.                           |                             |
Industrial Linux Solutions                 | http://www.pengutronix.de/  |
Peiner Str. 6-8, 31137 Hildesheim, Germany | Phone: +49-5121-206917-0    |
Amtsgericht Hildesheim, HRA 2686           | Fax:   +49-5121-206917-5555 |

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

^ permalink raw reply	[flat|nested] 12+ messages in thread
* Re: [PATCH v2 6/6] iio: bmg160: Add SPI driver
  2015-08-04 11:02 ` [PATCH v2 6/6] iio: bmg160: Add SPI driver Markus Pargmann
@ 2015-08-10 13:38   ` Markus Pargmann
  0 siblings, 0 replies; 12+ messages in thread
From: Markus Pargmann @ 2015-08-10 13:38 UTC (permalink / raw)
  To: Jonathan Cameron
  Cc: Vlad Dogaru, Paul Bolle, linux-iio, linux-kernel, kernel,
	Srinivas Pandruvada

[-- Attachment #1: Type: text/plain, Size: 3934 bytes --]

On Tue, Aug 04, 2015 at 01:02:59PM +0200, Markus Pargmann wrote:
> Signed-off-by: Markus Pargmann <mpa@pengutronix.de>
> ---
>  drivers/iio/gyro/Kconfig      | 11 ++++++++
>  drivers/iio/gyro/Makefile     |  1 +
>  drivers/iio/gyro/bmg160_spi.c | 60 +++++++++++++++++++++++++++++++++++++++++++
>  3 files changed, 72 insertions(+)
>  create mode 100644 drivers/iio/gyro/bmg160_spi.c
> 
> diff --git a/drivers/iio/gyro/Kconfig b/drivers/iio/gyro/Kconfig
> index 1e6cfff5546f..420aea844216 100644
> --- a/drivers/iio/gyro/Kconfig
> +++ b/drivers/iio/gyro/Kconfig
> @@ -72,6 +72,17 @@ config BMG160_I2C
>  	  This driver can also be built as a module.  If so, the module
>  	  will be called bmg160_i2c.
>  
> +config BMG160_SPI
> +	tristate "Driver for connection via SPI"
> +	depends on SPI
> +	select REGMAP_SPI
> +	help
> +	  Say yes here to build support for Bosch BMG160 Tri-axis Gyro Sensor
> +	  driver connected via SPI. This driver also supports BMI055 gyroscope.
> +
> +	  This driver can also be built as a module.  If so, the module
> +	  will be called bmg160_spi.
> +
>  endif
>  
>  config HID_SENSOR_GYRO_3D
> diff --git a/drivers/iio/gyro/Makefile b/drivers/iio/gyro/Makefile
> index 608401041550..f866a4be0667 100644
> --- a/drivers/iio/gyro/Makefile
> +++ b/drivers/iio/gyro/Makefile
> @@ -10,6 +10,7 @@ obj-$(CONFIG_ADIS16260) += adis16260.o
>  obj-$(CONFIG_ADXRS450) += adxrs450.o
>  obj-$(CONFIG_BMG160) += bmg160_core.o
>  obj-$(CONFIG_BMG160_I2C) += bmg160_i2c.o
> +obj-$(CONFIG_BMG160_SPI) += bmg160_spi.o
>  
>  obj-$(CONFIG_HID_SENSOR_GYRO_3D) += hid-sensor-gyro-3d.o
>  
> diff --git a/drivers/iio/gyro/bmg160_spi.c b/drivers/iio/gyro/bmg160_spi.c
> new file mode 100644
> index 000000000000..4dcef65f3476
> --- /dev/null
> +++ b/drivers/iio/gyro/bmg160_spi.c
> @@ -0,0 +1,60 @@
> +#include <linux/spi/spi.h>
> +#include <linux/regmap.h>
> +#include <linux/iio/iio.h>
> +#include <linux/module.h>
> +
> +#include <bmg160.h>
> +
> +static const struct regmap_config bmg160_regmap_spi_conf = {
> +	.reg_bits = 8,
> +	.val_bits = 8,
> +	.read_flag_mask = 0x80,

This read_flag_mask seems to be the default for spi. The regmap spi bus
driver already defines this so it is not necessary here, will remove it.

Best regards,

Markus

> +
> +	.use_single_rw = true,
> +	.cache_type = REGCACHE_NONE,
> +};
> +
> +static int bmg160_spi_probe(struct spi_device *spi)
> +{
> +	struct regmap *regmap;
> +	const struct spi_device_id *id = spi_get_device_id(spi);
> +
> +	regmap = devm_regmap_init_spi(spi, &bmg160_regmap_spi_conf);
> +	if (IS_ERR(regmap)) {
> +		dev_err(&spi->dev, "Failed to register spi regmap %d\n",
> +			(int)PTR_ERR(regmap));
> +		return PTR_ERR(regmap);
> +	}
> +
> +	return bmg160_core_probe(&spi->dev, regmap, spi->irq, id->name);
> +}
> +
> +static int bmg160_spi_remove(struct spi_device *spi)
> +{
> +	bmg160_core_remove(&spi->dev);
> +
> +	return 0;
> +}
> +
> +static const struct spi_device_id bmg160_spi_id[] = {
> +	{"bmg160", 0},
> +	{"bmi055_gyro", 0},
> +	{}
> +};
> +
> +MODULE_DEVICE_TABLE(spi, bmg160_spi_id);
> +
> +static struct spi_driver bmg160_spi_driver = {
> +	.driver = {
> +		.name	= "bmg160_spi",
> +		.pm	= &bmg160_pm_ops,
> +	},
> +	.probe		= bmg160_spi_probe,
> +	.remove		= bmg160_spi_remove,
> +	.id_table	= bmg160_spi_id,
> +};
> +module_spi_driver(bmg160_spi_driver);
> +
> +MODULE_AUTHOR("Markus Pargmann <mpa@pengutronix.de>");
> +MODULE_LICENSE("GPL v2");
> +MODULE_DESCRIPTION("BMG160 SPI Gyro driver");
> -- 
> 2.1.4
> 
> 
> 

-- 
Pengutronix e.K.                           |                             |
Industrial Linux Solutions                 | http://www.pengutronix.de/  |
Peiner Str. 6-8, 31137 Hildesheim, Germany | Phone: +49-5121-206917-0    |
Amtsgericht Hildesheim, HRA 2686           | Fax:   +49-5121-206917-5555 |

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

^ permalink raw reply	[flat|nested] 12+ messages in thread
end of thread, other threads:[~2015-08-10 13:38 UTC | newest]

Thread overview: 12+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2015-08-04 11:02 [PATCH v2 0/6] iio: bmg160: Add SPI connection Markus Pargmann
2015-08-04 11:02 ` [PATCH v2 1/6] iio: bmg160: Use i2c regmap instead of direct i2c access Markus Pargmann
2015-08-09  6:47   ` Markus Pargmann
2015-08-04 11:02 ` [PATCH v2 2/6] iio: bmg160: Remove i2c_client from data struct Markus Pargmann
2015-08-04 11:02 ` [PATCH v2 3/6] iio: bmg160: Use generic dev_drvdata Markus Pargmann
2015-08-04 11:02 ` [PATCH v2 4/6] iio: bmg160: Remove remaining uses of i2c_client Markus Pargmann
2015-08-04 11:02 ` [PATCH v2 5/6] iio: bmg160: Separate i2c and core driver Markus Pargmann
2015-08-08 16:11   ` Jonathan Cameron
2015-08-09  6:45     ` Markus Pargmann
2015-08-04 11:02 ` [PATCH v2 6/6] iio: bmg160: Add SPI driver Markus Pargmann
2015-08-10 13:38   ` Markus Pargmann
2015-08-08 16:12 ` [PATCH v2 0/6] iio: bmg160: Add SPI connection Jonathan Cameron

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.