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