root/drivers/iio/gyro/bmg160_core.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. bmg160_set_mode
  2. bmg160_convert_freq_to_bit
  3. bmg160_set_bw
  4. bmg160_get_filter
  5. bmg160_set_filter
  6. bmg160_chip_init
  7. bmg160_set_power_state
  8. bmg160_setup_any_motion_interrupt
  9. bmg160_setup_new_data_interrupt
  10. bmg160_get_bw
  11. bmg160_set_scale
  12. bmg160_get_temp
  13. bmg160_get_axis
  14. bmg160_read_raw
  15. bmg160_write_raw
  16. bmg160_read_event
  17. bmg160_write_event
  18. bmg160_read_event_config
  19. bmg160_write_event_config
  20. bmg160_get_mount_matrix
  21. bmg160_trigger_handler
  22. bmg160_trig_try_reen
  23. bmg160_data_rdy_trigger_set_state
  24. bmg160_event_handler
  25. bmg160_data_rdy_trig_poll
  26. bmg160_buffer_preenable
  27. bmg160_buffer_postdisable
  28. bmg160_match_acpi_device
  29. bmg160_core_probe
  30. bmg160_core_remove
  31. bmg160_suspend
  32. bmg160_resume
  33. bmg160_runtime_suspend
  34. bmg160_runtime_resume

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * BMG160 Gyro Sensor driver
   4  * Copyright (c) 2014, Intel Corporation.
   5  */
   6 
   7 #include <linux/module.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/delay.h>
  10 #include <linux/slab.h>
  11 #include <linux/acpi.h>
  12 #include <linux/pm.h>
  13 #include <linux/pm_runtime.h>
  14 #include <linux/iio/iio.h>
  15 #include <linux/iio/sysfs.h>
  16 #include <linux/iio/buffer.h>
  17 #include <linux/iio/trigger.h>
  18 #include <linux/iio/events.h>
  19 #include <linux/iio/trigger_consumer.h>
  20 #include <linux/iio/triggered_buffer.h>
  21 #include <linux/regmap.h>
  22 #include "bmg160.h"
  23 
  24 #define BMG160_IRQ_NAME         "bmg160_event"
  25 
  26 #define BMG160_REG_CHIP_ID              0x00
  27 #define BMG160_CHIP_ID_VAL              0x0F
  28 
  29 #define BMG160_REG_PMU_LPW              0x11
  30 #define BMG160_MODE_NORMAL              0x00
  31 #define BMG160_MODE_DEEP_SUSPEND        0x20
  32 #define BMG160_MODE_SUSPEND             0x80
  33 
  34 #define BMG160_REG_RANGE                0x0F
  35 
  36 #define BMG160_RANGE_2000DPS            0
  37 #define BMG160_RANGE_1000DPS            1
  38 #define BMG160_RANGE_500DPS             2
  39 #define BMG160_RANGE_250DPS             3
  40 #define BMG160_RANGE_125DPS             4
  41 
  42 #define BMG160_REG_PMU_BW               0x10
  43 #define BMG160_NO_FILTER                0
  44 #define BMG160_DEF_BW                   100
  45 #define BMG160_REG_PMU_BW_RES           BIT(7)
  46 
  47 #define BMG160_GYRO_REG_RESET           0x14
  48 #define BMG160_GYRO_RESET_VAL           0xb6
  49 
  50 #define BMG160_REG_INT_MAP_0            0x17
  51 #define BMG160_INT_MAP_0_BIT_ANY        BIT(1)
  52 
  53 #define BMG160_REG_INT_MAP_1            0x18
  54 #define BMG160_INT_MAP_1_BIT_NEW_DATA   BIT(0)
  55 
  56 #define BMG160_REG_INT_RST_LATCH        0x21
  57 #define BMG160_INT_MODE_LATCH_RESET     0x80
  58 #define BMG160_INT_MODE_LATCH_INT       0x0F
  59 #define BMG160_INT_MODE_NON_LATCH_INT   0x00
  60 
  61 #define BMG160_REG_INT_EN_0             0x15
  62 #define BMG160_DATA_ENABLE_INT          BIT(7)
  63 
  64 #define BMG160_REG_INT_EN_1             0x16
  65 #define BMG160_INT1_BIT_OD              BIT(1)
  66 
  67 #define BMG160_REG_XOUT_L               0x02
  68 #define BMG160_AXIS_TO_REG(axis)        (BMG160_REG_XOUT_L + (axis * 2))
  69 
  70 #define BMG160_REG_SLOPE_THRES          0x1B
  71 #define BMG160_SLOPE_THRES_MASK 0x0F
  72 
  73 #define BMG160_REG_MOTION_INTR          0x1C
  74 #define BMG160_INT_MOTION_X             BIT(0)
  75 #define BMG160_INT_MOTION_Y             BIT(1)
  76 #define BMG160_INT_MOTION_Z             BIT(2)
  77 #define BMG160_ANY_DUR_MASK             0x30
  78 #define BMG160_ANY_DUR_SHIFT            4
  79 
  80 #define BMG160_REG_INT_STATUS_2 0x0B
  81 #define BMG160_ANY_MOTION_MASK          0x07
  82 #define BMG160_ANY_MOTION_BIT_X         BIT(0)
  83 #define BMG160_ANY_MOTION_BIT_Y         BIT(1)
  84 #define BMG160_ANY_MOTION_BIT_Z         BIT(2)
  85 
  86 #define BMG160_REG_TEMP         0x08
  87 #define BMG160_TEMP_CENTER_VAL          23
  88 
  89 #define BMG160_MAX_STARTUP_TIME_MS      80
  90 
  91 #define BMG160_AUTO_SUSPEND_DELAY_MS    2000
  92 
  93 struct bmg160_data {
  94         struct regmap *regmap;
  95         struct iio_trigger *dready_trig;
  96         struct iio_trigger *motion_trig;
  97         struct iio_mount_matrix orientation;
  98         struct mutex mutex;
  99         s16 buffer[8];
 100         u32 dps_range;
 101         int ev_enable_state;
 102         int slope_thres;
 103         bool dready_trigger_on;
 104         bool motion_trigger_on;
 105         int irq;
 106 };
 107 
 108 enum bmg160_axis {
 109         AXIS_X,
 110         AXIS_Y,
 111         AXIS_Z,
 112         AXIS_MAX,
 113 };
 114 
 115 static const struct {
 116         int odr;
 117         int filter;
 118         int bw_bits;
 119 } bmg160_samp_freq_table[] = { {100, 32, 0x07},
 120                                {200, 64, 0x06},
 121                                {100, 12, 0x05},
 122                                {200, 23, 0x04},
 123                                {400, 47, 0x03},
 124                                {1000, 116, 0x02},
 125                                {2000, 230, 0x01} };
 126 
 127 static const struct {
 128         int scale;
 129         int dps_range;
 130 } bmg160_scale_table[] = { { 1065, BMG160_RANGE_2000DPS},
 131                            { 532, BMG160_RANGE_1000DPS},
 132                            { 266, BMG160_RANGE_500DPS},
 133                            { 133, BMG160_RANGE_250DPS},
 134                            { 66, BMG160_RANGE_125DPS} };
 135 
 136 static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
 137 {
 138         struct device *dev = regmap_get_device(data->regmap);
 139         int ret;
 140 
 141         ret = regmap_write(data->regmap, BMG160_REG_PMU_LPW, mode);
 142         if (ret < 0) {
 143                 dev_err(dev, "Error writing reg_pmu_lpw\n");
 144                 return ret;
 145         }
 146 
 147         return 0;
 148 }
 149 
 150 static int bmg160_convert_freq_to_bit(int val)
 151 {
 152         int i;
 153 
 154         for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
 155                 if (bmg160_samp_freq_table[i].odr == val)
 156                         return bmg160_samp_freq_table[i].bw_bits;
 157         }
 158 
 159         return -EINVAL;
 160 }
 161 
 162 static int bmg160_set_bw(struct bmg160_data *data, int val)
 163 {
 164         struct device *dev = regmap_get_device(data->regmap);
 165         int ret;
 166         int bw_bits;
 167 
 168         bw_bits = bmg160_convert_freq_to_bit(val);
 169         if (bw_bits < 0)
 170                 return bw_bits;
 171 
 172         ret = regmap_write(data->regmap, BMG160_REG_PMU_BW, bw_bits);
 173         if (ret < 0) {
 174                 dev_err(dev, "Error writing reg_pmu_bw\n");
 175                 return ret;
 176         }
 177 
 178         return 0;
 179 }
 180 
 181 static int bmg160_get_filter(struct bmg160_data *data, int *val)
 182 {
 183         struct device *dev = regmap_get_device(data->regmap);
 184         int ret;
 185         int i;
 186         unsigned int bw_bits;
 187 
 188         ret = regmap_read(data->regmap, BMG160_REG_PMU_BW, &bw_bits);
 189         if (ret < 0) {
 190                 dev_err(dev, "Error reading reg_pmu_bw\n");
 191                 return ret;
 192         }
 193 
 194         /* Ignore the readonly reserved bit. */
 195         bw_bits &= ~BMG160_REG_PMU_BW_RES;
 196 
 197         for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
 198                 if (bmg160_samp_freq_table[i].bw_bits == bw_bits)
 199                         break;
 200         }
 201 
 202         *val = bmg160_samp_freq_table[i].filter;
 203 
 204         return ret ? ret : IIO_VAL_INT;
 205 }
 206 
 207 
 208 static int bmg160_set_filter(struct bmg160_data *data, int val)
 209 {
 210         struct device *dev = regmap_get_device(data->regmap);
 211         int ret;
 212         int i;
 213 
 214         for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
 215                 if (bmg160_samp_freq_table[i].filter == val)
 216                         break;
 217         }
 218 
 219         ret = regmap_write(data->regmap, BMG160_REG_PMU_BW,
 220                            bmg160_samp_freq_table[i].bw_bits);
 221         if (ret < 0) {
 222                 dev_err(dev, "Error writing reg_pmu_bw\n");
 223                 return ret;
 224         }
 225 
 226         return 0;
 227 }
 228 
 229 static int bmg160_chip_init(struct bmg160_data *data)
 230 {
 231         struct device *dev = regmap_get_device(data->regmap);
 232         int ret;
 233         unsigned int val;
 234 
 235         /*
 236          * Reset chip to get it in a known good state. A delay of 30ms after
 237          * reset is required according to the datasheet.
 238          */
 239         regmap_write(data->regmap, BMG160_GYRO_REG_RESET,
 240                      BMG160_GYRO_RESET_VAL);
 241         usleep_range(30000, 30700);
 242 
 243         ret = regmap_read(data->regmap, BMG160_REG_CHIP_ID, &val);
 244         if (ret < 0) {
 245                 dev_err(dev, "Error reading reg_chip_id\n");
 246                 return ret;
 247         }
 248 
 249         dev_dbg(dev, "Chip Id %x\n", val);
 250         if (val != BMG160_CHIP_ID_VAL) {
 251                 dev_err(dev, "invalid chip %x\n", val);
 252                 return -ENODEV;
 253         }
 254 
 255         ret = bmg160_set_mode(data, BMG160_MODE_NORMAL);
 256         if (ret < 0)
 257                 return ret;
 258 
 259         /* Wait upto 500 ms to be ready after changing mode */
 260         usleep_range(500, 1000);
 261 
 262         /* Set Bandwidth */
 263         ret = bmg160_set_bw(data, BMG160_DEF_BW);
 264         if (ret < 0)
 265                 return ret;
 266 
 267         /* Set Default Range */
 268         ret = regmap_write(data->regmap, BMG160_REG_RANGE, BMG160_RANGE_500DPS);
 269         if (ret < 0) {
 270                 dev_err(dev, "Error writing reg_range\n");
 271                 return ret;
 272         }
 273         data->dps_range = BMG160_RANGE_500DPS;
 274 
 275         ret = regmap_read(data->regmap, BMG160_REG_SLOPE_THRES, &val);
 276         if (ret < 0) {
 277                 dev_err(dev, "Error reading reg_slope_thres\n");
 278                 return ret;
 279         }
 280         data->slope_thres = val;
 281 
 282         /* Set default interrupt mode */
 283         ret = regmap_update_bits(data->regmap, BMG160_REG_INT_EN_1,
 284                                  BMG160_INT1_BIT_OD, 0);
 285         if (ret < 0) {
 286                 dev_err(dev, "Error updating bits in reg_int_en_1\n");
 287                 return ret;
 288         }
 289 
 290         ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
 291                            BMG160_INT_MODE_LATCH_INT |
 292                            BMG160_INT_MODE_LATCH_RESET);
 293         if (ret < 0) {
 294                 dev_err(dev,
 295                         "Error writing reg_motion_intr\n");
 296                 return ret;
 297         }
 298 
 299         return 0;
 300 }
 301 
 302 static int bmg160_set_power_state(struct bmg160_data *data, bool on)
 303 {
 304 #ifdef CONFIG_PM
 305         struct device *dev = regmap_get_device(data->regmap);
 306         int ret;
 307 
 308         if (on)
 309                 ret = pm_runtime_get_sync(dev);
 310         else {
 311                 pm_runtime_mark_last_busy(dev);
 312                 ret = pm_runtime_put_autosuspend(dev);
 313         }
 314 
 315         if (ret < 0) {
 316                 dev_err(dev, "Failed: bmg160_set_power_state for %d\n", on);
 317 
 318                 if (on)
 319                         pm_runtime_put_noidle(dev);
 320 
 321                 return ret;
 322         }
 323 #endif
 324 
 325         return 0;
 326 }
 327 
 328 static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 329                                              bool status)
 330 {
 331         struct device *dev = regmap_get_device(data->regmap);
 332         int ret;
 333 
 334         /* Enable/Disable INT_MAP0 mapping */
 335         ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_0,
 336                                  BMG160_INT_MAP_0_BIT_ANY,
 337                                  (status ? BMG160_INT_MAP_0_BIT_ANY : 0));
 338         if (ret < 0) {
 339                 dev_err(dev, "Error updating bits reg_int_map0\n");
 340                 return ret;
 341         }
 342 
 343         /* Enable/Disable slope interrupts */
 344         if (status) {
 345                 /* Update slope thres */
 346                 ret = regmap_write(data->regmap, BMG160_REG_SLOPE_THRES,
 347                                    data->slope_thres);
 348                 if (ret < 0) {
 349                         dev_err(dev, "Error writing reg_slope_thres\n");
 350                         return ret;
 351                 }
 352 
 353                 ret = regmap_write(data->regmap, BMG160_REG_MOTION_INTR,
 354                                    BMG160_INT_MOTION_X | BMG160_INT_MOTION_Y |
 355                                    BMG160_INT_MOTION_Z);
 356                 if (ret < 0) {
 357                         dev_err(dev, "Error writing reg_motion_intr\n");
 358                         return ret;
 359                 }
 360 
 361                 /*
 362                  * New data interrupt is always non-latched,
 363                  * which will have higher priority, so no need
 364                  * to set latched mode, we will be flooded anyway with INTR
 365                  */
 366                 if (!data->dready_trigger_on) {
 367                         ret = regmap_write(data->regmap,
 368                                            BMG160_REG_INT_RST_LATCH,
 369                                            BMG160_INT_MODE_LATCH_INT |
 370                                            BMG160_INT_MODE_LATCH_RESET);
 371                         if (ret < 0) {
 372                                 dev_err(dev, "Error writing reg_rst_latch\n");
 373                                 return ret;
 374                         }
 375                 }
 376 
 377                 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
 378                                    BMG160_DATA_ENABLE_INT);
 379 
 380         } else {
 381                 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
 382         }
 383 
 384         if (ret < 0) {
 385                 dev_err(dev, "Error writing reg_int_en0\n");
 386                 return ret;
 387         }
 388 
 389         return 0;
 390 }
 391 
 392 static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
 393                                            bool status)
 394 {
 395         struct device *dev = regmap_get_device(data->regmap);
 396         int ret;
 397 
 398         /* Enable/Disable INT_MAP1 mapping */
 399         ret = regmap_update_bits(data->regmap, BMG160_REG_INT_MAP_1,
 400                                  BMG160_INT_MAP_1_BIT_NEW_DATA,
 401                                  (status ? BMG160_INT_MAP_1_BIT_NEW_DATA : 0));
 402         if (ret < 0) {
 403                 dev_err(dev, "Error updating bits in reg_int_map1\n");
 404                 return ret;
 405         }
 406 
 407         if (status) {
 408                 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
 409                                    BMG160_INT_MODE_NON_LATCH_INT |
 410                                    BMG160_INT_MODE_LATCH_RESET);
 411                 if (ret < 0) {
 412                         dev_err(dev, "Error writing reg_rst_latch\n");
 413                         return ret;
 414                 }
 415 
 416                 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
 417                                    BMG160_DATA_ENABLE_INT);
 418 
 419         } else {
 420                 /* Restore interrupt mode */
 421                 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
 422                                    BMG160_INT_MODE_LATCH_INT |
 423                                    BMG160_INT_MODE_LATCH_RESET);
 424                 if (ret < 0) {
 425                         dev_err(dev, "Error writing reg_rst_latch\n");
 426                         return ret;
 427                 }
 428 
 429                 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
 430         }
 431 
 432         if (ret < 0) {
 433                 dev_err(dev, "Error writing reg_int_en0\n");
 434                 return ret;
 435         }
 436 
 437         return 0;
 438 }
 439 
 440 static int bmg160_get_bw(struct bmg160_data *data, int *val)
 441 {
 442         struct device *dev = regmap_get_device(data->regmap);   
 443         int i;
 444         unsigned int bw_bits;
 445         int ret;
 446 
 447         ret = regmap_read(data->regmap, BMG160_REG_PMU_BW, &bw_bits);
 448         if (ret < 0) {
 449                 dev_err(dev, "Error reading reg_pmu_bw\n");
 450                 return ret;
 451         }
 452 
 453         /* Ignore the readonly reserved bit. */
 454         bw_bits &= ~BMG160_REG_PMU_BW_RES;
 455 
 456         for (i = 0; i < ARRAY_SIZE(bmg160_samp_freq_table); ++i) {
 457                 if (bmg160_samp_freq_table[i].bw_bits == bw_bits) {
 458                         *val = bmg160_samp_freq_table[i].odr;
 459                         return IIO_VAL_INT;
 460                 }
 461         }
 462 
 463         return -EINVAL;
 464 }
 465 
 466 static int bmg160_set_scale(struct bmg160_data *data, int val)
 467 {
 468         struct device *dev = regmap_get_device(data->regmap);
 469         int ret, i;
 470 
 471         for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
 472                 if (bmg160_scale_table[i].scale == val) {
 473                         ret = regmap_write(data->regmap, BMG160_REG_RANGE,
 474                                            bmg160_scale_table[i].dps_range);
 475                         if (ret < 0) {
 476                                 dev_err(dev, "Error writing reg_range\n");
 477                                 return ret;
 478                         }
 479                         data->dps_range = bmg160_scale_table[i].dps_range;
 480                         return 0;
 481                 }
 482         }
 483 
 484         return -EINVAL;
 485 }
 486 
 487 static int bmg160_get_temp(struct bmg160_data *data, int *val)
 488 {
 489         struct device *dev = regmap_get_device(data->regmap);
 490         int ret;
 491         unsigned int raw_val;
 492 
 493         mutex_lock(&data->mutex);
 494         ret = bmg160_set_power_state(data, true);
 495         if (ret < 0) {
 496                 mutex_unlock(&data->mutex);
 497                 return ret;
 498         }
 499 
 500         ret = regmap_read(data->regmap, BMG160_REG_TEMP, &raw_val);
 501         if (ret < 0) {
 502                 dev_err(dev, "Error reading reg_temp\n");
 503                 bmg160_set_power_state(data, false);
 504                 mutex_unlock(&data->mutex);
 505                 return ret;
 506         }
 507 
 508         *val = sign_extend32(raw_val, 7);
 509         ret = bmg160_set_power_state(data, false);
 510         mutex_unlock(&data->mutex);
 511         if (ret < 0)
 512                 return ret;
 513 
 514         return IIO_VAL_INT;
 515 }
 516 
 517 static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
 518 {
 519         struct device *dev = regmap_get_device(data->regmap);
 520         int ret;
 521         __le16 raw_val;
 522 
 523         mutex_lock(&data->mutex);
 524         ret = bmg160_set_power_state(data, true);
 525         if (ret < 0) {
 526                 mutex_unlock(&data->mutex);
 527                 return ret;
 528         }
 529 
 530         ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(axis), &raw_val,
 531                                sizeof(raw_val));
 532         if (ret < 0) {
 533                 dev_err(dev, "Error reading axis %d\n", axis);
 534                 bmg160_set_power_state(data, false);
 535                 mutex_unlock(&data->mutex);
 536                 return ret;
 537         }
 538 
 539         *val = sign_extend32(le16_to_cpu(raw_val), 15);
 540         ret = bmg160_set_power_state(data, false);
 541         mutex_unlock(&data->mutex);
 542         if (ret < 0)
 543                 return ret;
 544 
 545         return IIO_VAL_INT;
 546 }
 547 
 548 static int bmg160_read_raw(struct iio_dev *indio_dev,
 549                            struct iio_chan_spec const *chan,
 550                            int *val, int *val2, long mask)
 551 {
 552         struct bmg160_data *data = iio_priv(indio_dev);
 553         int ret;
 554 
 555         switch (mask) {
 556         case IIO_CHAN_INFO_RAW:
 557                 switch (chan->type) {
 558                 case IIO_TEMP:
 559                         return bmg160_get_temp(data, val);
 560                 case IIO_ANGL_VEL:
 561                         if (iio_buffer_enabled(indio_dev))
 562                                 return -EBUSY;
 563                         else
 564                                 return bmg160_get_axis(data, chan->scan_index,
 565                                                        val);
 566                 default:
 567                         return -EINVAL;
 568                 }
 569         case IIO_CHAN_INFO_OFFSET:
 570                 if (chan->type == IIO_TEMP) {
 571                         *val = BMG160_TEMP_CENTER_VAL;
 572                         return IIO_VAL_INT;
 573                 } else
 574                         return -EINVAL;
 575         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 576                 return bmg160_get_filter(data, val);
 577         case IIO_CHAN_INFO_SCALE:
 578                 switch (chan->type) {
 579                 case IIO_TEMP:
 580                         *val = 500;
 581                         return IIO_VAL_INT;
 582                 case IIO_ANGL_VEL:
 583                 {
 584                         int i;
 585 
 586                         for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
 587                                 if (bmg160_scale_table[i].dps_range ==
 588                                                         data->dps_range) {
 589                                         *val = 0;
 590                                         *val2 = bmg160_scale_table[i].scale;
 591                                         return IIO_VAL_INT_PLUS_MICRO;
 592                                 }
 593                         }
 594                         return -EINVAL;
 595                 }
 596                 default:
 597                         return -EINVAL;
 598                 }
 599         case IIO_CHAN_INFO_SAMP_FREQ:
 600                 *val2 = 0;
 601                 mutex_lock(&data->mutex);
 602                 ret = bmg160_get_bw(data, val);
 603                 mutex_unlock(&data->mutex);
 604                 return ret;
 605         default:
 606                 return -EINVAL;
 607         }
 608 }
 609 
 610 static int bmg160_write_raw(struct iio_dev *indio_dev,
 611                             struct iio_chan_spec const *chan,
 612                             int val, int val2, long mask)
 613 {
 614         struct bmg160_data *data = iio_priv(indio_dev);
 615         int ret;
 616 
 617         switch (mask) {
 618         case IIO_CHAN_INFO_SAMP_FREQ:
 619                 mutex_lock(&data->mutex);
 620                 /*
 621                  * Section 4.2 of spec
 622                  * In suspend mode, the only supported operations are reading
 623                  * registers as well as writing to the (0x14) softreset
 624                  * register. Since we will be in suspend mode by default, change
 625                  * mode to power on for other writes.
 626                  */
 627                 ret = bmg160_set_power_state(data, true);
 628                 if (ret < 0) {
 629                         mutex_unlock(&data->mutex);
 630                         return ret;
 631                 }
 632                 ret = bmg160_set_bw(data, val);
 633                 if (ret < 0) {
 634                         bmg160_set_power_state(data, false);
 635                         mutex_unlock(&data->mutex);
 636                         return ret;
 637                 }
 638                 ret = bmg160_set_power_state(data, false);
 639                 mutex_unlock(&data->mutex);
 640                 return ret;
 641         case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
 642                 if (val2)
 643                         return -EINVAL;
 644 
 645                 mutex_lock(&data->mutex);
 646                 ret = bmg160_set_power_state(data, true);
 647                 if (ret < 0) {
 648                         bmg160_set_power_state(data, false);
 649                         mutex_unlock(&data->mutex);
 650                         return ret;
 651                 }
 652                 ret = bmg160_set_filter(data, val);
 653                 if (ret < 0) {
 654                         bmg160_set_power_state(data, false);
 655                         mutex_unlock(&data->mutex);
 656                         return ret;
 657                 }
 658                 ret = bmg160_set_power_state(data, false);
 659                 mutex_unlock(&data->mutex);
 660                 return ret;
 661         case IIO_CHAN_INFO_SCALE:
 662                 if (val)
 663                         return -EINVAL;
 664 
 665                 mutex_lock(&data->mutex);
 666                 /* Refer to comments above for the suspend mode ops */
 667                 ret = bmg160_set_power_state(data, true);
 668                 if (ret < 0) {
 669                         mutex_unlock(&data->mutex);
 670                         return ret;
 671                 }
 672                 ret = bmg160_set_scale(data, val2);
 673                 if (ret < 0) {
 674                         bmg160_set_power_state(data, false);
 675                         mutex_unlock(&data->mutex);
 676                         return ret;
 677                 }
 678                 ret = bmg160_set_power_state(data, false);
 679                 mutex_unlock(&data->mutex);
 680                 return ret;
 681         default:
 682                 return -EINVAL;
 683         }
 684 
 685         return -EINVAL;
 686 }
 687 
 688 static int bmg160_read_event(struct iio_dev *indio_dev,
 689                              const struct iio_chan_spec *chan,
 690                              enum iio_event_type type,
 691                              enum iio_event_direction dir,
 692                              enum iio_event_info info,
 693                              int *val, int *val2)
 694 {
 695         struct bmg160_data *data = iio_priv(indio_dev);
 696 
 697         *val2 = 0;
 698         switch (info) {
 699         case IIO_EV_INFO_VALUE:
 700                 *val = data->slope_thres & BMG160_SLOPE_THRES_MASK;
 701                 break;
 702         default:
 703                 return -EINVAL;
 704         }
 705 
 706         return IIO_VAL_INT;
 707 }
 708 
 709 static int bmg160_write_event(struct iio_dev *indio_dev,
 710                               const struct iio_chan_spec *chan,
 711                               enum iio_event_type type,
 712                               enum iio_event_direction dir,
 713                               enum iio_event_info info,
 714                               int val, int val2)
 715 {
 716         struct bmg160_data *data = iio_priv(indio_dev);
 717 
 718         switch (info) {
 719         case IIO_EV_INFO_VALUE:
 720                 if (data->ev_enable_state)
 721                         return -EBUSY;
 722                 data->slope_thres &= ~BMG160_SLOPE_THRES_MASK;
 723                 data->slope_thres |= (val & BMG160_SLOPE_THRES_MASK);
 724                 break;
 725         default:
 726                 return -EINVAL;
 727         }
 728 
 729         return 0;
 730 }
 731 
 732 static int bmg160_read_event_config(struct iio_dev *indio_dev,
 733                                     const struct iio_chan_spec *chan,
 734                                     enum iio_event_type type,
 735                                     enum iio_event_direction dir)
 736 {
 737 
 738         struct bmg160_data *data = iio_priv(indio_dev);
 739 
 740         return data->ev_enable_state;
 741 }
 742 
 743 static int bmg160_write_event_config(struct iio_dev *indio_dev,
 744                                      const struct iio_chan_spec *chan,
 745                                      enum iio_event_type type,
 746                                      enum iio_event_direction dir,
 747                                      int state)
 748 {
 749         struct bmg160_data *data = iio_priv(indio_dev);
 750         int ret;
 751 
 752         if (state && data->ev_enable_state)
 753                 return 0;
 754 
 755         mutex_lock(&data->mutex);
 756 
 757         if (!state && data->motion_trigger_on) {
 758                 data->ev_enable_state = 0;
 759                 mutex_unlock(&data->mutex);
 760                 return 0;
 761         }
 762         /*
 763          * We will expect the enable and disable to do operation in
 764          * in reverse order. This will happen here anyway as our
 765          * resume operation uses sync mode runtime pm calls, the
 766          * suspend operation will be delayed by autosuspend delay
 767          * So the disable operation will still happen in reverse of
 768          * enable operation. When runtime pm is disabled the mode
 769          * is always on so sequence doesn't matter
 770          */
 771         ret = bmg160_set_power_state(data, state);
 772         if (ret < 0) {
 773                 mutex_unlock(&data->mutex);
 774                 return ret;
 775         }
 776 
 777         ret =  bmg160_setup_any_motion_interrupt(data, state);
 778         if (ret < 0) {
 779                 bmg160_set_power_state(data, false);
 780                 mutex_unlock(&data->mutex);
 781                 return ret;
 782         }
 783 
 784         data->ev_enable_state = state;
 785         mutex_unlock(&data->mutex);
 786 
 787         return 0;
 788 }
 789 
 790 static const struct iio_mount_matrix *
 791 bmg160_get_mount_matrix(const struct iio_dev *indio_dev,
 792                          const struct iio_chan_spec *chan)
 793 {
 794         struct bmg160_data *data = iio_priv(indio_dev);
 795 
 796         return &data->orientation;
 797 }
 798 
 799 static const struct iio_chan_spec_ext_info bmg160_ext_info[] = {
 800         IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, bmg160_get_mount_matrix),
 801         { }
 802 };
 803 
 804 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("100 200 400 1000 2000");
 805 
 806 static IIO_CONST_ATTR(in_anglvel_scale_available,
 807                       "0.001065 0.000532 0.000266 0.000133 0.000066");
 808 
 809 static struct attribute *bmg160_attributes[] = {
 810         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 811         &iio_const_attr_in_anglvel_scale_available.dev_attr.attr,
 812         NULL,
 813 };
 814 
 815 static const struct attribute_group bmg160_attrs_group = {
 816         .attrs = bmg160_attributes,
 817 };
 818 
 819 static const struct iio_event_spec bmg160_event = {
 820                 .type = IIO_EV_TYPE_ROC,
 821                 .dir = IIO_EV_DIR_EITHER,
 822                 .mask_shared_by_type = BIT(IIO_EV_INFO_VALUE) |
 823                                        BIT(IIO_EV_INFO_ENABLE)
 824 };
 825 
 826 #define BMG160_CHANNEL(_axis) {                                 \
 827         .type = IIO_ANGL_VEL,                                           \
 828         .modified = 1,                                                  \
 829         .channel2 = IIO_MOD_##_axis,                                    \
 830         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
 831         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |          \
 832                 BIT(IIO_CHAN_INFO_SAMP_FREQ) |                          \
 833                 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY),       \
 834         .scan_index = AXIS_##_axis,                                     \
 835         .scan_type = {                                                  \
 836                 .sign = 's',                                            \
 837                 .realbits = 16,                                 \
 838                 .storagebits = 16,                                      \
 839                 .endianness = IIO_LE,                                   \
 840         },                                                              \
 841         .ext_info = bmg160_ext_info,                                    \
 842         .event_spec = &bmg160_event,                                    \
 843         .num_event_specs = 1                                            \
 844 }
 845 
 846 static const struct iio_chan_spec bmg160_channels[] = {
 847         {
 848                 .type = IIO_TEMP,
 849                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
 850                                       BIT(IIO_CHAN_INFO_SCALE) |
 851                                       BIT(IIO_CHAN_INFO_OFFSET),
 852                 .scan_index = -1,
 853         },
 854         BMG160_CHANNEL(X),
 855         BMG160_CHANNEL(Y),
 856         BMG160_CHANNEL(Z),
 857         IIO_CHAN_SOFT_TIMESTAMP(3),
 858 };
 859 
 860 static const struct iio_info bmg160_info = {
 861         .attrs                  = &bmg160_attrs_group,
 862         .read_raw               = bmg160_read_raw,
 863         .write_raw              = bmg160_write_raw,
 864         .read_event_value       = bmg160_read_event,
 865         .write_event_value      = bmg160_write_event,
 866         .write_event_config     = bmg160_write_event_config,
 867         .read_event_config      = bmg160_read_event_config,
 868 };
 869 
 870 static const unsigned long bmg160_accel_scan_masks[] = {
 871                                         BIT(AXIS_X) | BIT(AXIS_Y) | BIT(AXIS_Z),
 872                                         0};
 873 
 874 static irqreturn_t bmg160_trigger_handler(int irq, void *p)
 875 {
 876         struct iio_poll_func *pf = p;
 877         struct iio_dev *indio_dev = pf->indio_dev;
 878         struct bmg160_data *data = iio_priv(indio_dev);
 879         int ret;
 880 
 881         mutex_lock(&data->mutex);
 882         ret = regmap_bulk_read(data->regmap, BMG160_REG_XOUT_L,
 883                                data->buffer, AXIS_MAX * 2);
 884         mutex_unlock(&data->mutex);
 885         if (ret < 0)
 886                 goto err;
 887 
 888         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 889                                            pf->timestamp);
 890 err:
 891         iio_trigger_notify_done(indio_dev->trig);
 892 
 893         return IRQ_HANDLED;
 894 }
 895 
 896 static int bmg160_trig_try_reen(struct iio_trigger *trig)
 897 {
 898         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 899         struct bmg160_data *data = iio_priv(indio_dev);
 900         struct device *dev = regmap_get_device(data->regmap);
 901         int ret;
 902 
 903         /* new data interrupts don't need ack */
 904         if (data->dready_trigger_on)
 905                 return 0;
 906 
 907         /* Set latched mode interrupt and clear any latched interrupt */
 908         ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
 909                            BMG160_INT_MODE_LATCH_INT |
 910                            BMG160_INT_MODE_LATCH_RESET);
 911         if (ret < 0) {
 912                 dev_err(dev, "Error writing reg_rst_latch\n");
 913                 return ret;
 914         }
 915 
 916         return 0;
 917 }
 918 
 919 static int bmg160_data_rdy_trigger_set_state(struct iio_trigger *trig,
 920                                              bool state)
 921 {
 922         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 923         struct bmg160_data *data = iio_priv(indio_dev);
 924         int ret;
 925 
 926         mutex_lock(&data->mutex);
 927 
 928         if (!state && data->ev_enable_state && data->motion_trigger_on) {
 929                 data->motion_trigger_on = false;
 930                 mutex_unlock(&data->mutex);
 931                 return 0;
 932         }
 933 
 934         /*
 935          * Refer to comment in bmg160_write_event_config for
 936          * enable/disable operation order
 937          */
 938         ret = bmg160_set_power_state(data, state);
 939         if (ret < 0) {
 940                 mutex_unlock(&data->mutex);
 941                 return ret;
 942         }
 943         if (data->motion_trig == trig)
 944                 ret =  bmg160_setup_any_motion_interrupt(data, state);
 945         else
 946                 ret = bmg160_setup_new_data_interrupt(data, state);
 947         if (ret < 0) {
 948                 bmg160_set_power_state(data, false);
 949                 mutex_unlock(&data->mutex);
 950                 return ret;
 951         }
 952         if (data->motion_trig == trig)
 953                 data->motion_trigger_on = state;
 954         else
 955                 data->dready_trigger_on = state;
 956 
 957         mutex_unlock(&data->mutex);
 958 
 959         return 0;
 960 }
 961 
 962 static const struct iio_trigger_ops bmg160_trigger_ops = {
 963         .set_trigger_state = bmg160_data_rdy_trigger_set_state,
 964         .try_reenable = bmg160_trig_try_reen,
 965 };
 966 
 967 static irqreturn_t bmg160_event_handler(int irq, void *private)
 968 {
 969         struct iio_dev *indio_dev = private;
 970         struct bmg160_data *data = iio_priv(indio_dev);
 971         struct device *dev = regmap_get_device(data->regmap);
 972         int ret;
 973         int dir;
 974         unsigned int val;
 975 
 976         ret = regmap_read(data->regmap, BMG160_REG_INT_STATUS_2, &val);
 977         if (ret < 0) {
 978                 dev_err(dev, "Error reading reg_int_status2\n");
 979                 goto ack_intr_status;
 980         }
 981 
 982         if (val & 0x08)
 983                 dir = IIO_EV_DIR_RISING;
 984         else
 985                 dir = IIO_EV_DIR_FALLING;
 986 
 987         if (val & BMG160_ANY_MOTION_BIT_X)
 988                 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
 989                                                              0,
 990                                                              IIO_MOD_X,
 991                                                              IIO_EV_TYPE_ROC,
 992                                                              dir),
 993                                iio_get_time_ns(indio_dev));
 994         if (val & BMG160_ANY_MOTION_BIT_Y)
 995                 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
 996                                                              0,
 997                                                              IIO_MOD_Y,
 998                                                              IIO_EV_TYPE_ROC,
 999                                                              dir),
