1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2015 Intel Corporation 4 * 5 * Driver for UPISEMI us5182d Proximity and Ambient Light Sensor. 6 * 7 * To do: Interrupt support. 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/delay.h> 13 #include <linux/i2c.h> 14 #include <linux/iio/events.h> 15 #include <linux/iio/iio.h> 16 #include <linux/interrupt.h> 17 #include <linux/irq.h> 18 #include <linux/iio/sysfs.h> 19 #include <linux/mutex.h> 20 #include <linux/pm.h> 21 #include <linux/pm_runtime.h> 22 23 #define US5182D_REG_CFG0 0x00 24 #define US5182D_CFG0_ONESHOT_EN BIT(6) 25 #define US5182D_CFG0_SHUTDOWN_EN BIT(7) 26 #define US5182D_CFG0_WORD_ENABLE BIT(0) 27 #define US5182D_CFG0_PROX BIT(3) 28 #define US5182D_CFG0_PX_IRQ BIT(2) 29 30 #define US5182D_REG_CFG1 0x01 31 #define US5182D_CFG1_ALS_RES16 BIT(4) 32 #define US5182D_CFG1_AGAIN_DEFAULT 0x00 33 34 #define US5182D_REG_CFG2 0x02 35 #define US5182D_CFG2_PX_RES16 BIT(4) 36 #define US5182D_CFG2_PXGAIN_DEFAULT BIT(2) 37 38 #define US5182D_REG_CFG3 0x03 39 #define US5182D_CFG3_LED_CURRENT100 (BIT(4) | BIT(5)) 40 #define US5182D_CFG3_INT_SOURCE_PX BIT(3) 41 42 #define US5182D_REG_CFG4 0x10 43 44 /* 45 * Registers for tuning the auto dark current cancelling feature. 46 * DARK_TH(reg 0x27,0x28) - threshold (counts) for auto dark cancelling. 47 * when ALS > DARK_TH --> ALS_Code = ALS - Upper(0x2A) * Dark 48 * when ALS < DARK_TH --> ALS_Code = ALS - Lower(0x29) * Dark 49 */ 50 #define US5182D_REG_UDARK_TH 0x27 51 #define US5182D_REG_DARK_AUTO_EN 0x2b 52 #define US5182D_REG_AUTO_LDARK_GAIN 0x29 53 #define US5182D_REG_AUTO_HDARK_GAIN 0x2a 54 55 /* Thresholds for events: px low (0x08-l, 0x09-h), px high (0x0a-l 0x0b-h) */ 56 #define US5182D_REG_PXL_TH 0x08 57 #define US5182D_REG_PXH_TH 0x0a 58 59 #define US5182D_REG_PXL_TH_DEFAULT 1000 60 #define US5182D_REG_PXH_TH_DEFAULT 30000 61 62 #define US5182D_OPMODE_ALS 0x01 63 #define US5182D_OPMODE_PX 0x02 64 #define US5182D_OPMODE_SHIFT 4 65 66 #define US5182D_REG_DARK_AUTO_EN_DEFAULT 0x80 67 #define US5182D_REG_AUTO_LDARK_GAIN_DEFAULT 0x16 68 #define US5182D_REG_AUTO_HDARK_GAIN_DEFAULT 0x00 69 70 #define US5182D_REG_ADL 0x0c 71 #define US5182D_REG_PDL 0x0e 72 73 #define US5182D_REG_MODE_STORE 0x21 74 #define US5182D_STORE_MODE 0x01 75 76 #define US5182D_REG_CHIPID 0xb2 77 78 #define US5182D_OPMODE_MASK GENMASK(5, 4) 79 #define US5182D_AGAIN_MASK 0x07 80 #define US5182D_RESET_CHIP 0x01 81 82 #define US5182D_CHIPID 0x26 83 #define US5182D_DRV_NAME "us5182d" 84 85 #define US5182D_GA_RESOLUTION 1000 86 87 #define US5182D_READ_BYTE 1 88 #define US5182D_READ_WORD 2 89 #define US5182D_OPSTORE_SLEEP_TIME 20 /* ms */ 90 #define US5182D_SLEEP_MS 3000 /* ms */ 91 #define US5182D_PXH_TH_DISABLE 0xffff 92 #define US5182D_PXL_TH_DISABLE 0x0000 93 94 /* Available ranges: [12354, 7065, 3998, 2202, 1285, 498, 256, 138] lux */ 95 static const int us5182d_scales[] = {188500, 107800, 61000, 33600, 19600, 7600, 96 3900, 2100}; 97 98 /* 99 * Experimental thresholds that work with US5182D sensor on evaluation board 100 * roughly between 12-32 lux 101 */ 102 static u16 us5182d_dark_ths_vals[] = {170, 200, 512, 512, 800, 2000, 4000, 103 8000}; 104 105 enum mode { 106 US5182D_ALS_PX, 107 US5182D_ALS_ONLY, 108 US5182D_PX_ONLY 109 }; 110 111 enum pmode { 112 US5182D_CONTINUOUS, 113 US5182D_ONESHOT 114 }; 115 116 struct us5182d_data { 117 struct i2c_client *client; 118 struct mutex lock; 119 120 /* Glass attenuation factor */ 121 u32 ga; 122 123 /* Dark gain tuning */ 124 u8 lower_dark_gain; 125 u8 upper_dark_gain; 126 u16 *us5182d_dark_ths; 127 128 u16 px_low_th; 129 u16 px_high_th; 130 131 int rising_en; 132 int falling_en; 133 134 u8 opmode; 135 u8 power_mode; 136 137 bool als_enabled; 138 bool px_enabled; 139 140 bool default_continuous; 141 }; 142 143 static IIO_CONST_ATTR(in_illuminance_scale_available, 144 "0.0021 0.0039 0.0076 0.0196 0.0336 0.061 0.1078 0.1885"); 145 146 static struct attribute *us5182d_attrs[] = { 147 &iio_const_attr_in_illuminance_scale_available.dev_attr.attr, 148 NULL 149 }; 150 151 static const struct attribute_group us5182d_attr_group = { 152 .attrs = us5182d_attrs, 153 }; 154 155 static const struct { 156 u8 reg; 157 u8 val; 158 } us5182d_regvals[] = { 159 {US5182D_REG_CFG0, US5182D_CFG0_WORD_ENABLE}, 160 {US5182D_REG_CFG1, US5182D_CFG1_ALS_RES16}, 161 {US5182D_REG_CFG2, (US5182D_CFG2_PX_RES16 | 162 US5182D_CFG2_PXGAIN_DEFAULT)}, 163 {US5182D_REG_CFG3, US5182D_CFG3_LED_CURRENT100 | 164 US5182D_CFG3_INT_SOURCE_PX}, 165 {US5182D_REG_CFG4, 0x00}, 166 }; 167 168 static const struct iio_event_spec us5182d_events[] = { 169 { 170 .type = IIO_EV_TYPE_THRESH, 171 .dir = IIO_EV_DIR_RISING, 172 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 173 BIT(IIO_EV_INFO_ENABLE), 174 }, 175 { 176 .type = IIO_EV_TYPE_THRESH, 177 .dir = IIO_EV_DIR_FALLING, 178 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 179 BIT(IIO_EV_INFO_ENABLE), 180 }, 181 }; 182 183 static const struct iio_chan_spec us5182d_channels[] = { 184 { 185 .type = IIO_LIGHT, 186 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 187 BIT(IIO_CHAN_INFO_SCALE), 188 }, 189 { 190 .type = IIO_PROXIMITY, 191 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 192 .event_spec = us5182d_events, 193 .num_event_specs = ARRAY_SIZE(us5182d_events), 194 } 195 }; 196 197 static int us5182d_oneshot_en(struct us5182d_data *data) 198 { 199 int ret; 200 201 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG0); 202 if (ret < 0) 203 return ret; 204 205 /* 206 * In oneshot mode the chip will power itself down after taking the 207 * required measurement. 208 */ 209 ret = ret | US5182D_CFG0_ONESHOT_EN; 210 211 return i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG0, ret); 212 } 213 214 static int us5182d_set_opmode(struct us5182d_data *data, u8 mode) 215 { 216 int ret; 217 218 if (mode == data->opmode) 219 return 0; 220 221 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG0); 222 if (ret < 0) 223 return ret; 224 225 /* update mode */ 226 ret = ret & ~US5182D_OPMODE_MASK; 227 ret = ret | (mode << US5182D_OPMODE_SHIFT); 228 229 /* 230 * After updating the operating mode, the chip requires that 231 * the operation is stored, by writing 1 in the STORE_MODE 232 * register (auto-clearing). 233 */ 234 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG0, ret); 235 if (ret < 0) 236 return ret; 237 238 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_MODE_STORE, 239 US5182D_STORE_MODE); 240 if (ret < 0) 241 return ret; 242 243 data->opmode = mode; 244 msleep(US5182D_OPSTORE_SLEEP_TIME); 245 246 return 0; 247 } 248 249 static int us5182d_als_enable(struct us5182d_data *data) 250 { 251 int ret; 252 u8 mode; 253 254 if (data->power_mode == US5182D_ONESHOT) { 255 ret = us5182d_set_opmode(data, US5182D_ALS_ONLY); 256 if (ret < 0) 257 return ret; 258 data->px_enabled = false; 259 } 260 261 if (data->als_enabled) 262 return 0; 263 264 mode = data->px_enabled ? US5182D_ALS_PX : US5182D_ALS_ONLY; 265 266 ret = us5182d_set_opmode(data, mode); 267 if (ret < 0) 268 return ret; 269 270 data->als_enabled = true; 271 272 return 0; 273 } 274 275 static int us5182d_px_enable(struct us5182d_data *data) 276 { 277 int ret; 278 u8 mode; 279 280 if (data->power_mode == US5182D_ONESHOT) { 281 ret = us5182d_set_opmode(data, US5182D_PX_ONLY); 282 if (ret < 0) 283 return ret; 284 data->als_enabled = false; 285 } 286 287 if (data->px_enabled) 288 return 0; 289 290 mode = data->als_enabled ? US5182D_ALS_PX : US5182D_PX_ONLY; 291 292 ret = us5182d_set_opmode(data, mode); 293 if (ret < 0) 294 return ret; 295 296 data->px_enabled = true; 297 298 return 0; 299 } 300 301 static int us5182d_get_als(struct us5182d_data *data) 302 { 303 int ret; 304 unsigned long result; 305 306 ret = us5182d_als_enable(data); 307 if (ret < 0) 308 return ret; 309 310 ret = i2c_smbus_read_word_data(data->client, 311 US5182D_REG_ADL); 312 if (ret < 0) 313 return ret; 314 315 result = ret * data->ga / US5182D_GA_RESOLUTION; 316 if (result > 0xffff) 317 result = 0xffff; 318 319 return result; 320 } 321 322 static int us5182d_get_px(struct us5182d_data *data) 323 { 324 int ret; 325 326 ret = us5182d_px_enable(data); 327 if (ret < 0) 328 return ret; 329 330 return i2c_smbus_read_word_data(data->client, 331 US5182D_REG_PDL); 332 } 333 334 static int us5182d_shutdown_en(struct us5182d_data *data, u8 state) 335 { 336 int ret; 337 338 if (data->power_mode == US5182D_ONESHOT) 339 return 0; 340 341 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG0); 342 if (ret < 0) 343 return ret; 344 345 ret = ret & ~US5182D_CFG0_SHUTDOWN_EN; 346 ret = ret | state; 347 348 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG0, ret); 349 if (ret < 0) 350 return ret; 351 352 if (state & US5182D_CFG0_SHUTDOWN_EN) { 353 data->als_enabled = false; 354 data->px_enabled = false; 355 } 356 357 return ret; 358 } 359 360 361 static int us5182d_set_power_state(struct us5182d_data *data, bool on) 362 { 363 if (data->power_mode == US5182D_ONESHOT) 364 return 0; 365 366 if (on) 367 return pm_runtime_resume_and_get(&data->client->dev); 368 369 return pm_runtime_put_autosuspend(&data->client->dev); 370 } 371 372 static int us5182d_read_value(struct us5182d_data *data, 373 struct iio_chan_spec const *chan) 374 { 375 int ret, value; 376 377 mutex_lock(&data->lock); 378 379 if (data->power_mode == US5182D_ONESHOT) { 380 ret = us5182d_oneshot_en(data); 381 if (ret < 0) 382 goto out_err; 383 } 384 385 ret = us5182d_set_power_state(data, true); 386 if (ret < 0) 387 goto out_err; 388 389 if (chan->type == IIO_LIGHT) 390 ret = us5182d_get_als(data); 391 else 392 ret = us5182d_get_px(data); 393 if (ret < 0) 394 goto out_poweroff; 395 396 value = ret; 397 398 ret = us5182d_set_power_state(data, false); 399 if (ret < 0) 400 goto out_err; 401 402 mutex_unlock(&data->lock); 403 return value; 404 405 out_poweroff: 406 us5182d_set_power_state(data, false); 407 out_err: 408 mutex_unlock(&data->lock); 409 return ret; 410 } 411 412 static int us5182d_read_raw(struct iio_dev *indio_dev, 413 struct iio_chan_spec const *chan, int *val, 414 int *val2, long mask) 415 { 416 struct us5182d_data *data = iio_priv(indio_dev); 417 int ret; 418 419 switch (mask) { 420 case IIO_CHAN_INFO_RAW: 421 ret = us5182d_read_value(data, chan); 422 if (ret < 0) 423 return ret; 424 *val = ret; 425 return IIO_VAL_INT; 426 case IIO_CHAN_INFO_SCALE: 427 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG1); 428 if (ret < 0) 429 return ret; 430 *val = 0; 431 *val2 = us5182d_scales[ret & US5182D_AGAIN_MASK]; 432 return IIO_VAL_INT_PLUS_MICRO; 433 default: 434 return -EINVAL; 435 } 436 } 437 438 /** 439 * us5182d_update_dark_th - update Darh_Th registers 440 * @data: us5182d_data structure 441 * @index: index in us5182d_dark_ths array to use for the updated value 442 * 443 * Function needs to be called with a lock held because it needs two i2c write 444 * byte operations as these registers (0x27 0x28) don't work in word mode 445 * accessing. 446 */ 447 static int us5182d_update_dark_th(struct us5182d_data *data, int index) 448 { 449 __be16 dark_th = cpu_to_be16(data->us5182d_dark_ths[index]); 450 int ret; 451 452 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_UDARK_TH, 453 ((u8 *)&dark_th)[0]); 454 if (ret < 0) 455 return ret; 456 457 return i2c_smbus_write_byte_data(data->client, US5182D_REG_UDARK_TH + 1, 458 ((u8 *)&dark_th)[1]); 459 } 460 461 /** 462 * us5182d_apply_scale - update the ALS scale 463 * @data: us5182d_data structure 464 * @index: index in us5182d_scales array to use for the updated value 465 * 466 * Function needs to be called with a lock held as we're having more than one 467 * i2c operation. 468 */ 469 static int us5182d_apply_scale(struct us5182d_data *data, int index) 470 { 471 int ret; 472 473 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG1); 474 if (ret < 0) 475 return ret; 476 477 ret = ret & (~US5182D_AGAIN_MASK); 478 ret |= index; 479 480 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG1, ret); 481 if (ret < 0) 482 return ret; 483 484 return us5182d_update_dark_th(data, index); 485 } 486 487 static int us5182d_write_raw(struct iio_dev *indio_dev, 488 struct iio_chan_spec const *chan, int val, 489 int val2, long mask) 490 { 491 struct us5182d_data *data = iio_priv(indio_dev); 492 int ret, i; 493 494 switch (mask) { 495 case IIO_CHAN_INFO_SCALE: 496 if (val != 0) 497 return -EINVAL; 498 for (i = 0; i < ARRAY_SIZE(us5182d_scales); i++) 499 if (val2 == us5182d_scales[i]) { 500 mutex_lock(&data->lock); 501 ret = us5182d_apply_scale(data, i); 502 mutex_unlock(&data->lock); 503 return ret; 504 } 505 break; 506 default: 507 return -EINVAL; 508 } 509 510 return -EINVAL; 511 } 512 513 static int us5182d_setup_prox(struct iio_dev *indio_dev, 514 enum iio_event_direction dir, u16 val) 515 { 516 struct us5182d_data *data = iio_priv(indio_dev); 517 518 if (dir == IIO_EV_DIR_FALLING) 519 return i2c_smbus_write_word_data(data->client, 520 US5182D_REG_PXL_TH, val); 521 else if (dir == IIO_EV_DIR_RISING) 522 return i2c_smbus_write_word_data(data->client, 523 US5182D_REG_PXH_TH, val); 524 525 return 0; 526 } 527 528 static int us5182d_read_thresh(struct iio_dev *indio_dev, 529 const struct iio_chan_spec *chan, enum iio_event_type type, 530 enum iio_event_direction dir, enum iio_event_info info, int *val, 531 int *val2) 532 { 533 struct us5182d_data *data = iio_priv(indio_dev); 534 535 switch (dir) { 536 case IIO_EV_DIR_RISING: 537 mutex_lock(&data->lock); 538 *val = data->px_high_th; 539 mutex_unlock(&data->lock); 540 break; 541 case IIO_EV_DIR_FALLING: 542 mutex_lock(&data->lock); 543 *val = data->px_low_th; 544 mutex_unlock(&data->lock); 545 break; 546 default: 547 return -EINVAL; 548 } 549 550 return IIO_VAL_INT; 551 } 552 553 static int us5182d_write_thresh(struct iio_dev *indio_dev, 554 const struct iio_chan_spec *chan, enum iio_event_type type, 555 enum iio_event_direction dir, enum iio_event_info info, int val, 556 int val2) 557 { 558 struct us5182d_data *data = iio_priv(indio_dev); 559 int ret; 560 561 if (val < 0 || val > USHRT_MAX || val2 != 0) 562 return -EINVAL; 563 564 switch (dir) { 565 case IIO_EV_DIR_RISING: 566 mutex_lock(&data->lock); 567 if (data->rising_en) { 568 ret = us5182d_setup_prox(indio_dev, dir, val); 569 if (ret < 0) 570 goto err; 571 } 572 data->px_high_th = val; 573 mutex_unlock(&data->lock); 574 break; 575 case IIO_EV_DIR_FALLING: 576 mutex_lock(&data->lock); 577 if (data->falling_en) { 578 ret = us5182d_setup_prox(indio_dev, dir, val); 579 if (ret < 0) 580 goto err; 581 } 582 data->px_low_th = val; 583 mutex_unlock(&data->lock); 584 break; 585 default: 586 return -EINVAL; 587 } 588 589 return 0; 590 err: 591 mutex_unlock(&data->lock); 592 return ret; 593 } 594 595 static int us5182d_read_event_config(struct iio_dev *indio_dev, 596 const struct iio_chan_spec *chan, enum iio_event_type type, 597 enum iio_event_direction dir) 598 { 599 struct us5182d_data *data = iio_priv(indio_dev); 600 int ret; 601 602 switch (dir) { 603 case IIO_EV_DIR_RISING: 604 mutex_lock(&data->lock); 605 ret = data->rising_en; 606 mutex_unlock(&data->lock); 607 break; 608 case IIO_EV_DIR_FALLING: 609 mutex_lock(&data->lock); 610 ret = data->falling_en; 611 mutex_unlock(&data->lock); 612 break; 613 default: 614 ret = -EINVAL; 615 break; 616 } 617 618 return ret; 619 } 620 621 static int us5182d_write_event_config(struct iio_dev *indio_dev, 622 const struct iio_chan_spec *chan, enum iio_event_type type, 623 enum iio_event_direction dir, bool state) 624 { 625 struct us5182d_data *data = iio_priv(indio_dev); 626 int ret; 627 u16 new_th; 628 629 mutex_lock(&data->lock); 630 631 switch (dir) { 632 case IIO_EV_DIR_RISING: 633 if (data->rising_en == state) { 634 mutex_unlock(&data->lock); 635 return 0; 636 } 637 new_th = US5182D_PXH_TH_DISABLE; 638 if (state) { 639 data->power_mode = US5182D_CONTINUOUS; 640 ret = us5182d_set_power_state(data, true); 641 if (ret < 0) 642 goto err; 643 ret = us5182d_px_enable(data); 644 if (ret < 0) 645 goto err_poweroff; 646 new_th = data->px_high_th; 647 } 648 ret = us5182d_setup_prox(indio_dev, dir, new_th); 649 if (ret < 0) 650 goto err_poweroff; 651 data->rising_en = state; 652 break; 653 case IIO_EV_DIR_FALLING: 654 if (data->falling_en == state) { 655 mutex_unlock(&data->lock); 656 return 0; 657 } 658 new_th = US5182D_PXL_TH_DISABLE; 659 if (state) { 660 data->power_mode = US5182D_CONTINUOUS; 661 ret = us5182d_set_power_state(data, true); 662 if (ret < 0) 663 goto err; 664 ret = us5182d_px_enable(data); 665 if (ret < 0) 666 goto err_poweroff; 667 new_th = data->px_low_th; 668 } 669 ret = us5182d_setup_prox(indio_dev, dir, new_th); 670 if (ret < 0) 671 goto err_poweroff; 672 data->falling_en = state; 673 break; 674 default: 675 ret = -EINVAL; 676 goto err; 677 } 678 679 if (!state) { 680 ret = us5182d_set_power_state(data, false); 681 if (ret < 0) 682 goto err; 683 } 684 685 if (!data->falling_en && !data->rising_en && !data->default_continuous) 686 data->power_mode = US5182D_ONESHOT; 687 688 mutex_unlock(&data->lock); 689 return 0; 690 691 err_poweroff: 692 if (state) 693 us5182d_set_power_state(data, false); 694 err: 695 mutex_unlock(&data->lock); 696 return ret; 697 } 698 699 static const struct iio_info us5182d_info = { 700 .read_raw = us5182d_read_raw, 701 .write_raw = us5182d_write_raw, 702 .attrs = &us5182d_attr_group, 703 .read_event_value = &us5182d_read_thresh, 704 .write_event_value = &us5182d_write_thresh, 705 .read_event_config = &us5182d_read_event_config, 706 .write_event_config = &us5182d_write_event_config, 707 }; 708 709 static int us5182d_reset(struct iio_dev *indio_dev) 710 { 711 struct us5182d_data *data = iio_priv(indio_dev); 712 713 return i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG3, 714 US5182D_RESET_CHIP); 715 } 716 717 static int us5182d_init(struct iio_dev *indio_dev) 718 { 719 struct us5182d_data *data = iio_priv(indio_dev); 720 int i, ret; 721 722 ret = us5182d_reset(indio_dev); 723 if (ret < 0) 724 return ret; 725 726 data->opmode = 0; 727 data->power_mode = US5182D_CONTINUOUS; 728 data->px_low_th = US5182D_REG_PXL_TH_DEFAULT; 729 data->px_high_th = US5182D_REG_PXH_TH_DEFAULT; 730 731 for (i = 0; i < ARRAY_SIZE(us5182d_regvals); i++) { 732 ret = i2c_smbus_write_byte_data(data->client, 733 us5182d_regvals[i].reg, 734 us5182d_regvals[i].val); 735 if (ret < 0) 736 return ret; 737 } 738 739 data->als_enabled = true; 740 data->px_enabled = true; 741 742 if (!data->default_continuous) { 743 ret = us5182d_shutdown_en(data, US5182D_CFG0_SHUTDOWN_EN); 744 if (ret < 0) 745 return ret; 746 data->power_mode = US5182D_ONESHOT; 747 } 748 749 return ret; 750 } 751 752 static void us5182d_get_platform_data(struct iio_dev *indio_dev) 753 { 754 struct us5182d_data *data = iio_priv(indio_dev); 755 756 if (device_property_read_u32(&data->client->dev, "upisemi,glass-coef", 757 &data->ga)) 758 data->ga = US5182D_GA_RESOLUTION; 759 if (device_property_read_u16_array(&data->client->dev, 760 "upisemi,dark-ths", 761 data->us5182d_dark_ths, 762 ARRAY_SIZE(us5182d_dark_ths_vals))) 763 data->us5182d_dark_ths = us5182d_dark_ths_vals; 764 if (device_property_read_u8(&data->client->dev, 765 "upisemi,upper-dark-gain", 766 &data->upper_dark_gain)) 767 data->upper_dark_gain = US5182D_REG_AUTO_HDARK_GAIN_DEFAULT; 768 if (device_property_read_u8(&data->client->dev, 769 "upisemi,lower-dark-gain", 770 &data->lower_dark_gain)) 771 data->lower_dark_gain = US5182D_REG_AUTO_LDARK_GAIN_DEFAULT; 772 data->default_continuous = device_property_read_bool(&data->client->dev, 773 "upisemi,continuous"); 774 } 775 776 static int us5182d_dark_gain_config(struct iio_dev *indio_dev) 777 { 778 struct us5182d_data *data = iio_priv(indio_dev); 779 int ret; 780 781 ret = us5182d_update_dark_th(data, US5182D_CFG1_AGAIN_DEFAULT); 782 if (ret < 0) 783 return ret; 784 785 ret = i2c_smbus_write_byte_data(data->client, 786 US5182D_REG_AUTO_LDARK_GAIN, 787 data->lower_dark_gain); 788 if (ret < 0) 789 return ret; 790 791 ret = i2c_smbus_write_byte_data(data->client, 792 US5182D_REG_AUTO_HDARK_GAIN, 793 data->upper_dark_gain); 794 if (ret < 0) 795 return ret; 796 797 return i2c_smbus_write_byte_data(data->client, US5182D_REG_DARK_AUTO_EN, 798 US5182D_REG_DARK_AUTO_EN_DEFAULT); 799 } 800 801 static irqreturn_t us5182d_irq_thread_handler(int irq, void *private) 802 { 803 struct iio_dev *indio_dev = private; 804 struct us5182d_data *data = iio_priv(indio_dev); 805 enum iio_event_direction dir; 806 int ret; 807 u64 ev; 808 809 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CFG0); 810 if (ret < 0) { 811 dev_err(&data->client->dev, "i2c transfer error in irq\n"); 812 return IRQ_HANDLED; 813 } 814 815 dir = ret & US5182D_CFG0_PROX ? IIO_EV_DIR_RISING : IIO_EV_DIR_FALLING; 816 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 1, IIO_EV_TYPE_THRESH, dir); 817 818 iio_push_event(indio_dev, ev, iio_get_time_ns(indio_dev)); 819 820 ret = i2c_smbus_write_byte_data(data->client, US5182D_REG_CFG0, 821 ret & ~US5182D_CFG0_PX_IRQ); 822 if (ret < 0) 823 dev_err(&data->client->dev, "i2c transfer error in irq\n"); 824 825 return IRQ_HANDLED; 826 } 827 828 static int us5182d_probe(struct i2c_client *client) 829 { 830 struct us5182d_data *data; 831 struct iio_dev *indio_dev; 832 int ret; 833 834 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 835 if (!indio_dev) 836 return -ENOMEM; 837 838 data = iio_priv(indio_dev); 839 i2c_set_clientdata(client, indio_dev); 840 data->client = client; 841 842 mutex_init(&data->lock); 843 844 indio_dev->info = &us5182d_info; 845 indio_dev->name = US5182D_DRV_NAME; 846 indio_dev->channels = us5182d_channels; 847 indio_dev->num_channels = ARRAY_SIZE(us5182d_channels); 848 indio_dev->modes = INDIO_DIRECT_MODE; 849 850 ret = i2c_smbus_read_byte_data(data->client, US5182D_REG_CHIPID); 851 if (ret != US5182D_CHIPID) { 852 dev_err(&data->client->dev, 853 "Failed to detect US5182 light chip\n"); 854 return (ret < 0) ? ret : -ENODEV; 855 } 856 857 if (client->irq > 0) { 858 ret = devm_request_threaded_irq(&client->dev, client->irq, NULL, 859 us5182d_irq_thread_handler, 860 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 861 "us5182d-irq", indio_dev); 862 if (ret < 0) 863 return ret; 864 } else 865 dev_warn(&client->dev, "no valid irq found\n"); 866 867 us5182d_get_platform_data(indio_dev); 868 ret = us5182d_init(indio_dev); 869 if (ret < 0) 870 return ret; 871 872 ret = us5182d_dark_gain_config(indio_dev); 873 if (ret < 0) 874 goto out_err; 875 876 if (data->default_continuous) { 877 ret = pm_runtime_set_active(&client->dev); 878 if (ret < 0) 879 goto out_err; 880 } 881 882 pm_runtime_enable(&client->dev); 883 pm_runtime_set_autosuspend_delay(&client->dev, 884 US5182D_SLEEP_MS); 885 pm_runtime_use_autosuspend(&client->dev); 886 887 ret = iio_device_register(indio_dev); 888 if (ret < 0) 889 goto out_err; 890 891 return 0; 892 893 out_err: 894 us5182d_shutdown_en(data, US5182D_CFG0_SHUTDOWN_EN); 895 return ret; 896 897 } 898 899 static void us5182d_remove(struct i2c_client *client) 900 { 901 struct us5182d_data *data = iio_priv(i2c_get_clientdata(client)); 902 int ret; 903 904 iio_device_unregister(i2c_get_clientdata(client)); 905 906 pm_runtime_disable(&client->dev); 907 pm_runtime_set_suspended(&client->dev); 908 909 ret = us5182d_shutdown_en(data, US5182D_CFG0_SHUTDOWN_EN); 910 if (ret) 911 dev_warn(&client->dev, "Failed to shut down (%pe)\n", 912 ERR_PTR(ret)); 913 } 914 915 static int us5182d_suspend(struct device *dev) 916 { 917 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 918 struct us5182d_data *data = iio_priv(indio_dev); 919 920 if (data->power_mode == US5182D_CONTINUOUS) 921 return us5182d_shutdown_en(data, US5182D_CFG0_SHUTDOWN_EN); 922 923 return 0; 924 } 925 926 static int us5182d_resume(struct device *dev) 927 { 928 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 929 struct us5182d_data *data = iio_priv(indio_dev); 930 931 if (data->power_mode == US5182D_CONTINUOUS) 932 return us5182d_shutdown_en(data, 933 ~US5182D_CFG0_SHUTDOWN_EN & 0xff); 934 935 return 0; 936 } 937 938 static const struct dev_pm_ops us5182d_pm_ops = { 939 SYSTEM_SLEEP_PM_OPS(us5182d_suspend, us5182d_resume) 940 RUNTIME_PM_OPS(us5182d_suspend, us5182d_resume, NULL) 941 }; 942 943 static const struct acpi_device_id us5182d_acpi_match[] = { 944 { "USD5182", 0 }, 945 { } 946 }; 947 948 MODULE_DEVICE_TABLE(acpi, us5182d_acpi_match); 949 950 static const struct i2c_device_id us5182d_id[] = { 951 { .name = "usd5182" }, 952 { } 953 }; 954 955 MODULE_DEVICE_TABLE(i2c, us5182d_id); 956 957 static const struct of_device_id us5182d_of_match[] = { 958 { .compatible = "upisemi,usd5182" }, 959 { } 960 }; 961 MODULE_DEVICE_TABLE(of, us5182d_of_match); 962 963 static struct i2c_driver us5182d_driver = { 964 .driver = { 965 .name = US5182D_DRV_NAME, 966 .pm = pm_ptr(&us5182d_pm_ops), 967 .of_match_table = us5182d_of_match, 968 .acpi_match_table = us5182d_acpi_match, 969 }, 970 .probe = us5182d_probe, 971 .remove = us5182d_remove, 972 .id_table = us5182d_id, 973 974 }; 975 module_i2c_driver(us5182d_driver); 976 977 MODULE_AUTHOR("Adriana Reus <adriana.reus@intel.com>"); 978 MODULE_DESCRIPTION("Driver for us5182d Proximity and Light Sensor"); 979 MODULE_LICENSE("GPL v2"); 980