1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * KMX61 - Kionix 6-axis Accelerometer/Magnetometer 4 * 5 * Copyright (c) 2014, Intel Corporation. 6 * 7 * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F). 8 */ 9 10 #include <linux/cleanup.h> 11 #include <linux/i2c.h> 12 #include <linux/interrupt.h> 13 #include <linux/mod_devicetable.h> 14 #include <linux/module.h> 15 #include <linux/pm.h> 16 #include <linux/pm_runtime.h> 17 18 #include <linux/iio/iio.h> 19 #include <linux/iio/sysfs.h> 20 #include <linux/iio/events.h> 21 #include <linux/iio/trigger.h> 22 #include <linux/iio/buffer.h> 23 #include <linux/iio/triggered_buffer.h> 24 #include <linux/iio/trigger_consumer.h> 25 26 #define KMX61_REG_WHO_AM_I 0x00 27 #define KMX61_REG_INS1 0x01 28 #define KMX61_REG_INS2 0x02 29 30 /* 31 * three 16-bit accelerometer output registers for X/Y/Z axis 32 * we use only XOUT_L as a base register, all other addresses 33 * can be obtained by applying an offset and are provided here 34 * only for clarity. 35 */ 36 #define KMX61_ACC_XOUT_L 0x0A 37 #define KMX61_ACC_XOUT_H 0x0B 38 #define KMX61_ACC_YOUT_L 0x0C 39 #define KMX61_ACC_YOUT_H 0x0D 40 #define KMX61_ACC_ZOUT_L 0x0E 41 #define KMX61_ACC_ZOUT_H 0x0F 42 43 /* 44 * one 16-bit temperature output register 45 */ 46 #define KMX61_TEMP_L 0x10 47 #define KMX61_TEMP_H 0x11 48 49 /* 50 * three 16-bit magnetometer output registers for X/Y/Z axis 51 */ 52 #define KMX61_MAG_XOUT_L 0x12 53 #define KMX61_MAG_XOUT_H 0x13 54 #define KMX61_MAG_YOUT_L 0x14 55 #define KMX61_MAG_YOUT_H 0x15 56 #define KMX61_MAG_ZOUT_L 0x16 57 #define KMX61_MAG_ZOUT_H 0x17 58 59 #define KMX61_REG_INL 0x28 60 #define KMX61_REG_STBY 0x29 61 #define KMX61_REG_CTRL1 0x2A 62 #define KMX61_REG_CTRL2 0x2B 63 #define KMX61_REG_ODCNTL 0x2C 64 #define KMX61_REG_INC1 0x2D 65 66 #define KMX61_REG_WUF_THRESH 0x3D 67 #define KMX61_REG_WUF_TIMER 0x3E 68 69 #define KMX61_ACC_STBY_BIT BIT(0) 70 #define KMX61_MAG_STBY_BIT BIT(1) 71 #define KMX61_ACT_STBY_BIT BIT(7) 72 73 #define KMX61_ALL_STBY (KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT) 74 75 #define KMX61_REG_INS1_BIT_WUFS BIT(1) 76 77 #define KMX61_REG_INS2_BIT_ZP BIT(0) 78 #define KMX61_REG_INS2_BIT_ZN BIT(1) 79 #define KMX61_REG_INS2_BIT_YP BIT(2) 80 #define KMX61_REG_INS2_BIT_YN BIT(3) 81 #define KMX61_REG_INS2_BIT_XP BIT(4) 82 #define KMX61_REG_INS2_BIT_XN BIT(5) 83 84 #define KMX61_REG_CTRL1_GSEL_MASK 0x03 85 86 #define KMX61_REG_CTRL1_BIT_RES BIT(4) 87 #define KMX61_REG_CTRL1_BIT_DRDYE BIT(5) 88 #define KMX61_REG_CTRL1_BIT_WUFE BIT(6) 89 #define KMX61_REG_CTRL1_BIT_BTSE BIT(7) 90 91 #define KMX61_REG_INC1_BIT_WUFS BIT(0) 92 #define KMX61_REG_INC1_BIT_DRDYM BIT(1) 93 #define KMX61_REG_INC1_BIT_DRDYA BIT(2) 94 #define KMX61_REG_INC1_BIT_IEN BIT(5) 95 96 #define KMX61_ACC_ODR_SHIFT 0 97 #define KMX61_MAG_ODR_SHIFT 4 98 #define KMX61_ACC_ODR_MASK 0x0F 99 #define KMX61_MAG_ODR_MASK 0xF0 100 101 #define KMX61_OWUF_MASK 0x7 102 103 #define KMX61_DEFAULT_WAKE_THRESH 1 104 #define KMX61_DEFAULT_WAKE_DURATION 1 105 106 #define KMX61_SLEEP_DELAY_MS 2000 107 108 #define KMX61_CHIP_ID 0x12 109 110 /* KMX61 devices */ 111 #define KMX61_ACC 0x01 112 #define KMX61_MAG 0x02 113 114 struct kmx61_data { 115 struct i2c_client *client; 116 117 /* serialize access to non-atomic ops, e.g set_mode */ 118 struct mutex lock; 119 120 /* standby state */ 121 bool acc_stby; 122 bool mag_stby; 123 124 /* power state */ 125 bool acc_ps; 126 bool mag_ps; 127 128 /* config bits */ 129 u8 range; 130 u8 odr_bits; 131 u8 wake_thresh; 132 u8 wake_duration; 133 134 /* accelerometer specific data */ 135 struct iio_dev *acc_indio_dev; 136 struct iio_trigger *acc_dready_trig; 137 struct iio_trigger *motion_trig; 138 bool acc_dready_trig_on; 139 bool motion_trig_on; 140 bool ev_enable_state; 141 142 /* magnetometer specific data */ 143 struct iio_dev *mag_indio_dev; 144 struct iio_trigger *mag_dready_trig; 145 bool mag_dready_trig_on; 146 }; 147 148 enum kmx61_range { 149 KMX61_RANGE_2G, 150 KMX61_RANGE_4G, 151 KMX61_RANGE_8G, 152 }; 153 154 enum kmx61_axis { 155 KMX61_AXIS_X, 156 KMX61_AXIS_Y, 157 KMX61_AXIS_Z, 158 }; 159 160 static const u16 kmx61_uscale_table[] = {9582, 19163, 38326}; 161 162 static const struct { 163 int val; 164 int val2; 165 } kmx61_samp_freq_table[] = { {12, 500000}, 166 {25, 0}, 167 {50, 0}, 168 {100, 0}, 169 {200, 0}, 170 {400, 0}, 171 {800, 0}, 172 {1600, 0}, 173 {0, 781000}, 174 {1, 563000}, 175 {3, 125000}, 176 {6, 250000} }; 177 178 static const struct { 179 int val; 180 int val2; 181 int odr_bits; 182 } kmx61_wake_up_odr_table[] = { {0, 781000, 0x00}, 183 {1, 563000, 0x01}, 184 {3, 125000, 0x02}, 185 {6, 250000, 0x03}, 186 {12, 500000, 0x04}, 187 {25, 0, 0x05}, 188 {50, 0, 0x06}, 189 {100, 0, 0x06}, 190 {200, 0, 0x06}, 191 {400, 0, 0x06}, 192 {800, 0, 0x06}, 193 {1600, 0, 0x06} }; 194 195 static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326"); 196 static IIO_CONST_ATTR(magn_scale_available, "0.001465"); 197 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL( 198 "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800"); 199 200 static struct attribute *kmx61_acc_attributes[] = { 201 &iio_const_attr_accel_scale_available.dev_attr.attr, 202 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 203 NULL, 204 }; 205 206 static struct attribute *kmx61_mag_attributes[] = { 207 &iio_const_attr_magn_scale_available.dev_attr.attr, 208 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 209 NULL, 210 }; 211 212 static const struct attribute_group kmx61_acc_attribute_group = { 213 .attrs = kmx61_acc_attributes, 214 }; 215 216 static const struct attribute_group kmx61_mag_attribute_group = { 217 .attrs = kmx61_mag_attributes, 218 }; 219 220 static const struct iio_event_spec kmx61_event = { 221 .type = IIO_EV_TYPE_THRESH, 222 .dir = IIO_EV_DIR_EITHER, 223 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 224 BIT(IIO_EV_INFO_ENABLE) | 225 BIT(IIO_EV_INFO_PERIOD), 226 }; 227 228 #define KMX61_ACC_CHAN(_axis) { \ 229 .type = IIO_ACCEL, \ 230 .modified = 1, \ 231 .channel2 = IIO_MOD_ ## _axis, \ 232 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 233 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 234 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 235 .address = KMX61_ACC, \ 236 .scan_index = KMX61_AXIS_ ## _axis, \ 237 .scan_type = { \ 238 .sign = 's', \ 239 .realbits = 12, \ 240 .storagebits = 16, \ 241 .shift = 4, \ 242 .endianness = IIO_LE, \ 243 }, \ 244 .event_spec = &kmx61_event, \ 245 .num_event_specs = 1 \ 246 } 247 248 #define KMX61_MAG_CHAN(_axis) { \ 249 .type = IIO_MAGN, \ 250 .modified = 1, \ 251 .channel2 = IIO_MOD_ ## _axis, \ 252 .address = KMX61_MAG, \ 253 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 254 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 255 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 256 .scan_index = KMX61_AXIS_ ## _axis, \ 257 .scan_type = { \ 258 .sign = 's', \ 259 .realbits = 14, \ 260 .storagebits = 16, \ 261 .shift = 2, \ 262 .endianness = IIO_LE, \ 263 }, \ 264 } 265 266 static const struct iio_chan_spec kmx61_acc_channels[] = { 267 KMX61_ACC_CHAN(X), 268 KMX61_ACC_CHAN(Y), 269 KMX61_ACC_CHAN(Z), 270 }; 271 272 static const struct iio_chan_spec kmx61_mag_channels[] = { 273 KMX61_MAG_CHAN(X), 274 KMX61_MAG_CHAN(Y), 275 KMX61_MAG_CHAN(Z), 276 }; 277 278 static void kmx61_set_data(struct iio_dev *indio_dev, struct kmx61_data *data) 279 { 280 struct kmx61_data **priv = iio_priv(indio_dev); 281 282 *priv = data; 283 } 284 285 static struct kmx61_data *kmx61_get_data(struct iio_dev *indio_dev) 286 { 287 return *(struct kmx61_data **)iio_priv(indio_dev); 288 } 289 290 static int kmx61_convert_freq_to_bit(int val, int val2) 291 { 292 int i; 293 294 for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++) 295 if (val == kmx61_samp_freq_table[i].val && 296 val2 == kmx61_samp_freq_table[i].val2) 297 return i; 298 return -EINVAL; 299 } 300 301 static int kmx61_convert_wake_up_odr_to_bit(int val, int val2) 302 { 303 int i; 304 305 for (i = 0; i < ARRAY_SIZE(kmx61_wake_up_odr_table); ++i) 306 if (kmx61_wake_up_odr_table[i].val == val && 307 kmx61_wake_up_odr_table[i].val2 == val2) 308 return kmx61_wake_up_odr_table[i].odr_bits; 309 return -EINVAL; 310 } 311 312 /** 313 * kmx61_set_mode() - set KMX61 device operating mode 314 * @data: kmx61 device private data pointer 315 * @mode: bitmask, indicating operating mode for @device 316 * @device: bitmask, indicating device for which @mode needs to be set 317 * @update: update stby bits stored in device's private @data 318 * 319 * For each sensor (accelerometer/magnetometer) there are two operating modes 320 * STANDBY and OPERATION. Neither accel nor magn can be disabled independently 321 * if they are both enabled. Internal sensors state is saved in acc_stby and 322 * mag_stby members of driver's private @data. 323 */ 324 static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device, 325 bool update) 326 { 327 int ret; 328 int acc_stby = -1, mag_stby = -1; 329 330 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY); 331 if (ret < 0) { 332 dev_err(&data->client->dev, "Error reading reg_stby\n"); 333 return ret; 334 } 335 if (device & KMX61_ACC) { 336 if (mode & KMX61_ACC_STBY_BIT) { 337 ret |= KMX61_ACC_STBY_BIT; 338 acc_stby = 1; 339 } else { 340 ret &= ~KMX61_ACC_STBY_BIT; 341 acc_stby = 0; 342 } 343 } 344 345 if (device & KMX61_MAG) { 346 if (mode & KMX61_MAG_STBY_BIT) { 347 ret |= KMX61_MAG_STBY_BIT; 348 mag_stby = 1; 349 } else { 350 ret &= ~KMX61_MAG_STBY_BIT; 351 mag_stby = 0; 352 } 353 } 354 355 if (mode & KMX61_ACT_STBY_BIT) 356 ret |= KMX61_ACT_STBY_BIT; 357 358 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret); 359 if (ret < 0) { 360 dev_err(&data->client->dev, "Error writing reg_stby\n"); 361 return ret; 362 } 363 364 if (acc_stby != -1 && update) 365 data->acc_stby = acc_stby; 366 if (mag_stby != -1 && update) 367 data->mag_stby = mag_stby; 368 369 return 0; 370 } 371 372 static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device) 373 { 374 int ret; 375 376 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY); 377 if (ret < 0) { 378 dev_err(&data->client->dev, "Error reading reg_stby\n"); 379 return ret; 380 } 381 *mode = 0; 382 383 if (device & KMX61_ACC) { 384 if (ret & KMX61_ACC_STBY_BIT) 385 *mode |= KMX61_ACC_STBY_BIT; 386 else 387 *mode &= ~KMX61_ACC_STBY_BIT; 388 } 389 390 if (device & KMX61_MAG) { 391 if (ret & KMX61_MAG_STBY_BIT) 392 *mode |= KMX61_MAG_STBY_BIT; 393 else 394 *mode &= ~KMX61_MAG_STBY_BIT; 395 } 396 397 return 0; 398 } 399 400 static int kmx61_set_wake_up_odr(struct kmx61_data *data, int val, int val2) 401 { 402 int ret, odr_bits; 403 404 odr_bits = kmx61_convert_wake_up_odr_to_bit(val, val2); 405 if (odr_bits < 0) 406 return odr_bits; 407 408 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL2, 409 odr_bits); 410 if (ret < 0) 411 dev_err(&data->client->dev, "Error writing reg_ctrl2\n"); 412 return ret; 413 } 414 415 static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device) 416 { 417 int ret; 418 u8 mode; 419 int lodr_bits, odr_bits; 420 421 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG); 422 if (ret < 0) 423 return ret; 424 425 lodr_bits = kmx61_convert_freq_to_bit(val, val2); 426 if (lodr_bits < 0) 427 return lodr_bits; 428 429 /* To change ODR, accel and magn must be in STDBY */ 430 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, 431 true); 432 if (ret < 0) 433 return ret; 434 435 odr_bits = 0; 436 if (device & KMX61_ACC) 437 odr_bits |= lodr_bits << KMX61_ACC_ODR_SHIFT; 438 if (device & KMX61_MAG) 439 odr_bits |= lodr_bits << KMX61_MAG_ODR_SHIFT; 440 441 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL, 442 odr_bits); 443 if (ret < 0) 444 return ret; 445 446 data->odr_bits = odr_bits; 447 448 if (device & KMX61_ACC) { 449 ret = kmx61_set_wake_up_odr(data, val, val2); 450 if (ret) 451 return ret; 452 } 453 454 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true); 455 } 456 457 static int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2, 458 u8 device) 459 { 460 u8 lodr_bits; 461 462 if (device & KMX61_ACC) 463 lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) & 464 KMX61_ACC_ODR_MASK; 465 else if (device & KMX61_MAG) 466 lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) & 467 KMX61_MAG_ODR_MASK; 468 else 469 return -EINVAL; 470 471 if (lodr_bits >= ARRAY_SIZE(kmx61_samp_freq_table)) 472 return -EINVAL; 473 474 *val = kmx61_samp_freq_table[lodr_bits].val; 475 *val2 = kmx61_samp_freq_table[lodr_bits].val2; 476 477 return 0; 478 } 479 480 static int kmx61_set_range(struct kmx61_data *data, u8 range) 481 { 482 int ret; 483 484 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1); 485 if (ret < 0) { 486 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 487 return ret; 488 } 489 490 ret &= ~KMX61_REG_CTRL1_GSEL_MASK; 491 ret |= range & KMX61_REG_CTRL1_GSEL_MASK; 492 493 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret); 494 if (ret < 0) { 495 dev_err(&data->client->dev, "Error writing reg_ctrl1\n"); 496 return ret; 497 } 498 499 data->range = range; 500 501 return 0; 502 } 503 504 static int kmx61_set_scale(struct kmx61_data *data, u16 uscale) 505 { 506 int ret, i; 507 u8 mode; 508 509 for (i = 0; i < ARRAY_SIZE(kmx61_uscale_table); i++) { 510 if (kmx61_uscale_table[i] == uscale) { 511 ret = kmx61_get_mode(data, &mode, 512 KMX61_ACC | KMX61_MAG); 513 if (ret < 0) 514 return ret; 515 516 ret = kmx61_set_mode(data, KMX61_ALL_STBY, 517 KMX61_ACC | KMX61_MAG, true); 518 if (ret < 0) 519 return ret; 520 521 ret = kmx61_set_range(data, i); 522 if (ret < 0) 523 return ret; 524 525 return kmx61_set_mode(data, mode, 526 KMX61_ACC | KMX61_MAG, true); 527 } 528 } 529 return -EINVAL; 530 } 531 532 static int kmx61_chip_init(struct kmx61_data *data) 533 { 534 int ret, val, val2; 535 536 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I); 537 if (ret < 0) { 538 dev_err(&data->client->dev, "Error reading who_am_i\n"); 539 return ret; 540 } 541 542 if (ret != KMX61_CHIP_ID) { 543 dev_err(&data->client->dev, 544 "Wrong chip id, got %x expected %x\n", 545 ret, KMX61_CHIP_ID); 546 return -EINVAL; 547 } 548 549 /* set accel 12bit, 4g range */ 550 ret = kmx61_set_range(data, KMX61_RANGE_4G); 551 if (ret < 0) 552 return ret; 553 554 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_ODCNTL); 555 if (ret < 0) { 556 dev_err(&data->client->dev, "Error reading reg_odcntl\n"); 557 return ret; 558 } 559 data->odr_bits = ret; 560 561 /* 562 * set output data rate for wake up (motion detection) function 563 * to match data rate for accelerometer sampling 564 */ 565 ret = kmx61_get_odr(data, &val, &val2, KMX61_ACC); 566 if (ret < 0) 567 return ret; 568 569 ret = kmx61_set_wake_up_odr(data, val, val2); 570 if (ret < 0) 571 return ret; 572 573 /* set acc/magn to OPERATION mode */ 574 ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG, true); 575 if (ret < 0) 576 return ret; 577 578 data->wake_thresh = KMX61_DEFAULT_WAKE_THRESH; 579 data->wake_duration = KMX61_DEFAULT_WAKE_DURATION; 580 581 return 0; 582 } 583 584 static int kmx61_setup_new_data_interrupt(struct kmx61_data *data, 585 bool status, u8 device) 586 { 587 u8 mode; 588 int ret; 589 590 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG); 591 if (ret < 0) 592 return ret; 593 594 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true); 595 if (ret < 0) 596 return ret; 597 598 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1); 599 if (ret < 0) { 600 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 601 return ret; 602 } 603 604 if (status) { 605 ret |= KMX61_REG_INC1_BIT_IEN; 606 if (device & KMX61_ACC) 607 ret |= KMX61_REG_INC1_BIT_DRDYA; 608 if (device & KMX61_MAG) 609 ret |= KMX61_REG_INC1_BIT_DRDYM; 610 } else { 611 ret &= ~KMX61_REG_INC1_BIT_IEN; 612 if (device & KMX61_ACC) 613 ret &= ~KMX61_REG_INC1_BIT_DRDYA; 614 if (device & KMX61_MAG) 615 ret &= ~KMX61_REG_INC1_BIT_DRDYM; 616 } 617 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret); 618 if (ret < 0) { 619 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n"); 620 return ret; 621 } 622 623 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1); 624 if (ret < 0) { 625 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 626 return ret; 627 } 628 629 if (status) 630 ret |= KMX61_REG_CTRL1_BIT_DRDYE; 631 else 632 ret &= ~KMX61_REG_CTRL1_BIT_DRDYE; 633 634 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret); 635 if (ret < 0) { 636 dev_err(&data->client->dev, "Error writing reg_ctrl1\n"); 637 return ret; 638 } 639 640 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true); 641 } 642 643 static int kmx61_chip_update_thresholds(struct kmx61_data *data) 644 { 645 int ret; 646 647 ret = i2c_smbus_write_byte_data(data->client, 648 KMX61_REG_WUF_TIMER, 649 data->wake_duration); 650 if (ret < 0) { 651 dev_err(&data->client->dev, "Error writing reg_wuf_timer\n"); 652 return ret; 653 } 654 655 ret = i2c_smbus_write_byte_data(data->client, 656 KMX61_REG_WUF_THRESH, 657 data->wake_thresh); 658 if (ret < 0) 659 dev_err(&data->client->dev, "Error writing reg_wuf_thresh\n"); 660 661 return ret; 662 } 663 664 static int kmx61_setup_any_motion_interrupt(struct kmx61_data *data, 665 bool status) 666 { 667 u8 mode; 668 int ret; 669 670 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG); 671 if (ret < 0) 672 return ret; 673 674 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true); 675 if (ret < 0) 676 return ret; 677 678 ret = kmx61_chip_update_thresholds(data); 679 if (ret < 0) 680 return ret; 681 682 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1); 683 if (ret < 0) { 684 dev_err(&data->client->dev, "Error reading reg_inc1\n"); 685 return ret; 686 } 687 if (status) 688 ret |= (KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS); 689 else 690 ret &= ~(KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS); 691 692 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret); 693 if (ret < 0) { 694 dev_err(&data->client->dev, "Error writing reg_inc1\n"); 695 return ret; 696 } 697 698 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1); 699 if (ret < 0) { 700 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 701 return ret; 702 } 703 704 if (status) 705 ret |= KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE; 706 else 707 ret &= ~(KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE); 708 709 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret); 710 if (ret < 0) { 711 dev_err(&data->client->dev, "Error writing reg_ctrl1\n"); 712 return ret; 713 } 714 mode |= KMX61_ACT_STBY_BIT; 715 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true); 716 } 717 718 /** 719 * kmx61_set_power_state() - set power state for kmx61 @device 720 * @data: kmx61 device private pointer 721 * @on: power state to be set for @device 722 * @device: bitmask indicating device for which @on state needs to be set 723 * 724 * Notice that when ACC power state needs to be set to ON and MAG is in 725 * OPERATION then we know that kmx61_runtime_resume was already called 726 * so we must set ACC OPERATION mode here. The same happens when MAG power 727 * state needs to be set to ON and ACC is in OPERATION. 728 */ 729 static int kmx61_set_power_state(struct kmx61_data *data, bool on, u8 device) 730 { 731 #ifdef CONFIG_PM 732 int ret; 733 734 if (device & KMX61_ACC) { 735 if (on && !data->acc_ps && !data->mag_stby) { 736 ret = kmx61_set_mode(data, 0, KMX61_ACC, true); 737 if (ret < 0) 738 return ret; 739 } 740 data->acc_ps = on; 741 } 742 if (device & KMX61_MAG) { 743 if (on && !data->mag_ps && !data->acc_stby) { 744 ret = kmx61_set_mode(data, 0, KMX61_MAG, true); 745 if (ret < 0) 746 return ret; 747 } 748 data->mag_ps = on; 749 } 750 751 if (on) 752 ret = pm_runtime_resume_and_get(&data->client->dev); 753 else 754 ret = pm_runtime_put_autosuspend(&data->client->dev); 755 if (ret < 0) { 756 dev_err(&data->client->dev, 757 "Failed: kmx61_set_power_state for %d, ret %d\n", 758 on, ret); 759 760 return ret; 761 } 762 #endif 763 return 0; 764 } 765 766 static int kmx61_read_measurement(struct kmx61_data *data, u8 base, u8 offset) 767 { 768 int ret; 769 u8 reg = base + offset * 2; 770 771 ret = i2c_smbus_read_word_data(data->client, reg); 772 if (ret < 0) 773 dev_err(&data->client->dev, "failed to read reg at %x\n", reg); 774 775 return ret; 776 } 777 778 static int kmx61_read_raw(struct iio_dev *indio_dev, 779 struct iio_chan_spec const *chan, int *val, 780 int *val2, long mask) 781 { 782 int ret; 783 u8 base_reg; 784 struct kmx61_data *data = kmx61_get_data(indio_dev); 785 786 switch (mask) { 787 case IIO_CHAN_INFO_RAW: { 788 switch (chan->type) { 789 case IIO_ACCEL: 790 base_reg = KMX61_ACC_XOUT_L; 791 break; 792 case IIO_MAGN: 793 base_reg = KMX61_MAG_XOUT_L; 794 break; 795 default: 796 return -EINVAL; 797 } 798 guard(mutex)(&data->lock); 799 800 ret = kmx61_set_power_state(data, true, chan->address); 801 if (ret) 802 return ret; 803 804 ret = kmx61_read_measurement(data, base_reg, chan->scan_index); 805 if (ret < 0) { 806 kmx61_set_power_state(data, false, chan->address); 807 return ret; 808 } 809 *val = sign_extend32(ret >> chan->scan_type.shift, 810 chan->scan_type.realbits - 1); 811 ret = kmx61_set_power_state(data, false, chan->address); 812 if (ret) 813 return ret; 814 return IIO_VAL_INT; 815 } 816 case IIO_CHAN_INFO_SCALE: 817 switch (chan->type) { 818 case IIO_ACCEL: 819 *val = 0; 820 *val2 = kmx61_uscale_table[data->range]; 821 return IIO_VAL_INT_PLUS_MICRO; 822 case IIO_MAGN: 823 /* 14 bits res, 1465 microGauss per magn count */ 824 *val = 0; 825 *val2 = 1465; 826 return IIO_VAL_INT_PLUS_MICRO; 827 default: 828 return -EINVAL; 829 } 830 case IIO_CHAN_INFO_SAMP_FREQ: { 831 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN) 832 return -EINVAL; 833 834 guard(mutex)(&data->lock); 835 836 ret = kmx61_get_odr(data, val, val2, chan->address); 837 if (ret) 838 return -EINVAL; 839 return IIO_VAL_INT_PLUS_MICRO; 840 } 841 default: 842 return -EINVAL; 843 } 844 } 845 846 static int kmx61_write_raw(struct iio_dev *indio_dev, 847 struct iio_chan_spec const *chan, int val, 848 int val2, long mask) 849 { 850 struct kmx61_data *data = kmx61_get_data(indio_dev); 851 852 switch (mask) { 853 case IIO_CHAN_INFO_SAMP_FREQ: { 854 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN) 855 return -EINVAL; 856 857 guard(mutex)(&data->lock); 858 859 return kmx61_set_odr(data, val, val2, chan->address); 860 } 861 case IIO_CHAN_INFO_SCALE: 862 switch (chan->type) { 863 case IIO_ACCEL: { 864 if (val != 0) 865 return -EINVAL; 866 guard(mutex)(&data->lock); 867 868 return kmx61_set_scale(data, val2); 869 } 870 default: 871 return -EINVAL; 872 } 873 default: 874 return -EINVAL; 875 } 876 } 877 878 static int kmx61_read_event(struct iio_dev *indio_dev, 879 const struct iio_chan_spec *chan, 880 enum iio_event_type type, 881 enum iio_event_direction dir, 882 enum iio_event_info info, 883 int *val, int *val2) 884 { 885 struct kmx61_data *data = kmx61_get_data(indio_dev); 886 887 *val2 = 0; 888 switch (info) { 889 case IIO_EV_INFO_VALUE: 890 *val = data->wake_thresh; 891 return IIO_VAL_INT; 892 case IIO_EV_INFO_PERIOD: 893 *val = data->wake_duration; 894 return IIO_VAL_INT; 895 default: 896 return -EINVAL; 897 } 898 } 899 900 static int kmx61_write_event(struct iio_dev *indio_dev, 901 const struct iio_chan_spec *chan, 902 enum iio_event_type type, 903 enum iio_event_direction dir, 904 enum iio_event_info info, 905 int val, int val2) 906 { 907 struct kmx61_data *data = kmx61_get_data(indio_dev); 908 909 if (data->ev_enable_state) 910 return -EBUSY; 911 912 switch (info) { 913 case IIO_EV_INFO_VALUE: 914 data->wake_thresh = val; 915 return IIO_VAL_INT; 916 case IIO_EV_INFO_PERIOD: 917 data->wake_duration = val; 918 return IIO_VAL_INT; 919 default: 920 return -EINVAL; 921 } 922 } 923 924 static int kmx61_read_event_config(struct iio_dev *indio_dev, 925 const struct iio_chan_spec *chan, 926 enum iio_event_type type, 927 enum iio_event_direction dir) 928 { 929 struct kmx61_data *data = kmx61_get_data(indio_dev); 930 931 return data->ev_enable_state; 932 } 933 934 static int kmx61_write_event_config(struct iio_dev *indio_dev, 935 const struct iio_chan_spec *chan, 936 enum iio_event_type type, 937 enum iio_event_direction dir, 938 bool state) 939 { 940 struct kmx61_data *data = kmx61_get_data(indio_dev); 941 int ret = 0; 942 943 if (state && data->ev_enable_state) 944 return 0; 945 946 guard(mutex)(&data->lock); 947 948 if (!state && data->motion_trig_on) { 949 data->ev_enable_state = false; 950 return ret; 951 } 952 953 ret = kmx61_set_power_state(data, state, KMX61_ACC); 954 if (ret < 0) 955 return ret; 956 957 ret = kmx61_setup_any_motion_interrupt(data, state); 958 if (ret < 0) { 959 kmx61_set_power_state(data, false, KMX61_ACC); 960 return ret; 961 } 962 963 data->ev_enable_state = state; 964 965 return 0; 966 } 967 968 static int kmx61_acc_validate_trigger(struct iio_dev *indio_dev, 969 struct iio_trigger *trig) 970 { 971 struct kmx61_data *data = kmx61_get_data(indio_dev); 972 973 if (data->acc_dready_trig != trig && data->motion_trig != trig) 974 return -EINVAL; 975 976 return 0; 977 } 978 979 static int kmx61_mag_validate_trigger(struct iio_dev *indio_dev, 980 struct iio_trigger *trig) 981 { 982 struct kmx61_data *data = kmx61_get_data(indio_dev); 983 984 if (data->mag_dready_trig != trig) 985 return -EINVAL; 986 987 return 0; 988 } 989 990 static const struct iio_info kmx61_acc_info = { 991 .read_raw = kmx61_read_raw, 992 .write_raw = kmx61_write_raw, 993 .attrs = &kmx61_acc_attribute_group, 994 .read_event_value = kmx61_read_event, 995 .write_event_value = kmx61_write_event, 996 .read_event_config = kmx61_read_event_config, 997 .write_event_config = kmx61_write_event_config, 998 .validate_trigger = kmx61_acc_validate_trigger, 999 }; 1000 1001 static const struct iio_info kmx61_mag_info = { 1002 .read_raw = kmx61_read_raw, 1003 .write_raw = kmx61_write_raw, 1004 .attrs = &kmx61_mag_attribute_group, 1005 .validate_trigger = kmx61_mag_validate_trigger, 1006 }; 1007 1008 1009 static int kmx61_data_rdy_trigger_set_state(struct iio_trigger *trig, 1010 bool state) 1011 { 1012 int ret = 0; 1013 u8 device; 1014 1015 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 1016 struct kmx61_data *data = kmx61_get_data(indio_dev); 1017 1018 guard(mutex)(&data->lock); 1019 1020 if (!state && data->ev_enable_state && data->motion_trig_on) { 1021 data->motion_trig_on = false; 1022 return ret; 1023 } 1024 1025 if (data->acc_dready_trig == trig || data->motion_trig == trig) 1026 device = KMX61_ACC; 1027 else 1028 device = KMX61_MAG; 1029 1030 ret = kmx61_set_power_state(data, state, device); 1031 if (ret < 0) 1032 return ret; 1033 1034 if (data->acc_dready_trig == trig || data->mag_dready_trig == trig) 1035 ret = kmx61_setup_new_data_interrupt(data, state, device); 1036 else 1037 ret = kmx61_setup_any_motion_interrupt(data, state); 1038 if (ret < 0) { 1039 kmx61_set_power_state(data, false, device); 1040 return ret; 1041 } 1042 1043 if (data->acc_dready_trig == trig) 1044 data->acc_dready_trig_on = state; 1045 else if (data->mag_dready_trig == trig) 1046 data->mag_dready_trig_on = state; 1047 else 1048 data->motion_trig_on = state; 1049 1050 return 0; 1051 } 1052 1053 static void kmx61_trig_reenable(struct iio_trigger *trig) 1054 { 1055 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 1056 struct kmx61_data *data = kmx61_get_data(indio_dev); 1057 int ret; 1058 1059 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL); 1060 if (ret < 0) 1061 dev_err(&data->client->dev, "Error reading reg_inl\n"); 1062 } 1063 1064 static const struct iio_trigger_ops kmx61_trigger_ops = { 1065 .set_trigger_state = kmx61_data_rdy_trigger_set_state, 1066 .reenable = kmx61_trig_reenable, 1067 }; 1068 1069 static irqreturn_t kmx61_event_handler(int irq, void *private) 1070 { 1071 struct kmx61_data *data = private; 1072 struct iio_dev *indio_dev = data->acc_indio_dev; 1073 int ret; 1074 1075 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS1); 1076 if (ret < 0) { 1077 dev_err(&data->client->dev, "Error reading reg_ins1\n"); 1078 goto ack_intr; 1079 } 1080 1081 if (ret & KMX61_REG_INS1_BIT_WUFS) { 1082 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS2); 1083 if (ret < 0) { 1084 dev_err(&data->client->dev, "Error reading reg_ins2\n"); 1085 goto ack_intr; 1086 } 1087 1088 if (ret & KMX61_REG_INS2_BIT_XN) 1089 iio_push_event(indio_dev, 1090 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1091 0, 1092 IIO_MOD_X, 1093 IIO_EV_TYPE_THRESH, 1094 IIO_EV_DIR_FALLING), 1095 0); 1096 1097 if (ret & KMX61_REG_INS2_BIT_XP) 1098 iio_push_event(indio_dev, 1099 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1100 0, 1101 IIO_MOD_X, 1102 IIO_EV_TYPE_THRESH, 1103 IIO_EV_DIR_RISING), 1104 0); 1105 1106 if (ret & KMX61_REG_INS2_BIT_YN) 1107 iio_push_event(indio_dev, 1108 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1109 0, 1110 IIO_MOD_Y, 1111 IIO_EV_TYPE_THRESH, 1112 IIO_EV_DIR_FALLING), 1113 0); 1114 1115 if (ret & KMX61_REG_INS2_BIT_YP) 1116 iio_push_event(indio_dev, 1117 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1118 0, 1119 IIO_MOD_Y, 1120 IIO_EV_TYPE_THRESH, 1121 IIO_EV_DIR_RISING), 1122 0); 1123 1124 if (ret & KMX61_REG_INS2_BIT_ZN) 1125 iio_push_event(indio_dev, 1126 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1127 0, 1128 IIO_MOD_Z, 1129 IIO_EV_TYPE_THRESH, 1130 IIO_EV_DIR_FALLING), 1131 0); 1132 1133 if (ret & KMX61_REG_INS2_BIT_ZP) 1134 iio_push_event(indio_dev, 1135 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1136 0, 1137 IIO_MOD_Z, 1138 IIO_EV_TYPE_THRESH, 1139 IIO_EV_DIR_RISING), 1140 0); 1141 } 1142 1143 ack_intr: 1144 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1); 1145 if (ret < 0) 1146 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 1147 1148 ret |= KMX61_REG_CTRL1_BIT_RES; 1149 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret); 1150 if (ret < 0) 1151 dev_err(&data->client->dev, "Error writing reg_ctrl1\n"); 1152 1153 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL); 1154 if (ret < 0) 1155 dev_err(&data->client->dev, "Error reading reg_inl\n"); 1156 1157 return IRQ_HANDLED; 1158 } 1159 1160 static irqreturn_t kmx61_data_rdy_trig_poll(int irq, void *private) 1161 { 1162 struct kmx61_data *data = private; 1163 1164 if (data->acc_dready_trig_on) 1165 iio_trigger_poll(data->acc_dready_trig); 1166 if (data->mag_dready_trig_on) 1167 iio_trigger_poll(data->mag_dready_trig); 1168 1169 if (data->motion_trig_on) 1170 iio_trigger_poll(data->motion_trig); 1171 1172 if (data->ev_enable_state) 1173 return IRQ_WAKE_THREAD; 1174 return IRQ_HANDLED; 1175 } 1176 1177 /** 1178 * kmx61_read_for_each_active_channel() - Read each active channel into a buffer 1179 * 1180 * @indio_dev: IIO Device struct to read from 1181 * @buffer: Destination buffer to write to, the array must be of at least size 8 1182 * 1183 * Return: 1184 * 0 on success, negative errno on failure. 1185 */ 1186 static int kmx61_read_for_each_active_channel(struct iio_dev *indio_dev, s16 *buffer) 1187 { 1188 struct kmx61_data *data = kmx61_get_data(indio_dev); 1189 u8 base; 1190 int ret, bit; 1191 int i = 0; 1192 1193 if (indio_dev == data->acc_indio_dev) 1194 base = KMX61_ACC_XOUT_L; 1195 else 1196 base = KMX61_MAG_XOUT_L; 1197 1198 guard(mutex)(&data->lock); 1199 1200 iio_for_each_active_channel(indio_dev, bit) { 1201 ret = kmx61_read_measurement(data, base, bit); 1202 if (ret < 0) 1203 return ret; 1204 buffer[i++] = ret; 1205 } 1206 1207 return 0; 1208 } 1209 1210 static irqreturn_t kmx61_trigger_handler(int irq, void *p) 1211 { 1212 struct iio_poll_func *pf = p; 1213 struct iio_dev *indio_dev = pf->indio_dev; 1214 int ret; 1215 s16 buffer[8] = { }; 1216 1217 ret = kmx61_read_for_each_active_channel(indio_dev, buffer); 1218 if (ret < 0) 1219 goto err; 1220 1221 iio_push_to_buffers(indio_dev, buffer); 1222 err: 1223 iio_trigger_notify_done(indio_dev->trig); 1224 1225 return IRQ_HANDLED; 1226 } 1227 1228 static struct iio_dev *kmx61_indiodev_setup(struct kmx61_data *data, 1229 const struct iio_info *info, 1230 const struct iio_chan_spec *chan, 1231 int num_channels, 1232 const char *name) 1233 { 1234 struct iio_dev *indio_dev; 1235 1236 indio_dev = devm_iio_device_alloc(&data->client->dev, sizeof(data)); 1237 if (!indio_dev) 1238 return ERR_PTR(-ENOMEM); 1239 1240 kmx61_set_data(indio_dev, data); 1241 1242 indio_dev->channels = chan; 1243 indio_dev->num_channels = num_channels; 1244 indio_dev->name = name; 1245 indio_dev->modes = INDIO_DIRECT_MODE; 1246 indio_dev->info = info; 1247 1248 return indio_dev; 1249 } 1250 1251 static struct iio_trigger *kmx61_trigger_setup(struct kmx61_data *data, 1252 struct iio_dev *indio_dev, 1253 const char *tag) 1254 { 1255 struct iio_trigger *trig; 1256 int ret; 1257 1258 trig = devm_iio_trigger_alloc(&data->client->dev, 1259 "%s-%s-dev%d", 1260 indio_dev->name, 1261 tag, 1262 iio_device_id(indio_dev)); 1263 if (!trig) 1264 return ERR_PTR(-ENOMEM); 1265 1266 trig->ops = &kmx61_trigger_ops; 1267 iio_trigger_set_drvdata(trig, indio_dev); 1268 1269 ret = iio_trigger_register(trig); 1270 if (ret) 1271 return ERR_PTR(ret); 1272 1273 return trig; 1274 } 1275 1276 static int kmx61_probe(struct i2c_client *client) 1277 { 1278 const struct i2c_device_id *id = i2c_client_get_device_id(client); 1279 int ret; 1280 struct kmx61_data *data; 1281 const char *name = NULL; 1282 1283 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 1284 if (!data) 1285 return -ENOMEM; 1286 1287 i2c_set_clientdata(client, data); 1288 data->client = client; 1289 1290 mutex_init(&data->lock); 1291 1292 if (id) 1293 name = id->name; 1294 else 1295 return -ENODEV; 1296 1297 data->acc_indio_dev = 1298 kmx61_indiodev_setup(data, &kmx61_acc_info, 1299 kmx61_acc_channels, 1300 ARRAY_SIZE(kmx61_acc_channels), 1301 name); 1302 if (IS_ERR(data->acc_indio_dev)) 1303 return PTR_ERR(data->acc_indio_dev); 1304 1305 data->mag_indio_dev = 1306 kmx61_indiodev_setup(data, &kmx61_mag_info, 1307 kmx61_mag_channels, 1308 ARRAY_SIZE(kmx61_mag_channels), 1309 name); 1310 if (IS_ERR(data->mag_indio_dev)) 1311 return PTR_ERR(data->mag_indio_dev); 1312 1313 ret = kmx61_chip_init(data); 1314 if (ret < 0) 1315 return ret; 1316 1317 if (client->irq > 0) { 1318 ret = devm_request_threaded_irq(&client->dev, client->irq, 1319 kmx61_data_rdy_trig_poll, 1320 kmx61_event_handler, 1321 IRQF_TRIGGER_RISING, 1322 "kmx61_event", 1323 data); 1324 if (ret) 1325 goto err_chip_uninit; 1326 1327 data->acc_dready_trig = 1328 kmx61_trigger_setup(data, data->acc_indio_dev, 1329 "dready"); 1330 if (IS_ERR(data->acc_dready_trig)) { 1331 ret = PTR_ERR(data->acc_dready_trig); 1332 goto err_chip_uninit; 1333 } 1334 1335 data->mag_dready_trig = 1336 kmx61_trigger_setup(data, data->mag_indio_dev, 1337 "dready"); 1338 if (IS_ERR(data->mag_dready_trig)) { 1339 ret = PTR_ERR(data->mag_dready_trig); 1340 goto err_trigger_unregister_acc_dready; 1341 } 1342 1343 data->motion_trig = 1344 kmx61_trigger_setup(data, data->acc_indio_dev, 1345 "any-motion"); 1346 if (IS_ERR(data->motion_trig)) { 1347 ret = PTR_ERR(data->motion_trig); 1348 goto err_trigger_unregister_mag_dready; 1349 } 1350 1351 ret = iio_triggered_buffer_setup(data->acc_indio_dev, 1352 &iio_pollfunc_store_time, 1353 kmx61_trigger_handler, 1354 NULL); 1355 if (ret < 0) { 1356 dev_err(&data->client->dev, 1357 "Failed to setup acc triggered buffer\n"); 1358 goto err_trigger_unregister_motion; 1359 } 1360 1361 ret = iio_triggered_buffer_setup(data->mag_indio_dev, 1362 &iio_pollfunc_store_time, 1363 kmx61_trigger_handler, 1364 NULL); 1365 if (ret < 0) { 1366 dev_err(&data->client->dev, 1367 "Failed to setup mag triggered buffer\n"); 1368 goto err_buffer_cleanup_acc; 1369 } 1370 } 1371 1372 ret = pm_runtime_set_active(&client->dev); 1373 if (ret < 0) 1374 goto err_buffer_cleanup_mag; 1375 1376 pm_runtime_enable(&client->dev); 1377 pm_runtime_set_autosuspend_delay(&client->dev, KMX61_SLEEP_DELAY_MS); 1378 pm_runtime_use_autosuspend(&client->dev); 1379 1380 ret = iio_device_register(data->acc_indio_dev); 1381 if (ret < 0) { 1382 dev_err(&client->dev, "Failed to register acc iio device\n"); 1383 goto err_pm_cleanup; 1384 } 1385 1386 ret = iio_device_register(data->mag_indio_dev); 1387 if (ret < 0) { 1388 dev_err(&client->dev, "Failed to register mag iio device\n"); 1389 goto err_iio_unregister_acc; 1390 } 1391 1392 return 0; 1393 1394 err_iio_unregister_acc: 1395 iio_device_unregister(data->acc_indio_dev); 1396 err_pm_cleanup: 1397 pm_runtime_dont_use_autosuspend(&client->dev); 1398 pm_runtime_disable(&client->dev); 1399 err_buffer_cleanup_mag: 1400 if (client->irq > 0) 1401 iio_triggered_buffer_cleanup(data->mag_indio_dev); 1402 err_buffer_cleanup_acc: 1403 if (client->irq > 0) 1404 iio_triggered_buffer_cleanup(data->acc_indio_dev); 1405 err_trigger_unregister_motion: 1406 iio_trigger_unregister(data->motion_trig); 1407 err_trigger_unregister_mag_dready: 1408 iio_trigger_unregister(data->mag_dready_trig); 1409 err_trigger_unregister_acc_dready: 1410 iio_trigger_unregister(data->acc_dready_trig); 1411 err_chip_uninit: 1412 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true); 1413 return ret; 1414 } 1415 1416 static void kmx61_remove(struct i2c_client *client) 1417 { 1418 struct kmx61_data *data = i2c_get_clientdata(client); 1419 1420 iio_device_unregister(data->acc_indio_dev); 1421 iio_device_unregister(data->mag_indio_dev); 1422 1423 pm_runtime_disable(&client->dev); 1424 pm_runtime_set_suspended(&client->dev); 1425 1426 if (client->irq > 0) { 1427 iio_triggered_buffer_cleanup(data->acc_indio_dev); 1428 iio_triggered_buffer_cleanup(data->mag_indio_dev); 1429 iio_trigger_unregister(data->acc_dready_trig); 1430 iio_trigger_unregister(data->mag_dready_trig); 1431 iio_trigger_unregister(data->motion_trig); 1432 } 1433 1434 guard(mutex)(&data->lock); 1435 1436 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true); 1437 } 1438 1439 static int kmx61_suspend(struct device *dev) 1440 { 1441 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev)); 1442 1443 guard(mutex)(&data->lock); 1444 1445 return kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, false); 1446 } 1447 1448 static int kmx61_resume(struct device *dev) 1449 { 1450 u8 stby = 0; 1451 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev)); 1452 1453 if (data->acc_stby) 1454 stby |= KMX61_ACC_STBY_BIT; 1455 if (data->mag_stby) 1456 stby |= KMX61_MAG_STBY_BIT; 1457 1458 return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true); 1459 } 1460 1461 static int kmx61_runtime_suspend(struct device *dev) 1462 { 1463 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev)); 1464 1465 guard(mutex)(&data->lock); 1466 1467 return kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true); 1468 } 1469 1470 static int kmx61_runtime_resume(struct device *dev) 1471 { 1472 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev)); 1473 u8 stby = 0; 1474 1475 if (!data->acc_ps) 1476 stby |= KMX61_ACC_STBY_BIT; 1477 if (!data->mag_ps) 1478 stby |= KMX61_MAG_STBY_BIT; 1479 1480 return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true); 1481 } 1482 1483 static const struct dev_pm_ops kmx61_pm_ops = { 1484 SYSTEM_SLEEP_PM_OPS(kmx61_suspend, kmx61_resume) 1485 RUNTIME_PM_OPS(kmx61_runtime_suspend, kmx61_runtime_resume, NULL) 1486 }; 1487 1488 static const struct i2c_device_id kmx61_id[] = { 1489 { .name = "kmx611021" }, 1490 { } 1491 }; 1492 1493 MODULE_DEVICE_TABLE(i2c, kmx61_id); 1494 1495 static struct i2c_driver kmx61_driver = { 1496 .driver = { 1497 .name = "kmx61", 1498 .pm = pm_ptr(&kmx61_pm_ops), 1499 }, 1500 .probe = kmx61_probe, 1501 .remove = kmx61_remove, 1502 .id_table = kmx61_id, 1503 }; 1504 1505 module_i2c_driver(kmx61_driver); 1506 1507 MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>"); 1508 MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver"); 1509 MODULE_LICENSE("GPL v2"); 1510