From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Message-ID: <1506707107.3098.3.camel@linux.intel.com> Subject: Re: [PATCH v3 8/8] iio: accel: kxcjk1013: drop variation number from driver's name From: Srinivas Pandruvada To: Jonathan Cameron , =?UTF-8?Q?Micha=C5=82_Miros=C5=82aw?= Cc: linux-iio@vger.kernel.org, Hartmut Knaack , Lars-Peter Clausen , Peter Meerwald-Stadler Date: Fri, 29 Sep 2017 10:45:07 -0700 In-Reply-To: <20170924160326.7e5d3497@archlinux> References: <20170924160326.7e5d3497@archlinux> Content-Type: text/plain; charset="UTF-8" Mime-Version: 1.0 List-ID: On Sun, 2017-09-24 at 16:03 +0100, Jonathan Cameron wrote: > On Sun, 17 Sep 2017 17:01:05 +0200 > Michał Mirosław wrote: > > > Rename kxcjk-1013 driver by removing -1013 suffix. '1013' is a > > variation > > specifier only (eg. different voltage) as can be seen in datasheet > > for eg. KXTF9 parts. > > > > Old name is left as an modules's alias. Should not matter, though, > > for distros using proper module loading based on device name not > > module name. > > > > Mostly a mechanical change + whitespace fixes. > > > > Signed-off-by: Michał Mirosław > > Whilst this seems logical I worry we'll break some random platforms > init scripts.   I think I'd rather not risk breakage and leave it as > it is.  Once we make a mistake like this, sometimes we are stuck > with it long term unfortunately. > Agree. The config files are not touched when user upgrade kernel. So this may be simply overlooked. That is why we have compatible ids in both ACPI and DTs. Thanks, Srinivas > Jonathan > > > --- > >  drivers/iio/accel/Kconfig                   |   9 +- > >  drivers/iio/accel/Makefile                  |   2 +- > >  drivers/iio/accel/{kxcjk-1013.c => kxcjk.c} | 634 ++++++++++++++ > > -------------- > >  3 files changed, 322 insertions(+), 323 deletions(-) > > > > diff --git a/drivers/iio/accel/Kconfig b/drivers/iio/accel/Kconfig > > index 0be352a7b6f4..627f35af4d12 100644 > > --- a/drivers/iio/accel/Kconfig > > +++ b/drivers/iio/accel/Kconfig > > @@ -212,18 +212,17 @@ config KXSD9_I2C > >     Say yes here to enable the Kionix KXSD9 accelerometer > >     I2C transport channel. > >   > > -config KXCJK1013 > > +config KXCJK > >   tristate "Kionix 3-Axis Accelerometer Driver" > >   depends on I2C > >   select IIO_BUFFER > >   select IIO_TRIGGERED_BUFFER > >   help > > -   Say Y here if you want to build a driver for the Kionix > > KXCJK-1013 > > -   triaxial acceleration sensor. This driver also supports > > KXCJ9-1008, > > -   KXTJ2-1009 and KXTF9. > > +   Say Y here if you want to build a driver for the Kionix > > triaxial > > +   acceleration sensors: KXCJK-1013, KXCJ9-1008, KXTJ2-1009 > > and KXTF9. > >   > >     To compile this driver as a module, choose M here: the > > module will > > -   be called kxcjk-1013. > > +   be called kxcjk. > >   > >  config MC3230 > >   tristate "mCube MC3230 Digital Accelerometer Driver" > > diff --git a/drivers/iio/accel/Makefile > > b/drivers/iio/accel/Makefile > > index 31fba1974e95..bf99eebd774b 100644 > > --- a/drivers/iio/accel/Makefile > > +++ b/drivers/iio/accel/Makefile > > @@ -17,7 +17,7 @@ obj-$(CONFIG_DMARD06) += dmard06.o > >  obj-$(CONFIG_DMARD09) += dmard09.o > >  obj-$(CONFIG_DMARD10) += dmard10.o > >  obj-$(CONFIG_HID_SENSOR_ACCEL_3D) += hid-sensor-accel-3d.o > > -obj-$(CONFIG_KXCJK1013) += kxcjk-1013.o > > +obj-$(CONFIG_KXCJK) += kxcjk.o > >  obj-$(CONFIG_KXSD9) += kxsd9.o > >  obj-$(CONFIG_KXSD9_SPI) += kxsd9-spi.o > >  obj-$(CONFIG_KXSD9_I2C) += kxsd9-i2c.o > > diff --git a/drivers/iio/accel/kxcjk-1013.c > > b/drivers/iio/accel/kxcjk.c > > similarity index 60% > > rename from drivers/iio/accel/kxcjk-1013.c > > rename to drivers/iio/accel/kxcjk.c > > index 7c010892945c..4c830fe76255 100644 > > --- a/drivers/iio/accel/kxcjk-1013.c > > +++ b/drivers/iio/accel/kxcjk.c > > @@ -30,8 +30,8 @@ > >  #include > >  #include > >   > > -#define KXCJK1013_DRV_NAME "kxcjk1013" > > -#define KXCJK1013_IRQ_NAME "kxcjk1013_event" > > +#define KXCJK_DRV_NAME "kxcjk" > > +#define KXCJK_IRQ_NAME "kxcjk-event" > >   > >  #define KXTF9_REG_HP_XOUT_L 0x00 > >  #define KXTF9_REG_HP_XOUT_H 0x01 > > @@ -40,36 +40,36 @@ > >  #define KXTF9_REG_HP_ZOUT_L 0x04 > >  #define KXTF9_REG_HP_ZOUT_H 0x05 > >   > > -#define KXCJK1013_REG_XOUT_L 0x06 > > +#define KXCJK_REG_XOUT_L 0x06 > >  /* > >   * From low byte X axis register, all the other addresses of Y and > > Z can be > >   * obtained by just applying axis offset. The following axis > > defines are just > >   * provide clarity, but not used. > >   */ > > -#define KXCJK1013_REG_XOUT_H 0x07 > > -#define KXCJK1013_REG_YOUT_L 0x08 > > -#define KXCJK1013_REG_YOUT_H 0x09 > > -#define KXCJK1013_REG_ZOUT_L 0x0A > > -#define KXCJK1013_REG_ZOUT_H 0x0B > > +#define KXCJK_REG_XOUT_H 0x07 > > +#define KXCJK_REG_YOUT_L 0x08 > > +#define KXCJK_REG_YOUT_H 0x09 > > +#define KXCJK_REG_ZOUT_L 0x0A > > +#define KXCJK_REG_ZOUT_H 0x0B > >   > > -#define KXCJK1013_REG_DCST_RESP 0x0C > > -#define KXCJK1013_REG_WHO_AM_I 0x0F > > +#define KXCJK_REG_DCST_RESP 0x0C > > +#define KXCJK_REG_WHO_AM_I 0x0F > >  #define KXTF9_REG_TILT_POS_CUR 0x10 > >  #define KXTF9_REG_TILT_POS_PREV 0x11 > >  #define KXTF9_REG_INT_SRC1 0x15 > > -#define KXCJK1013_REG_INT_SRC1 0x16 /* > > compatible, but called INT_SRC2 in KXTF9 ds */ > > -#define KXCJK1013_REG_INT_SRC2 0x17 > > -#define KXCJK1013_REG_STATUS_REG 0x18 > > -#define KXCJK1013_REG_INT_REL 0x1A > > -#define KXCJK1013_REG_CTRL1 0x1B > > +#define KXCJK_REG_INT_SRC1 0x16 /* > > compatible, but called INT_SRC2 in KXTF9 ds */ > > +#define KXCJK_REG_INT_SRC2 0x17 > > +#define KXCJK_REG_STATUS_REG 0x18 > > +#define KXCJK_REG_INT_REL 0x1A > > +#define KXCJK_REG_CTRL1 0x1B > >  #define KXTF9_REG_CTRL2 0x1C > > -#define KXCJK1013_REG_CTRL2 0x1D /* mostly > > compatible, CTRL_REG3 in KTXF9 ds */ > > -#define KXCJK1013_REG_INT_CTRL1 0x1E > > -#define KXCJK1013_REG_INT_CTRL2 0x1F > > +#define KXCJK_REG_CTRL2 0x1D /* > > mostly compatible, CTRL_REG3 in KTXF9 ds */ > > +#define KXCJK_REG_INT_CTRL1 0x1E > > +#define KXCJK_REG_INT_CTRL2 0x1F > >  #define KXTF9_REG_INT_CTRL3 0x20 > > -#define KXCJK1013_REG_DATA_CTRL 0x21 > > +#define KXCJK_REG_DATA_CTRL 0x21 > >  #define KXTF9_REG_TILT_TIMER 0x28 > > -#define KXCJK1013_REG_WAKE_TIMER 0x29 > > +#define KXCJK_REG_WAKE_TIMER 0x29 > >  #define KXTF9_REG_TDT_TIMER 0x2B > >  #define KXTF9_REG_TDT_THRESH_H 0x2C > >  #define KXTF9_REG_TDT_THRESH_L 0x2D > > @@ -77,23 +77,23 @@ > >  #define KXTF9_REG_TDT_TOTAL_TIMER 0x2F > >  #define KXTF9_REG_TDT_LATENCY_TIMER 0x30 > >  #define KXTF9_REG_TDT_WINDOW_TIMER 0x31 > > -#define KXCJK1013_REG_SELF_TEST 0x3A > > +#define KXCJK_REG_SELF_TEST 0x3A > >  #define KXTF9_REG_WAKE_THRESH 0x5A > >  #define KXTF9_REG_TILT_ANGLE 0x5C > >  #define KXTF9_REG_HYST_SET 0x5F > > -#define KXCJK1013_REG_WAKE_THRES 0x6A > > +#define KXCJK_REG_WAKE_THRES 0x6A > >   > > -#define KXCJK1013_REG_CTRL1_BIT_PC1 BIT(7) > > -#define KXCJK1013_REG_CTRL1_BIT_RES BIT(6) > > -#define KXCJK1013_REG_CTRL1_BIT_DRDY BIT(5) > > -#define KXCJK1013_REG_CTRL1_BIT_GSEL1 BIT(4) > > -#define KXCJK1013_REG_CTRL1_BIT_GSEL0 BIT(3) > > -#define KXCJK1013_REG_CTRL1_BIT_WUFE BIT(1) > > +#define KXCJK_REG_CTRL1_BIT_PC1 BIT(7) > > +#define KXCJK_REG_CTRL1_BIT_RES BIT(6) > > +#define KXCJK_REG_CTRL1_BIT_DRDY BIT(5) > > +#define KXCJK_REG_CTRL1_BIT_GSEL1 BIT(4) > > +#define KXCJK_REG_CTRL1_BIT_GSEL0 BIT(3) > > +#define KXCJK_REG_CTRL1_BIT_WUFE BIT(1) > >   > > -#define KXCJK1013_REG_INT_CTRL1_BIT_IEU BIT(2) /* > > KXTF9 */ > > -#define KXCJK1013_REG_INT_CTRL1_BIT_IEL BIT(3) > > -#define KXCJK1013_REG_INT_CTRL1_BIT_IEA BIT(4) > > -#define KXCJK1013_REG_INT_CTRL1_BIT_IEN BIT(5) > > +#define KXCJK_REG_INT_CTRL1_BIT_IEU BIT(2) /* KXTF9 > > */ > > +#define KXCJK_REG_INT_CTRL1_BIT_IEL BIT(3) > > +#define KXCJK_REG_INT_CTRL1_BIT_IEA BIT(4) > > +#define KXCJK_REG_INT_CTRL1_BIT_IEN BIT(5) > >   > >  #define KXTF9_REG_TILT_BIT_LEFT_EDGE BIT(5) > >  #define KXTF9_REG_TILT_BIT_RIGHT_EDGE BIT(4) > > @@ -102,28 +102,28 @@ > >  #define KXTF9_REG_TILT_BIT_FACE_DOWN BIT(1) > >  #define KXTF9_REG_TILT_BIT_FACE_UP BIT(0) > >   > > -#define KXCJK1013_DATA_MASK_12_BIT 0x0FFF > > -#define KXCJK1013_MAX_STARTUP_TIME_US 100000 > > +#define KXCJK_DATA_MASK_12_BIT 0x0FFF > > +#define KXCJK_MAX_STARTUP_TIME_US 100000 > >   > > -#define KXCJK1013_SLEEP_DELAY_MS 2000 > > +#define KXCJK_SLEEP_DELAY_MS 2000 > >   > > -#define KXCJK1013_REG_INT_SRC1_BIT_TPS BIT(0) /* > > KXTF9 */ > > -#define KXCJK1013_REG_INT_SRC1_BIT_WUFS BIT(1) > > -#define KXCJK1013_REG_INT_SRC1_MASK_TDTS (BIT(2) | BIT(3)) > > /* KXTF9 */ > > -#define KXCJK1013_REG_INT_SRC1_TAP_NONE 0 > > -#define KXCJK1013_REG_INT_SRC1_TAP_SINGLE BIT(2) > > -#define KXCJK1013_REG_INT_SRC1_TAP_DOUBLE BIT(3) > > -#define KXCJK1013_REG_INT_SRC1_BIT_DRDY BIT(4) > > +#define KXCJK_REG_INT_SRC1_BIT_TPS BIT(0) /* KXTF9 > > */ > > +#define KXCJK_REG_INT_SRC1_BIT_WUFS BIT(1) > > +#define KXCJK_REG_INT_SRC1_MASK_TDTS (BIT(2) | BIT(3)) > > /* KXTF9 */ > > +#define KXCJK_REG_INT_SRC1_TAP_NONE 0 > > +#define KXCJK_REG_INT_SRC1_TAP_SINGLE BIT(2) > > +#define KXCJK_REG_INT_SRC1_TAP_DOUBLE BIT(3) > > +#define KXCJK_REG_INT_SRC1_BIT_DRDY BIT(4) > >   > >  /* KXCJK: INT_SOURCE2: motion detect, KXTF9: INT_SRC_REG1: tap > > detect */ > > -#define KXCJK1013_REG_INT_SRC2_BIT_ZP BIT(0) > > -#define KXCJK1013_REG_INT_SRC2_BIT_ZN BIT(1) > > -#define KXCJK1013_REG_INT_SRC2_BIT_YP BIT(2) > > -#define KXCJK1013_REG_INT_SRC2_BIT_YN BIT(3) > > -#define KXCJK1013_REG_INT_SRC2_BIT_XP BIT(4) > > -#define KXCJK1013_REG_INT_SRC2_BIT_XN BIT(5) > > +#define KXCJK_REG_INT_SRC2_BIT_ZP BIT(0) > > +#define KXCJK_REG_INT_SRC2_BIT_ZN BIT(1) > > +#define KXCJK_REG_INT_SRC2_BIT_YP BIT(2) > > +#define KXCJK_REG_INT_SRC2_BIT_YN BIT(3) > > +#define KXCJK_REG_INT_SRC2_BIT_XP BIT(4) > > +#define KXCJK_REG_INT_SRC2_BIT_XN BIT(5) > >   > > -#define KXCJK1013_DEFAULT_WAKE_THRES 1 > > +#define KXCJK_DEFAULT_WAKE_THRES 1 > >   > >  enum kx_chipset { > >   KXCJK1013, > > @@ -133,7 +133,7 @@ enum kx_chipset { > >   KX_MAX_CHIPS /* this must be last */ > >  }; > >   > > -struct kxcjk1013_data { > > +struct kxcjk_data { > >   struct i2c_client *client; > >   struct iio_trigger *dready_trig; > >   struct iio_trigger *motion_trig; > > @@ -151,22 +151,22 @@ struct kxcjk1013_data { > >   bool is_smo8500_device; > >  }; > >   > > -enum kxcjk1013_axis { > > +enum kxcjk_axis { > >   AXIS_X, > >   AXIS_Y, > >   AXIS_Z, > >   AXIS_MAX, > >  }; > >   > > -enum kxcjk1013_mode { > > +enum kxcjk_mode { > >   STANDBY, > >   OPERATION, > >  }; > >   > > -enum kxcjk1013_range { > > - KXCJK1013_RANGE_2G, > > - KXCJK1013_RANGE_4G, > > - KXCJK1013_RANGE_8G, > > +enum kxcjk_range { > > + KXCJK_RANGE_2G, > > + KXCJK_RANGE_4G, > > + KXCJK_RANGE_8G, > >  }; > >   > >  struct kx_odr_map { > > @@ -191,7 +191,7 @@ static const struct kx_odr_map > > samp_freq_table[] = { > >   { 1600, 0, 0x07, 0x06 }, > >  }; > >   > > -static const char *const kxcjk1013_samp_freq_avail = > > +static const char *const kxcjk_samp_freq_avail = > >   "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 > > 200 400 800 1600"; > >   > >  static const struct kx_odr_map kxtf9_samp_freq_table[] = { > > @@ -271,28 +271,28 @@ static const struct { > >   u16 scale; > >   u8 gsel_0; > >   u8 gsel_1; > > -} KXCJK1013_scale_table[] = { {9582, 0, 0}, > > -       {19163, 1, 0}, > > -       {38326, 0, 1} }; > > +} kxcjk_scale_table[] = { {9582, 0, 0}, > > +   {19163, 1, 0}, > > +   {38326, 0, 1} }; > >   > > -static int kxcjk1013_set_mode(struct kxcjk1013_data *data, > > -       enum kxcjk1013_mode mode) > > +static int kxcjk_set_mode(struct kxcjk_data *data, > > +       enum kxcjk_mode mode) > >  { > >   int ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_CTRL1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_CTRL1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_ctrl1\n"); > >   return ret; > >   } > >   > >   if (mode == STANDBY) > > - ret &= ~KXCJK1013_REG_CTRL1_BIT_PC1; > > + ret &= ~KXCJK_REG_CTRL1_BIT_PC1; > >   else > > - ret |= KXCJK1013_REG_CTRL1_BIT_PC1; > > + ret |= KXCJK_REG_CTRL1_BIT_PC1; > >   > >   ret = i2c_smbus_write_byte_data(data->client, > > - KXCJK1013_REG_CTRL1, ret); > > + KXCJK_REG_CTRL1, ret); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error writing > > reg_ctrl1\n"); > >   return ret; > > @@ -301,18 +301,18 @@ static int kxcjk1013_set_mode(struct > > kxcjk1013_data *data, > >   return 0; > >  } > >   > > -static int kxcjk1013_get_mode(struct kxcjk1013_data *data, > > -       enum kxcjk1013_mode *mode) > > +static int kxcjk_get_mode(struct kxcjk_data *data, > > +       enum kxcjk_mode *mode) > >  { > >   int ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_CTRL1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_CTRL1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_ctrl1\n"); > >   return ret; > >   } > >   > > - if (ret & KXCJK1013_REG_CTRL1_BIT_PC1) > > + if (ret & KXCJK_REG_CTRL1_BIT_PC1) > >   *mode = OPERATION; > >   else > >   *mode = STANDBY; > > @@ -320,23 +320,23 @@ static int kxcjk1013_get_mode(struct > > kxcjk1013_data *data, > >   return 0; > >  } > >   > > -static int kxcjk1013_set_range(struct kxcjk1013_data *data, int > > range_index) > > +static int kxcjk_set_range(struct kxcjk_data *data, int > > range_index) > >  { > >   int ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_CTRL1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_CTRL1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_ctrl1\n"); > >   return ret; > >   } > >   > > - ret &= ~(KXCJK1013_REG_CTRL1_BIT_GSEL0 | > > -  KXCJK1013_REG_CTRL1_BIT_GSEL1); > > - ret |= (KXCJK1013_scale_table[range_index].gsel_0 << 3); > > - ret |= (KXCJK1013_scale_table[range_index].gsel_1 << 4); > > + ret &= ~(KXCJK_REG_CTRL1_BIT_GSEL0 | > > +  KXCJK_REG_CTRL1_BIT_GSEL1); > > + ret |= (kxcjk_scale_table[range_index].gsel_0 << 3); > > + ret |= (kxcjk_scale_table[range_index].gsel_1 << 4); > >   > >   ret = i2c_smbus_write_byte_data(data->client, > > - KXCJK1013_REG_CTRL1, > > + KXCJK_REG_CTRL1, > >   ret); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error writing > > reg_ctrl1\n"); > > @@ -348,11 +348,11 @@ static int kxcjk1013_set_range(struct > > kxcjk1013_data *data, int range_index) > >   return 0; > >  } > >   > > -static int kxcjk1013_chip_init(struct kxcjk1013_data *data) > > +static int kxcjk_chip_init(struct kxcjk_data *data) > >  { > >   int ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_WHO_AM_I); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_WHO_AM_I); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > who_am_i\n"); > >   return ret; > > @@ -360,20 +360,20 @@ static int kxcjk1013_chip_init(struct > > kxcjk1013_data *data) > >   > >   dev_dbg(&data->client->dev, "KXCJK1013 Chip Id %x\n", > > ret); > >   > > - ret = kxcjk1013_set_mode(data, STANDBY); > > + ret = kxcjk_set_mode(data, STANDBY); > >   if (ret < 0) > >   return ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_CTRL1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_CTRL1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_ctrl1\n"); > >   return ret; > >   } > >   > >   /* Set 12 bit mode */ > > - ret |= KXCJK1013_REG_CTRL1_BIT_RES; > > + ret |= KXCJK_REG_CTRL1_BIT_RES; > >   > > - ret = i2c_smbus_write_byte_data(data->client, > > KXCJK1013_REG_CTRL1, > > + ret = i2c_smbus_write_byte_data(data->client, > > KXCJK_REG_CTRL1, > >   ret); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_ctrl\n"); > > @@ -381,11 +381,11 @@ static int kxcjk1013_chip_init(struct > > kxcjk1013_data *data) > >   } > >   > >   /* Setting range to 4G */ > > - ret = kxcjk1013_set_range(data, KXCJK1013_RANGE_4G); > > + ret = kxcjk_set_range(data, KXCJK_RANGE_4G); > >   if (ret < 0) > >   return ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_DATA_CTRL); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_DATA_CTRL); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_data_ctrl\n"); > >   return ret; > > @@ -394,32 +394,32 @@ static int kxcjk1013_chip_init(struct > > kxcjk1013_data *data) > >   data->odr_bits = ret; > >   > >   /* Set up INT polarity */ > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_INT_CTRL1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_INT_CTRL1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_int_ctrl1\n"); > >   return ret; > >   } > >   > > - ret |= KXCJK1013_REG_INT_CTRL1_BIT_IEA; > > + ret |= KXCJK_REG_INT_CTRL1_BIT_IEA; > >   > > - ret = i2c_smbus_write_byte_data(data->client, > > KXCJK1013_REG_INT_CTRL1, > > + ret = i2c_smbus_write_byte_data(data->client, > > KXCJK_REG_INT_CTRL1, > >   ret); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error writing > > reg_int_ctrl1\n"); > >   return ret; > >   } > >   > > - ret = kxcjk1013_set_mode(data, OPERATION); > > + ret = kxcjk_set_mode(data, OPERATION); > >   if (ret < 0) > >   return ret; > >   > > - data->wake_thres = KXCJK1013_DEFAULT_WAKE_THRES; > > + data->wake_thres = KXCJK_DEFAULT_WAKE_THRES; > >   > >   return 0; > >  } > >   > >  #ifdef CONFIG_PM > > -static int kxcjk1013_get_startup_times(struct kxcjk1013_data > > *data) > > +static int kxcjk_get_startup_times(struct kxcjk_data *data) > >  { > >   int i; > >   int idx = data->chipset; > > @@ -429,11 +429,11 @@ static int kxcjk1013_get_startup_times(struct > > kxcjk1013_data *data) > >   return odr_start_up_times[idx][i].usec; > >   } > >   > > - return KXCJK1013_MAX_STARTUP_TIME_US; > > + return KXCJK_MAX_STARTUP_TIME_US; > >  } > >  #endif > >   > > -static int kxcjk1013_set_power_state(struct kxcjk1013_data *data, > > bool on) > > +static int kxcjk_set_power_state(struct kxcjk_data *data, bool on) > >  { > >  #ifdef CONFIG_PM > >   int ret; > > @@ -446,7 +446,7 @@ static int kxcjk1013_set_power_state(struct > > kxcjk1013_data *data, bool on) > >   } > >   if (ret < 0) { > >   dev_err(&data->client->dev, > > - "Failed: kxcjk1013_set_power_state for > > %d\n", on); > > + "Failed: kxcjk_set_power_state for %d\n", > > on); > >   if (on) > >   pm_runtime_put_noidle(&data->client->dev); > >   return ret; > > @@ -456,12 +456,12 @@ static int kxcjk1013_set_power_state(struct > > kxcjk1013_data *data, bool on) > >   return 0; > >  } > >   > > -static int kxcjk1013_chip_update_thresholds(struct kxcjk1013_data > > *data) > > +static int kxcjk_chip_update_thresholds(struct kxcjk_data *data) > >  { > >   int waketh_reg, ret; > >   > >   ret = i2c_smbus_write_byte_data(data->client, > > - KXCJK1013_REG_WAKE_TIMER, > > + KXCJK_REG_WAKE_TIMER, > >   data->wake_dur); > >   if (ret < 0) { > >   dev_err(&data->client->dev, > > @@ -470,7 +470,7 @@ static int > > kxcjk1013_chip_update_thresholds(struct kxcjk1013_data *data) > >   } > >   > >   waketh_reg = data->chipset == KXTF9 ? > > - KXTF9_REG_WAKE_THRESH : KXCJK1013_REG_WAKE_THRES; > > + KXTF9_REG_WAKE_THRESH : KXCJK_REG_WAKE_THRES; > >   ret = i2c_smbus_write_byte_data(data->client, waketh_reg, > >   data->wake_thres); > >   if (ret < 0) { > > @@ -481,63 +481,63 @@ static int > > kxcjk1013_chip_update_thresholds(struct kxcjk1013_data *data) > >   return 0; > >  } > >   > > -static int kxcjk1013_setup_any_motion_interrupt(struct > > kxcjk1013_data *data, > > - bool status) > > +static int kxcjk_setup_any_motion_interrupt(struct kxcjk_data > > *data, > > +     bool status) > >  { > >   int ret; > > - enum kxcjk1013_mode store_mode; > > + enum kxcjk_mode store_mode; > >   > > - ret = kxcjk1013_get_mode(data, &store_mode); > > + ret = kxcjk_get_mode(data, &store_mode); > >   if (ret < 0) > >   return ret; > >   > >   /* This is requirement by spec to change state to STANDBY > > */ > > - ret = kxcjk1013_set_mode(data, STANDBY); > > + ret = kxcjk_set_mode(data, STANDBY); > >   if (ret < 0) > >   return ret; > >   > > - ret = kxcjk1013_chip_update_thresholds(data); > > + ret = kxcjk_chip_update_thresholds(data); > >   if (ret < 0) > >   return ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_INT_CTRL1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_INT_CTRL1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_int_ctrl1\n"); > >   return ret; > >   } > >   > >   if (status) > > - ret |= KXCJK1013_REG_INT_CTRL1_BIT_IEN; > > + ret |= KXCJK_REG_INT_CTRL1_BIT_IEN; > >   else > > - ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEN; > > + ret &= ~KXCJK_REG_INT_CTRL1_BIT_IEN; > >   > > - ret = i2c_smbus_write_byte_data(data->client, > > KXCJK1013_REG_INT_CTRL1, > > + ret = i2c_smbus_write_byte_data(data->client, > > KXCJK_REG_INT_CTRL1, > >   ret); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error writing > > reg_int_ctrl1\n"); > >   return ret; > >   } > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_CTRL1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_CTRL1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_ctrl1\n"); > >   return ret; > >   } > >   > >   if (status) > > - ret |= KXCJK1013_REG_CTRL1_BIT_WUFE; > > + ret |= KXCJK_REG_CTRL1_BIT_WUFE; > >   else > > - ret &= ~KXCJK1013_REG_CTRL1_BIT_WUFE; > > + ret &= ~KXCJK_REG_CTRL1_BIT_WUFE; > >   > >   ret = i2c_smbus_write_byte_data(data->client, > > - KXCJK1013_REG_CTRL1, ret); > > + KXCJK_REG_CTRL1, ret); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error writing > > reg_ctrl1\n"); > >   return ret; > >   } > >   > >   if (store_mode == OPERATION) { > > - ret = kxcjk1013_set_mode(data, OPERATION); > > + ret = kxcjk_set_mode(data, OPERATION); > >   if (ret < 0) > >   return ret; > >   } > > @@ -545,59 +545,58 @@ static int > > kxcjk1013_setup_any_motion_interrupt(struct kxcjk1013_data *data, > >   return 0; > >  } > >   > > -static int kxcjk1013_setup_new_data_interrupt(struct > > kxcjk1013_data *data, > > -       bool status) > > +static int kxcjk_setup_new_data_interrupt(struct kxcjk_data *data, > > bool status) > >  { > >   int ret; > > - enum kxcjk1013_mode store_mode; > > + enum kxcjk_mode store_mode; > >   > > - ret = kxcjk1013_get_mode(data, &store_mode); > > + ret = kxcjk_get_mode(data, &store_mode); > >   if (ret < 0) > >   return ret; > >   > >   /* This is requirement by spec to change state to STANDBY > > */ > > - ret = kxcjk1013_set_mode(data, STANDBY); > > + ret = kxcjk_set_mode(data, STANDBY); > >   if (ret < 0) > >   return ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_INT_CTRL1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_INT_CTRL1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_int_ctrl1\n"); > >   return ret; > >   } > >   > >   if (status) > > - ret |= KXCJK1013_REG_INT_CTRL1_BIT_IEN; > > + ret |= KXCJK_REG_INT_CTRL1_BIT_IEN; > >   else > > - ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEN; > > + ret &= ~KXCJK_REG_INT_CTRL1_BIT_IEN; > >   > > - ret = i2c_smbus_write_byte_data(data->client, > > KXCJK1013_REG_INT_CTRL1, > > + ret = i2c_smbus_write_byte_data(data->client, > > KXCJK_REG_INT_CTRL1, > >   ret); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error writing > > reg_int_ctrl1\n"); > >   return ret; > >   } > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_CTRL1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_CTRL1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_ctrl1\n"); > >   return ret; > >   } > >   > >   if (status) > > - ret |= KXCJK1013_REG_CTRL1_BIT_DRDY; > > + ret |= KXCJK_REG_CTRL1_BIT_DRDY; > >   else > > - ret &= ~KXCJK1013_REG_CTRL1_BIT_DRDY; > > + ret &= ~KXCJK_REG_CTRL1_BIT_DRDY; > >   > >   ret = i2c_smbus_write_byte_data(data->client, > > - KXCJK1013_REG_CTRL1, ret); > > + KXCJK_REG_CTRL1, ret); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error writing > > reg_ctrl1\n"); > >   return ret; > >   } > >   > >   if (store_mode == OPERATION) { > > - ret = kxcjk1013_set_mode(data, OPERATION); > > + ret = kxcjk_set_mode(data, OPERATION); > >   if (ret < 0) > >   return ret; > >   } > > @@ -605,7 +604,7 @@ static int > > kxcjk1013_setup_new_data_interrupt(struct kxcjk1013_data *data, > >   return 0; > >  } > >   > > -static const struct kx_odr_map *kxcjk1013_find_odr_value( > > +static const struct kx_odr_map *kxcjk_find_odr_value( > >   const struct kx_odr_map *map, size_t map_size, int val, > > int val2) > >  { > >   int i; > > @@ -618,9 +617,9 @@ static const struct kx_odr_map > > *kxcjk1013_find_odr_value( > >   return ERR_PTR(-EINVAL); > >  } > >   > > -static int kxcjk1013_convert_odr_value(const struct kx_odr_map > > *map, > > -        size_t map_size, int > > odr_bits, > > -        int *val, int *val2) > > +static int kxcjk_convert_odr_value(const struct kx_odr_map *map, > > +    size_t map_size, int odr_bits, > > +    int *val, int *val2) > >  { > >   int i; > >   > > @@ -635,22 +634,22 @@ static int kxcjk1013_convert_odr_value(const > > struct kx_odr_map *map, > >   return -EINVAL; > >  } > >   > > -static int kxcjk1013_set_odr(struct kxcjk1013_data *data, int val, > > int val2) > > +static int kxcjk_set_odr(struct kxcjk_data *data, int val, int > > val2) > >  { > >   int ret; > > - enum kxcjk1013_mode store_mode; > > + enum kxcjk_mode store_mode; > >   const struct kx_odr_map *odr_setting; > >   > > - ret = kxcjk1013_get_mode(data, &store_mode); > > + ret = kxcjk_get_mode(data, &store_mode); > >   if (ret < 0) > >   return ret; > >   > >   if (data->chipset == KXTF9) > > - odr_setting = > > kxcjk1013_find_odr_value(kxtf9_samp_freq_table, > > + odr_setting = > > kxcjk_find_odr_value(kxtf9_samp_freq_table, > >          ARRAY_SIZE( > > kxtf9_samp_freq_table), > >          val, val2); > >   else > > - odr_setting = > > kxcjk1013_find_odr_value(samp_freq_table, > > + odr_setting = > > kxcjk_find_odr_value(samp_freq_table, > >          ARRAY_SIZE( > > samp_freq_table), > >          val, val2); > >   > > @@ -658,11 +657,11 @@ static int kxcjk1013_set_odr(struct > > kxcjk1013_data *data, int val, int val2) > >   return PTR_ERR(odr_setting); > >   > >   /* To change ODR, the chip must be set to STANDBY as per > > spec */ > > - ret = kxcjk1013_set_mode(data, STANDBY); > > + ret = kxcjk_set_mode(data, STANDBY); > >   if (ret < 0) > >   return ret; > >   > > - ret = i2c_smbus_write_byte_data(data->client, > > KXCJK1013_REG_DATA_CTRL, > > + ret = i2c_smbus_write_byte_data(data->client, > > KXCJK_REG_DATA_CTRL, > >   odr_setting->odr_bits); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error writing > > data_ctrl\n"); > > @@ -671,7 +670,7 @@ static int kxcjk1013_set_odr(struct > > kxcjk1013_data *data, int val, int val2) > >   > >   data->odr_bits = odr_setting->odr_bits; > >   > > - ret = i2c_smbus_write_byte_data(data->client, > > KXCJK1013_REG_CTRL2, > > + ret = i2c_smbus_write_byte_data(data->client, > > KXCJK_REG_CTRL2, > >   odr_setting->wuf_bits); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error writing > > reg_ctrl2\n"); > > @@ -679,7 +678,7 @@ static int kxcjk1013_set_odr(struct > > kxcjk1013_data *data, int val, int val2) > >   } > >   > >   if (store_mode == OPERATION) { > > - ret = kxcjk1013_set_mode(data, OPERATION); > > + ret = kxcjk_set_mode(data, OPERATION); > >   if (ret < 0) > >   return ret; > >   } > > @@ -687,21 +686,21 @@ static int kxcjk1013_set_odr(struct > > kxcjk1013_data *data, int val, int val2) > >   return 0; > >  } > >   > > -static int kxcjk1013_get_odr(struct kxcjk1013_data *data, int > > *val, int *val2) > > +static int kxcjk_get_odr(struct kxcjk_data *data, int *val, int > > *val2) > >  { > >   if (data->chipset == KXTF9) > > - return > > kxcjk1013_convert_odr_value(kxtf9_samp_freq_table, > > + return > > kxcjk_convert_odr_value(kxtf9_samp_freq_table, > >      ARRAY_SIZE(kxtf > > 9_samp_freq_table), > >      data->odr_bits, > > val, val2); > >   else > > - return > > kxcjk1013_convert_odr_value(samp_freq_table, > > + return kxcjk_convert_odr_value(samp_freq_table, > >      ARRAY_SIZE(samp > > _freq_table), > >      data->odr_bits, > > val, val2); > >  } > >   > > -static int kxcjk1013_get_acc_reg(struct kxcjk1013_data *data, int > > axis) > > +static int kxcjk_get_acc_reg(struct kxcjk_data *data, int axis) > >  { > > - u8 reg = KXCJK1013_REG_XOUT_L + axis * 2; > > + u8 reg = KXCJK_REG_XOUT_L + axis * 2; > >   int ret; > >   > >   ret = i2c_smbus_read_word_data(data->client, reg); > > @@ -714,27 +713,27 @@ static int kxcjk1013_get_acc_reg(struct > > kxcjk1013_data *data, int axis) > >   return ret; > >  } > >   > > -static int kxcjk1013_set_scale(struct kxcjk1013_data *data, int > > val) > > +static int kxcjk_set_scale(struct kxcjk_data *data, int val) > >  { > >   int ret, i; > > - enum kxcjk1013_mode store_mode; > > + enum kxcjk_mode store_mode; > >   > > - for (i = 0; i < ARRAY_SIZE(KXCJK1013_scale_table); ++i) { > > - if (KXCJK1013_scale_table[i].scale == val) { > > - ret = kxcjk1013_get_mode(data, > > &store_mode); > > + for (i = 0; i < ARRAY_SIZE(kxcjk_scale_table); ++i) { > > + if (kxcjk_scale_table[i].scale == val) { > > + ret = kxcjk_get_mode(data, &store_mode); > >   if (ret < 0) > >   return ret; > >   > > - ret = kxcjk1013_set_mode(data, STANDBY); > > + ret = kxcjk_set_mode(data, STANDBY); > >   if (ret < 0) > >   return ret; > >   > > - ret = kxcjk1013_set_range(data, i); > > + ret = kxcjk_set_range(data, i); > >   if (ret < 0) > >   return ret; > >   > >   if (store_mode == OPERATION) { > > - ret = kxcjk1013_set_mode(data, > > OPERATION); > > + ret = kxcjk_set_mode(data, > > OPERATION); > >   if (ret) > >   return ret; > >   } > > @@ -746,11 +745,11 @@ static int kxcjk1013_set_scale(struct > > kxcjk1013_data *data, int val) > >   return -EINVAL; > >  } > >   > > -static int kxcjk1013_read_raw(struct iio_dev *indio_dev, > > +static int kxcjk_read_raw(struct iio_dev *indio_dev, > >         struct iio_chan_spec const *chan, > > int *val, > >         int *val2, long mask) > >  { > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   > >   switch (mask) { > > @@ -759,19 +758,19 @@ static int kxcjk1013_read_raw(struct iio_dev > > *indio_dev, > >   if (iio_buffer_enabled(indio_dev)) > >   ret = -EBUSY; > >   else { > > - ret = kxcjk1013_set_power_state(data, > > true); > > + ret = kxcjk_set_power_state(data, true); > >   if (ret < 0) { > >   mutex_unlock(&data->mutex); > >   return ret; > >   } > > - ret = kxcjk1013_get_acc_reg(data, chan- > > >scan_index); > > + ret = kxcjk_get_acc_reg(data, chan- > > >scan_index); > >   if (ret < 0) { > > - kxcjk1013_set_power_state(data, > > false); > > + kxcjk_set_power_state(data, > > false); > >   mutex_unlock(&data->mutex); > >   return ret; > >   } > >   *val = sign_extend32(ret >> 4, 11); > > - ret = kxcjk1013_set_power_state(data, > > false); > > + ret = kxcjk_set_power_state(data, false); > >   } > >   mutex_unlock(&data->mutex); > >   > > @@ -782,12 +781,12 @@ static int kxcjk1013_read_raw(struct iio_dev > > *indio_dev, > >   > >   case IIO_CHAN_INFO_SCALE: > >   *val = 0; > > - *val2 = KXCJK1013_scale_table[data->range].scale; > > + *val2 = kxcjk_scale_table[data->range].scale; > >   return IIO_VAL_INT_PLUS_MICRO; > >   > >   case IIO_CHAN_INFO_SAMP_FREQ: > >   mutex_lock(&data->mutex); > > - ret = kxcjk1013_get_odr(data, val, val2); > > + ret = kxcjk_get_odr(data, val, val2); > >   mutex_unlock(&data->mutex); > >   return ret; > >   > > @@ -796,17 +795,17 @@ static int kxcjk1013_read_raw(struct iio_dev > > *indio_dev, > >   } > >  } > >   > > -static int kxcjk1013_write_raw(struct iio_dev *indio_dev, > > -        struct iio_chan_spec const *chan, > > int val, > > -        int val2, long mask) > > +static int kxcjk_write_raw(struct iio_dev *indio_dev, > > +    struct iio_chan_spec const *chan, int > > val, > > +    int val2, long mask) > >  { > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   > >   switch (mask) { > >   case IIO_CHAN_INFO_SAMP_FREQ: > >   mutex_lock(&data->mutex); > > - ret = kxcjk1013_set_odr(data, val, val2); > > + ret = kxcjk_set_odr(data, val, val2); > >   mutex_unlock(&data->mutex); > >   break; > >   case IIO_CHAN_INFO_SCALE: > > @@ -814,7 +813,7 @@ static int kxcjk1013_write_raw(struct iio_dev > > *indio_dev, > >   return -EINVAL; > >   > >   mutex_lock(&data->mutex); > > - ret = kxcjk1013_set_scale(data, val2); > > + ret = kxcjk_set_scale(data, val2); > >   mutex_unlock(&data->mutex); > >   break; > >   default: > > @@ -824,14 +823,14 @@ static int kxcjk1013_write_raw(struct iio_dev > > *indio_dev, > >   return ret; > >  } > >   > > -static int kxcjk1013_read_event(struct iio_dev *indio_dev, > > -    const struct iio_chan_spec > > *chan, > > -    enum iio_event_type type, > > -    enum iio_event_direction dir, > > -    enum iio_event_info info, > > -    int *val, int *val2) > > +static int kxcjk_read_event(struct iio_dev *indio_dev, > > +     const struct iio_chan_spec *chan, > > +     enum iio_event_type type, > > +     enum iio_event_direction dir, > > +     enum iio_event_info info, > > +     int *val, int *val2) > >  { > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   > >   *val2 = 0; > >   switch (info) { > > @@ -848,14 +847,14 @@ static int kxcjk1013_read_event(struct > > iio_dev *indio_dev, > >   return IIO_VAL_INT; > >  } > >   > > -static int kxcjk1013_write_event(struct iio_dev *indio_dev, > > -     const struct iio_chan_spec > > *chan, > > -     enum iio_event_type type, > > -     enum iio_event_direction dir, > > -     enum iio_event_info info, > > -     int val, int val2) > > +static int kxcjk_write_event(struct iio_dev *indio_dev, > > +      const struct iio_chan_spec *chan, > > +      enum iio_event_type type, > > +      enum iio_event_direction dir, > > +      enum iio_event_info info, > > +      int val, int val2) > >  { > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   > >   if (data->ev_enable_state) > >   return -EBUSY; > > @@ -874,23 +873,23 @@ static int kxcjk1013_write_event(struct > > iio_dev *indio_dev, > >   return 0; > >  } > >   > > -static int kxcjk1013_read_event_config(struct iio_dev *indio_dev, > > -   const struct > > iio_chan_spec *chan, > > -   enum iio_event_type > > type, > > -   enum iio_event_direction > > dir) > > +static int kxcjk_read_event_config(struct iio_dev *indio_dev, > > +    const struct iio_chan_spec > > *chan, > > +    enum iio_event_type type, > > +    enum iio_event_direction dir) > >  { > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   > >   return data->ev_enable_state; > >  } > >   > > -static int kxcjk1013_write_event_config(struct iio_dev *indio_dev, > > -    const struct > > iio_chan_spec *chan, > > -    enum iio_event_type > > type, > > -    enum > > iio_event_direction dir, > > -    int state) > > +static int kxcjk_write_event_config(struct iio_dev *indio_dev, > > +     const struct iio_chan_spec > > *chan, > > +     enum iio_event_type type, > > +     enum iio_event_direction dir, > > +     int state) > >  { > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   > >   if (state && data->ev_enable_state) > > @@ -913,15 +912,15 @@ static int > > kxcjk1013_write_event_config(struct iio_dev *indio_dev, > >    * enable operation. When runtime pm is disabled the mode > >    * is always on so sequence doesn't matter > >    */ > > - ret = kxcjk1013_set_power_state(data, state); > > + ret = kxcjk_set_power_state(data, state); > >   if (ret < 0) { > >   mutex_unlock(&data->mutex); > >   return ret; > >   } > >   > > - ret =  kxcjk1013_setup_any_motion_interrupt(data, state); > > + ret =  kxcjk_setup_any_motion_interrupt(data, state); > >   if (ret < 0) { > > - kxcjk1013_set_power_state(data, false); > > + kxcjk_set_power_state(data, false); > >   data->ev_enable_state = 0; > >   mutex_unlock(&data->mutex); > >   return ret; > > @@ -933,66 +932,66 @@ static int > > kxcjk1013_write_event_config(struct iio_dev *indio_dev, > >   return 0; > >  } > >   > > -static int kxcjk1013_buffer_preenable(struct iio_dev *indio_dev) > > +static int kxcjk_buffer_preenable(struct iio_dev *indio_dev) > >  { > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   > > - return kxcjk1013_set_power_state(data, true); > > + return kxcjk_set_power_state(data, true); > >  } > >   > > -static int kxcjk1013_buffer_postdisable(struct iio_dev *indio_dev) > > +static int kxcjk_buffer_postdisable(struct iio_dev *indio_dev) > >  { > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   > > - return kxcjk1013_set_power_state(data, false); > > + return kxcjk_set_power_state(data, false); > >  } > >   > > -static ssize_t kxcjk1013_get_samp_freq_avail(struct device *dev, > > -      struct > > device_attribute *attr, > > -      char *buf) > > +static ssize_t kxcjk_get_samp_freq_avail(struct device *dev, > > +  struct device_attribute > > *attr, > > +  char *buf) > >  { > >   struct iio_dev *indio_dev = dev_to_iio_dev(dev); > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   const char *str; > >   > >   if (data->chipset == KXTF9) > >   str = kxtf9_samp_freq_avail; > >   else > > - str = kxcjk1013_samp_freq_avail; > > + str = kxcjk_samp_freq_avail; > >   > >   return sprintf(buf, "%s\n", str); > >  } > >   > >  static IIO_DEVICE_ATTR(in_accel_sampling_frequency_available, > > S_IRUGO, > > -        kxcjk1013_get_samp_freq_avail, NULL, 0); > > +        kxcjk_get_samp_freq_avail, NULL, 0); > >   > >  static IIO_CONST_ATTR(in_accel_scale_available, "0.009582 0.019163 > > 0.038326"); > >   > > -static struct attribute *kxcjk1013_attributes[] = { > > +static struct attribute *kxcjk_attributes[] = { > >   &iio_dev_attr_in_accel_sampling_frequency_available.dev_at > > tr.attr, > >   &iio_const_attr_in_accel_scale_available.dev_attr.attr, > >   NULL, > >  }; > >   > > -static const struct attribute_group kxcjk1013_attrs_group = { > > - .attrs = kxcjk1013_attributes, > > +static const struct attribute_group kxcjk_attrs_group = { > > + .attrs = kxcjk_attributes, > >  }; > >   > > -static const struct iio_event_spec kxcjk1013_event = { > > - .type = IIO_EV_TYPE_THRESH, > > - .dir = IIO_EV_DIR_EITHER, > > - .mask_separate = BIT(IIO_EV_INFO_VALUE) | > > -  BIT(IIO_EV_INFO_ENABLE) | > > -  BIT(IIO_EV_INFO_PERIOD) > > +static const struct iio_event_spec kxcjk_event = { > > + .type = IIO_EV_TYPE_THRESH, > > + .dir = IIO_EV_DIR_EITHER, > > + .mask_separate = BIT(IIO_EV_INFO_VALUE) | > > +  BIT(IIO_EV_INFO_ENABLE) | > > +  BIT(IIO_EV_INFO_PERIOD) > >  }; > >   > > -#define KXCJK1013_CHANNEL(_axis) { > > \ > > +#define KXCJK_CHANNEL(_axis) { > > \ > >   .type = IIO_ACCEL, > > \ > >   .modified = 1, > > \ > >   .channel2 = IIO_MOD_##_axis, > > \ > >   .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), > > \ > >   .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | > > \ > > - BIT(IIO_CHAN_INFO_SAMP_FREQ), > > \ > > +     BIT(IIO_CHAN_INFO_SAMP_FREQ), > > \ > >   .scan_index = AXIS_##_axis, > > \ > >   .scan_type = { > > \ > >   .sign = 's', > > \ > > @@ -1001,47 +1000,47 @@ static const struct iio_event_spec > > kxcjk1013_event = { > >   .shift = 4, > > \ > >   .endianness = IIO_LE, > > \ > >   }, > > \ > > - .event_spec = &kxcjk1013_event, > > \ > > + .event_spec = &kxcjk_event, > > \ > >   .num_event_specs = 1 > > \ > >  } > >   > > -static const struct iio_chan_spec kxcjk1013_channels[] = { > > - KXCJK1013_CHANNEL(X), > > - KXCJK1013_CHANNEL(Y), > > - KXCJK1013_CHANNEL(Z), > > +static const struct iio_chan_spec kxcjk_channels[] = { > > + KXCJK_CHANNEL(X), > > + KXCJK_CHANNEL(Y), > > + KXCJK_CHANNEL(Z), > >   IIO_CHAN_SOFT_TIMESTAMP(3), > >  }; > >   > > -static const struct iio_buffer_setup_ops > > kxcjk1013_buffer_setup_ops = { > > - .preenable = kxcjk1013_buffer_preenable, > > +static const struct iio_buffer_setup_ops kxcjk_buffer_setup_ops = > > { > > + .preenable = kxcjk_buffer_preenable, > >   .postenable = > > iio_triggered_buffer_postenable, > > - .postdisable = > > kxcjk1013_buffer_postdisable, > > + .postdisable = kxcjk_buffer_postdisable, > >   .predisable = > > iio_triggered_buffer_predisable, > >  }; > >   > > -static const struct iio_info kxcjk1013_info = { > > - .attrs = &kxcjk1013_attrs_group, > > - .read_raw = kxcjk1013_read_raw, > > - .write_raw = kxcjk1013_write_raw, > > - .read_event_value = kxcjk1013_read_event, > > - .write_event_value = kxcjk1013_write_event, > > - .write_event_config = kxcjk1013_write_event_config, > > - .read_event_config = kxcjk1013_read_event_config, > > +static const struct iio_info kxcjk_info = { > > + .attrs = &kxcjk_attrs_group, > > + .read_raw = kxcjk_read_raw, > > + .write_raw = kxcjk_write_raw, > > + .read_event_value = kxcjk_read_event, > > + .write_event_value = kxcjk_write_event, > > + .write_event_config = kxcjk_write_event_config, > > + .read_event_config = kxcjk_read_event_config, > >   .driver_module = THIS_MODULE, > >  }; > >   > > -static const unsigned long kxcjk1013_scan_masks[] = {0x7, 0}; > > +static const unsigned long kxcjk_scan_masks[] = {0x7, 0}; > >   > > -static irqreturn_t kxcjk1013_trigger_handler(int irq, void *p) > > +static irqreturn_t kxcjk_trigger_handler(int irq, void *p) > >  { > >   struct iio_poll_func *pf = p; > >   struct iio_dev *indio_dev = pf->indio_dev; > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   > >   mutex_lock(&data->mutex); > >   ret = i2c_smbus_read_i2c_block_data_or_emulated(data- > > >client, > > - KXCJK1013_ > > REG_XOUT_L, > > + KXCJK_REG_ > > XOUT_L, > >   AXIS_MAX * > > 2, > >   (u8 > > *)data->buffer); > >   mutex_unlock(&data->mutex); > > @@ -1056,13 +1055,13 @@ static irqreturn_t > > kxcjk1013_trigger_handler(int irq, void *p) > >   return IRQ_HANDLED; > >  } > >   > > -static int kxcjk1013_trig_try_reen(struct iio_trigger *trig) > > +static int kxcjk_trig_try_reen(struct iio_trigger *trig) > >  { > >   struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_INT_REL); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_INT_REL); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_int_rel\n"); > >   return ret; > > @@ -1071,11 +1070,11 @@ static int kxcjk1013_trig_try_reen(struct > > iio_trigger *trig) > >   return 0; > >  } > >   > > -static int kxcjk1013_data_rdy_trigger_set_state(struct iio_trigger > > *trig, > > - bool state) > > +static int kxcjk_data_rdy_trigger_set_state(struct iio_trigger > > *trig, > > +     bool state) > >  { > >   struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   > >   mutex_lock(&data->mutex); > > @@ -1086,17 +1085,17 @@ static int > > kxcjk1013_data_rdy_trigger_set_state(struct iio_trigger *trig, > >   return 0; > >   } > >   > > - ret = kxcjk1013_set_power_state(data, state); > > + ret = kxcjk_set_power_state(data, state); > >   if (ret < 0) { > >   mutex_unlock(&data->mutex); > >   return ret; > >   } > >   if (data->motion_trig == trig) > > - ret = kxcjk1013_setup_any_motion_interrupt(data, > > state); > > + ret = kxcjk_setup_any_motion_interrupt(data, > > state); > >   else > > - ret = kxcjk1013_setup_new_data_interrupt(data, > > state); > > + ret = kxcjk_setup_new_data_interrupt(data, state); > >   if (ret < 0) { > > - kxcjk1013_set_power_state(data, false); > > + kxcjk_set_power_state(data, false); > >   mutex_unlock(&data->mutex); > >   return ret; > >   } > > @@ -1110,24 +1109,24 @@ static int > > kxcjk1013_data_rdy_trigger_set_state(struct iio_trigger *trig, > >   return 0; > >  } > >   > > -static const struct iio_trigger_ops kxcjk1013_trigger_ops = { > > - .set_trigger_state = kxcjk1013_data_rdy_trigger_set_state, > > - .try_reenable = kxcjk1013_trig_try_reen, > > +static const struct iio_trigger_ops kxcjk_trigger_ops = { > > + .set_trigger_state = kxcjk_data_rdy_trigger_set_state, > > + .try_reenable = kxcjk_trig_try_reen, > >   .owner = THIS_MODULE, > >  }; > >   > > -static void kxcjk1013_report_motion_event(struct iio_dev > > *indio_dev) > > +static void kxcjk_report_motion_event(struct iio_dev *indio_dev) > >  { > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   > >   int ret = i2c_smbus_read_byte_data(data->client, > > -    KXCJK1013_REG_INT_SRC2) > > ; > > +    KXCJK_REG_INT_SRC2); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_int_src2\n"); > >   return; > >   } > >   > > - if (ret & KXCJK1013_REG_INT_SRC2_BIT_XN) > > + if (ret & KXCJK_REG_INT_SRC2_BIT_XN) > >   iio_push_event(indio_dev, > >          IIO_MOD_EVENT_CODE(IIO_ACCEL, > >     0, > > @@ -1136,7 +1135,7 @@ static void > > kxcjk1013_report_motion_event(struct iio_dev *indio_dev) > >     IIO_EV_DIR_FALLI > > NG), > >          data->timestamp); > >   > > - if (ret & KXCJK1013_REG_INT_SRC2_BIT_XP) > > + if (ret & KXCJK_REG_INT_SRC2_BIT_XP) > >   iio_push_event(indio_dev, > >          IIO_MOD_EVENT_CODE(IIO_ACCEL, > >     0, > > @@ -1145,7 +1144,7 @@ static void > > kxcjk1013_report_motion_event(struct iio_dev *indio_dev) > >     IIO_EV_DIR_RISIN > > G), > >          data->timestamp); > >   > > - if (ret & KXCJK1013_REG_INT_SRC2_BIT_YN) > > + if (ret & KXCJK_REG_INT_SRC2_BIT_YN) > >   iio_push_event(indio_dev, > >          IIO_MOD_EVENT_CODE(IIO_ACCEL, > >     0, > > @@ -1154,7 +1153,7 @@ static void > > kxcjk1013_report_motion_event(struct iio_dev *indio_dev) > >     IIO_EV_DIR_FALLI > > NG), > >          data->timestamp); > >   > > - if (ret & KXCJK1013_REG_INT_SRC2_BIT_YP) > > + if (ret & KXCJK_REG_INT_SRC2_BIT_YP) > >   iio_push_event(indio_dev, > >          IIO_MOD_EVENT_CODE(IIO_ACCEL, > >     0, > > @@ -1163,7 +1162,7 @@ static void > > kxcjk1013_report_motion_event(struct iio_dev *indio_dev) > >     IIO_EV_DIR_RISIN > > G), > >          data->timestamp); > >   > > - if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZN) > > + if (ret & KXCJK_REG_INT_SRC2_BIT_ZN) > >   iio_push_event(indio_dev, > >          IIO_MOD_EVENT_CODE(IIO_ACCEL, > >     0, > > @@ -1172,7 +1171,7 @@ static void > > kxcjk1013_report_motion_event(struct iio_dev *indio_dev) > >     IIO_EV_DIR_FALLI > > NG), > >          data->timestamp); > >   > > - if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZP) > > + if (ret & KXCJK_REG_INT_SRC2_BIT_ZP) > >   iio_push_event(indio_dev, > >          IIO_MOD_EVENT_CODE(IIO_ACCEL, > >     0, > > @@ -1182,19 +1181,19 @@ static void > > kxcjk1013_report_motion_event(struct iio_dev *indio_dev) > >          data->timestamp); > >  } > >   > > -static irqreturn_t kxcjk1013_event_handler(int irq, void *private) > > +static irqreturn_t kxcjk_event_handler(int irq, void *private) > >  { > >   struct iio_dev *indio_dev = private; > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_INT_SRC1); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_INT_SRC1); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "Error reading > > reg_int_src1\n"); > >   goto ack_intr; > >   } > >   > > - if (ret & KXCJK1013_REG_INT_SRC1_BIT_WUFS) { > > + if (ret & KXCJK_REG_INT_SRC1_BIT_WUFS) { > >   if (data->chipset == KXTF9) > >   iio_push_event(indio_dev, > >          IIO_MOD_EVENT_CODE(IIO_ACCE > > L, > > @@ -1204,24 +1203,24 @@ static irqreturn_t > > kxcjk1013_event_handler(int irq, void *private) > >          IIO_EV_DIR_RISING), > >          data->timestamp); > >   else > > - kxcjk1013_report_motion_event(indio_dev); > > + kxcjk_report_motion_event(indio_dev); > >   } > >   > >  ack_intr: > >   if (data->dready_trigger_on) > >   return IRQ_HANDLED; > >   > > - ret = i2c_smbus_read_byte_data(data->client, > > KXCJK1013_REG_INT_REL); > > + ret = i2c_smbus_read_byte_data(data->client, > > KXCJK_REG_INT_REL); > >   if (ret < 0) > >   dev_err(&data->client->dev, "Error reading > > reg_int_rel\n"); > >   > >   return IRQ_HANDLED; > >  } > >   > > -static irqreturn_t kxcjk1013_data_rdy_trig_poll(int irq, void > > *private) > > +static irqreturn_t kxcjk_data_rdy_trig_poll(int irq, void > > *private) > >  { > >   struct iio_dev *indio_dev = private; > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   > >   data->timestamp = iio_get_time_ns(indio_dev); > >   > > @@ -1236,9 +1235,9 @@ static irqreturn_t > > kxcjk1013_data_rdy_trig_poll(int irq, void *private) > >   return IRQ_HANDLED; > >  } > >   > > -static const char *kxcjk1013_match_acpi_device(struct device *dev, > > -        enum kx_chipset > > *chipset, > > -        bool > > *is_smo8500_device) > > +static const char *kxcjk_match_acpi_device(struct device *dev, > > +    enum kx_chipset > > *chipset, > > +    bool > > *is_smo8500_device) > >  { > >   const struct acpi_device_id *id; > >   > > @@ -1254,10 +1253,10 @@ static const char > > *kxcjk1013_match_acpi_device(struct device *dev, > >   return dev_name(dev); > >  } > >   > > -static int kxcjk1013_probe(struct i2c_client *client, > > -    const struct i2c_device_id *id) > > +static int kxcjk_probe(struct i2c_client *client, > > +        const struct i2c_device_id *id) > >  { > > - struct kxcjk1013_data *data; > > + struct kxcjk_data *data; > >   struct iio_dev *indio_dev; > >   const char *name; > >   int ret; > > @@ -1274,32 +1273,32 @@ static int kxcjk1013_probe(struct > > i2c_client *client, > >   data->chipset = (enum kx_chipset)(id- > > >driver_data); > >   name = id->name; > >   } else if (ACPI_HANDLE(&client->dev)) { > > - name = kxcjk1013_match_acpi_device(&client->dev, > > + name = kxcjk_match_acpi_device(&client->dev, > >      &data->chipset, > >      &data- > > >is_smo8500_device); > >   } else > >   return -ENODEV; > >   > > - ret = kxcjk1013_chip_init(data); > > + ret = kxcjk_chip_init(data); > >   if (ret < 0) > >   return ret; > >   > >   mutex_init(&data->mutex); > >   > >   indio_dev->dev.parent = &client->dev; > > - indio_dev->channels = kxcjk1013_channels; > > - indio_dev->num_channels = ARRAY_SIZE(kxcjk1013_channels); > > - indio_dev->available_scan_masks = kxcjk1013_scan_masks; > > + indio_dev->channels = kxcjk_channels; > > + indio_dev->num_channels = ARRAY_SIZE(kxcjk_channels); > > + indio_dev->available_scan_masks = kxcjk_scan_masks; > >   indio_dev->name = name; > >   indio_dev->modes = INDIO_DIRECT_MODE; > > - indio_dev->info = &kxcjk1013_info; > > + indio_dev->info = &kxcjk_info; > >   > >   if (client->irq > 0 && !data->is_smo8500_device) { > >   ret = devm_request_threaded_irq(&client->dev, > > client->irq, > > - kxcjk1013_data_rdy > > _trig_poll, > > - kxcjk1013_event_ha > > ndler, > > + kxcjk_data_rdy_tri > > g_poll, > > + kxcjk_event_handle > > r, > >   IRQF_TRIGGER_RISIN > > G, > > - KXCJK1013_IRQ_NAME > > , > > + KXCJK_IRQ_NAME, > >   indio_dev); > >   if (ret) > >   goto err_poweroff; > > @@ -1323,7 +1322,7 @@ static int kxcjk1013_probe(struct i2c_client > > *client, > >   } > >   > >   data->dready_trig->dev.parent = &client->dev; > > - data->dready_trig->ops = &kxcjk1013_trigger_ops; > > + data->dready_trig->ops = &kxcjk_trigger_ops; > >   iio_trigger_set_drvdata(data->dready_trig, > > indio_dev); > >   indio_dev->trig = data->dready_trig; > >   iio_trigger_get(indio_dev->trig); > > @@ -1332,7 +1331,7 @@ static int kxcjk1013_probe(struct i2c_client > > *client, > >   goto err_poweroff; > >   > >   data->motion_trig->dev.parent = &client->dev; > > - data->motion_trig->ops = &kxcjk1013_trigger_ops; > > + data->motion_trig->ops = &kxcjk_trigger_ops; > >   iio_trigger_set_drvdata(data->motion_trig, > > indio_dev); > >   ret = iio_trigger_register(data->motion_trig); > >   if (ret) { > > @@ -1343,8 +1342,8 @@ static int kxcjk1013_probe(struct i2c_client > > *client, > >   > >   ret = iio_triggered_buffer_setup(indio_dev, > >    &iio_pollfunc_store_time, > > -  kxcjk1013_trigger_handler > > , > > -  &kxcjk1013_buffer_setup_o > > ps); > > +  kxcjk_trigger_handler, > > +  &kxcjk_buffer_setup_ops); > >   if (ret < 0) { > >   dev_err(&client->dev, "iio triggered buffer setup > > failed\n"); > >   goto err_trigger_unregister; > > @@ -1356,7 +1355,7 @@ static int kxcjk1013_probe(struct i2c_client > > *client, > >   > >   pm_runtime_enable(&client->dev); > >   pm_runtime_set_autosuspend_delay(&client->dev, > > -  KXCJK1013_SLEEP_DELAY_MS) > > ; > > +  KXCJK_SLEEP_DELAY_MS); > >   pm_runtime_use_autosuspend(&client->dev); > >   > >   ret = iio_device_register(indio_dev); > > @@ -1376,15 +1375,15 @@ static int kxcjk1013_probe(struct > > i2c_client *client, > >   if (data->motion_trig) > >   iio_trigger_unregister(data->motion_trig); > >  err_poweroff: > > - kxcjk1013_set_mode(data, STANDBY); > > + kxcjk_set_mode(data, STANDBY); > >   > >   return ret; > >  } > >   > > -static int kxcjk1013_remove(struct i2c_client *client) > > +static int kxcjk_remove(struct i2c_client *client) > >  { > >   struct iio_dev *indio_dev = i2c_get_clientdata(client); > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   > >   iio_device_unregister(indio_dev); > >   > > @@ -1399,34 +1398,34 @@ static int kxcjk1013_remove(struct > > i2c_client *client) > >   } > >   > >   mutex_lock(&data->mutex); > > - kxcjk1013_set_mode(data, STANDBY); > > + kxcjk_set_mode(data, STANDBY); > >   mutex_unlock(&data->mutex); > >   > >   return 0; > >  } > >   > >  #ifdef CONFIG_PM_SLEEP > > -static int kxcjk1013_suspend(struct device *dev) > > +static int kxcjk_suspend(struct device *dev) > >  { > >   struct iio_dev *indio_dev = > > i2c_get_clientdata(to_i2c_client(dev)); > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   > >   mutex_lock(&data->mutex); > > - ret = kxcjk1013_set_mode(data, STANDBY); > > + ret = kxcjk_set_mode(data, STANDBY); > >   mutex_unlock(&data->mutex); > >   > >   return ret; > >  } > >   > > -static int kxcjk1013_resume(struct device *dev) > > +static int kxcjk_resume(struct device *dev) > >  { > >   struct iio_dev *indio_dev = > > i2c_get_clientdata(to_i2c_client(dev)); > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret = 0; > >   > >   mutex_lock(&data->mutex); > > - ret = kxcjk1013_set_mode(data, OPERATION); > > + ret = kxcjk_set_mode(data, OPERATION); > >   mutex_unlock(&data->mutex); > >   > >   return ret; > > @@ -1434,13 +1433,13 @@ static int kxcjk1013_resume(struct device > > *dev) > >  #endif > >   > >  #ifdef CONFIG_PM > > -static int kxcjk1013_runtime_suspend(struct device *dev) > > +static int kxcjk_runtime_suspend(struct device *dev) > >  { > >   struct iio_dev *indio_dev = > > i2c_get_clientdata(to_i2c_client(dev)); > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   > > - ret = kxcjk1013_set_mode(data, STANDBY); > > + ret = kxcjk_set_mode(data, STANDBY); > >   if (ret < 0) { > >   dev_err(&data->client->dev, "powering off device > > failed\n"); > >   return -EAGAIN; > > @@ -1448,18 +1447,18 @@ static int kxcjk1013_runtime_suspend(struct > > device *dev) > >   return 0; > >  } > >   > > -static int kxcjk1013_runtime_resume(struct device *dev) > > +static int kxcjk_runtime_resume(struct device *dev) > >  { > >   struct iio_dev *indio_dev = > > i2c_get_clientdata(to_i2c_client(dev)); > > - struct kxcjk1013_data *data = iio_priv(indio_dev); > > + struct kxcjk_data *data = iio_priv(indio_dev); > >   int ret; > >   int sleep_val; > >   > > - ret = kxcjk1013_set_mode(data, OPERATION); > > + ret = kxcjk_set_mode(data, OPERATION); > >   if (ret < 0) > >   return ret; > >   > > - sleep_val = kxcjk1013_get_startup_times(data); > > + sleep_val = kxcjk_get_startup_times(data); > >   if (sleep_val < 20000) > >   usleep_range(sleep_val, 20000); > >   else > > @@ -1469,10 +1468,10 @@ static int kxcjk1013_runtime_resume(struct > > device *dev) > >  } > >  #endif > >   > > -static const struct dev_pm_ops kxcjk1013_pm_ops = { > > - SET_SYSTEM_SLEEP_PM_OPS(kxcjk1013_suspend, > > kxcjk1013_resume) > > - SET_RUNTIME_PM_OPS(kxcjk1013_runtime_suspend, > > -    kxcjk1013_runtime_resume, NULL) > > +static const struct dev_pm_ops kxcjk_pm_ops = { > > + SET_SYSTEM_SLEEP_PM_OPS(kxcjk_suspend, kxcjk_resume) > > + SET_RUNTIME_PM_OPS(kxcjk_runtime_suspend, > > +    kxcjk_runtime_resume, NULL) > >  }; > >   > >  static const struct acpi_device_id kx_acpi_match[] = { > > @@ -1486,7 +1485,7 @@ static const struct acpi_device_id > > kx_acpi_match[] = { > >  }; > >  MODULE_DEVICE_TABLE(acpi, kx_acpi_match); > >   > > -static const struct i2c_device_id kxcjk1013_id[] = { > > +static const struct i2c_device_id kxcjk_id[] = { > >   {"kxcjk1013", KXCJK1013}, > >   {"kxcj91008", KXCJ91008}, > >   {"kxtj21009", KXTJ21009}, > > @@ -1495,20 +1494,21 @@ static const struct i2c_device_id > > kxcjk1013_id[] = { > >   {} > >  }; > >   > > -MODULE_DEVICE_TABLE(i2c, kxcjk1013_id); > > +MODULE_DEVICE_TABLE(i2c, kxcjk_id); > >   > > -static struct i2c_driver kxcjk1013_driver = { > > +static struct i2c_driver kxcjk_driver = { > >   .driver = { > > - .name = KXCJK1013_DRV_NAME, > > + .name = KXCJK_DRV_NAME, > >   .acpi_match_table = ACPI_PTR(kx_acpi_match), > > - .pm = &kxcjk1013_pm_ops, > > + .pm = &kxcjk_pm_ops, > >   }, > > - .probe = kxcjk1013_probe, > > - .remove = kxcjk1013_remove, > > - .id_table = kxcjk1013_id, > > + .probe = kxcjk_probe, > > + .remove = kxcjk_remove, > > + .id_table = kxcjk_id, > >  }; > > -module_i2c_driver(kxcjk1013_driver); > > +module_i2c_driver(kxcjk_driver); > >   > > +MODULE_ALIAS("kxcjk-1013"); > >  MODULE_AUTHOR("Srinivas Pandruvada > l.com>"); > >  MODULE_LICENSE("GPL v2"); > >  MODULE_DESCRIPTION("KXCJK1013 accelerometer driver"); > >