1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * KXCJK-1013 3-axis accelerometer driver 4 * Copyright (c) 2014, Intel Corporation. 5 */ 6 7#include <linux/module.h> 8#include <linux/i2c.h> 9#include <linux/interrupt.h> 10#include <linux/delay.h> 11#include <linux/bitops.h> 12#include <linux/slab.h> 13#include <linux/string.h> 14#include <linux/acpi.h> 15#include <linux/pm.h> 16#include <linux/pm_runtime.h> 17#include <linux/iio/iio.h> 18#include <linux/iio/sysfs.h> 19#include <linux/iio/buffer.h> 20#include <linux/iio/trigger.h> 21#include <linux/iio/events.h> 22#include <linux/iio/trigger_consumer.h> 23#include <linux/iio/triggered_buffer.h> 24#include <linux/iio/accel/kxcjk_1013.h> 25 26#define KXCJK1013_DRV_NAME "kxcjk1013" 27#define KXCJK1013_IRQ_NAME "kxcjk1013_event" 28 29#define KXTF9_REG_HP_XOUT_L 0x00 30#define KXTF9_REG_HP_XOUT_H 0x01 31#define KXTF9_REG_HP_YOUT_L 0x02 32#define KXTF9_REG_HP_YOUT_H 0x03 33#define KXTF9_REG_HP_ZOUT_L 0x04 34#define KXTF9_REG_HP_ZOUT_H 0x05 35 36#define KXCJK1013_REG_XOUT_L 0x06 37/* 38 * From low byte X axis register, all the other addresses of Y and Z can be 39 * obtained by just applying axis offset. The following axis defines are just 40 * provide clarity, but not used. 41 */ 42#define KXCJK1013_REG_XOUT_H 0x07 43#define KXCJK1013_REG_YOUT_L 0x08 44#define KXCJK1013_REG_YOUT_H 0x09 45#define KXCJK1013_REG_ZOUT_L 0x0A 46#define KXCJK1013_REG_ZOUT_H 0x0B 47 48#define KXCJK1013_REG_DCST_RESP 0x0C 49#define KXCJK1013_REG_WHO_AM_I 0x0F 50#define KXTF9_REG_TILT_POS_CUR 0x10 51#define KXTF9_REG_TILT_POS_PREV 0x11 52#define KXTF9_REG_INT_SRC1 0x15 53#define KXCJK1013_REG_INT_SRC1 0x16 /* compatible, but called INT_SRC2 in KXTF9 ds */ 54#define KXCJK1013_REG_INT_SRC2 0x17 55#define KXCJK1013_REG_STATUS_REG 0x18 56#define KXCJK1013_REG_INT_REL 0x1A 57#define KXCJK1013_REG_CTRL1 0x1B 58#define KXTF9_REG_CTRL2 0x1C 59#define KXCJK1013_REG_CTRL2 0x1D /* mostly compatible, CTRL_REG3 in KTXF9 ds */ 60#define KXCJK1013_REG_INT_CTRL1 0x1E 61#define KXCJK1013_REG_INT_CTRL2 0x1F 62#define KXTF9_REG_INT_CTRL3 0x20 63#define KXCJK1013_REG_DATA_CTRL 0x21 64#define KXTF9_REG_TILT_TIMER 0x28 65#define KXCJK1013_REG_WAKE_TIMER 0x29 66#define KXTF9_REG_TDT_TIMER 0x2B 67#define KXTF9_REG_TDT_THRESH_H 0x2C 68#define KXTF9_REG_TDT_THRESH_L 0x2D 69#define KXTF9_REG_TDT_TAP_TIMER 0x2E 70#define KXTF9_REG_TDT_TOTAL_TIMER 0x2F 71#define KXTF9_REG_TDT_LATENCY_TIMER 0x30 72#define KXTF9_REG_TDT_WINDOW_TIMER 0x31 73#define KXCJK1013_REG_SELF_TEST 0x3A 74#define KXTF9_REG_WAKE_THRESH 0x5A 75#define KXTF9_REG_TILT_ANGLE 0x5C 76#define KXTF9_REG_HYST_SET 0x5F 77#define KXCJK1013_REG_WAKE_THRES 0x6A 78 79#define KXCJK1013_REG_CTRL1_BIT_PC1 BIT(7) 80#define KXCJK1013_REG_CTRL1_BIT_RES BIT(6) 81#define KXCJK1013_REG_CTRL1_BIT_DRDY BIT(5) 82#define KXCJK1013_REG_CTRL1_BIT_GSEL1 BIT(4) 83#define KXCJK1013_REG_CTRL1_BIT_GSEL0 BIT(3) 84#define KXCJK1013_REG_CTRL1_BIT_WUFE BIT(1) 85 86#define KXCJK1013_REG_INT_CTRL1_BIT_IEU BIT(2) /* KXTF9 */ 87#define KXCJK1013_REG_INT_CTRL1_BIT_IEL BIT(3) 88#define KXCJK1013_REG_INT_CTRL1_BIT_IEA BIT(4) 89#define KXCJK1013_REG_INT_CTRL1_BIT_IEN BIT(5) 90 91#define KXTF9_REG_TILT_BIT_LEFT_EDGE BIT(5) 92#define KXTF9_REG_TILT_BIT_RIGHT_EDGE BIT(4) 93#define KXTF9_REG_TILT_BIT_LOWER_EDGE BIT(3) 94#define KXTF9_REG_TILT_BIT_UPPER_EDGE BIT(2) 95#define KXTF9_REG_TILT_BIT_FACE_DOWN BIT(1) 96#define KXTF9_REG_TILT_BIT_FACE_UP BIT(0) 97 98#define KXCJK1013_DATA_MASK_12_BIT 0x0FFF 99#define KXCJK1013_MAX_STARTUP_TIME_US 100000 100 101#define KXCJK1013_SLEEP_DELAY_MS 2000 102 103#define KXCJK1013_REG_INT_SRC1_BIT_TPS BIT(0) /* KXTF9 */ 104#define KXCJK1013_REG_INT_SRC1_BIT_WUFS BIT(1) 105#define KXCJK1013_REG_INT_SRC1_MASK_TDTS (BIT(2) | BIT(3)) /* KXTF9 */ 106#define KXCJK1013_REG_INT_SRC1_TAP_NONE 0 107#define KXCJK1013_REG_INT_SRC1_TAP_SINGLE BIT(2) 108#define KXCJK1013_REG_INT_SRC1_TAP_DOUBLE BIT(3) 109#define KXCJK1013_REG_INT_SRC1_BIT_DRDY BIT(4) 110 111/* KXCJK: INT_SOURCE2: motion detect, KXTF9: INT_SRC_REG1: tap detect */ 112#define KXCJK1013_REG_INT_SRC2_BIT_ZP BIT(0) 113#define KXCJK1013_REG_INT_SRC2_BIT_ZN BIT(1) 114#define KXCJK1013_REG_INT_SRC2_BIT_YP BIT(2) 115#define KXCJK1013_REG_INT_SRC2_BIT_YN BIT(3) 116#define KXCJK1013_REG_INT_SRC2_BIT_XP BIT(4) 117#define KXCJK1013_REG_INT_SRC2_BIT_XN BIT(5) 118 119#define KXCJK1013_DEFAULT_WAKE_THRES 1 120 121enum kx_chipset { 122 KXCJK1013, 123 KXCJ91008, 124 KXTJ21009, 125 KXTF9, 126 KX_MAX_CHIPS /* this must be last */ 127}; 128 129enum kx_acpi_type { 130 ACPI_GENERIC, 131 ACPI_SMO8500, 132 ACPI_KIOX010A, 133}; 134 135enum kxcjk1013_axis { 136 AXIS_X, 137 AXIS_Y, 138 AXIS_Z, 139 AXIS_MAX 140}; 141 142struct kxcjk1013_data { 143 struct i2c_client *client; 144 struct iio_trigger *dready_trig; 145 struct iio_trigger *motion_trig; 146 struct iio_mount_matrix orientation; 147 struct mutex mutex; 148 /* Ensure timestamp naturally aligned */ 149 struct { 150 s16 chans[AXIS_MAX]; 151 s64 timestamp __aligned(8); 152 } scan; 153 u8 odr_bits; 154 u8 range; 155 int wake_thres; 156 int wake_dur; 157 bool active_high_intr; 158 bool dready_trigger_on; 159 int ev_enable_state; 160 bool motion_trigger_on; 161 int64_t timestamp; 162 enum kx_chipset chipset; 163 enum kx_acpi_type acpi_type; 164}; 165 166enum kxcjk1013_mode { 167 STANDBY, 168 OPERATION, 169}; 170 171enum kxcjk1013_range { 172 KXCJK1013_RANGE_2G, 173 KXCJK1013_RANGE_4G, 174 KXCJK1013_RANGE_8G, 175}; 176 177struct kx_odr_map { 178 int val; 179 int val2; 180 int odr_bits; 181 int wuf_bits; 182}; 183 184static const struct kx_odr_map samp_freq_table[] = { 185 { 0, 781000, 0x08, 0x00 }, 186 { 1, 563000, 0x09, 0x01 }, 187 { 3, 125000, 0x0A, 0x02 }, 188 { 6, 250000, 0x0B, 0x03 }, 189 { 12, 500000, 0x00, 0x04 }, 190 { 25, 0, 0x01, 0x05 }, 191 { 50, 0, 0x02, 0x06 }, 192 { 100, 0, 0x03, 0x06 }, 193 { 200, 0, 0x04, 0x06 }, 194 { 400, 0, 0x05, 0x06 }, 195 { 800, 0, 0x06, 0x06 }, 196 { 1600, 0, 0x07, 0x06 }, 197}; 198 199static const char *const kxcjk1013_samp_freq_avail = 200 "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800 1600"; 201 202static const struct kx_odr_map kxtf9_samp_freq_table[] = { 203 { 25, 0, 0x01, 0x00 }, 204 { 50, 0, 0x02, 0x01 }, 205 { 100, 0, 0x03, 0x01 }, 206 { 200, 0, 0x04, 0x01 }, 207 { 400, 0, 0x05, 0x01 }, 208 { 800, 0, 0x06, 0x01 }, 209}; 210 211static const char *const kxtf9_samp_freq_avail = 212 "25 50 100 200 400 800"; 213 214/* Refer to section 4 of the specification */ 215static const struct { 216 int odr_bits; 217 int usec; 218} odr_start_up_times[KX_MAX_CHIPS][12] = { 219 /* KXCJK-1013 */ 220 { 221 {0x08, 100000}, 222 {0x09, 100000}, 223 {0x0A, 100000}, 224 {0x0B, 100000}, 225 {0, 80000}, 226 {0x01, 41000}, 227 {0x02, 21000}, 228 {0x03, 11000}, 229 {0x04, 6400}, 230 {0x05, 3900}, 231 {0x06, 2700}, 232 {0x07, 2100}, 233 }, 234 /* KXCJ9-1008 */ 235 { 236 {0x08, 100000}, 237 {0x09, 100000}, 238 {0x0A, 100000}, 239 {0x0B, 100000}, 240 {0, 80000}, 241 {0x01, 41000}, 242 {0x02, 21000}, 243 {0x03, 11000}, 244 {0x04, 6400}, 245 {0x05, 3900}, 246 {0x06, 2700}, 247 {0x07, 2100}, 248 }, 249 /* KXCTJ2-1009 */ 250 { 251 {0x08, 1240000}, 252 {0x09, 621000}, 253 {0x0A, 309000}, 254 {0x0B, 151000}, 255 {0, 80000}, 256 {0x01, 41000}, 257 {0x02, 21000}, 258 {0x03, 11000}, 259 {0x04, 6000}, 260 {0x05, 4000}, 261 {0x06, 3000}, 262 {0x07, 2000}, 263 }, 264 /* KXTF9 */ 265 { 266 {0x01, 81000}, 267 {0x02, 41000}, 268 {0x03, 21000}, 269 {0x04, 11000}, 270 {0x05, 5100}, 271 {0x06, 2700}, 272 }, 273}; 274 275static const struct { 276 u16 scale; 277 u8 gsel_0; 278 u8 gsel_1; 279} KXCJK1013_scale_table[] = { {9582, 0, 0}, 280 {19163, 1, 0}, 281 {38326, 0, 1} }; 282 283#ifdef CONFIG_ACPI 284enum kiox010a_fn_index { 285 KIOX010A_SET_LAPTOP_MODE = 1, 286 KIOX010A_SET_TABLET_MODE = 2, 287}; 288 289static int kiox010a_dsm(struct device *dev, int fn_index) 290{ 291 acpi_handle handle = ACPI_HANDLE(dev); 292 guid_t kiox010a_dsm_guid; 293 union acpi_object *obj; 294 295 if (!handle) 296 return -ENODEV; 297 298 guid_parse("1f339696-d475-4e26-8cad-2e9f8e6d7a91", &kiox010a_dsm_guid); 299 300 obj = acpi_evaluate_dsm(handle, &kiox010a_dsm_guid, 1, fn_index, NULL); 301 if (!obj) 302 return -EIO; 303 304 ACPI_FREE(obj); 305 return 0; 306} 307#endif 308 309static int kxcjk1013_set_mode(struct kxcjk1013_data *data, 310 enum kxcjk1013_mode mode) 311{ 312 int ret; 313 314 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1); 315 if (ret < 0) { 316 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 317 return ret; 318 } 319 320 if (mode == STANDBY) 321 ret &= ~KXCJK1013_REG_CTRL1_BIT_PC1; 322 else 323 ret |= KXCJK1013_REG_CTRL1_BIT_PC1; 324 325 ret = i2c_smbus_write_byte_data(data->client, 326 KXCJK1013_REG_CTRL1, ret); 327 if (ret < 0) { 328 dev_err(&data->client->dev, "Error writing reg_ctrl1\n"); 329 return ret; 330 } 331 332 return 0; 333} 334 335static int kxcjk1013_get_mode(struct kxcjk1013_data *data, 336 enum kxcjk1013_mode *mode) 337{ 338 int ret; 339 340 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1); 341 if (ret < 0) { 342 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 343 return ret; 344 } 345 346 if (ret & KXCJK1013_REG_CTRL1_BIT_PC1) 347 *mode = OPERATION; 348 else 349 *mode = STANDBY; 350 351 return 0; 352} 353 354static int kxcjk1013_set_range(struct kxcjk1013_data *data, int range_index) 355{ 356 int ret; 357 358 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1); 359 if (ret < 0) { 360 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 361 return ret; 362 } 363 364 ret &= ~(KXCJK1013_REG_CTRL1_BIT_GSEL0 | 365 KXCJK1013_REG_CTRL1_BIT_GSEL1); 366 ret |= (KXCJK1013_scale_table[range_index].gsel_0 << 3); 367 ret |= (KXCJK1013_scale_table[range_index].gsel_1 << 4); 368 369 ret = i2c_smbus_write_byte_data(data->client, 370 KXCJK1013_REG_CTRL1, 371 ret); 372 if (ret < 0) { 373 dev_err(&data->client->dev, "Error writing reg_ctrl1\n"); 374 return ret; 375 } 376 377 data->range = range_index; 378 379 return 0; 380} 381 382static int kxcjk1013_chip_init(struct kxcjk1013_data *data) 383{ 384 int ret; 385 386#ifdef CONFIG_ACPI 387 if (data->acpi_type == ACPI_KIOX010A) { 388 /* Make sure the kbd and touchpad on 2-in-1s using 2 KXCJ91008-s work */ 389 kiox010a_dsm(&data->client->dev, KIOX010A_SET_LAPTOP_MODE); 390 } 391#endif 392 393 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_WHO_AM_I); 394 if (ret < 0) { 395 dev_err(&data->client->dev, "Error reading who_am_i\n"); 396 return ret; 397 } 398 399 dev_dbg(&data->client->dev, "KXCJK1013 Chip Id %x\n", ret); 400 401 ret = kxcjk1013_set_mode(data, STANDBY); 402 if (ret < 0) 403 return ret; 404 405 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1); 406 if (ret < 0) { 407 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 408 return ret; 409 } 410 411 /* Set 12 bit mode */ 412 ret |= KXCJK1013_REG_CTRL1_BIT_RES; 413 414 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL1, 415 ret); 416 if (ret < 0) { 417 dev_err(&data->client->dev, "Error reading reg_ctrl\n"); 418 return ret; 419 } 420 421 /* Setting range to 4G */ 422 ret = kxcjk1013_set_range(data, KXCJK1013_RANGE_4G); 423 if (ret < 0) 424 return ret; 425 426 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_DATA_CTRL); 427 if (ret < 0) { 428 dev_err(&data->client->dev, "Error reading reg_data_ctrl\n"); 429 return ret; 430 } 431 432 data->odr_bits = ret; 433 434 /* Set up INT polarity */ 435 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1); 436 if (ret < 0) { 437 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n"); 438 return ret; 439 } 440 441 if (data->active_high_intr) 442 ret |= KXCJK1013_REG_INT_CTRL1_BIT_IEA; 443 else 444 ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEA; 445 446 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1, 447 ret); 448 if (ret < 0) { 449 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n"); 450 return ret; 451 } 452 453 ret = kxcjk1013_set_mode(data, OPERATION); 454 if (ret < 0) 455 return ret; 456 457 data->wake_thres = KXCJK1013_DEFAULT_WAKE_THRES; 458 459 return 0; 460} 461 462#ifdef CONFIG_PM 463static int kxcjk1013_get_startup_times(struct kxcjk1013_data *data) 464{ 465 int i; 466 int idx = data->chipset; 467 468 for (i = 0; i < ARRAY_SIZE(odr_start_up_times[idx]); ++i) { 469 if (odr_start_up_times[idx][i].odr_bits == data->odr_bits) 470 return odr_start_up_times[idx][i].usec; 471 } 472 473 return KXCJK1013_MAX_STARTUP_TIME_US; 474} 475#endif 476 477static int kxcjk1013_set_power_state(struct kxcjk1013_data *data, bool on) 478{ 479#ifdef CONFIG_PM 480 int ret; 481 482 if (on) 483 ret = pm_runtime_get_sync(&data->client->dev); 484 else { 485 pm_runtime_mark_last_busy(&data->client->dev); 486 ret = pm_runtime_put_autosuspend(&data->client->dev); 487 } 488 if (ret < 0) { 489 dev_err(&data->client->dev, 490 "Failed: %s for %d\n", __func__, on); 491 if (on) 492 pm_runtime_put_noidle(&data->client->dev); 493 return ret; 494 } 495#endif 496 497 return 0; 498} 499 500static int kxcjk1013_chip_update_thresholds(struct kxcjk1013_data *data) 501{ 502 int waketh_reg, ret; 503 504 ret = i2c_smbus_write_byte_data(data->client, 505 KXCJK1013_REG_WAKE_TIMER, 506 data->wake_dur); 507 if (ret < 0) { 508 dev_err(&data->client->dev, 509 "Error writing reg_wake_timer\n"); 510 return ret; 511 } 512 513 waketh_reg = data->chipset == KXTF9 ? 514 KXTF9_REG_WAKE_THRESH : KXCJK1013_REG_WAKE_THRES; 515 ret = i2c_smbus_write_byte_data(data->client, waketh_reg, 516 data->wake_thres); 517 if (ret < 0) { 518 dev_err(&data->client->dev, "Error writing reg_wake_thres\n"); 519 return ret; 520 } 521 522 return 0; 523} 524 525static int kxcjk1013_setup_any_motion_interrupt(struct kxcjk1013_data *data, 526 bool status) 527{ 528 int ret; 529 enum kxcjk1013_mode store_mode; 530 531 ret = kxcjk1013_get_mode(data, &store_mode); 532 if (ret < 0) 533 return ret; 534 535 /* This is requirement by spec to change state to STANDBY */ 536 ret = kxcjk1013_set_mode(data, STANDBY); 537 if (ret < 0) 538 return ret; 539 540 ret = kxcjk1013_chip_update_thresholds(data); 541 if (ret < 0) 542 return ret; 543 544 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1); 545 if (ret < 0) { 546 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n"); 547 return ret; 548 } 549 550 if (status) 551 ret |= KXCJK1013_REG_INT_CTRL1_BIT_IEN; 552 else 553 ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEN; 554 555 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1, 556 ret); 557 if (ret < 0) { 558 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n"); 559 return ret; 560 } 561 562 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1); 563 if (ret < 0) { 564 dev_err(&data->client->dev, "Error reading reg_ctrl1\n"); 565 return ret; 566 } 567 568 if (status) 569 ret |= KXCJK1013_REG_CTRL1_BIT_WUFE; 570 else 571 ret &= ~KXCJK1013_REG_CTRL1_BIT_WUFE; 572 573 ret = i2c_smbus_write_byte_data(data->client, 574 KXCJK1013_REG_CTRL1, ret); 575 if (ret < 0) { 576 dev_err(&data->client->dev, "Error writing reg_ctrl1\n"); 577 return ret; 578 } 579 580 if (store_mode == OPERATION) { 581 ret = kxcjk1013_set_mode(data, OPERATION); 582 if (ret < 0) 583 return ret; 584 } 585 586 return 0; 587} 588 589static int kxcjk1013_setup_new_data_interrupt(struct kxcjk1013_data *data, 590 bool status) 591{ 592 int ret; 593 enum kxcjk1013_mode store_mode; 594 595 ret = kxcjk1013_get_mode(data, &store_mode); 596 if (ret < 0) 597 return ret; 598 599 /* This is requirement by spec to change state to STANDBY */ 600 ret = kxcjk1013_set_mode(data, STANDBY); 601 if (ret < 0) 602 return ret; 603 604 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1); 605 if (ret < 0) { 606 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n"); 607 return ret; 608 } 609 610 if (status) 611 ret |= KXCJK1013_REG_INT_CTRL1_BIT_IEN; 612 else 613 ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEN; 614 615 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1, 616 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, KXCJK1013_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 |= KXCJK1013_REG_CTRL1_BIT_DRDY; 630 else 631 ret &= ~KXCJK1013_REG_CTRL1_BIT_DRDY; 632 633 ret = i2c_smbus_write_byte_data(data->client, 634 KXCJK1013_REG_CTRL1, ret); 635 if (ret < 0) { 636 dev_err(&data->client->dev, "Error writing reg_ctrl1\n"); 637 return ret; 638 } 639 640 if (store_mode == OPERATION) { 641 ret = kxcjk1013_set_mode(data, OPERATION); 642 if (ret < 0) 643 return ret; 644 } 645 646 return 0; 647} 648 649static const struct kx_odr_map *kxcjk1013_find_odr_value( 650 const struct kx_odr_map *map, size_t map_size, int val, int val2) 651{ 652 int i; 653 654 for (i = 0; i < map_size; ++i) { 655 if (map[i].val == val && map[i].val2 == val2) 656 return &map[i]; 657 } 658 659 return ERR_PTR(-EINVAL); 660} 661 662static int kxcjk1013_convert_odr_value(const struct kx_odr_map *map, 663 size_t map_size, int odr_bits, 664 int *val, int *val2) 665{ 666 int i; 667 668 for (i = 0; i < map_size; ++i) { 669 if (map[i].odr_bits == odr_bits) { 670 *val = map[i].val; 671 *val2 = map[i].val2; 672 return IIO_VAL_INT_PLUS_MICRO; 673 } 674 } 675 676 return -EINVAL; 677} 678 679static int kxcjk1013_set_odr(struct kxcjk1013_data *data, int val, int val2) 680{ 681 int ret; 682 enum kxcjk1013_mode store_mode; 683 const struct kx_odr_map *odr_setting; 684 685 ret = kxcjk1013_get_mode(data, &store_mode); 686 if (ret < 0) 687 return ret; 688 689 if (data->chipset == KXTF9) 690 odr_setting = kxcjk1013_find_odr_value(kxtf9_samp_freq_table, 691 ARRAY_SIZE(kxtf9_samp_freq_table), 692 val, val2); 693 else 694 odr_setting = kxcjk1013_find_odr_value(samp_freq_table, 695 ARRAY_SIZE(samp_freq_table), 696 val, val2); 697 698 if (IS_ERR(odr_setting)) 699 return PTR_ERR(odr_setting); 700 701 /* To change ODR, the chip must be set to STANDBY as per spec */ 702 ret = kxcjk1013_set_mode(data, STANDBY); 703 if (ret < 0) 704 return ret; 705 706 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_DATA_CTRL, 707 odr_setting->odr_bits); 708 if (ret < 0) { 709 dev_err(&data->client->dev, "Error writing data_ctrl\n"); 710 return ret; 711 } 712 713 data->odr_bits = odr_setting->odr_bits; 714 715 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL2, 716 odr_setting->wuf_bits); 717 if (ret < 0) { 718 dev_err(&data->client->dev, "Error writing reg_ctrl2\n"); 719 return ret; 720 } 721 722 if (store_mode == OPERATION) { 723 ret = kxcjk1013_set_mode(data, OPERATION); 724 if (ret < 0) 725 return ret; 726 } 727 728 return 0; 729} 730 731static int kxcjk1013_get_odr(struct kxcjk1013_data *data, int *val, int *val2) 732{ 733 if (data->chipset == KXTF9) 734 return kxcjk1013_convert_odr_value(kxtf9_samp_freq_table, 735 ARRAY_SIZE(kxtf9_samp_freq_table), 736 data->odr_bits, val, val2); 737 else 738 return kxcjk1013_convert_odr_value(samp_freq_table, 739 ARRAY_SIZE(samp_freq_table), 740 data->odr_bits, val, val2); 741} 742 743static int kxcjk1013_get_acc_reg(struct kxcjk1013_data *data, int axis) 744{ 745 u8 reg = KXCJK1013_REG_XOUT_L + axis * 2; 746 int ret; 747 748 ret = i2c_smbus_read_word_data(data->client, reg); 749 if (ret < 0) { 750 dev_err(&data->client->dev, 751 "failed to read accel_%c registers\n", 'x' + axis); 752 return ret; 753 } 754 755 return ret; 756} 757 758static int kxcjk1013_set_scale(struct kxcjk1013_data *data, int val) 759{ 760 int ret, i; 761 enum kxcjk1013_mode store_mode; 762 763 for (i = 0; i < ARRAY_SIZE(KXCJK1013_scale_table); ++i) { 764 if (KXCJK1013_scale_table[i].scale == val) { 765 ret = kxcjk1013_get_mode(data, &store_mode); 766 if (ret < 0) 767 return ret; 768 769 ret = kxcjk1013_set_mode(data, STANDBY); 770 if (ret < 0) 771 return ret; 772 773 ret = kxcjk1013_set_range(data, i); 774 if (ret < 0) 775 return ret; 776 777 if (store_mode == OPERATION) { 778 ret = kxcjk1013_set_mode(data, OPERATION); 779 if (ret) 780 return ret; 781 } 782 783 return 0; 784 } 785 } 786 787 return -EINVAL; 788} 789 790static int kxcjk1013_read_raw(struct iio_dev *indio_dev, 791 struct iio_chan_spec const *chan, int *val, 792 int *val2, long mask) 793{ 794 struct kxcjk1013_data *data = iio_priv(indio_dev); 795 int ret; 796 797 switch (mask) { 798 case IIO_CHAN_INFO_RAW: 799 mutex_lock(&data->mutex); 800 if (iio_buffer_enabled(indio_dev)) 801 ret = -EBUSY; 802 else { 803 ret = kxcjk1013_set_power_state(data, true); 804 if (ret < 0) { 805 mutex_unlock(&data->mutex); 806 return ret; 807 } 808 ret = kxcjk1013_get_acc_reg(data, chan->scan_index); 809 if (ret < 0) { 810 kxcjk1013_set_power_state(data, false); 811 mutex_unlock(&data->mutex); 812 return ret; 813 } 814 *val = sign_extend32(ret >> 4, 11); 815 ret = kxcjk1013_set_power_state(data, false); 816 } 817 mutex_unlock(&data->mutex); 818 819 if (ret < 0) 820 return ret; 821 822 return IIO_VAL_INT; 823 824 case IIO_CHAN_INFO_SCALE: 825 *val = 0; 826 *val2 = KXCJK1013_scale_table[data->range].scale; 827 return IIO_VAL_INT_PLUS_MICRO; 828 829 case IIO_CHAN_INFO_SAMP_FREQ: 830 mutex_lock(&data->mutex); 831 ret = kxcjk1013_get_odr(data, val, val2); 832 mutex_unlock(&data->mutex); 833 return ret; 834 835 default: 836 return -EINVAL; 837 } 838} 839 840static int kxcjk1013_write_raw(struct iio_dev *indio_dev, 841 struct iio_chan_spec const *chan, int val, 842 int val2, long mask) 843{ 844 struct kxcjk1013_data *data = iio_priv(indio_dev); 845 int ret; 846 847 switch (mask) { 848 case IIO_CHAN_INFO_SAMP_FREQ: 849 mutex_lock(&data->mutex); 850 ret = kxcjk1013_set_odr(data, val, val2); 851 mutex_unlock(&data->mutex); 852 break; 853 case IIO_CHAN_INFO_SCALE: 854 if (val) 855 return -EINVAL; 856 857 mutex_lock(&data->mutex); 858 ret = kxcjk1013_set_scale(data, val2); 859 mutex_unlock(&data->mutex); 860 break; 861 default: 862 ret = -EINVAL; 863 } 864 865 return ret; 866} 867 868static int kxcjk1013_read_event(struct iio_dev *indio_dev, 869 const struct iio_chan_spec *chan, 870 enum iio_event_type type, 871 enum iio_event_direction dir, 872 enum iio_event_info info, 873 int *val, int *val2) 874{ 875 struct kxcjk1013_data *data = iio_priv(indio_dev); 876 877 *val2 = 0; 878 switch (info) { 879 case IIO_EV_INFO_VALUE: 880 *val = data->wake_thres; 881 break; 882 case IIO_EV_INFO_PERIOD: 883 *val = data->wake_dur; 884 break; 885 default: 886 return -EINVAL; 887 } 888 889 return IIO_VAL_INT; 890} 891 892static int kxcjk1013_write_event(struct iio_dev *indio_dev, 893 const struct iio_chan_spec *chan, 894 enum iio_event_type type, 895 enum iio_event_direction dir, 896 enum iio_event_info info, 897 int val, int val2) 898{ 899 struct kxcjk1013_data *data = iio_priv(indio_dev); 900 901 if (data->ev_enable_state) 902 return -EBUSY; 903 904 switch (info) { 905 case IIO_EV_INFO_VALUE: 906 data->wake_thres = val; 907 break; 908 case IIO_EV_INFO_PERIOD: 909 data->wake_dur = val; 910 break; 911 default: 912 return -EINVAL; 913 } 914 915 return 0; 916} 917 918static int kxcjk1013_read_event_config(struct iio_dev *indio_dev, 919 const struct iio_chan_spec *chan, 920 enum iio_event_type type, 921 enum iio_event_direction dir) 922{ 923 struct kxcjk1013_data *data = iio_priv(indio_dev); 924 925 return data->ev_enable_state; 926} 927 928static int kxcjk1013_write_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 int state) 933{ 934 struct kxcjk1013_data *data = iio_priv(indio_dev); 935 int ret; 936 937 if (state && data->ev_enable_state) 938 return 0; 939 940 mutex_lock(&data->mutex); 941 942 if (!state && data->motion_trigger_on) { 943 data->ev_enable_state = 0; 944 mutex_unlock(&data->mutex); 945 return 0; 946 } 947 948 /* 949 * We will expect the enable and disable to do operation in 950 * in reverse order. This will happen here anyway as our 951 * resume operation uses sync mode runtime pm calls, the 952 * suspend operation will be delayed by autosuspend delay 953 * So the disable operation will still happen in reverse of 954 * enable operation. When runtime pm is disabled the mode 955 * is always on so sequence doesn't matter 956 */ 957 ret = kxcjk1013_set_power_state(data, state); 958 if (ret < 0) { 959 mutex_unlock(&data->mutex); 960 return ret; 961 } 962 963 ret = kxcjk1013_setup_any_motion_interrupt(data, state); 964 if (ret < 0) { 965 kxcjk1013_set_power_state(data, false); 966 data->ev_enable_state = 0; 967 mutex_unlock(&data->mutex); 968 return ret; 969 } 970 971 data->ev_enable_state = state; 972 mutex_unlock(&data->mutex); 973 974 return 0; 975} 976 977static int kxcjk1013_buffer_preenable(struct iio_dev *indio_dev) 978{ 979 struct kxcjk1013_data *data = iio_priv(indio_dev); 980 981 return kxcjk1013_set_power_state(data, true); 982} 983 984static int kxcjk1013_buffer_postdisable(struct iio_dev *indio_dev) 985{ 986 struct kxcjk1013_data *data = iio_priv(indio_dev); 987 988 return kxcjk1013_set_power_state(data, false); 989} 990 991static ssize_t kxcjk1013_get_samp_freq_avail(struct device *dev, 992 struct device_attribute *attr, 993 char *buf) 994{ 995 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 996 struct kxcjk1013_data *data = iio_priv(indio_dev); 997 const char *str; 998 999 if (data->chipset == KXTF9) 1000 str = kxtf9_samp_freq_avail; 1001 else 1002 str = kxcjk1013_samp_freq_avail; 1003 1004 return sprintf(buf, "%s\n", str); 1005} 1006 1007static IIO_DEVICE_ATTR(in_accel_sampling_frequency_available, S_IRUGO, 1008 kxcjk1013_get_samp_freq_avail, NULL, 0); 1009 1010static IIO_CONST_ATTR(in_accel_scale_available, "0.009582 0.019163 0.038326"); 1011 1012static struct attribute *kxcjk1013_attributes[] = { 1013 &iio_dev_attr_in_accel_sampling_frequency_available.dev_attr.attr, 1014 &iio_const_attr_in_accel_scale_available.dev_attr.attr, 1015 NULL, 1016}; 1017 1018static const struct attribute_group kxcjk1013_attrs_group = { 1019 .attrs = kxcjk1013_attributes, 1020}; 1021 1022static const struct iio_event_spec kxcjk1013_event = { 1023 .type = IIO_EV_TYPE_THRESH, 1024 .dir = IIO_EV_DIR_EITHER, 1025 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 1026 BIT(IIO_EV_INFO_ENABLE) | 1027 BIT(IIO_EV_INFO_PERIOD) 1028}; 1029 1030static const struct iio_mount_matrix * 1031kxcjk1013_get_mount_matrix(const struct iio_dev *indio_dev, 1032 const struct iio_chan_spec *chan) 1033{ 1034 struct kxcjk1013_data *data = iio_priv(indio_dev); 1035 1036 return &data->orientation; 1037} 1038 1039static const struct iio_chan_spec_ext_info kxcjk1013_ext_info[] = { 1040 IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, kxcjk1013_get_mount_matrix), 1041 { } 1042}; 1043 1044#define KXCJK1013_CHANNEL(_axis) { \ 1045 .type = IIO_ACCEL, \ 1046 .modified = 1, \ 1047 .channel2 = IIO_MOD_##_axis, \ 1048 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 1049 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 1050 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 1051 .scan_index = AXIS_##_axis, \ 1052 .scan_type = { \ 1053 .sign = 's', \ 1054 .realbits = 12, \ 1055 .storagebits = 16, \ 1056 .shift = 4, \ 1057 .endianness = IIO_LE, \ 1058 }, \ 1059 .event_spec = &kxcjk1013_event, \ 1060 .ext_info = kxcjk1013_ext_info, \ 1061 .num_event_specs = 1 \ 1062} 1063 1064static const struct iio_chan_spec kxcjk1013_channels[] = { 1065 KXCJK1013_CHANNEL(X), 1066 KXCJK1013_CHANNEL(Y), 1067 KXCJK1013_CHANNEL(Z), 1068 IIO_CHAN_SOFT_TIMESTAMP(3), 1069}; 1070 1071static const struct iio_buffer_setup_ops kxcjk1013_buffer_setup_ops = { 1072 .preenable = kxcjk1013_buffer_preenable, 1073 .postdisable = kxcjk1013_buffer_postdisable, 1074}; 1075 1076static const struct iio_info kxcjk1013_info = { 1077 .attrs = &kxcjk1013_attrs_group, 1078 .read_raw = kxcjk1013_read_raw, 1079 .write_raw = kxcjk1013_write_raw, 1080 .read_event_value = kxcjk1013_read_event, 1081 .write_event_value = kxcjk1013_write_event, 1082 .write_event_config = kxcjk1013_write_event_config, 1083 .read_event_config = kxcjk1013_read_event_config, 1084}; 1085 1086static const unsigned long kxcjk1013_scan_masks[] = {0x7, 0}; 1087 1088static irqreturn_t kxcjk1013_trigger_handler(int irq, void *p) 1089{ 1090 struct iio_poll_func *pf = p; 1091 struct iio_dev *indio_dev = pf->indio_dev; 1092 struct kxcjk1013_data *data = iio_priv(indio_dev); 1093 int ret; 1094 1095 mutex_lock(&data->mutex); 1096 ret = i2c_smbus_read_i2c_block_data_or_emulated(data->client, 1097 KXCJK1013_REG_XOUT_L, 1098 AXIS_MAX * 2, 1099 (u8 *)data->scan.chans); 1100 mutex_unlock(&data->mutex); 1101 if (ret < 0) 1102 goto err; 1103 1104 iio_push_to_buffers_with_timestamp(indio_dev, &data->scan, 1105 data->timestamp); 1106err: 1107 iio_trigger_notify_done(indio_dev->trig); 1108 1109 return IRQ_HANDLED; 1110} 1111 1112static int kxcjk1013_trig_try_reen(struct iio_trigger *trig) 1113{ 1114 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 1115 struct kxcjk1013_data *data = iio_priv(indio_dev); 1116 int ret; 1117 1118 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL); 1119 if (ret < 0) { 1120 dev_err(&data->client->dev, "Error reading reg_int_rel\n"); 1121 return ret; 1122 } 1123 1124 return 0; 1125} 1126 1127static int kxcjk1013_data_rdy_trigger_set_state(struct iio_trigger *trig, 1128 bool state) 1129{ 1130 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 1131 struct kxcjk1013_data *data = iio_priv(indio_dev); 1132 int ret; 1133 1134 mutex_lock(&data->mutex); 1135 1136 if (!state && data->ev_enable_state && data->motion_trigger_on) { 1137 data->motion_trigger_on = false; 1138 mutex_unlock(&data->mutex); 1139 return 0; 1140 } 1141 1142 ret = kxcjk1013_set_power_state(data, state); 1143 if (ret < 0) { 1144 mutex_unlock(&data->mutex); 1145 return ret; 1146 } 1147 if (data->motion_trig == trig) 1148 ret = kxcjk1013_setup_any_motion_interrupt(data, state); 1149 else 1150 ret = kxcjk1013_setup_new_data_interrupt(data, state); 1151 if (ret < 0) { 1152 kxcjk1013_set_power_state(data, false); 1153 mutex_unlock(&data->mutex); 1154 return ret; 1155 } 1156 if (data->motion_trig == trig) 1157 data->motion_trigger_on = state; 1158 else 1159 data->dready_trigger_on = state; 1160 1161 mutex_unlock(&data->mutex); 1162 1163 return 0; 1164} 1165 1166static const struct iio_trigger_ops kxcjk1013_trigger_ops = { 1167 .set_trigger_state = kxcjk1013_data_rdy_trigger_set_state, 1168 .try_reenable = kxcjk1013_trig_try_reen, 1169}; 1170 1171static void kxcjk1013_report_motion_event(struct iio_dev *indio_dev) 1172{ 1173 struct kxcjk1013_data *data = iio_priv(indio_dev); 1174 1175 int ret = i2c_smbus_read_byte_data(data->client, 1176 KXCJK1013_REG_INT_SRC2); 1177 if (ret < 0) { 1178 dev_err(&data->client->dev, "Error reading reg_int_src2\n"); 1179 return; 1180 } 1181 1182 if (ret & KXCJK1013_REG_INT_SRC2_BIT_XN) 1183 iio_push_event(indio_dev, 1184 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1185 0, 1186 IIO_MOD_X, 1187 IIO_EV_TYPE_THRESH, 1188 IIO_EV_DIR_FALLING), 1189 data->timestamp); 1190 1191 if (ret & KXCJK1013_REG_INT_SRC2_BIT_XP) 1192 iio_push_event(indio_dev, 1193 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1194 0, 1195 IIO_MOD_X, 1196 IIO_EV_TYPE_THRESH, 1197 IIO_EV_DIR_RISING), 1198 data->timestamp); 1199 1200 if (ret & KXCJK1013_REG_INT_SRC2_BIT_YN) 1201 iio_push_event(indio_dev, 1202 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1203 0, 1204 IIO_MOD_Y, 1205 IIO_EV_TYPE_THRESH, 1206 IIO_EV_DIR_FALLING), 1207 data->timestamp); 1208 1209 if (ret & KXCJK1013_REG_INT_SRC2_BIT_YP) 1210 iio_push_event(indio_dev, 1211 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1212 0, 1213 IIO_MOD_Y, 1214 IIO_EV_TYPE_THRESH, 1215 IIO_EV_DIR_RISING), 1216 data->timestamp); 1217 1218 if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZN) 1219 iio_push_event(indio_dev, 1220 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1221 0, 1222 IIO_MOD_Z, 1223 IIO_EV_TYPE_THRESH, 1224 IIO_EV_DIR_FALLING), 1225 data->timestamp); 1226 1227 if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZP) 1228 iio_push_event(indio_dev, 1229 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1230 0, 1231 IIO_MOD_Z, 1232 IIO_EV_TYPE_THRESH, 1233 IIO_EV_DIR_RISING), 1234 data->timestamp); 1235} 1236 1237static irqreturn_t kxcjk1013_event_handler(int irq, void *private) 1238{ 1239 struct iio_dev *indio_dev = private; 1240 struct kxcjk1013_data *data = iio_priv(indio_dev); 1241 int ret; 1242 1243 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_SRC1); 1244 if (ret < 0) { 1245 dev_err(&data->client->dev, "Error reading reg_int_src1\n"); 1246 goto ack_intr; 1247 } 1248 1249 if (ret & KXCJK1013_REG_INT_SRC1_BIT_WUFS) { 1250 if (data->chipset == KXTF9) 1251 iio_push_event(indio_dev, 1252 IIO_MOD_EVENT_CODE(IIO_ACCEL, 1253 0, 1254 IIO_MOD_X_AND_Y_AND_Z, 1255 IIO_EV_TYPE_THRESH, 1256 IIO_EV_DIR_RISING), 1257 data->timestamp); 1258 else 1259 kxcjk1013_report_motion_event(indio_dev); 1260 } 1261 1262ack_intr: 1263 if (data->dready_trigger_on) 1264 return IRQ_HANDLED; 1265 1266 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL); 1267 if (ret < 0) 1268 dev_err(&data->client->dev, "Error reading reg_int_rel\n"); 1269 1270 return IRQ_HANDLED; 1271} 1272 1273static irqreturn_t kxcjk1013_data_rdy_trig_poll(int irq, void *private) 1274{ 1275 struct iio_dev *indio_dev = private; 1276 struct kxcjk1013_data *data = iio_priv(indio_dev); 1277 1278 data->timestamp = iio_get_time_ns(indio_dev); 1279 1280 if (data->dready_trigger_on) 1281 iio_trigger_poll(data->dready_trig); 1282 else if (data->motion_trigger_on) 1283 iio_trigger_poll(data->motion_trig); 1284 1285 if (data->ev_enable_state) 1286 return IRQ_WAKE_THREAD; 1287 else 1288 return IRQ_HANDLED; 1289} 1290 1291static const char *kxcjk1013_match_acpi_device(struct device *dev, 1292 enum kx_chipset *chipset, 1293 enum kx_acpi_type *acpi_type) 1294{ 1295 const struct acpi_device_id *id; 1296 1297 id = acpi_match_device(dev->driver->acpi_match_table, dev); 1298 if (!id) 1299 return NULL; 1300 1301 if (strcmp(id->id, "SMO8500") == 0) 1302 *acpi_type = ACPI_SMO8500; 1303 else if (strcmp(id->id, "KIOX010A") == 0) 1304 *acpi_type = ACPI_KIOX010A; 1305 1306 *chipset = (enum kx_chipset)id->driver_data; 1307 1308 return dev_name(dev); 1309} 1310 1311static int kxcjk1013_probe(struct i2c_client *client, 1312 const struct i2c_device_id *id) 1313{ 1314 struct kxcjk1013_data *data; 1315 struct iio_dev *indio_dev; 1316 struct kxcjk_1013_platform_data *pdata; 1317 const char *name; 1318 int ret; 1319 1320 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1321 if (!indio_dev) 1322 return -ENOMEM; 1323 1324 data = iio_priv(indio_dev); 1325 i2c_set_clientdata(client, indio_dev); 1326 data->client = client; 1327 1328 pdata = dev_get_platdata(&client->dev); 1329 if (pdata) { 1330 data->active_high_intr = pdata->active_high_intr; 1331 data->orientation = pdata->orientation; 1332 } else { 1333 data->active_high_intr = true; /* default polarity */ 1334 1335 ret = iio_read_mount_matrix(&client->dev, "mount-matrix", 1336 &data->orientation); 1337 if (ret) 1338 return ret; 1339 } 1340 1341 if (id) { 1342 data->chipset = (enum kx_chipset)(id->driver_data); 1343 name = id->name; 1344 } else if (ACPI_HANDLE(&client->dev)) { 1345 name = kxcjk1013_match_acpi_device(&client->dev, 1346 &data->chipset, 1347 &data->acpi_type); 1348 } else 1349 return -ENODEV; 1350 1351 ret = kxcjk1013_chip_init(data); 1352 if (ret < 0) 1353 return ret; 1354 1355 mutex_init(&data->mutex); 1356 1357 indio_dev->channels = kxcjk1013_channels; 1358 indio_dev->num_channels = ARRAY_SIZE(kxcjk1013_channels); 1359 indio_dev->available_scan_masks = kxcjk1013_scan_masks; 1360 indio_dev->name = name; 1361 indio_dev->modes = INDIO_DIRECT_MODE; 1362 indio_dev->info = &kxcjk1013_info; 1363 1364 if (client->irq > 0 && data->acpi_type != ACPI_SMO8500) { 1365 ret = devm_request_threaded_irq(&client->dev, client->irq, 1366 kxcjk1013_data_rdy_trig_poll, 1367 kxcjk1013_event_handler, 1368 IRQF_TRIGGER_RISING, 1369 KXCJK1013_IRQ_NAME, 1370 indio_dev); 1371 if (ret) 1372 goto err_poweroff; 1373 1374 data->dready_trig = devm_iio_trigger_alloc(&client->dev, 1375 "%s-dev%d", 1376 indio_dev->name, 1377 indio_dev->id); 1378 if (!data->dready_trig) { 1379 ret = -ENOMEM; 1380 goto err_poweroff; 1381 } 1382 1383 data->motion_trig = devm_iio_trigger_alloc(&client->dev, 1384 "%s-any-motion-dev%d", 1385 indio_dev->name, 1386 indio_dev->id); 1387 if (!data->motion_trig) { 1388 ret = -ENOMEM; 1389 goto err_poweroff; 1390 } 1391 1392 data->dready_trig->dev.parent = &client->dev; 1393 data->dready_trig->ops = &kxcjk1013_trigger_ops; 1394 iio_trigger_set_drvdata(data->dready_trig, indio_dev); 1395 indio_dev->trig = data->dready_trig; 1396 iio_trigger_get(indio_dev->trig); 1397 ret = iio_trigger_register(data->dready_trig); 1398 if (ret) 1399 goto err_poweroff; 1400 1401 data->motion_trig->dev.parent = &client->dev; 1402 data->motion_trig->ops = &kxcjk1013_trigger_ops; 1403 iio_trigger_set_drvdata(data->motion_trig, indio_dev); 1404 ret = iio_trigger_register(data->motion_trig); 1405 if (ret) { 1406 data->motion_trig = NULL; 1407 goto err_trigger_unregister; 1408 } 1409 } 1410 1411 ret = iio_triggered_buffer_setup(indio_dev, 1412 &iio_pollfunc_store_time, 1413 kxcjk1013_trigger_handler, 1414 &kxcjk1013_buffer_setup_ops); 1415 if (ret < 0) { 1416 dev_err(&client->dev, "iio triggered buffer setup failed\n"); 1417 goto err_trigger_unregister; 1418 } 1419 1420 ret = pm_runtime_set_active(&client->dev); 1421 if (ret) 1422 goto err_buffer_cleanup; 1423 1424 pm_runtime_enable(&client->dev); 1425 pm_runtime_set_autosuspend_delay(&client->dev, 1426 KXCJK1013_SLEEP_DELAY_MS); 1427 pm_runtime_use_autosuspend(&client->dev); 1428 1429 ret = iio_device_register(indio_dev); 1430 if (ret < 0) { 1431 dev_err(&client->dev, "unable to register iio device\n"); 1432 goto err_pm_cleanup; 1433 } 1434 1435 return 0; 1436 1437err_pm_cleanup: 1438 pm_runtime_dont_use_autosuspend(&client->dev); 1439 pm_runtime_disable(&client->dev); 1440err_buffer_cleanup: 1441 iio_triggered_buffer_cleanup(indio_dev); 1442err_trigger_unregister: 1443 if (data->dready_trig) 1444 iio_trigger_unregister(data->dready_trig); 1445 if (data->motion_trig) 1446 iio_trigger_unregister(data->motion_trig); 1447err_poweroff: 1448 kxcjk1013_set_mode(data, STANDBY); 1449 1450 return ret; 1451} 1452 1453static int kxcjk1013_remove(struct i2c_client *client) 1454{ 1455 struct iio_dev *indio_dev = i2c_get_clientdata(client); 1456 struct kxcjk1013_data *data = iio_priv(indio_dev); 1457 1458 iio_device_unregister(indio_dev); 1459 1460 pm_runtime_disable(&client->dev); 1461 pm_runtime_set_suspended(&client->dev); 1462 pm_runtime_put_noidle(&client->dev); 1463 1464 iio_triggered_buffer_cleanup(indio_dev); 1465 if (data->dready_trig) { 1466 iio_trigger_unregister(data->dready_trig); 1467 iio_trigger_unregister(data->motion_trig); 1468 } 1469 1470 mutex_lock(&data->mutex); 1471 kxcjk1013_set_mode(data, STANDBY); 1472 mutex_unlock(&data->mutex); 1473 1474 return 0; 1475} 1476 1477#ifdef CONFIG_PM_SLEEP 1478static int kxcjk1013_suspend(struct device *dev) 1479{ 1480 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1481 struct kxcjk1013_data *data = iio_priv(indio_dev); 1482 int ret; 1483 1484 mutex_lock(&data->mutex); 1485 ret = kxcjk1013_set_mode(data, STANDBY); 1486 mutex_unlock(&data->mutex); 1487 1488 return ret; 1489} 1490 1491static int kxcjk1013_resume(struct device *dev) 1492{ 1493 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1494 struct kxcjk1013_data *data = iio_priv(indio_dev); 1495 int ret = 0; 1496 1497 mutex_lock(&data->mutex); 1498 ret = kxcjk1013_set_mode(data, OPERATION); 1499 if (ret == 0) 1500 ret = kxcjk1013_set_range(data, data->range); 1501 mutex_unlock(&data->mutex); 1502 1503 return ret; 1504} 1505#endif 1506 1507#ifdef CONFIG_PM 1508static int kxcjk1013_runtime_suspend(struct device *dev) 1509{ 1510 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1511 struct kxcjk1013_data *data = iio_priv(indio_dev); 1512 int ret; 1513 1514 ret = kxcjk1013_set_mode(data, STANDBY); 1515 if (ret < 0) { 1516 dev_err(&data->client->dev, "powering off device failed\n"); 1517 return -EAGAIN; 1518 } 1519 return 0; 1520} 1521 1522static int kxcjk1013_runtime_resume(struct device *dev) 1523{ 1524 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1525 struct kxcjk1013_data *data = iio_priv(indio_dev); 1526 int ret; 1527 int sleep_val; 1528 1529 ret = kxcjk1013_set_mode(data, OPERATION); 1530 if (ret < 0) 1531 return ret; 1532 1533 sleep_val = kxcjk1013_get_startup_times(data); 1534 if (sleep_val < 20000) 1535 usleep_range(sleep_val, 20000); 1536 else 1537 msleep_interruptible(sleep_val/1000); 1538 1539 return 0; 1540} 1541#endif 1542 1543static const struct dev_pm_ops kxcjk1013_pm_ops = { 1544 SET_SYSTEM_SLEEP_PM_OPS(kxcjk1013_suspend, kxcjk1013_resume) 1545 SET_RUNTIME_PM_OPS(kxcjk1013_runtime_suspend, 1546 kxcjk1013_runtime_resume, NULL) 1547}; 1548 1549static const struct acpi_device_id kx_acpi_match[] = { 1550 {"KXCJ1013", KXCJK1013}, 1551 {"KXCJ1008", KXCJ91008}, 1552 {"KXCJ9000", KXCJ91008}, 1553 {"KIOX0008", KXCJ91008}, 1554 {"KIOX0009", KXTJ21009}, 1555 {"KIOX000A", KXCJ91008}, 1556 {"KIOX010A", KXCJ91008}, /* KXCJ91008 in the display of a yoga 2-in-1 */ 1557 {"KIOX020A", KXCJ91008}, /* KXCJ91008 in the base of a yoga 2-in-1 */ 1558 {"KXTJ1009", KXTJ21009}, 1559 {"KXJ2109", KXTJ21009}, 1560 {"SMO8500", KXCJ91008}, 1561 { }, 1562}; 1563MODULE_DEVICE_TABLE(acpi, kx_acpi_match); 1564 1565static const struct i2c_device_id kxcjk1013_id[] = { 1566 {"kxcjk1013", KXCJK1013}, 1567 {"kxcj91008", KXCJ91008}, 1568 {"kxtj21009", KXTJ21009}, 1569 {"kxtf9", KXTF9}, 1570 {"SMO8500", KXCJ91008}, 1571 {} 1572}; 1573 1574MODULE_DEVICE_TABLE(i2c, kxcjk1013_id); 1575 1576static const struct of_device_id kxcjk1013_of_match[] = { 1577 { .compatible = "kionix,kxcjk1013", }, 1578 { .compatible = "kionix,kxcj91008", }, 1579 { .compatible = "kionix,kxtj21009", }, 1580 { .compatible = "kionix,kxtf9", }, 1581 { } 1582}; 1583MODULE_DEVICE_TABLE(of, kxcjk1013_of_match); 1584 1585static struct i2c_driver kxcjk1013_driver = { 1586 .driver = { 1587 .name = KXCJK1013_DRV_NAME, 1588 .acpi_match_table = ACPI_PTR(kx_acpi_match), 1589 .of_match_table = kxcjk1013_of_match, 1590 .pm = &kxcjk1013_pm_ops, 1591 }, 1592 .probe = kxcjk1013_probe, 1593 .remove = kxcjk1013_remove, 1594 .id_table = kxcjk1013_id, 1595}; 1596module_i2c_driver(kxcjk1013_driver); 1597 1598MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>"); 1599MODULE_LICENSE("GPL v2"); 1600MODULE_DESCRIPTION("KXCJK1013 accelerometer driver"); 1601