1 /* 2 * apds9960.c - Support for Avago APDS9960 gesture/RGB/ALS/proximity sensor 3 * 4 * Copyright (C) 2015 Matt Ranostay <mranostay@gmail.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * TODO: gesture + proximity calib offsets 17 */ 18 19 #include <linux/module.h> 20 #include <linux/init.h> 21 #include <linux/interrupt.h> 22 #include <linux/delay.h> 23 #include <linux/mutex.h> 24 #include <linux/err.h> 25 #include <linux/irq.h> 26 #include <linux/gpio.h> 27 #include <linux/i2c.h> 28 #include <linux/pm_runtime.h> 29 #include <linux/regmap.h> 30 #include <linux/iio/iio.h> 31 #include <linux/iio/buffer.h> 32 #include <linux/iio/events.h> 33 #include <linux/iio/kfifo_buf.h> 34 #include <linux/iio/sysfs.h> 35 #include <linux/of_gpio.h> 36 37 #define APDS9960_REGMAP_NAME "apds9960_regmap" 38 #define APDS9960_DRV_NAME "apds9960" 39 40 #define APDS9960_REG_RAM_START 0x00 41 #define APDS9960_REG_RAM_END 0x7f 42 43 #define APDS9960_REG_ENABLE 0x80 44 #define APDS9960_REG_ATIME 0x81 45 #define APDS9960_REG_WTIME 0x83 46 47 #define APDS9960_REG_AILTL 0x84 48 #define APDS9960_REG_AILTH 0x85 49 #define APDS9960_REG_AIHTL 0x86 50 #define APDS9960_REG_AIHTH 0x87 51 52 #define APDS9960_REG_PILT 0x89 53 #define APDS9960_REG_PIHT 0x8b 54 #define APDS9960_REG_PERS 0x8c 55 56 #define APDS9960_REG_CONFIG_1 0x8d 57 #define APDS9960_REG_PPULSE 0x8e 58 59 #define APDS9960_REG_CONTROL 0x8f 60 #define APDS9960_REG_CONTROL_AGAIN_MASK 0x03 61 #define APDS9960_REG_CONTROL_PGAIN_MASK 0x0c 62 #define APDS9960_REG_CONTROL_AGAIN_MASK_SHIFT 0 63 #define APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT 2 64 65 #define APDS9960_REG_CONFIG_2 0x90 66 #define APDS9960_REG_CONFIG_2_GGAIN_MASK 0x60 67 #define APDS9960_REG_CONFIG_2_GGAIN_MASK_SHIFT 5 68 69 #define APDS9960_REG_ID 0x92 70 71 #define APDS9960_REG_STATUS 0x93 72 #define APDS9960_REG_STATUS_PS_INT BIT(5) 73 #define APDS9960_REG_STATUS_ALS_INT BIT(4) 74 #define APDS9960_REG_STATUS_GINT BIT(2) 75 76 #define APDS9960_REG_PDATA 0x9c 77 #define APDS9960_REG_POFFSET_UR 0x9d 78 #define APDS9960_REG_POFFSET_DL 0x9e 79 #define APDS9960_REG_CONFIG_3 0x9f 80 81 #define APDS9960_REG_GPENTH 0xa0 82 #define APDS9960_REG_GEXTH 0xa1 83 84 #define APDS9960_REG_GCONF_1 0xa2 85 #define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK 0xc0 86 #define APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT 6 87 88 #define APDS9960_REG_GCONF_2 0xa3 89 #define APDS9960_REG_GOFFSET_U 0xa4 90 #define APDS9960_REG_GOFFSET_D 0xa5 91 #define APDS9960_REG_GPULSE 0xa6 92 #define APDS9960_REG_GOFFSET_L 0xa7 93 #define APDS9960_REG_GOFFSET_R 0xa9 94 #define APDS9960_REG_GCONF_3 0xaa 95 96 #define APDS9960_REG_GCONF_4 0xab 97 #define APDS9960_REG_GFLVL 0xae 98 #define APDS9960_REG_GSTATUS 0xaf 99 100 #define APDS9960_REG_IFORCE 0xe4 101 #define APDS9960_REG_PICLEAR 0xe5 102 #define APDS9960_REG_CICLEAR 0xe6 103 #define APDS9960_REG_AICLEAR 0xe7 104 105 #define APDS9960_DEFAULT_PERS 0x33 106 #define APDS9960_DEFAULT_GPENTH 0x50 107 #define APDS9960_DEFAULT_GEXTH 0x40 108 109 #define APDS9960_MAX_PXS_THRES_VAL 255 110 #define APDS9960_MAX_ALS_THRES_VAL 0xffff 111 #define APDS9960_MAX_INT_TIME_IN_US 1000000 112 113 enum apds9960_als_channel_idx { 114 IDX_ALS_CLEAR, IDX_ALS_RED, IDX_ALS_GREEN, IDX_ALS_BLUE, 115 }; 116 117 #define APDS9960_REG_ALS_BASE 0x94 118 #define APDS9960_REG_ALS_CHANNEL(_colour) \ 119 (APDS9960_REG_ALS_BASE + (IDX_ALS_##_colour * 2)) 120 121 enum apds9960_gesture_channel_idx { 122 IDX_DIR_UP, IDX_DIR_DOWN, IDX_DIR_LEFT, IDX_DIR_RIGHT, 123 }; 124 125 #define APDS9960_REG_GFIFO_BASE 0xfc 126 #define APDS9960_REG_GFIFO_DIR(_dir) \ 127 (APDS9960_REG_GFIFO_BASE + IDX_DIR_##_dir) 128 129 struct apds9960_data { 130 struct i2c_client *client; 131 struct iio_dev *indio_dev; 132 struct mutex lock; 133 134 /* regmap fields */ 135 struct regmap *regmap; 136 struct regmap_field *reg_int_als; 137 struct regmap_field *reg_int_ges; 138 struct regmap_field *reg_int_pxs; 139 140 struct regmap_field *reg_enable_als; 141 struct regmap_field *reg_enable_ges; 142 struct regmap_field *reg_enable_pxs; 143 144 /* state */ 145 int als_int; 146 int pxs_int; 147 int gesture_mode_running; 148 149 /* gain values */ 150 int als_gain; 151 int pxs_gain; 152 153 /* integration time value in us */ 154 int als_adc_int_us; 155 156 /* gesture buffer */ 157 u8 buffer[4]; /* 4 8-bit channels */ 158 }; 159 160 static const struct reg_default apds9960_reg_defaults[] = { 161 /* Default ALS integration time = 2.48ms */ 162 { APDS9960_REG_ATIME, 0xff }, 163 }; 164 165 static const struct regmap_range apds9960_volatile_ranges[] = { 166 regmap_reg_range(APDS9960_REG_STATUS, 167 APDS9960_REG_PDATA), 168 regmap_reg_range(APDS9960_REG_GFLVL, 169 APDS9960_REG_GSTATUS), 170 regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP), 171 APDS9960_REG_GFIFO_DIR(RIGHT)), 172 regmap_reg_range(APDS9960_REG_IFORCE, 173 APDS9960_REG_AICLEAR), 174 }; 175 176 static const struct regmap_access_table apds9960_volatile_table = { 177 .yes_ranges = apds9960_volatile_ranges, 178 .n_yes_ranges = ARRAY_SIZE(apds9960_volatile_ranges), 179 }; 180 181 static const struct regmap_range apds9960_precious_ranges[] = { 182 regmap_reg_range(APDS9960_REG_RAM_START, APDS9960_REG_RAM_END), 183 }; 184 185 static const struct regmap_access_table apds9960_precious_table = { 186 .yes_ranges = apds9960_precious_ranges, 187 .n_yes_ranges = ARRAY_SIZE(apds9960_precious_ranges), 188 }; 189 190 static const struct regmap_range apds9960_readable_ranges[] = { 191 regmap_reg_range(APDS9960_REG_ENABLE, 192 APDS9960_REG_GSTATUS), 193 regmap_reg_range(APDS9960_REG_GFIFO_DIR(UP), 194 APDS9960_REG_GFIFO_DIR(RIGHT)), 195 }; 196 197 static const struct regmap_access_table apds9960_readable_table = { 198 .yes_ranges = apds9960_readable_ranges, 199 .n_yes_ranges = ARRAY_SIZE(apds9960_readable_ranges), 200 }; 201 202 static const struct regmap_range apds9960_writeable_ranges[] = { 203 regmap_reg_range(APDS9960_REG_ENABLE, APDS9960_REG_CONFIG_2), 204 regmap_reg_range(APDS9960_REG_POFFSET_UR, APDS9960_REG_GCONF_4), 205 regmap_reg_range(APDS9960_REG_IFORCE, APDS9960_REG_AICLEAR), 206 }; 207 208 static const struct regmap_access_table apds9960_writeable_table = { 209 .yes_ranges = apds9960_writeable_ranges, 210 .n_yes_ranges = ARRAY_SIZE(apds9960_writeable_ranges), 211 }; 212 213 static const struct regmap_config apds9960_regmap_config = { 214 .name = APDS9960_REGMAP_NAME, 215 .reg_bits = 8, 216 .val_bits = 8, 217 .use_single_rw = 1, 218 219 .volatile_table = &apds9960_volatile_table, 220 .precious_table = &apds9960_precious_table, 221 .rd_table = &apds9960_readable_table, 222 .wr_table = &apds9960_writeable_table, 223 224 .reg_defaults = apds9960_reg_defaults, 225 .num_reg_defaults = ARRAY_SIZE(apds9960_reg_defaults), 226 .max_register = APDS9960_REG_GFIFO_DIR(RIGHT), 227 .cache_type = REGCACHE_RBTREE, 228 }; 229 230 static const struct iio_event_spec apds9960_pxs_event_spec[] = { 231 { 232 .type = IIO_EV_TYPE_THRESH, 233 .dir = IIO_EV_DIR_RISING, 234 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 235 BIT(IIO_EV_INFO_ENABLE), 236 }, 237 { 238 .type = IIO_EV_TYPE_THRESH, 239 .dir = IIO_EV_DIR_FALLING, 240 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 241 BIT(IIO_EV_INFO_ENABLE), 242 }, 243 }; 244 245 static const struct iio_event_spec apds9960_als_event_spec[] = { 246 { 247 .type = IIO_EV_TYPE_THRESH, 248 .dir = IIO_EV_DIR_RISING, 249 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 250 BIT(IIO_EV_INFO_ENABLE), 251 }, 252 { 253 .type = IIO_EV_TYPE_THRESH, 254 .dir = IIO_EV_DIR_FALLING, 255 .mask_separate = BIT(IIO_EV_INFO_VALUE) | 256 BIT(IIO_EV_INFO_ENABLE), 257 }, 258 }; 259 260 #define APDS9960_GESTURE_CHANNEL(_dir, _si) { \ 261 .type = IIO_PROXIMITY, \ 262 .channel = _si + 1, \ 263 .scan_index = _si, \ 264 .indexed = 1, \ 265 .scan_type = { \ 266 .sign = 'u', \ 267 .realbits = 8, \ 268 .storagebits = 8, \ 269 }, \ 270 } 271 272 #define APDS9960_INTENSITY_CHANNEL(_colour) { \ 273 .type = IIO_INTENSITY, \ 274 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 275 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 276 BIT(IIO_CHAN_INFO_INT_TIME), \ 277 .channel2 = IIO_MOD_LIGHT_##_colour, \ 278 .address = APDS9960_REG_ALS_CHANNEL(_colour), \ 279 .modified = 1, \ 280 .scan_index = -1, \ 281 } 282 283 static const unsigned long apds9960_scan_masks[] = {0xf, 0}; 284 285 static const struct iio_chan_spec apds9960_channels[] = { 286 { 287 .type = IIO_PROXIMITY, 288 .address = APDS9960_REG_PDATA, 289 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 290 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), 291 .channel = 0, 292 .indexed = 0, 293 .scan_index = -1, 294 295 .event_spec = apds9960_pxs_event_spec, 296 .num_event_specs = ARRAY_SIZE(apds9960_pxs_event_spec), 297 }, 298 /* Gesture Sensor */ 299 APDS9960_GESTURE_CHANNEL(UP, 0), 300 APDS9960_GESTURE_CHANNEL(DOWN, 1), 301 APDS9960_GESTURE_CHANNEL(LEFT, 2), 302 APDS9960_GESTURE_CHANNEL(RIGHT, 3), 303 /* ALS */ 304 { 305 .type = IIO_INTENSITY, 306 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), 307 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | 308 BIT(IIO_CHAN_INFO_INT_TIME), 309 .channel2 = IIO_MOD_LIGHT_CLEAR, 310 .address = APDS9960_REG_ALS_CHANNEL(CLEAR), 311 .modified = 1, 312 .scan_index = -1, 313 314 .event_spec = apds9960_als_event_spec, 315 .num_event_specs = ARRAY_SIZE(apds9960_als_event_spec), 316 }, 317 /* RGB Sensor */ 318 APDS9960_INTENSITY_CHANNEL(RED), 319 APDS9960_INTENSITY_CHANNEL(GREEN), 320 APDS9960_INTENSITY_CHANNEL(BLUE), 321 }; 322 323 /* integration time in us */ 324 static const int apds9960_int_time[][2] = { 325 { 28000, 246}, 326 {100000, 219}, 327 {200000, 182}, 328 {700000, 0} 329 }; 330 331 /* gain mapping */ 332 static const int apds9960_pxs_gain_map[] = {1, 2, 4, 8}; 333 static const int apds9960_als_gain_map[] = {1, 4, 16, 64}; 334 335 static IIO_CONST_ATTR(proximity_scale_available, "1 2 4 8"); 336 static IIO_CONST_ATTR(intensity_scale_available, "1 4 16 64"); 337 static IIO_CONST_ATTR_INT_TIME_AVAIL("0.028 0.1 0.2 0.7"); 338 339 static struct attribute *apds9960_attributes[] = { 340 &iio_const_attr_proximity_scale_available.dev_attr.attr, 341 &iio_const_attr_intensity_scale_available.dev_attr.attr, 342 &iio_const_attr_integration_time_available.dev_attr.attr, 343 NULL, 344 }; 345 346 static const struct attribute_group apds9960_attribute_group = { 347 .attrs = apds9960_attributes, 348 }; 349 350 static const struct reg_field apds9960_reg_field_int_als = 351 REG_FIELD(APDS9960_REG_ENABLE, 4, 4); 352 353 static const struct reg_field apds9960_reg_field_int_ges = 354 REG_FIELD(APDS9960_REG_GCONF_4, 1, 1); 355 356 static const struct reg_field apds9960_reg_field_int_pxs = 357 REG_FIELD(APDS9960_REG_ENABLE, 5, 5); 358 359 static const struct reg_field apds9960_reg_field_enable_als = 360 REG_FIELD(APDS9960_REG_ENABLE, 1, 1); 361 362 static const struct reg_field apds9960_reg_field_enable_ges = 363 REG_FIELD(APDS9960_REG_ENABLE, 6, 6); 364 365 static const struct reg_field apds9960_reg_field_enable_pxs = 366 REG_FIELD(APDS9960_REG_ENABLE, 2, 2); 367 368 static int apds9960_set_it_time(struct apds9960_data *data, int val2) 369 { 370 int ret = -EINVAL; 371 int idx; 372 373 for (idx = 0; idx < ARRAY_SIZE(apds9960_int_time); idx++) { 374 if (apds9960_int_time[idx][0] == val2) { 375 mutex_lock(&data->lock); 376 ret = regmap_write(data->regmap, APDS9960_REG_ATIME, 377 apds9960_int_time[idx][1]); 378 if (!ret) 379 data->als_adc_int_us = val2; 380 mutex_unlock(&data->lock); 381 break; 382 } 383 } 384 385 return ret; 386 } 387 388 static int apds9960_set_pxs_gain(struct apds9960_data *data, int val) 389 { 390 int ret = -EINVAL; 391 int idx; 392 393 for (idx = 0; idx < ARRAY_SIZE(apds9960_pxs_gain_map); idx++) { 394 if (apds9960_pxs_gain_map[idx] == val) { 395 /* pxs + gesture gains are mirrored */ 396 mutex_lock(&data->lock); 397 ret = regmap_update_bits(data->regmap, 398 APDS9960_REG_CONTROL, 399 APDS9960_REG_CONTROL_PGAIN_MASK, 400 idx << APDS9960_REG_CONTROL_PGAIN_MASK_SHIFT); 401 if (ret) { 402 mutex_unlock(&data->lock); 403 break; 404 } 405 406 ret = regmap_update_bits(data->regmap, 407 APDS9960_REG_CONFIG_2, 408 APDS9960_REG_CONFIG_2_GGAIN_MASK, 409 idx << APDS9960_REG_CONFIG_2_GGAIN_MASK_SHIFT); 410 if (!ret) 411 data->pxs_gain = idx; 412 mutex_unlock(&data->lock); 413 break; 414 } 415 } 416 417 return ret; 418 } 419 420 static int apds9960_set_als_gain(struct apds9960_data *data, int val) 421 { 422 int ret = -EINVAL; 423 int idx; 424 425 for (idx = 0; idx < ARRAY_SIZE(apds9960_als_gain_map); idx++) { 426 if (apds9960_als_gain_map[idx] == val) { 427 mutex_lock(&data->lock); 428 ret = regmap_update_bits(data->regmap, 429 APDS9960_REG_CONTROL, 430 APDS9960_REG_CONTROL_AGAIN_MASK, idx); 431 if (!ret) 432 data->als_gain = idx; 433 mutex_unlock(&data->lock); 434 break; 435 } 436 } 437 438 return ret; 439 } 440 441 #ifdef CONFIG_PM 442 static int apds9960_set_power_state(struct apds9960_data *data, bool on) 443 { 444 struct device *dev = &data->client->dev; 445 int ret = 0; 446 447 mutex_lock(&data->lock); 448 449 if (on) { 450 int suspended; 451 452 suspended = pm_runtime_suspended(dev); 453 ret = pm_runtime_get_sync(dev); 454 455 /* Allow one integration cycle before allowing a reading */ 456 if (suspended) 457 usleep_range(data->als_adc_int_us, 458 APDS9960_MAX_INT_TIME_IN_US); 459 } else { 460 pm_runtime_mark_last_busy(dev); 461 ret = pm_runtime_put_autosuspend(dev); 462 } 463 464 mutex_unlock(&data->lock); 465 466 return ret; 467 } 468 #else 469 static int apds9960_set_power_state(struct apds9960_data *data, bool on) 470 { 471 return 0; 472 } 473 #endif 474 475 static int apds9960_read_raw(struct iio_dev *indio_dev, 476 struct iio_chan_spec const *chan, 477 int *val, int *val2, long mask) 478 { 479 struct apds9960_data *data = iio_priv(indio_dev); 480 __le16 buf; 481 int ret = -EINVAL; 482 483 if (data->gesture_mode_running) 484 return -EBUSY; 485 486 switch (mask) { 487 case IIO_CHAN_INFO_RAW: 488 apds9960_set_power_state(data, true); 489 switch (chan->type) { 490 case IIO_PROXIMITY: 491 ret = regmap_read(data->regmap, chan->address, val); 492 if (!ret) 493 ret = IIO_VAL_INT; 494 break; 495 case IIO_INTENSITY: 496 ret = regmap_bulk_read(data->regmap, chan->address, 497 &buf, 2); 498 if (!ret) { 499 ret = IIO_VAL_INT; 500 *val = le16_to_cpu(buf); 501 } 502 break; 503 default: 504 ret = -EINVAL; 505 } 506 apds9960_set_power_state(data, false); 507 break; 508 case IIO_CHAN_INFO_INT_TIME: 509 /* RGB + ALS sensors only have integration time */ 510 mutex_lock(&data->lock); 511 switch (chan->type) { 512 case IIO_INTENSITY: 513 *val = 0; 514 *val2 = data->als_adc_int_us; 515 ret = IIO_VAL_INT_PLUS_MICRO; 516 break; 517 default: 518 ret = -EINVAL; 519 } 520 mutex_unlock(&data->lock); 521 break; 522 case IIO_CHAN_INFO_SCALE: 523 mutex_lock(&data->lock); 524 switch (chan->type) { 525 case IIO_PROXIMITY: 526 *val = apds9960_pxs_gain_map[data->pxs_gain]; 527 ret = IIO_VAL_INT; 528 break; 529 case IIO_INTENSITY: 530 *val = apds9960_als_gain_map[data->als_gain]; 531 ret = IIO_VAL_INT; 532 break; 533 default: 534 ret = -EINVAL; 535 } 536 mutex_unlock(&data->lock); 537 break; 538 } 539 540 return ret; 541 }; 542 543 static int apds9960_write_raw(struct iio_dev *indio_dev, 544 struct iio_chan_spec const *chan, 545 int val, int val2, long mask) 546 { 547 struct apds9960_data *data = iio_priv(indio_dev); 548 549 switch (mask) { 550 case IIO_CHAN_INFO_INT_TIME: 551 /* RGB + ALS sensors only have int time */ 552 switch (chan->type) { 553 case IIO_INTENSITY: 554 if (val != 0) 555 return -EINVAL; 556 return apds9960_set_it_time(data, val2); 557 default: 558 return -EINVAL; 559 } 560 case IIO_CHAN_INFO_SCALE: 561 if (val2 != 0) 562 return -EINVAL; 563 switch (chan->type) { 564 case IIO_PROXIMITY: 565 return apds9960_set_pxs_gain(data, val); 566 case IIO_INTENSITY: 567 return apds9960_set_als_gain(data, val); 568 default: 569 return -EINVAL; 570 } 571 default: 572 return -EINVAL; 573 }; 574 575 return 0; 576 } 577 578 static inline int apds9960_get_thres_reg(const struct iio_chan_spec *chan, 579 enum iio_event_direction dir, 580 u8 *reg) 581 { 582 switch (dir) { 583 case IIO_EV_DIR_RISING: 584 switch (chan->type) { 585 case IIO_PROXIMITY: 586 *reg = APDS9960_REG_PIHT; 587 break; 588 case IIO_INTENSITY: 589 *reg = APDS9960_REG_AIHTL; 590 break; 591 default: 592 return -EINVAL; 593 } 594 break; 595 case IIO_EV_DIR_FALLING: 596 switch (chan->type) { 597 case IIO_PROXIMITY: 598 *reg = APDS9960_REG_PILT; 599 break; 600 case IIO_INTENSITY: 601 *reg = APDS9960_REG_AILTL; 602 break; 603 default: 604 return -EINVAL; 605 } 606 break; 607 default: 608 return -EINVAL; 609 } 610 611 return 0; 612 } 613 614 static int apds9960_read_event(struct iio_dev *indio_dev, 615 const struct iio_chan_spec *chan, 616 enum iio_event_type type, 617 enum iio_event_direction dir, 618 enum iio_event_info info, 619 int *val, int *val2) 620 { 621 u8 reg; 622 __le16 buf; 623 int ret = 0; 624 struct apds9960_data *data = iio_priv(indio_dev); 625 626 if (info != IIO_EV_INFO_VALUE) 627 return -EINVAL; 628 629 ret = apds9960_get_thres_reg(chan, dir, ®); 630 if (ret < 0) 631 return ret; 632 633 if (chan->type == IIO_PROXIMITY) { 634 ret = regmap_read(data->regmap, reg, val); 635 if (ret < 0) 636 return ret; 637 } else if (chan->type == IIO_INTENSITY) { 638 ret = regmap_bulk_read(data->regmap, reg, &buf, 2); 639 if (ret < 0) 640 return ret; 641 *val = le16_to_cpu(buf); 642 } else 643 return -EINVAL; 644 645 *val2 = 0; 646 647 return IIO_VAL_INT; 648 } 649 650 static int apds9960_write_event(struct iio_dev *indio_dev, 651 const struct iio_chan_spec *chan, 652 enum iio_event_type type, 653 enum iio_event_direction dir, 654 enum iio_event_info info, 655 int val, int val2) 656 { 657 u8 reg; 658 __le16 buf; 659 int ret = 0; 660 struct apds9960_data *data = iio_priv(indio_dev); 661 662 if (info != IIO_EV_INFO_VALUE) 663 return -EINVAL; 664 665 ret = apds9960_get_thres_reg(chan, dir, ®); 666 if (ret < 0) 667 return ret; 668 669 if (chan->type == IIO_PROXIMITY) { 670 if (val < 0 || val > APDS9960_MAX_PXS_THRES_VAL) 671 return -EINVAL; 672 ret = regmap_write(data->regmap, reg, val); 673 if (ret < 0) 674 return ret; 675 } else if (chan->type == IIO_INTENSITY) { 676 if (val < 0 || val > APDS9960_MAX_ALS_THRES_VAL) 677 return -EINVAL; 678 buf = cpu_to_le16(val); 679 ret = regmap_bulk_write(data->regmap, reg, &buf, 2); 680 if (ret < 0) 681 return ret; 682 } else 683 return -EINVAL; 684 685 return 0; 686 } 687 688 static int apds9960_read_event_config(struct iio_dev *indio_dev, 689 const struct iio_chan_spec *chan, 690 enum iio_event_type type, 691 enum iio_event_direction dir) 692 { 693 struct apds9960_data *data = iio_priv(indio_dev); 694 695 switch (chan->type) { 696 case IIO_PROXIMITY: 697 return data->pxs_int; 698 case IIO_INTENSITY: 699 return data->als_int; 700 default: 701 return -EINVAL; 702 } 703 704 return 0; 705 } 706 707 static int apds9960_write_event_config(struct iio_dev *indio_dev, 708 const struct iio_chan_spec *chan, 709 enum iio_event_type type, 710 enum iio_event_direction dir, 711 int state) 712 { 713 struct apds9960_data *data = iio_priv(indio_dev); 714 int ret; 715 716 state = !!state; 717 718 switch (chan->type) { 719 case IIO_PROXIMITY: 720 if (data->pxs_int == state) 721 return -EINVAL; 722 723 ret = regmap_field_write(data->reg_int_pxs, state); 724 if (ret) 725 return ret; 726 data->pxs_int = state; 727 apds9960_set_power_state(data, state); 728 break; 729 case IIO_INTENSITY: 730 if (data->als_int == state) 731 return -EINVAL; 732 733 ret = regmap_field_write(data->reg_int_als, state); 734 if (ret) 735 return ret; 736 data->als_int = state; 737 apds9960_set_power_state(data, state); 738 break; 739 default: 740 return -EINVAL; 741 } 742 743 return 0; 744 } 745 746 static const struct iio_info apds9960_info = { 747 .attrs = &apds9960_attribute_group, 748 .read_raw = apds9960_read_raw, 749 .write_raw = apds9960_write_raw, 750 .read_event_value = apds9960_read_event, 751 .write_event_value = apds9960_write_event, 752 .read_event_config = apds9960_read_event_config, 753 .write_event_config = apds9960_write_event_config, 754 755 }; 756 757 static inline int apds9660_fifo_is_empty(struct apds9960_data *data) 758 { 759 int cnt; 760 int ret; 761 762 ret = regmap_read(data->regmap, APDS9960_REG_GFLVL, &cnt); 763 if (ret) 764 return ret; 765 766 return cnt; 767 } 768 769 static void apds9960_read_gesture_fifo(struct apds9960_data *data) 770 { 771 int ret, cnt = 0; 772 773 mutex_lock(&data->lock); 774 data->gesture_mode_running = 1; 775 776 while (cnt || (cnt = apds9660_fifo_is_empty(data) > 0)) { 777 ret = regmap_bulk_read(data->regmap, APDS9960_REG_GFIFO_BASE, 778 &data->buffer, 4); 779 780 if (ret) 781 goto err_read; 782 783 iio_push_to_buffers(data->indio_dev, data->buffer); 784 cnt--; 785 } 786 787 err_read: 788 data->gesture_mode_running = 0; 789 mutex_unlock(&data->lock); 790 } 791 792 static irqreturn_t apds9960_interrupt_handler(int irq, void *private) 793 { 794 struct iio_dev *indio_dev = private; 795 struct apds9960_data *data = iio_priv(indio_dev); 796 int ret, status; 797 798 ret = regmap_read(data->regmap, APDS9960_REG_STATUS, &status); 799 if (ret < 0) { 800 dev_err(&data->client->dev, "irq status reg read failed\n"); 801 return IRQ_HANDLED; 802 } 803 804 if ((status & APDS9960_REG_STATUS_ALS_INT) && data->als_int) { 805 iio_push_event(indio_dev, 806 IIO_UNMOD_EVENT_CODE(IIO_INTENSITY, 0, 807 IIO_EV_TYPE_THRESH, 808 IIO_EV_DIR_EITHER), 809 iio_get_time_ns(indio_dev)); 810 regmap_write(data->regmap, APDS9960_REG_CICLEAR, 1); 811 } 812 813 if ((status & APDS9960_REG_STATUS_PS_INT) && data->pxs_int) { 814 iio_push_event(indio_dev, 815 IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 0, 816 IIO_EV_TYPE_THRESH, 817 IIO_EV_DIR_EITHER), 818 iio_get_time_ns(indio_dev)); 819 regmap_write(data->regmap, APDS9960_REG_PICLEAR, 1); 820 } 821 822 if (status & APDS9960_REG_STATUS_GINT) 823 apds9960_read_gesture_fifo(data); 824 825 return IRQ_HANDLED; 826 } 827 828 static int apds9960_set_powermode(struct apds9960_data *data, bool state) 829 { 830 return regmap_update_bits(data->regmap, APDS9960_REG_ENABLE, 1, state); 831 } 832 833 static int apds9960_buffer_postenable(struct iio_dev *indio_dev) 834 { 835 struct apds9960_data *data = iio_priv(indio_dev); 836 int ret; 837 838 ret = regmap_field_write(data->reg_int_ges, 1); 839 if (ret) 840 return ret; 841 842 ret = regmap_field_write(data->reg_enable_ges, 1); 843 if (ret) 844 return ret; 845 846 pm_runtime_get_sync(&data->client->dev); 847 848 return 0; 849 } 850 851 static int apds9960_buffer_predisable(struct iio_dev *indio_dev) 852 { 853 struct apds9960_data *data = iio_priv(indio_dev); 854 int ret; 855 856 ret = regmap_field_write(data->reg_enable_ges, 0); 857 if (ret) 858 return ret; 859 860 ret = regmap_field_write(data->reg_int_ges, 0); 861 if (ret) 862 return ret; 863 864 pm_runtime_put_autosuspend(&data->client->dev); 865 866 return 0; 867 } 868 869 static const struct iio_buffer_setup_ops apds9960_buffer_setup_ops = { 870 .postenable = apds9960_buffer_postenable, 871 .predisable = apds9960_buffer_predisable, 872 }; 873 874 static int apds9960_regfield_init(struct apds9960_data *data) 875 { 876 struct device *dev = &data->client->dev; 877 struct regmap *regmap = data->regmap; 878 879 data->reg_int_als = devm_regmap_field_alloc(dev, regmap, 880 apds9960_reg_field_int_als); 881 if (IS_ERR(data->reg_int_als)) { 882 dev_err(dev, "INT ALS reg field init failed\n"); 883 return PTR_ERR(data->reg_int_als); 884 } 885 886 data->reg_int_ges = devm_regmap_field_alloc(dev, regmap, 887 apds9960_reg_field_int_ges); 888 if (IS_ERR(data->reg_int_ges)) { 889 dev_err(dev, "INT gesture reg field init failed\n"); 890 return PTR_ERR(data->reg_int_ges); 891 } 892 893 data->reg_int_pxs = devm_regmap_field_alloc(dev, regmap, 894 apds9960_reg_field_int_pxs); 895 if (IS_ERR(data->reg_int_pxs)) { 896 dev_err(dev, "INT pxs reg field init failed\n"); 897 return PTR_ERR(data->reg_int_pxs); 898 } 899 900 data->reg_enable_als = devm_regmap_field_alloc(dev, regmap, 901 apds9960_reg_field_enable_als); 902 if (IS_ERR(data->reg_enable_als)) { 903 dev_err(dev, "Enable ALS reg field init failed\n"); 904 return PTR_ERR(data->reg_enable_als); 905 } 906 907 data->reg_enable_ges = devm_regmap_field_alloc(dev, regmap, 908 apds9960_reg_field_enable_ges); 909 if (IS_ERR(data->reg_enable_ges)) { 910 dev_err(dev, "Enable gesture reg field init failed\n"); 911 return PTR_ERR(data->reg_enable_ges); 912 } 913 914 data->reg_enable_pxs = devm_regmap_field_alloc(dev, regmap, 915 apds9960_reg_field_enable_pxs); 916 if (IS_ERR(data->reg_enable_pxs)) { 917 dev_err(dev, "Enable PXS reg field init failed\n"); 918 return PTR_ERR(data->reg_enable_pxs); 919 } 920 921 return 0; 922 } 923 924 static int apds9960_chip_init(struct apds9960_data *data) 925 { 926 int ret; 927 928 /* Default IT for ALS of 28 ms */ 929 ret = apds9960_set_it_time(data, 28000); 930 if (ret) 931 return ret; 932 933 /* Ensure gesture interrupt is OFF */ 934 ret = regmap_field_write(data->reg_int_ges, 0); 935 if (ret) 936 return ret; 937 938 /* Disable gesture sensor, since polling is useless from user-space */ 939 ret = regmap_field_write(data->reg_enable_ges, 0); 940 if (ret) 941 return ret; 942 943 /* Ensure proximity interrupt is OFF */ 944 ret = regmap_field_write(data->reg_int_pxs, 0); 945 if (ret) 946 return ret; 947 948 /* Enable proximity sensor for polling */ 949 ret = regmap_field_write(data->reg_enable_pxs, 1); 950 if (ret) 951 return ret; 952 953 /* Ensure ALS interrupt is OFF */ 954 ret = regmap_field_write(data->reg_int_als, 0); 955 if (ret) 956 return ret; 957 958 /* Enable ALS sensor for polling */ 959 ret = regmap_field_write(data->reg_enable_als, 1); 960 if (ret) 961 return ret; 962 /* 963 * When enabled trigger an interrupt after 3 readings 964 * outside threshold for ALS + PXS 965 */ 966 ret = regmap_write(data->regmap, APDS9960_REG_PERS, 967 APDS9960_DEFAULT_PERS); 968 if (ret) 969 return ret; 970 971 /* 972 * Wait for 4 event outside gesture threshold to prevent interrupt 973 * flooding. 974 */ 975 ret = regmap_update_bits(data->regmap, APDS9960_REG_GCONF_1, 976 APDS9960_REG_GCONF_1_GFIFO_THRES_MASK, 977 BIT(0) << APDS9960_REG_GCONF_1_GFIFO_THRES_MASK_SHIFT); 978 if (ret) 979 return ret; 980 981 /* Default ENTER and EXIT thresholds for the GESTURE engine. */ 982 ret = regmap_write(data->regmap, APDS9960_REG_GPENTH, 983 APDS9960_DEFAULT_GPENTH); 984 if (ret) 985 return ret; 986 987 ret = regmap_write(data->regmap, APDS9960_REG_GEXTH, 988 APDS9960_DEFAULT_GEXTH); 989 if (ret) 990 return ret; 991 992 return apds9960_set_powermode(data, 1); 993 } 994 995 static int apds9960_probe(struct i2c_client *client, 996 const struct i2c_device_id *id) 997 { 998 struct apds9960_data *data; 999 struct iio_buffer *buffer; 1000 struct iio_dev *indio_dev; 1001 int ret; 1002 1003 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1004 if (!indio_dev) 1005 return -ENOMEM; 1006 1007 buffer = devm_iio_kfifo_allocate(&client->dev); 1008 if (!buffer) 1009 return -ENOMEM; 1010 1011 iio_device_attach_buffer(indio_dev, buffer); 1012 1013 indio_dev->dev.parent = &client->dev; 1014 indio_dev->info = &apds9960_info; 1015 indio_dev->name = APDS9960_DRV_NAME; 1016 indio_dev->channels = apds9960_channels; 1017 indio_dev->num_channels = ARRAY_SIZE(apds9960_channels); 1018 indio_dev->available_scan_masks = apds9960_scan_masks; 1019 indio_dev->modes = (INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE); 1020 indio_dev->setup_ops = &apds9960_buffer_setup_ops; 1021 1022 data = iio_priv(indio_dev); 1023 i2c_set_clientdata(client, indio_dev); 1024 1025 data->regmap = devm_regmap_init_i2c(client, &apds9960_regmap_config); 1026 if (IS_ERR(data->regmap)) { 1027 dev_err(&client->dev, "regmap initialization failed.\n"); 1028 return PTR_ERR(data->regmap); 1029 } 1030 1031 data->client = client; 1032 data->indio_dev = indio_dev; 1033 mutex_init(&data->lock); 1034 1035 ret = pm_runtime_set_active(&client->dev); 1036 if (ret) 1037 goto error_power_down; 1038 1039 pm_runtime_enable(&client->dev); 1040 pm_runtime_set_autosuspend_delay(&client->dev, 5000); 1041 pm_runtime_use_autosuspend(&client->dev); 1042 1043 apds9960_set_power_state(data, true); 1044 1045 ret = apds9960_regfield_init(data); 1046 if (ret) 1047 goto error_power_down; 1048 1049 ret = apds9960_chip_init(data); 1050 if (ret) 1051 goto error_power_down; 1052 1053 if (client->irq <= 0) { 1054 dev_err(&client->dev, "no valid irq defined\n"); 1055 ret = -EINVAL; 1056 goto error_power_down; 1057 } 1058 ret = devm_request_threaded_irq(&client->dev, client->irq, 1059 NULL, apds9960_interrupt_handler, 1060 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 1061 "apds9960_event", 1062 indio_dev); 1063 if (ret) { 1064 dev_err(&client->dev, "request irq (%d) failed\n", client->irq); 1065 goto error_power_down; 1066 } 1067 1068 ret = iio_device_register(indio_dev); 1069 if (ret) 1070 goto error_power_down; 1071 1072 apds9960_set_power_state(data, false); 1073 1074 return 0; 1075 1076 error_power_down: 1077 apds9960_set_power_state(data, false); 1078 1079 return ret; 1080 } 1081 1082 static int apds9960_remove(struct i2c_client *client) 1083 { 1084 struct iio_dev *indio_dev = i2c_get_clientdata(client); 1085 struct apds9960_data *data = iio_priv(indio_dev); 1086 1087 iio_device_unregister(indio_dev); 1088 pm_runtime_disable(&client->dev); 1089 pm_runtime_set_suspended(&client->dev); 1090 apds9960_set_powermode(data, 0); 1091 1092 return 0; 1093 } 1094 1095 #ifdef CONFIG_PM 1096 static int apds9960_runtime_suspend(struct device *dev) 1097 { 1098 struct apds9960_data *data = 1099 iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 1100 1101 return apds9960_set_powermode(data, 0); 1102 } 1103 1104 static int apds9960_runtime_resume(struct device *dev) 1105 { 1106 struct apds9960_data *data = 1107 iio_priv(i2c_get_clientdata(to_i2c_client(dev))); 1108 1109 return apds9960_set_powermode(data, 1); 1110 } 1111 #endif 1112 1113 static const struct dev_pm_ops apds9960_pm_ops = { 1114 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 1115 pm_runtime_force_resume) 1116 SET_RUNTIME_PM_OPS(apds9960_runtime_suspend, 1117 apds9960_runtime_resume, NULL) 1118 }; 1119 1120 static const struct i2c_device_id apds9960_id[] = { 1121 { "apds9960", 0 }, 1122 {} 1123 }; 1124 MODULE_DEVICE_TABLE(i2c, apds9960_id); 1125 1126 static const struct of_device_id apds9960_of_match[] = { 1127 { .compatible = "avago,apds9960" }, 1128 { } 1129 }; 1130 MODULE_DEVICE_TABLE(of, apds9960_of_match); 1131 1132 static struct i2c_driver apds9960_driver = { 1133 .driver = { 1134 .name = APDS9960_DRV_NAME, 1135 .of_match_table = apds9960_of_match, 1136 .pm = &apds9960_pm_ops, 1137 }, 1138 .probe = apds9960_probe, 1139 .remove = apds9960_remove, 1140 .id_table = apds9960_id, 1141 }; 1142 module_i2c_driver(apds9960_driver); 1143 1144 MODULE_AUTHOR("Matt Ranostay <mranostay@gmail.com>"); 1145 MODULE_DESCRIPTION("ADPS9960 Gesture/RGB/ALS/Proximity sensor"); 1146 MODULE_LICENSE("GPL"); 1147