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