Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
0004  *
0005  * Copyright (c) 2014, Intel Corporation.
0006  *
0007  * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
0008  */
0009 
0010 #include <linux/module.h>
0011 #include <linux/i2c.h>
0012 #include <linux/acpi.h>
0013 #include <linux/interrupt.h>
0014 #include <linux/pm.h>
0015 #include <linux/pm_runtime.h>
0016 #include <linux/iio/iio.h>
0017 #include <linux/iio/sysfs.h>
0018 #include <linux/iio/events.h>
0019 #include <linux/iio/trigger.h>
0020 #include <linux/iio/buffer.h>
0021 #include <linux/iio/triggered_buffer.h>
0022 #include <linux/iio/trigger_consumer.h>
0023 
0024 #define KMX61_DRV_NAME "kmx61"
0025 #define KMX61_IRQ_NAME "kmx61_event"
0026 
0027 #define KMX61_REG_WHO_AM_I  0x00
0028 #define KMX61_REG_INS1      0x01
0029 #define KMX61_REG_INS2      0x02
0030 
0031 /*
0032  * three 16-bit accelerometer output registers for X/Y/Z axis
0033  * we use only XOUT_L as a base register, all other addresses
0034  * can be obtained by applying an offset and are provided here
0035  * only for clarity.
0036  */
0037 #define KMX61_ACC_XOUT_L    0x0A
0038 #define KMX61_ACC_XOUT_H    0x0B
0039 #define KMX61_ACC_YOUT_L    0x0C
0040 #define KMX61_ACC_YOUT_H    0x0D
0041 #define KMX61_ACC_ZOUT_L    0x0E
0042 #define KMX61_ACC_ZOUT_H    0x0F
0043 
0044 /*
0045  * one 16-bit temperature output register
0046  */
0047 #define KMX61_TEMP_L        0x10
0048 #define KMX61_TEMP_H        0x11
0049 
0050 /*
0051  * three 16-bit magnetometer output registers for X/Y/Z axis
0052  */
0053 #define KMX61_MAG_XOUT_L    0x12
0054 #define KMX61_MAG_XOUT_H    0x13
0055 #define KMX61_MAG_YOUT_L    0x14
0056 #define KMX61_MAG_YOUT_H    0x15
0057 #define KMX61_MAG_ZOUT_L    0x16
0058 #define KMX61_MAG_ZOUT_H    0x17
0059 
0060 #define KMX61_REG_INL       0x28
0061 #define KMX61_REG_STBY      0x29
0062 #define KMX61_REG_CTRL1     0x2A
0063 #define KMX61_REG_CTRL2     0x2B
0064 #define KMX61_REG_ODCNTL    0x2C
0065 #define KMX61_REG_INC1      0x2D
0066 
0067 #define KMX61_REG_WUF_THRESH    0x3D
0068 #define KMX61_REG_WUF_TIMER 0x3E
0069 
0070 #define KMX61_ACC_STBY_BIT  BIT(0)
0071 #define KMX61_MAG_STBY_BIT  BIT(1)
0072 #define KMX61_ACT_STBY_BIT  BIT(7)
0073 
0074 #define KMX61_ALL_STBY      (KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
0075 
0076 #define KMX61_REG_INS1_BIT_WUFS     BIT(1)
0077 
0078 #define KMX61_REG_INS2_BIT_ZP       BIT(0)
0079 #define KMX61_REG_INS2_BIT_ZN       BIT(1)
0080 #define KMX61_REG_INS2_BIT_YP       BIT(2)
0081 #define KMX61_REG_INS2_BIT_YN       BIT(3)
0082 #define KMX61_REG_INS2_BIT_XP       BIT(4)
0083 #define KMX61_REG_INS2_BIT_XN       BIT(5)
0084 
0085 #define KMX61_REG_CTRL1_GSEL_MASK   0x03
0086 
0087 #define KMX61_REG_CTRL1_BIT_RES     BIT(4)
0088 #define KMX61_REG_CTRL1_BIT_DRDYE   BIT(5)
0089 #define KMX61_REG_CTRL1_BIT_WUFE    BIT(6)
0090 #define KMX61_REG_CTRL1_BIT_BTSE    BIT(7)
0091 
0092 #define KMX61_REG_INC1_BIT_WUFS     BIT(0)
0093 #define KMX61_REG_INC1_BIT_DRDYM    BIT(1)
0094 #define KMX61_REG_INC1_BIT_DRDYA    BIT(2)
0095 #define KMX61_REG_INC1_BIT_IEN      BIT(5)
0096 
0097 #define KMX61_ACC_ODR_SHIFT 0
0098 #define KMX61_MAG_ODR_SHIFT 4
0099 #define KMX61_ACC_ODR_MASK  0x0F
0100 #define KMX61_MAG_ODR_MASK  0xF0
0101 
0102 #define KMX61_OWUF_MASK     0x7
0103 
0104 #define KMX61_DEFAULT_WAKE_THRESH   1
0105 #define KMX61_DEFAULT_WAKE_DURATION 1
0106 
0107 #define KMX61_SLEEP_DELAY_MS    2000
0108 
0109 #define KMX61_CHIP_ID       0x12
0110 
0111 /* KMX61 devices */
0112 #define KMX61_ACC   0x01
0113 #define KMX61_MAG   0x02
0114 
0115 struct kmx61_data {
0116     struct i2c_client *client;
0117 
0118     /* serialize access to non-atomic ops, e.g set_mode */
0119     struct mutex lock;
0120 
0121     /* standby state */
0122     bool acc_stby;
0123     bool mag_stby;
0124 
0125     /* power state */
0126     bool acc_ps;
0127     bool mag_ps;
0128 
0129     /* config bits */
0130     u8 range;
0131     u8 odr_bits;
0132     u8 wake_thresh;
0133     u8 wake_duration;
0134 
0135     /* accelerometer specific data */
0136     struct iio_dev *acc_indio_dev;
0137     struct iio_trigger *acc_dready_trig;
0138     struct iio_trigger *motion_trig;
0139     bool acc_dready_trig_on;
0140     bool motion_trig_on;
0141     bool ev_enable_state;
0142 
0143     /* magnetometer specific data */
0144     struct iio_dev *mag_indio_dev;
0145     struct iio_trigger *mag_dready_trig;
0146     bool mag_dready_trig_on;
0147 };
0148 
0149 enum kmx61_range {
0150     KMX61_RANGE_2G,
0151     KMX61_RANGE_4G,
0152     KMX61_RANGE_8G,
0153 };
0154 
0155 enum kmx61_axis {
0156     KMX61_AXIS_X,
0157     KMX61_AXIS_Y,
0158     KMX61_AXIS_Z,
0159 };
0160 
0161 static const u16 kmx61_uscale_table[] = {9582, 19163, 38326};
0162 
0163 static const struct {
0164     int val;
0165     int val2;
0166 } kmx61_samp_freq_table[] = { {12, 500000},
0167             {25, 0},
0168             {50, 0},
0169             {100, 0},
0170             {200, 0},
0171             {400, 0},
0172             {800, 0},
0173             {1600, 0},
0174             {0, 781000},
0175             {1, 563000},
0176             {3, 125000},
0177             {6, 250000} };
0178 
0179 static const struct {
0180     int val;
0181     int val2;
0182     int odr_bits;
0183 } kmx61_wake_up_odr_table[] = { {0, 781000, 0x00},
0184                  {1, 563000, 0x01},
0185                  {3, 125000, 0x02},
0186                  {6, 250000, 0x03},
0187                  {12, 500000, 0x04},
0188                  {25, 0, 0x05},
0189                  {50, 0, 0x06},
0190                  {100, 0, 0x06},
0191                  {200, 0, 0x06},
0192                  {400, 0, 0x06},
0193                  {800, 0, 0x06},
0194                  {1600, 0, 0x06} };
0195 
0196 static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
0197 static IIO_CONST_ATTR(magn_scale_available, "0.001465");
0198 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
0199     "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
0200 
0201 static struct attribute *kmx61_acc_attributes[] = {
0202     &iio_const_attr_accel_scale_available.dev_attr.attr,
0203     &iio_const_attr_sampling_frequency_available.dev_attr.attr,
0204     NULL,
0205 };
0206 
0207 static struct attribute *kmx61_mag_attributes[] = {
0208     &iio_const_attr_magn_scale_available.dev_attr.attr,
0209     &iio_const_attr_sampling_frequency_available.dev_attr.attr,
0210     NULL,
0211 };
0212 
0213 static const struct attribute_group kmx61_acc_attribute_group = {
0214     .attrs = kmx61_acc_attributes,
0215 };
0216 
0217 static const struct attribute_group kmx61_mag_attribute_group = {
0218     .attrs = kmx61_mag_attributes,
0219 };
0220 
0221 static const struct iio_event_spec kmx61_event = {
0222     .type = IIO_EV_TYPE_THRESH,
0223     .dir = IIO_EV_DIR_EITHER,
0224     .mask_separate = BIT(IIO_EV_INFO_VALUE) |
0225              BIT(IIO_EV_INFO_ENABLE) |
0226              BIT(IIO_EV_INFO_PERIOD),
0227 };
0228 
0229 #define KMX61_ACC_CHAN(_axis) { \
0230     .type = IIO_ACCEL, \
0231     .modified = 1, \
0232     .channel2 = IIO_MOD_ ## _axis, \
0233     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
0234     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
0235                 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
0236     .address = KMX61_ACC, \
0237     .scan_index = KMX61_AXIS_ ## _axis, \
0238     .scan_type = { \
0239         .sign = 's', \
0240         .realbits = 12, \
0241         .storagebits = 16, \
0242         .shift = 4, \
0243         .endianness = IIO_LE, \
0244     }, \
0245     .event_spec = &kmx61_event, \
0246     .num_event_specs = 1 \
0247 }
0248 
0249 #define KMX61_MAG_CHAN(_axis) { \
0250     .type = IIO_MAGN, \
0251     .modified = 1, \
0252     .channel2 = IIO_MOD_ ## _axis, \
0253     .address = KMX61_MAG, \
0254     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
0255     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
0256                 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
0257     .scan_index = KMX61_AXIS_ ## _axis, \
0258     .scan_type = { \
0259         .sign = 's', \
0260         .realbits = 14, \
0261         .storagebits = 16, \
0262         .shift = 2, \
0263         .endianness = IIO_LE, \
0264     }, \
0265 }
0266 
0267 static const struct iio_chan_spec kmx61_acc_channels[] = {
0268     KMX61_ACC_CHAN(X),
0269     KMX61_ACC_CHAN(Y),
0270     KMX61_ACC_CHAN(Z),
0271 };
0272 
0273 static const struct iio_chan_spec kmx61_mag_channels[] = {
0274     KMX61_MAG_CHAN(X),
0275     KMX61_MAG_CHAN(Y),
0276     KMX61_MAG_CHAN(Z),
0277 };
0278 
0279 static void kmx61_set_data(struct iio_dev *indio_dev, struct kmx61_data *data)
0280 {
0281     struct kmx61_data **priv = iio_priv(indio_dev);
0282 
0283     *priv = data;
0284 }
0285 
0286 static struct kmx61_data *kmx61_get_data(struct iio_dev *indio_dev)
0287 {
0288     return *(struct kmx61_data **)iio_priv(indio_dev);
0289 }
0290 
0291 static int kmx61_convert_freq_to_bit(int val, int val2)
0292 {
0293     int i;
0294 
0295     for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++)
0296         if (val == kmx61_samp_freq_table[i].val &&
0297             val2 == kmx61_samp_freq_table[i].val2)
0298             return i;
0299     return -EINVAL;
0300 }
0301 
0302 static int kmx61_convert_wake_up_odr_to_bit(int val, int val2)
0303 {
0304     int i;
0305 
0306     for (i = 0; i < ARRAY_SIZE(kmx61_wake_up_odr_table); ++i)
0307         if (kmx61_wake_up_odr_table[i].val == val &&
0308             kmx61_wake_up_odr_table[i].val2 == val2)
0309                 return kmx61_wake_up_odr_table[i].odr_bits;
0310     return -EINVAL;
0311 }
0312 
0313 /**
0314  * kmx61_set_mode() - set KMX61 device operating mode
0315  * @data: kmx61 device private data pointer
0316  * @mode: bitmask, indicating operating mode for @device
0317  * @device: bitmask, indicating device for which @mode needs to be set
0318  * @update: update stby bits stored in device's private  @data
0319  *
0320  * For each sensor (accelerometer/magnetometer) there are two operating modes
0321  * STANDBY and OPERATION. Neither accel nor magn can be disabled independently
0322  * if they are both enabled. Internal sensors state is saved in acc_stby and
0323  * mag_stby members of driver's private @data.
0324  */
0325 static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device,
0326               bool update)
0327 {
0328     int ret;
0329     int acc_stby = -1, mag_stby = -1;
0330 
0331     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
0332     if (ret < 0) {
0333         dev_err(&data->client->dev, "Error reading reg_stby\n");
0334         return ret;
0335     }
0336     if (device & KMX61_ACC) {
0337         if (mode & KMX61_ACC_STBY_BIT) {
0338             ret |= KMX61_ACC_STBY_BIT;
0339             acc_stby = 1;
0340         } else {
0341             ret &= ~KMX61_ACC_STBY_BIT;
0342             acc_stby = 0;
0343         }
0344     }
0345 
0346     if (device & KMX61_MAG) {
0347         if (mode & KMX61_MAG_STBY_BIT) {
0348             ret |= KMX61_MAG_STBY_BIT;
0349             mag_stby = 1;
0350         } else {
0351             ret &= ~KMX61_MAG_STBY_BIT;
0352             mag_stby = 0;
0353         }
0354     }
0355 
0356     if (mode & KMX61_ACT_STBY_BIT)
0357         ret |= KMX61_ACT_STBY_BIT;
0358 
0359     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
0360     if (ret < 0) {
0361         dev_err(&data->client->dev, "Error writing reg_stby\n");
0362         return ret;
0363     }
0364 
0365     if (acc_stby != -1 && update)
0366         data->acc_stby = acc_stby;
0367     if (mag_stby != -1 && update)
0368         data->mag_stby = mag_stby;
0369 
0370     return 0;
0371 }
0372 
0373 static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
0374 {
0375     int ret;
0376 
0377     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
0378     if (ret < 0) {
0379         dev_err(&data->client->dev, "Error reading reg_stby\n");
0380         return ret;
0381     }
0382     *mode = 0;
0383 
0384     if (device & KMX61_ACC) {
0385         if (ret & KMX61_ACC_STBY_BIT)
0386             *mode |= KMX61_ACC_STBY_BIT;
0387         else
0388             *mode &= ~KMX61_ACC_STBY_BIT;
0389     }
0390 
0391     if (device & KMX61_MAG) {
0392         if (ret & KMX61_MAG_STBY_BIT)
0393             *mode |= KMX61_MAG_STBY_BIT;
0394         else
0395             *mode &= ~KMX61_MAG_STBY_BIT;
0396     }
0397 
0398     return 0;
0399 }
0400 
0401 static int kmx61_set_wake_up_odr(struct kmx61_data *data, int val, int val2)
0402 {
0403     int ret, odr_bits;
0404 
0405     odr_bits = kmx61_convert_wake_up_odr_to_bit(val, val2);
0406     if (odr_bits < 0)
0407         return odr_bits;
0408 
0409     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL2,
0410                     odr_bits);
0411     if (ret < 0)
0412         dev_err(&data->client->dev, "Error writing reg_ctrl2\n");
0413     return ret;
0414 }
0415 
0416 static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
0417 {
0418     int ret;
0419     u8 mode;
0420     int lodr_bits, odr_bits;
0421 
0422     ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
0423     if (ret < 0)
0424         return ret;
0425 
0426     lodr_bits = kmx61_convert_freq_to_bit(val, val2);
0427     if (lodr_bits < 0)
0428         return lodr_bits;
0429 
0430     /* To change ODR, accel and magn must be in STDBY */
0431     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG,
0432                  true);
0433     if (ret < 0)
0434         return ret;
0435 
0436     odr_bits = 0;
0437     if (device & KMX61_ACC)
0438         odr_bits |= lodr_bits << KMX61_ACC_ODR_SHIFT;
0439     if (device & KMX61_MAG)
0440         odr_bits |= lodr_bits << KMX61_MAG_ODR_SHIFT;
0441 
0442     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
0443                     odr_bits);
0444     if (ret < 0)
0445         return ret;
0446 
0447     data->odr_bits = odr_bits;
0448 
0449     if (device & KMX61_ACC) {
0450         ret = kmx61_set_wake_up_odr(data, val, val2);
0451         if (ret)
0452             return ret;
0453     }
0454 
0455     return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
0456 }
0457 
0458 static int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2,
0459              u8 device)
0460 {
0461     u8 lodr_bits;
0462 
0463     if (device & KMX61_ACC)
0464         lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
0465                  KMX61_ACC_ODR_MASK;
0466     else if (device & KMX61_MAG)
0467         lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
0468                  KMX61_MAG_ODR_MASK;
0469     else
0470         return -EINVAL;
0471 
0472     if (lodr_bits >= ARRAY_SIZE(kmx61_samp_freq_table))
0473         return -EINVAL;
0474 
0475     *val = kmx61_samp_freq_table[lodr_bits].val;
0476     *val2 = kmx61_samp_freq_table[lodr_bits].val2;
0477 
0478     return 0;
0479 }
0480 
0481 static int kmx61_set_range(struct kmx61_data *data, u8 range)
0482 {
0483     int ret;
0484 
0485     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
0486     if (ret < 0) {
0487         dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
0488         return ret;
0489     }
0490 
0491     ret &= ~KMX61_REG_CTRL1_GSEL_MASK;
0492     ret |= range & KMX61_REG_CTRL1_GSEL_MASK;
0493 
0494     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
0495     if (ret < 0) {
0496         dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
0497         return ret;
0498     }
0499 
0500     data->range = range;
0501 
0502     return 0;
0503 }
0504 
0505 static int kmx61_set_scale(struct kmx61_data *data, u16 uscale)
0506 {
0507     int ret, i;
0508     u8  mode;
0509 
0510     for (i = 0; i < ARRAY_SIZE(kmx61_uscale_table); i++) {
0511         if (kmx61_uscale_table[i] == uscale) {
0512             ret = kmx61_get_mode(data, &mode,
0513                          KMX61_ACC | KMX61_MAG);
0514             if (ret < 0)
0515                 return ret;
0516 
0517             ret = kmx61_set_mode(data, KMX61_ALL_STBY,
0518                          KMX61_ACC | KMX61_MAG, true);
0519             if (ret < 0)
0520                 return ret;
0521 
0522             ret = kmx61_set_range(data, i);
0523             if (ret < 0)
0524                 return ret;
0525 
0526             return  kmx61_set_mode(data, mode,
0527                            KMX61_ACC | KMX61_MAG, true);
0528         }
0529     }
0530     return -EINVAL;
0531 }
0532 
0533 static int kmx61_chip_init(struct kmx61_data *data)
0534 {
0535     int ret, val, val2;
0536 
0537     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
0538     if (ret < 0) {
0539         dev_err(&data->client->dev, "Error reading who_am_i\n");
0540         return ret;
0541     }
0542 
0543     if (ret != KMX61_CHIP_ID) {
0544         dev_err(&data->client->dev,
0545             "Wrong chip id, got %x expected %x\n",
0546              ret, KMX61_CHIP_ID);
0547         return -EINVAL;
0548     }
0549 
0550     /* set accel 12bit, 4g range */
0551     ret = kmx61_set_range(data, KMX61_RANGE_4G);
0552     if (ret < 0)
0553         return ret;
0554 
0555     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_ODCNTL);
0556     if (ret < 0) {
0557         dev_err(&data->client->dev, "Error reading reg_odcntl\n");
0558         return ret;
0559     }
0560     data->odr_bits = ret;
0561 
0562     /*
0563      * set output data rate for wake up (motion detection) function
0564      * to match data rate for accelerometer sampling
0565      */
0566     ret = kmx61_get_odr(data, &val, &val2, KMX61_ACC);
0567     if (ret < 0)
0568         return ret;
0569 
0570     ret = kmx61_set_wake_up_odr(data, val, val2);
0571     if (ret < 0)
0572         return ret;
0573 
0574     /* set acc/magn to OPERATION mode */
0575     ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG, true);
0576     if (ret < 0)
0577         return ret;
0578 
0579     data->wake_thresh = KMX61_DEFAULT_WAKE_THRESH;
0580     data->wake_duration = KMX61_DEFAULT_WAKE_DURATION;
0581 
0582     return 0;
0583 }
0584 
0585 static int kmx61_setup_new_data_interrupt(struct kmx61_data *data,
0586                       bool status, u8 device)
0587 {
0588     u8 mode;
0589     int ret;
0590 
0591     ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
0592     if (ret < 0)
0593         return ret;
0594 
0595     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
0596     if (ret < 0)
0597         return ret;
0598 
0599     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1);
0600     if (ret < 0) {
0601         dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
0602         return ret;
0603     }
0604 
0605     if (status) {
0606         ret |= KMX61_REG_INC1_BIT_IEN;
0607         if (device & KMX61_ACC)
0608             ret |= KMX61_REG_INC1_BIT_DRDYA;
0609         if (device & KMX61_MAG)
0610             ret |=  KMX61_REG_INC1_BIT_DRDYM;
0611     } else {
0612         ret &= ~KMX61_REG_INC1_BIT_IEN;
0613         if (device & KMX61_ACC)
0614             ret &= ~KMX61_REG_INC1_BIT_DRDYA;
0615         if (device & KMX61_MAG)
0616             ret &= ~KMX61_REG_INC1_BIT_DRDYM;
0617     }
0618     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret);
0619     if (ret < 0) {
0620         dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
0621         return ret;
0622     }
0623 
0624     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
0625     if (ret < 0) {
0626         dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
0627         return ret;
0628     }
0629 
0630     if (status)
0631         ret |= KMX61_REG_CTRL1_BIT_DRDYE;
0632     else
0633         ret &= ~KMX61_REG_CTRL1_BIT_DRDYE;
0634 
0635     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
0636     if (ret < 0) {
0637         dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
0638         return ret;
0639     }
0640 
0641     return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
0642 }
0643 
0644 static int kmx61_chip_update_thresholds(struct kmx61_data *data)
0645 {
0646     int ret;
0647 
0648     ret = i2c_smbus_write_byte_data(data->client,
0649                     KMX61_REG_WUF_TIMER,
0650                     data->wake_duration);
0651     if (ret < 0) {
0652         dev_err(&data->client->dev, "Errow writing reg_wuf_timer\n");
0653         return ret;
0654     }
0655 
0656     ret = i2c_smbus_write_byte_data(data->client,
0657                     KMX61_REG_WUF_THRESH,
0658                     data->wake_thresh);
0659     if (ret < 0)
0660         dev_err(&data->client->dev, "Error writing reg_wuf_thresh\n");
0661 
0662     return ret;
0663 }
0664 
0665 static int kmx61_setup_any_motion_interrupt(struct kmx61_data *data,
0666                         bool status)
0667 {
0668     u8 mode;
0669     int ret;
0670 
0671     ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
0672     if (ret < 0)
0673         return ret;
0674 
0675     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
0676     if (ret < 0)
0677         return ret;
0678 
0679     ret = kmx61_chip_update_thresholds(data);
0680     if (ret < 0)
0681         return ret;
0682 
0683     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1);
0684     if (ret < 0) {
0685         dev_err(&data->client->dev, "Error reading reg_inc1\n");
0686         return ret;
0687     }
0688     if (status)
0689         ret |= (KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS);
0690     else
0691         ret &= ~(KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS);
0692 
0693     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret);
0694     if (ret < 0) {
0695         dev_err(&data->client->dev, "Error writing reg_inc1\n");
0696         return ret;
0697     }
0698 
0699     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
0700     if (ret < 0) {
0701         dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
0702         return ret;
0703     }
0704 
0705     if (status)
0706         ret |= KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE;
0707     else
0708         ret &= ~(KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE);
0709 
0710     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
0711     if (ret < 0) {
0712         dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
0713         return ret;
0714     }
0715     mode |= KMX61_ACT_STBY_BIT;
0716     return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
0717 }
0718 
0719 /**
0720  * kmx61_set_power_state() - set power state for kmx61 @device
0721  * @data: kmx61 device private pointer
0722  * @on: power state to be set for @device
0723  * @device: bitmask indicating device for which @on state needs to be set
0724  *
0725  * Notice that when ACC power state needs to be set to ON and MAG is in
0726  * OPERATION then we know that kmx61_runtime_resume was already called
0727  * so we must set ACC OPERATION mode here. The same happens when MAG power
0728  * state needs to be set to ON and ACC is in OPERATION.
0729  */
0730 static int kmx61_set_power_state(struct kmx61_data *data, bool on, u8 device)
0731 {
0732 #ifdef CONFIG_PM
0733     int ret;
0734 
0735     if (device & KMX61_ACC) {
0736         if (on && !data->acc_ps && !data->mag_stby) {
0737             ret = kmx61_set_mode(data, 0, KMX61_ACC, true);
0738             if (ret < 0)
0739                 return ret;
0740         }
0741         data->acc_ps = on;
0742     }
0743     if (device & KMX61_MAG) {
0744         if (on && !data->mag_ps && !data->acc_stby) {
0745             ret = kmx61_set_mode(data, 0, KMX61_MAG, true);
0746             if (ret < 0)
0747                 return ret;
0748         }
0749         data->mag_ps = on;
0750     }
0751 
0752     if (on) {
0753         ret = pm_runtime_resume_and_get(&data->client->dev);
0754     } else {
0755         pm_runtime_mark_last_busy(&data->client->dev);
0756         ret = pm_runtime_put_autosuspend(&data->client->dev);
0757     }
0758     if (ret < 0) {
0759         dev_err(&data->client->dev,
0760             "Failed: kmx61_set_power_state for %d, ret %d\n",
0761             on, ret);
0762 
0763         return ret;
0764     }
0765 #endif
0766     return 0;
0767 }
0768 
0769 static int kmx61_read_measurement(struct kmx61_data *data, u8 base, u8 offset)
0770 {
0771     int ret;
0772     u8 reg = base + offset * 2;
0773 
0774     ret = i2c_smbus_read_word_data(data->client, reg);
0775     if (ret < 0)
0776         dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
0777 
0778     return ret;
0779 }
0780 
0781 static int kmx61_read_raw(struct iio_dev *indio_dev,
0782               struct iio_chan_spec const *chan, int *val,
0783               int *val2, long mask)
0784 {
0785     int ret;
0786     u8 base_reg;
0787     struct kmx61_data *data = kmx61_get_data(indio_dev);
0788 
0789     switch (mask) {
0790     case IIO_CHAN_INFO_RAW:
0791         switch (chan->type) {
0792         case IIO_ACCEL:
0793             base_reg = KMX61_ACC_XOUT_L;
0794             break;
0795         case IIO_MAGN:
0796             base_reg = KMX61_MAG_XOUT_L;
0797             break;
0798         default:
0799             return -EINVAL;
0800         }
0801         mutex_lock(&data->lock);
0802 
0803         ret = kmx61_set_power_state(data, true, chan->address);
0804         if (ret) {
0805             mutex_unlock(&data->lock);
0806             return ret;
0807         }
0808 
0809         ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
0810         if (ret < 0) {
0811             kmx61_set_power_state(data, false, chan->address);
0812             mutex_unlock(&data->lock);
0813             return ret;
0814         }
0815         *val = sign_extend32(ret >> chan->scan_type.shift,
0816                      chan->scan_type.realbits - 1);
0817         ret = kmx61_set_power_state(data, false, chan->address);
0818 
0819         mutex_unlock(&data->lock);
0820         if (ret)
0821             return ret;
0822         return IIO_VAL_INT;
0823     case IIO_CHAN_INFO_SCALE:
0824         switch (chan->type) {
0825         case IIO_ACCEL:
0826             *val = 0;
0827             *val2 = kmx61_uscale_table[data->range];
0828             return IIO_VAL_INT_PLUS_MICRO;
0829         case IIO_MAGN:
0830             /* 14 bits res, 1465 microGauss per magn count */
0831             *val = 0;
0832             *val2 = 1465;
0833             return IIO_VAL_INT_PLUS_MICRO;
0834         default:
0835             return -EINVAL;
0836         }
0837     case IIO_CHAN_INFO_SAMP_FREQ:
0838         if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
0839             return -EINVAL;
0840 
0841         mutex_lock(&data->lock);
0842         ret = kmx61_get_odr(data, val, val2, chan->address);
0843         mutex_unlock(&data->lock);
0844         if (ret)
0845             return -EINVAL;
0846         return IIO_VAL_INT_PLUS_MICRO;
0847     }
0848     return -EINVAL;
0849 }
0850 
0851 static int kmx61_write_raw(struct iio_dev *indio_dev,
0852                struct iio_chan_spec const *chan, int val,
0853                int val2, long mask)
0854 {
0855     int ret;
0856     struct kmx61_data *data = kmx61_get_data(indio_dev);
0857 
0858     switch (mask) {
0859     case IIO_CHAN_INFO_SAMP_FREQ:
0860         if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
0861             return -EINVAL;
0862 
0863         mutex_lock(&data->lock);
0864         ret = kmx61_set_odr(data, val, val2, chan->address);
0865         mutex_unlock(&data->lock);
0866         return ret;
0867     case IIO_CHAN_INFO_SCALE:
0868         switch (chan->type) {
0869         case IIO_ACCEL:
0870             if (val != 0)
0871                 return -EINVAL;
0872             mutex_lock(&data->lock);
0873             ret = kmx61_set_scale(data, val2);
0874             mutex_unlock(&data->lock);
0875             return ret;
0876         default:
0877             return -EINVAL;
0878         }
0879     default:
0880         return -EINVAL;
0881     }
0882 }
0883 
0884 static int kmx61_read_event(struct iio_dev *indio_dev,
0885                 const struct iio_chan_spec *chan,
0886                 enum iio_event_type type,
0887                 enum iio_event_direction dir,
0888                 enum iio_event_info info,
0889                 int *val, int *val2)
0890 {
0891     struct kmx61_data *data = kmx61_get_data(indio_dev);
0892 
0893     *val2 = 0;
0894     switch (info) {
0895     case IIO_EV_INFO_VALUE:
0896         *val = data->wake_thresh;
0897         return IIO_VAL_INT;
0898     case IIO_EV_INFO_PERIOD:
0899         *val = data->wake_duration;
0900         return IIO_VAL_INT;
0901     default:
0902         return -EINVAL;
0903     }
0904 }
0905 
0906 static int kmx61_write_event(struct iio_dev *indio_dev,
0907                  const struct iio_chan_spec *chan,
0908                  enum iio_event_type type,
0909                  enum iio_event_direction dir,
0910                  enum iio_event_info info,
0911                  int val, int val2)
0912 {
0913     struct kmx61_data *data = kmx61_get_data(indio_dev);
0914 
0915     if (data->ev_enable_state)
0916         return -EBUSY;
0917 
0918     switch (info) {
0919     case IIO_EV_INFO_VALUE:
0920         data->wake_thresh = val;
0921         return IIO_VAL_INT;
0922     case IIO_EV_INFO_PERIOD:
0923         data->wake_duration = val;
0924         return IIO_VAL_INT;
0925     default:
0926         return -EINVAL;
0927     }
0928 }
0929 
0930 static int kmx61_read_event_config(struct iio_dev *indio_dev,
0931                    const struct iio_chan_spec *chan,
0932                    enum iio_event_type type,
0933                    enum iio_event_direction dir)
0934 {
0935     struct kmx61_data *data = kmx61_get_data(indio_dev);
0936 
0937     return data->ev_enable_state;
0938 }
0939 
0940 static int kmx61_write_event_config(struct iio_dev *indio_dev,
0941                     const struct iio_chan_spec *chan,
0942                     enum iio_event_type type,
0943                     enum iio_event_direction dir,
0944                     int state)
0945 {
0946     struct kmx61_data *data = kmx61_get_data(indio_dev);
0947     int ret = 0;
0948 
0949     if (state && data->ev_enable_state)
0950         return 0;
0951 
0952     mutex_lock(&data->lock);
0953 
0954     if (!state && data->motion_trig_on) {
0955         data->ev_enable_state = false;
0956         goto err_unlock;
0957     }
0958 
0959     ret = kmx61_set_power_state(data, state, KMX61_ACC);
0960     if (ret < 0)
0961         goto err_unlock;
0962 
0963     ret = kmx61_setup_any_motion_interrupt(data, state);
0964     if (ret < 0) {
0965         kmx61_set_power_state(data, false, KMX61_ACC);
0966         goto err_unlock;
0967     }
0968 
0969     data->ev_enable_state = state;
0970 
0971 err_unlock:
0972     mutex_unlock(&data->lock);
0973 
0974     return ret;
0975 }
0976 
0977 static int kmx61_acc_validate_trigger(struct iio_dev *indio_dev,
0978                       struct iio_trigger *trig)
0979 {
0980     struct kmx61_data *data = kmx61_get_data(indio_dev);
0981 
0982     if (data->acc_dready_trig != trig && data->motion_trig != trig)
0983         return -EINVAL;
0984 
0985     return 0;
0986 }
0987 
0988 static int kmx61_mag_validate_trigger(struct iio_dev *indio_dev,
0989                       struct iio_trigger *trig)
0990 {
0991     struct kmx61_data *data = kmx61_get_data(indio_dev);
0992 
0993     if (data->mag_dready_trig != trig)
0994         return -EINVAL;
0995 
0996     return 0;
0997 }
0998 
0999 static const struct iio_info kmx61_acc_info = {
1000     .read_raw       = kmx61_read_raw,
1001     .write_raw      = kmx61_write_raw,
1002     .attrs          = &kmx61_acc_attribute_group,
1003     .read_event_value   = kmx61_read_event,
1004     .write_event_value  = kmx61_write_event,
1005     .read_event_config  = kmx61_read_event_config,
1006     .write_event_config = kmx61_write_event_config,
1007     .validate_trigger   = kmx61_acc_validate_trigger,
1008 };
1009 
1010 static const struct iio_info kmx61_mag_info = {
1011     .read_raw       = kmx61_read_raw,
1012     .write_raw      = kmx61_write_raw,
1013     .attrs          = &kmx61_mag_attribute_group,
1014     .validate_trigger   = kmx61_mag_validate_trigger,
1015 };
1016 
1017 
1018 static int kmx61_data_rdy_trigger_set_state(struct iio_trigger *trig,
1019                         bool state)
1020 {
1021     int ret = 0;
1022     u8 device;
1023 
1024     struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1025     struct kmx61_data *data = kmx61_get_data(indio_dev);
1026 
1027     mutex_lock(&data->lock);
1028 
1029     if (!state && data->ev_enable_state && data->motion_trig_on) {
1030         data->motion_trig_on = false;
1031         goto err_unlock;
1032     }
1033 
1034     if (data->acc_dready_trig == trig || data->motion_trig == trig)
1035         device = KMX61_ACC;
1036     else
1037         device = KMX61_MAG;
1038 
1039     ret = kmx61_set_power_state(data, state, device);
1040     if (ret < 0)
1041         goto err_unlock;
1042 
1043     if (data->acc_dready_trig == trig || data->mag_dready_trig == trig)
1044         ret = kmx61_setup_new_data_interrupt(data, state, device);
1045     else
1046         ret = kmx61_setup_any_motion_interrupt(data, state);
1047     if (ret < 0) {
1048         kmx61_set_power_state(data, false, device);
1049         goto err_unlock;
1050     }
1051 
1052     if (data->acc_dready_trig == trig)
1053         data->acc_dready_trig_on = state;
1054     else if (data->mag_dready_trig == trig)
1055         data->mag_dready_trig_on = state;
1056     else
1057         data->motion_trig_on = state;
1058 err_unlock:
1059     mutex_unlock(&data->lock);
1060 
1061     return ret;
1062 }
1063 
1064 static void kmx61_trig_reenable(struct iio_trigger *trig)
1065 {
1066     struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1067     struct kmx61_data *data = kmx61_get_data(indio_dev);
1068     int ret;
1069 
1070     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1071     if (ret < 0)
1072         dev_err(&data->client->dev, "Error reading reg_inl\n");
1073 }
1074 
1075 static const struct iio_trigger_ops kmx61_trigger_ops = {
1076     .set_trigger_state = kmx61_data_rdy_trigger_set_state,
1077     .reenable = kmx61_trig_reenable,
1078 };
1079 
1080 static irqreturn_t kmx61_event_handler(int irq, void *private)
1081 {
1082     struct kmx61_data *data = private;
1083     struct iio_dev *indio_dev = data->acc_indio_dev;
1084     int ret;
1085 
1086     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS1);
1087     if (ret < 0) {
1088         dev_err(&data->client->dev, "Error reading reg_ins1\n");
1089         goto ack_intr;
1090     }
1091 
1092     if (ret & KMX61_REG_INS1_BIT_WUFS) {
1093         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS2);
1094         if (ret < 0) {
1095             dev_err(&data->client->dev, "Error reading reg_ins2\n");
1096             goto ack_intr;
1097         }
1098 
1099         if (ret & KMX61_REG_INS2_BIT_XN)
1100             iio_push_event(indio_dev,
1101                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1102                        0,
1103                        IIO_MOD_X,
1104                        IIO_EV_TYPE_THRESH,
1105                        IIO_EV_DIR_FALLING),
1106                        0);
1107 
1108         if (ret & KMX61_REG_INS2_BIT_XP)
1109             iio_push_event(indio_dev,
1110                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1111                        0,
1112                        IIO_MOD_X,
1113                        IIO_EV_TYPE_THRESH,
1114                        IIO_EV_DIR_RISING),
1115                        0);
1116 
1117         if (ret & KMX61_REG_INS2_BIT_YN)
1118             iio_push_event(indio_dev,
1119                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1120                        0,
1121                        IIO_MOD_Y,
1122                        IIO_EV_TYPE_THRESH,
1123                        IIO_EV_DIR_FALLING),
1124                        0);
1125 
1126         if (ret & KMX61_REG_INS2_BIT_YP)
1127             iio_push_event(indio_dev,
1128                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1129                        0,
1130                        IIO_MOD_Y,
1131                        IIO_EV_TYPE_THRESH,
1132                        IIO_EV_DIR_RISING),
1133                        0);
1134 
1135         if (ret & KMX61_REG_INS2_BIT_ZN)
1136             iio_push_event(indio_dev,
1137                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1138                        0,
1139                        IIO_MOD_Z,
1140                        IIO_EV_TYPE_THRESH,
1141                        IIO_EV_DIR_FALLING),
1142                        0);
1143 
1144         if (ret & KMX61_REG_INS2_BIT_ZP)
1145             iio_push_event(indio_dev,
1146                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1147                        0,
1148                        IIO_MOD_Z,
1149                        IIO_EV_TYPE_THRESH,
1150                        IIO_EV_DIR_RISING),
1151                        0);
1152     }
1153 
1154 ack_intr:
1155     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
1156     if (ret < 0)
1157         dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
1158 
1159     ret |= KMX61_REG_CTRL1_BIT_RES;
1160     ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
1161     if (ret < 0)
1162         dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
1163 
1164     ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1165     if (ret < 0)
1166         dev_err(&data->client->dev, "Error reading reg_inl\n");
1167 
1168     return IRQ_HANDLED;
1169 }
1170 
1171 static irqreturn_t kmx61_data_rdy_trig_poll(int irq, void *private)
1172 {
1173     struct kmx61_data *data = private;
1174 
1175     if (data->acc_dready_trig_on)
1176         iio_trigger_poll(data->acc_dready_trig);
1177     if (data->mag_dready_trig_on)
1178         iio_trigger_poll(data->mag_dready_trig);
1179 
1180     if (data->motion_trig_on)
1181         iio_trigger_poll(data->motion_trig);
1182 
1183     if (data->ev_enable_state)
1184         return IRQ_WAKE_THREAD;
1185     return IRQ_HANDLED;
1186 }
1187 
1188 static irqreturn_t kmx61_trigger_handler(int irq, void *p)
1189 {
1190     struct iio_poll_func *pf = p;
1191     struct iio_dev *indio_dev = pf->indio_dev;
1192     struct kmx61_data *data = kmx61_get_data(indio_dev);
1193     int bit, ret, i = 0;
1194     u8 base;
1195     s16 buffer[8];
1196 
1197     if (indio_dev == data->acc_indio_dev)
1198         base = KMX61_ACC_XOUT_L;
1199     else
1200         base = KMX61_MAG_XOUT_L;
1201 
1202     mutex_lock(&data->lock);
1203     for_each_set_bit(bit, indio_dev->active_scan_mask,
1204              indio_dev->masklength) {
1205         ret = kmx61_read_measurement(data, base, bit);
1206         if (ret < 0) {
1207             mutex_unlock(&data->lock);
1208             goto err;
1209         }
1210         buffer[i++] = ret;
1211     }
1212     mutex_unlock(&data->lock);
1213 
1214     iio_push_to_buffers(indio_dev, buffer);
1215 err:
1216     iio_trigger_notify_done(indio_dev->trig);
1217 
1218     return IRQ_HANDLED;
1219 }
1220 
1221 static const char *kmx61_match_acpi_device(struct device *dev)
1222 {
1223     const struct acpi_device_id *id;
1224 
1225     id = acpi_match_device(dev->driver->acpi_match_table, dev);
1226     if (!id)
1227         return NULL;
1228     return dev_name(dev);
1229 }
1230 
1231 static struct iio_dev *kmx61_indiodev_setup(struct kmx61_data *data,
1232                         const struct iio_info *info,
1233                         const struct iio_chan_spec *chan,
1234                         int num_channels,
1235                         const char *name)
1236 {
1237     struct iio_dev *indio_dev;
1238 
1239     indio_dev = devm_iio_device_alloc(&data->client->dev, sizeof(data));
1240     if (!indio_dev)
1241         return ERR_PTR(-ENOMEM);
1242 
1243     kmx61_set_data(indio_dev, data);
1244 
1245     indio_dev->channels = chan;
1246     indio_dev->num_channels = num_channels;
1247     indio_dev->name = name;
1248     indio_dev->modes = INDIO_DIRECT_MODE;
1249     indio_dev->info = info;
1250 
1251     return indio_dev;
1252 }
1253 
1254 static struct iio_trigger *kmx61_trigger_setup(struct kmx61_data *data,
1255                            struct iio_dev *indio_dev,
1256                            const char *tag)
1257 {
1258     struct iio_trigger *trig;
1259     int ret;
1260 
1261     trig = devm_iio_trigger_alloc(&data->client->dev,
1262                       "%s-%s-dev%d",
1263                       indio_dev->name,
1264                       tag,
1265                       iio_device_id(indio_dev));
1266     if (!trig)
1267         return ERR_PTR(-ENOMEM);
1268 
1269     trig->ops = &kmx61_trigger_ops;
1270     iio_trigger_set_drvdata(trig, indio_dev);
1271 
1272     ret = iio_trigger_register(trig);
1273     if (ret)
1274         return ERR_PTR(ret);
1275 
1276     return trig;
1277 }
1278 
1279 static int kmx61_probe(struct i2c_client *client,
1280                const struct i2c_device_id *id)
1281 {
1282     int ret;
1283     struct kmx61_data *data;
1284     const char *name = NULL;
1285 
1286     data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
1287     if (!data)
1288         return -ENOMEM;
1289 
1290     i2c_set_clientdata(client, data);
1291     data->client = client;
1292 
1293     mutex_init(&data->lock);
1294 
1295     if (id)
1296         name = id->name;
1297     else if (ACPI_HANDLE(&client->dev))
1298         name = kmx61_match_acpi_device(&client->dev);
1299     else
1300         return -ENODEV;
1301 
1302     data->acc_indio_dev =
1303         kmx61_indiodev_setup(data, &kmx61_acc_info,
1304                      kmx61_acc_channels,
1305                      ARRAY_SIZE(kmx61_acc_channels),
1306                      name);
1307     if (IS_ERR(data->acc_indio_dev))
1308         return PTR_ERR(data->acc_indio_dev);
1309 
1310     data->mag_indio_dev =
1311         kmx61_indiodev_setup(data, &kmx61_mag_info,
1312                      kmx61_mag_channels,
1313                      ARRAY_SIZE(kmx61_mag_channels),
1314                      name);
1315     if (IS_ERR(data->mag_indio_dev))
1316         return PTR_ERR(data->mag_indio_dev);
1317 
1318     ret = kmx61_chip_init(data);
1319     if (ret < 0)
1320         return ret;
1321 
1322     if (client->irq > 0) {
1323         ret = devm_request_threaded_irq(&client->dev, client->irq,
1324                         kmx61_data_rdy_trig_poll,
1325                         kmx61_event_handler,
1326                         IRQF_TRIGGER_RISING,
1327                         KMX61_IRQ_NAME,
1328                         data);
1329         if (ret)
1330             goto err_chip_uninit;
1331 
1332         data->acc_dready_trig =
1333             kmx61_trigger_setup(data, data->acc_indio_dev,
1334                         "dready");
1335         if (IS_ERR(data->acc_dready_trig)) {
1336             ret = PTR_ERR(data->acc_dready_trig);
1337             goto err_chip_uninit;
1338         }
1339 
1340         data->mag_dready_trig =
1341             kmx61_trigger_setup(data, data->mag_indio_dev,
1342                         "dready");
1343         if (IS_ERR(data->mag_dready_trig)) {
1344             ret = PTR_ERR(data->mag_dready_trig);
1345             goto err_trigger_unregister_acc_dready;
1346         }
1347 
1348         data->motion_trig =
1349             kmx61_trigger_setup(data, data->acc_indio_dev,
1350                         "any-motion");
1351         if (IS_ERR(data->motion_trig)) {
1352             ret = PTR_ERR(data->motion_trig);
1353             goto err_trigger_unregister_mag_dready;
1354         }
1355 
1356         ret = iio_triggered_buffer_setup(data->acc_indio_dev,
1357                          &iio_pollfunc_store_time,
1358                          kmx61_trigger_handler,
1359                          NULL);
1360         if (ret < 0) {
1361             dev_err(&data->client->dev,
1362                 "Failed to setup acc triggered buffer\n");
1363             goto err_trigger_unregister_motion;
1364         }
1365 
1366         ret = iio_triggered_buffer_setup(data->mag_indio_dev,
1367                          &iio_pollfunc_store_time,
1368                          kmx61_trigger_handler,
1369                          NULL);
1370         if (ret < 0) {
1371             dev_err(&data->client->dev,
1372                 "Failed to setup mag triggered buffer\n");
1373             goto err_buffer_cleanup_acc;
1374         }
1375     }
1376 
1377     ret = pm_runtime_set_active(&client->dev);
1378     if (ret < 0)
1379         goto err_buffer_cleanup_mag;
1380 
1381     pm_runtime_enable(&client->dev);
1382     pm_runtime_set_autosuspend_delay(&client->dev, KMX61_SLEEP_DELAY_MS);
1383     pm_runtime_use_autosuspend(&client->dev);
1384 
1385     ret = iio_device_register(data->acc_indio_dev);
1386     if (ret < 0) {
1387         dev_err(&client->dev, "Failed to register acc iio device\n");
1388         goto err_pm_cleanup;
1389     }
1390 
1391     ret = iio_device_register(data->mag_indio_dev);
1392     if (ret < 0) {
1393         dev_err(&client->dev, "Failed to register mag iio device\n");
1394         goto err_iio_unregister_acc;
1395     }
1396 
1397     return 0;
1398 
1399 err_iio_unregister_acc:
1400     iio_device_unregister(data->acc_indio_dev);
1401 err_pm_cleanup:
1402     pm_runtime_dont_use_autosuspend(&client->dev);
1403     pm_runtime_disable(&client->dev);
1404 err_buffer_cleanup_mag:
1405     if (client->irq > 0)
1406         iio_triggered_buffer_cleanup(data->mag_indio_dev);
1407 err_buffer_cleanup_acc:
1408     if (client->irq > 0)
1409         iio_triggered_buffer_cleanup(data->acc_indio_dev);
1410 err_trigger_unregister_motion:
1411     iio_trigger_unregister(data->motion_trig);
1412 err_trigger_unregister_mag_dready:
1413     iio_trigger_unregister(data->mag_dready_trig);
1414 err_trigger_unregister_acc_dready:
1415     iio_trigger_unregister(data->acc_dready_trig);
1416 err_chip_uninit:
1417     kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1418     return ret;
1419 }
1420 
1421 static int kmx61_remove(struct i2c_client *client)
1422 {
1423     struct kmx61_data *data = i2c_get_clientdata(client);
1424 
1425     iio_device_unregister(data->acc_indio_dev);
1426     iio_device_unregister(data->mag_indio_dev);
1427 
1428     pm_runtime_disable(&client->dev);
1429     pm_runtime_set_suspended(&client->dev);
1430 
1431     if (client->irq > 0) {
1432         iio_triggered_buffer_cleanup(data->acc_indio_dev);
1433         iio_triggered_buffer_cleanup(data->mag_indio_dev);
1434         iio_trigger_unregister(data->acc_dready_trig);
1435         iio_trigger_unregister(data->mag_dready_trig);
1436         iio_trigger_unregister(data->motion_trig);
1437     }
1438 
1439     mutex_lock(&data->lock);
1440     kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1441     mutex_unlock(&data->lock);
1442 
1443     return 0;
1444 }
1445 
1446 static int kmx61_suspend(struct device *dev)
1447 {
1448     int ret;
1449     struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1450 
1451     mutex_lock(&data->lock);
1452     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG,
1453                  false);
1454     mutex_unlock(&data->lock);
1455 
1456     return ret;
1457 }
1458 
1459 static int kmx61_resume(struct device *dev)
1460 {
1461     u8 stby = 0;
1462     struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1463 
1464     if (data->acc_stby)
1465         stby |= KMX61_ACC_STBY_BIT;
1466     if (data->mag_stby)
1467         stby |= KMX61_MAG_STBY_BIT;
1468 
1469     return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1470 }
1471 
1472 static int kmx61_runtime_suspend(struct device *dev)
1473 {
1474     struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1475     int ret;
1476 
1477     mutex_lock(&data->lock);
1478     ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1479     mutex_unlock(&data->lock);
1480 
1481     return ret;
1482 }
1483 
1484 static int kmx61_runtime_resume(struct device *dev)
1485 {
1486     struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1487     u8 stby = 0;
1488 
1489     if (!data->acc_ps)
1490         stby |= KMX61_ACC_STBY_BIT;
1491     if (!data->mag_ps)
1492         stby |= KMX61_MAG_STBY_BIT;
1493 
1494     return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1495 }
1496 
1497 static const struct dev_pm_ops kmx61_pm_ops = {
1498     SYSTEM_SLEEP_PM_OPS(kmx61_suspend, kmx61_resume)
1499     RUNTIME_PM_OPS(kmx61_runtime_suspend, kmx61_runtime_resume, NULL)
1500 };
1501 
1502 static const struct acpi_device_id kmx61_acpi_match[] = {
1503     {"KMX61021", 0},
1504     {}
1505 };
1506 
1507 MODULE_DEVICE_TABLE(acpi, kmx61_acpi_match);
1508 
1509 static const struct i2c_device_id kmx61_id[] = {
1510     {"kmx611021", 0},
1511     {}
1512 };
1513 
1514 MODULE_DEVICE_TABLE(i2c, kmx61_id);
1515 
1516 static struct i2c_driver kmx61_driver = {
1517     .driver = {
1518         .name = KMX61_DRV_NAME,
1519         .acpi_match_table = ACPI_PTR(kmx61_acpi_match),
1520         .pm = pm_ptr(&kmx61_pm_ops),
1521     },
1522     .probe      = kmx61_probe,
1523     .remove     = kmx61_remove,
1524     .id_table   = kmx61_id,
1525 };
1526 
1527 module_i2c_driver(kmx61_driver);
1528 
1529 MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
1530 MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
1531 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!