1000                                iio_get_time_ns(indio_dev));
1001         if (val & BMG160_ANY_MOTION_BIT_Z)
1002                 iio_push_event(indio_dev, IIO_MOD_EVENT_CODE(IIO_ANGL_VEL,
1003                                                              0,
1004                                                              IIO_MOD_Z,
1005                                                              IIO_EV_TYPE_ROC,
1006                                                              dir),
1007                                iio_get_time_ns(indio_dev));
1008 
1009 ack_intr_status:
1010         if (!data->dready_trigger_on) {
1011                 ret = regmap_write(data->regmap, BMG160_REG_INT_RST_LATCH,
1012                                    BMG160_INT_MODE_LATCH_INT |
1013                                    BMG160_INT_MODE_LATCH_RESET);
1014                 if (ret < 0)
1015                         dev_err(dev, "Error writing reg_rst_latch\n");
1016         }
1017 
1018         return IRQ_HANDLED;
1019 }
1020 
1021 static irqreturn_t bmg160_data_rdy_trig_poll(int irq, void *private)
1022 {
1023         struct iio_dev *indio_dev = private;
1024         struct bmg160_data *data = iio_priv(indio_dev);
1025 
1026         if (data->dready_trigger_on)
1027                 iio_trigger_poll(data->dready_trig);
1028         else if (data->motion_trigger_on)
1029                 iio_trigger_poll(data->motion_trig);
1030 
1031         if (data->ev_enable_state)
1032                 return IRQ_WAKE_THREAD;
1033         else
1034                 return IRQ_HANDLED;
1035 
1036 }
1037 
1038 static int bmg160_buffer_preenable(struct iio_dev *indio_dev)
1039 {
1040         struct bmg160_data *data = iio_priv(indio_dev);
1041 
1042         return bmg160_set_power_state(data, true);
1043 }
1044 
1045 static int bmg160_buffer_postdisable(struct iio_dev *indio_dev)
1046 {
1047         struct bmg160_data *data = iio_priv(indio_dev);
1048 
1049         return bmg160_set_power_state(data, false);
1050 }
1051 
1052 static const struct iio_buffer_setup_ops bmg160_buffer_setup_ops = {
1053         .preenable = bmg160_buffer_preenable,
1054         .postenable = iio_triggered_buffer_postenable,
1055         .predisable = iio_triggered_buffer_predisable,
1056         .postdisable = bmg160_buffer_postdisable,
1057 };
1058 
1059 static const char *bmg160_match_acpi_device(struct device *dev)
1060 {
1061         const struct acpi_device_id *id;
1062 
1063         id = acpi_match_device(dev->driver->acpi_match_table, dev);
1064         if (!id)
1065                 return NULL;
1066 
1067         return dev_name(dev);
1068 }
1069 
1070 int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
1071                       const char *name)
1072 {
1073         struct bmg160_data *data;
1074         struct iio_dev *indio_dev;
1075         int ret;
1076 
1077         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
1078         if (!indio_dev)
1079                 return -ENOMEM;
1080 
1081         data = iio_priv(indio_dev);
1082         dev_set_drvdata(dev, indio_dev);
1083         data->irq = irq;
1084         data->regmap = regmap;
1085 
1086         ret = iio_read_mount_matrix(dev, "mount-matrix",
1087                                 &data->orientation);
1088         if (ret)
1089                 return ret;
1090 
1091         ret = bmg160_chip_init(data);
1092         if (ret < 0)
1093                 return ret;
1094 
1095         mutex_init(&data->mutex);
1096 
1097         if (ACPI_HANDLE(dev))
1098                 name = bmg160_match_acpi_device(dev);
1099 
1100         indio_dev->dev.parent = dev;
1101         indio_dev->channels = bmg160_channels;
1102         indio_dev->num_channels = ARRAY_SIZE(bmg160_channels);
1103         indio_dev->name = name;
1104         indio_dev->available_scan_masks = bmg160_accel_scan_masks;
1105         indio_dev->modes = INDIO_DIRECT_MODE;
1106         indio_dev->info = &bmg160_info;
1107 
1108         if (data->irq > 0) {
1109                 ret = devm_request_threaded_irq(dev,
1110                                                 data->irq,
1111                                                 bmg160_data_rdy_trig_poll,
1112                                                 bmg160_event_handler,
1113                                                 IRQF_TRIGGER_RISING,
1114                                                 BMG160_IRQ_NAME,
1115                                                 indio_dev);
1116                 if (ret)
1117                         return ret;
1118 
1119                 data->dready_trig = devm_iio_trigger_alloc(dev,
1120                                                            "%s-dev%d",
1121                                                            indio_dev->name,
1122                                                            indio_dev->id);
1123                 if (!data->dready_trig)
1124                         return -ENOMEM;
1125 
1126                 data->motion_trig = devm_iio_trigger_alloc(dev,
1127                                                           "%s-any-motion-dev%d",
1128                                                           indio_dev->name,
1129                                                           indio_dev->id);
1130                 if (!data->motion_trig)
1131                         return -ENOMEM;
1132 
1133                 data->dready_trig->dev.parent = dev;
1134                 data->dready_trig->ops = &bmg160_trigger_ops;
1135                 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
1136                 ret = iio_trigger_register(data->dready_trig);
1137                 if (ret)
1138                         return ret;
1139 
1140                 data->motion_trig->dev.parent = dev;
1141                 data->motion_trig->ops = &bmg160_trigger_ops;
1142                 iio_trigger_set_drvdata(data->motion_trig, indio_dev);
1143                 ret = iio_trigger_register(data->motion_trig);
1144                 if (ret) {
1145                         data->motion_trig = NULL;
1146                         goto err_trigger_unregister;
1147                 }
1148         }
1149 
1150         ret = iio_triggered_buffer_setup(indio_dev,
1151                                          iio_pollfunc_store_time,
1152                                          bmg160_trigger_handler,
1153                                          &bmg160_buffer_setup_ops);
1154         if (ret < 0) {
1155                 dev_err(dev,
1156                         "iio triggered buffer setup failed\n");
1157                 goto err_trigger_unregister;
1158         }
1159 
1160         ret = pm_runtime_set_active(dev);
1161         if (ret)
1162                 goto err_buffer_cleanup;
1163 
1164         pm_runtime_enable(dev);
1165         pm_runtime_set_autosuspend_delay(dev,
1166                                          BMG160_AUTO_SUSPEND_DELAY_MS);
1167         pm_runtime_use_autosuspend(dev);
1168 
1169         ret = iio_device_register(indio_dev);
1170         if (ret < 0) {
1171                 dev_err(dev, "unable to register iio device\n");
1172                 goto err_buffer_cleanup;
1173         }
1174 
1175         return 0;
1176 
1177 err_buffer_cleanup:
1178         iio_triggered_buffer_cleanup(indio_dev);
1179 err_trigger_unregister:
1180         if (data->dready_trig)
1181                 iio_trigger_unregister(data->dready_trig);
1182         if (data->motion_trig)
1183                 iio_trigger_unregister(data->motion_trig);
1184 
1185         return ret;
1186 }
1187 EXPORT_SYMBOL_GPL(bmg160_core_probe);
1188 
1189 void bmg160_core_remove(struct device *dev)
1190 {
1191         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1192         struct bmg160_data *data = iio_priv(indio_dev);
1193 
1194         iio_device_unregister(indio_dev);
1195 
1196         pm_runtime_disable(dev);
1197         pm_runtime_set_suspended(dev);
1198         pm_runtime_put_noidle(dev);
1199 
1200         iio_triggered_buffer_cleanup(indio_dev);
1201 
1202         if (data->dready_trig) {
1203                 iio_trigger_unregister(data->dready_trig);
1204                 iio_trigger_unregister(data->motion_trig);
1205         }
1206 
1207         mutex_lock(&data->mutex);
1208         bmg160_set_mode(data, BMG160_MODE_DEEP_SUSPEND);
1209         mutex_unlock(&data->mutex);
1210 }
1211 EXPORT_SYMBOL_GPL(bmg160_core_remove);
1212 
1213 #ifdef CONFIG_PM_SLEEP
1214 static int bmg160_suspend(struct device *dev)
1215 {
1216         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1217         struct bmg160_data *data = iio_priv(indio_dev);
1218 
1219         mutex_lock(&data->mutex);
1220         bmg160_set_mode(data, BMG160_MODE_SUSPEND);
1221         mutex_unlock(&data->mutex);
1222 
1223         return 0;
1224 }
1225 
1226 static int bmg160_resume(struct device *dev)
1227 {
1228         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1229         struct bmg160_data *data = iio_priv(indio_dev);
1230 
1231         mutex_lock(&data->mutex);
1232         if (data->dready_trigger_on || data->motion_trigger_on ||
1233                                                         data->ev_enable_state)
1234                 bmg160_set_mode(data, BMG160_MODE_NORMAL);
1235         mutex_unlock(&data->mutex);
1236 
1237         return 0;
1238 }
1239 #endif
1240 
1241 #ifdef CONFIG_PM
1242 static int bmg160_runtime_suspend(struct device *dev)
1243 {
1244         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1245         struct bmg160_data *data = iio_priv(indio_dev);
1246         int ret;
1247 
1248         ret = bmg160_set_mode(data, BMG160_MODE_SUSPEND);
1249         if (ret < 0) {
1250                 dev_err(dev, "set mode failed\n");
1251                 return -EAGAIN;
1252         }
1253 
1254         return 0;
1255 }
1256 
1257 static int bmg160_runtime_resume(struct device *dev)
1258 {
1259         struct iio_dev *indio_dev = dev_get_drvdata(dev);
1260         struct bmg160_data *data = iio_priv(indio_dev);
1261         int ret;
1262 
1263         ret = bmg160_set_mode(data, BMG160_MODE_NORMAL);
1264         if (ret < 0)
1265                 return ret;
1266 
1267         msleep_interruptible(BMG160_MAX_STARTUP_TIME_MS);
1268 
1269         return 0;
1270 }
1271 #endif
1272 
1273 const struct dev_pm_ops bmg160_pm_ops = {
1274         SET_SYSTEM_SLEEP_PM_OPS(bmg160_suspend, bmg160_resume)
1275         SET_RUNTIME_PM_OPS(bmg160_runtime_suspend,
1276                            bmg160_runtime_resume, NULL)
1277 };
1278 EXPORT_SYMBOL_GPL(bmg160_pm_ops);
1279 
1280 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1281 MODULE_LICENSE("GPL v2");
1282 MODULE_DESCRIPTION("BMG160 Gyro driver");

/* [<][>][^][v][top][bottom][index][help] */