1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * isl29501.c: ISL29501 Time of Flight sensor driver. 4 * 5 * Copyright (C) 2018 6 * Author: Mathieu Othacehe <m.othacehe@gmail.com> 7 * 8 * 7-bit I2C slave address: 0x57 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/i2c.h> 14 #include <linux/err.h> 15 #include <linux/of_device.h> 16 #include <linux/iio/iio.h> 17 #include <linux/iio/sysfs.h> 18 19 #include <linux/iio/trigger_consumer.h> 20 #include <linux/iio/buffer.h> 21 #include <linux/iio/triggered_buffer.h> 22 23 /* Control, setting and status registers */ 24 #define ISL29501_DEVICE_ID 0x00 25 #define ISL29501_ID 0x0A 26 27 /* Sampling control registers */ 28 #define ISL29501_INTEGRATION_PERIOD 0x10 29 #define ISL29501_SAMPLE_PERIOD 0x11 30 31 /* Closed loop calibration registers */ 32 #define ISL29501_CROSSTALK_I_MSB 0x24 33 #define ISL29501_CROSSTALK_I_LSB 0x25 34 #define ISL29501_CROSSTALK_I_EXPONENT 0x26 35 #define ISL29501_CROSSTALK_Q_MSB 0x27 36 #define ISL29501_CROSSTALK_Q_LSB 0x28 37 #define ISL29501_CROSSTALK_Q_EXPONENT 0x29 38 #define ISL29501_CROSSTALK_GAIN_MSB 0x2A 39 #define ISL29501_CROSSTALK_GAIN_LSB 0x2B 40 #define ISL29501_MAGNITUDE_REF_EXP 0x2C 41 #define ISL29501_MAGNITUDE_REF_MSB 0x2D 42 #define ISL29501_MAGNITUDE_REF_LSB 0x2E 43 #define ISL29501_PHASE_OFFSET_MSB 0x2F 44 #define ISL29501_PHASE_OFFSET_LSB 0x30 45 46 /* Analog control registers */ 47 #define ISL29501_DRIVER_RANGE 0x90 48 #define ISL29501_EMITTER_DAC 0x91 49 50 #define ISL29501_COMMAND_REGISTER 0xB0 51 52 /* Commands */ 53 #define ISL29501_EMUL_SAMPLE_START_PIN 0x49 54 #define ISL29501_RESET_ALL_REGISTERS 0xD7 55 #define ISL29501_RESET_INT_SM 0xD1 56 57 /* Ambiant light and temperature corrections */ 58 #define ISL29501_TEMP_REFERENCE 0x31 59 #define ISL29501_PHASE_EXPONENT 0x33 60 #define ISL29501_TEMP_COEFF_A 0x34 61 #define ISL29501_TEMP_COEFF_B 0x39 62 #define ISL29501_AMBIANT_COEFF_A 0x36 63 #define ISL29501_AMBIANT_COEFF_B 0x3B 64 65 /* Data output registers */ 66 #define ISL29501_DISTANCE_MSB_DATA 0xD1 67 #define ISL29501_DISTANCE_LSB_DATA 0xD2 68 #define ISL29501_PRECISION_MSB 0xD3 69 #define ISL29501_PRECISION_LSB 0xD4 70 #define ISL29501_MAGNITUDE_EXPONENT 0xD5 71 #define ISL29501_MAGNITUDE_MSB 0xD6 72 #define ISL29501_MAGNITUDE_LSB 0xD7 73 #define ISL29501_PHASE_MSB 0xD8 74 #define ISL29501_PHASE_LSB 0xD9 75 #define ISL29501_I_RAW_EXPONENT 0xDA 76 #define ISL29501_I_RAW_MSB 0xDB 77 #define ISL29501_I_RAW_LSB 0xDC 78 #define ISL29501_Q_RAW_EXPONENT 0xDD 79 #define ISL29501_Q_RAW_MSB 0xDE 80 #define ISL29501_Q_RAW_LSB 0xDF 81 #define ISL29501_DIE_TEMPERATURE 0xE2 82 #define ISL29501_AMBIENT_LIGHT 0xE3 83 #define ISL29501_GAIN_MSB 0xE6 84 #define ISL29501_GAIN_LSB 0xE7 85 86 #define ISL29501_MAX_EXP_VAL 15 87 88 #define ISL29501_INT_TIME_AVAILABLE \ 89 "0.00007 0.00014 0.00028 0.00057 0.00114 " \ 90 "0.00228 0.00455 0.00910 0.01820 0.03640 " \ 91 "0.07281 0.14561" 92 93 #define ISL29501_CURRENT_SCALE_AVAILABLE \ 94 "0.0039 0.0078 0.0118 0.0157 0.0196 " \ 95 "0.0235 0.0275 0.0314 0.0352 0.0392 " \ 96 "0.0431 0.0471 0.0510 0.0549 0.0588" 97 98 enum isl29501_correction_coeff { 99 COEFF_TEMP_A, 100 COEFF_TEMP_B, 101 COEFF_LIGHT_A, 102 COEFF_LIGHT_B, 103 COEFF_MAX, 104 }; 105 106 struct isl29501_private { 107 struct i2c_client *client; 108 struct mutex lock; 109 /* Exact representation of correction coefficients. */ 110 unsigned int shadow_coeffs[COEFF_MAX]; 111 }; 112 113 enum isl29501_register_name { 114 REG_DISTANCE, 115 REG_PHASE, 116 REG_TEMPERATURE, 117 REG_AMBIENT_LIGHT, 118 REG_GAIN, 119 REG_GAIN_BIAS, 120 REG_PHASE_EXP, 121 REG_CALIB_PHASE_TEMP_A, 122 REG_CALIB_PHASE_TEMP_B, 123 REG_CALIB_PHASE_LIGHT_A, 124 REG_CALIB_PHASE_LIGHT_B, 125 REG_DISTANCE_BIAS, 126 REG_TEMPERATURE_BIAS, 127 REG_INT_TIME, 128 REG_SAMPLE_TIME, 129 REG_DRIVER_RANGE, 130 REG_EMITTER_DAC, 131 }; 132 133 struct isl29501_register_desc { 134 u8 msb; 135 u8 lsb; 136 }; 137 138 static const struct isl29501_register_desc isl29501_registers[] = { 139 [REG_DISTANCE] = { 140 .msb = ISL29501_DISTANCE_MSB_DATA, 141 .lsb = ISL29501_DISTANCE_LSB_DATA, 142 }, 143 [REG_PHASE] = { 144 .msb = ISL29501_PHASE_MSB, 145 .lsb = ISL29501_PHASE_LSB, 146 }, 147 [REG_TEMPERATURE] = { 148 .lsb = ISL29501_DIE_TEMPERATURE, 149 }, 150 [REG_AMBIENT_LIGHT] = { 151 .lsb = ISL29501_AMBIENT_LIGHT, 152 }, 153 [REG_GAIN] = { 154 .msb = ISL29501_GAIN_MSB, 155 .lsb = ISL29501_GAIN_LSB, 156 }, 157 [REG_GAIN_BIAS] = { 158 .msb = ISL29501_CROSSTALK_GAIN_MSB, 159 .lsb = ISL29501_CROSSTALK_GAIN_LSB, 160 }, 161 [REG_PHASE_EXP] = { 162 .lsb = ISL29501_PHASE_EXPONENT, 163 }, 164 [REG_CALIB_PHASE_TEMP_A] = { 165 .lsb = ISL29501_TEMP_COEFF_A, 166 }, 167 [REG_CALIB_PHASE_TEMP_B] = { 168 .lsb = ISL29501_TEMP_COEFF_B, 169 }, 170 [REG_CALIB_PHASE_LIGHT_A] = { 171 .lsb = ISL29501_AMBIANT_COEFF_A, 172 }, 173 [REG_CALIB_PHASE_LIGHT_B] = { 174 .lsb = ISL29501_AMBIANT_COEFF_B, 175 }, 176 [REG_DISTANCE_BIAS] = { 177 .msb = ISL29501_PHASE_OFFSET_MSB, 178 .lsb = ISL29501_PHASE_OFFSET_LSB, 179 }, 180 [REG_TEMPERATURE_BIAS] = { 181 .lsb = ISL29501_TEMP_REFERENCE, 182 }, 183 [REG_INT_TIME] = { 184 .lsb = ISL29501_INTEGRATION_PERIOD, 185 }, 186 [REG_SAMPLE_TIME] = { 187 .lsb = ISL29501_SAMPLE_PERIOD, 188 }, 189 [REG_DRIVER_RANGE] = { 190 .lsb = ISL29501_DRIVER_RANGE, 191 }, 192 [REG_EMITTER_DAC] = { 193 .lsb = ISL29501_EMITTER_DAC, 194 }, 195 }; 196 197 static int isl29501_register_read(struct isl29501_private *isl29501, 198 enum isl29501_register_name name, 199 u32 *val) 200 { 201 const struct isl29501_register_desc *reg = &isl29501_registers[name]; 202 u8 msb = 0, lsb = 0; 203 s32 ret; 204 205 mutex_lock(&isl29501->lock); 206 if (reg->msb) { 207 ret = i2c_smbus_read_byte_data(isl29501->client, reg->msb); 208 if (ret < 0) 209 goto err; 210 msb = ret; 211 } 212 213 if (reg->lsb) { 214 ret = i2c_smbus_read_byte_data(isl29501->client, reg->lsb); 215 if (ret < 0) 216 goto err; 217 lsb = ret; 218 } 219 mutex_unlock(&isl29501->lock); 220 221 *val = (msb << 8) + lsb; 222 223 return 0; 224 err: 225 mutex_unlock(&isl29501->lock); 226 227 return ret; 228 } 229 230 static u32 isl29501_register_write(struct isl29501_private *isl29501, 231 enum isl29501_register_name name, 232 u32 value) 233 { 234 const struct isl29501_register_desc *reg = &isl29501_registers[name]; 235 u8 msb, lsb; 236 int ret; 237 238 if (!reg->msb && value > U8_MAX) 239 return -ERANGE; 240 241 if (value > U16_MAX) 242 return -ERANGE; 243 244 if (!reg->msb) { 245 lsb = value & 0xFF; 246 } else { 247 msb = (value >> 8) & 0xFF; 248 lsb = value & 0xFF; 249 } 250 251 mutex_lock(&isl29501->lock); 252 if (reg->msb) { 253 ret = i2c_smbus_write_byte_data(isl29501->client, 254 reg->msb, msb); 255 if (ret < 0) 256 goto err; 257 } 258 259 ret = i2c_smbus_write_byte_data(isl29501->client, reg->lsb, lsb); 260 261 err: 262 mutex_unlock(&isl29501->lock); 263 return ret; 264 } 265 266 static ssize_t isl29501_read_ext(struct iio_dev *indio_dev, 267 uintptr_t private, 268 const struct iio_chan_spec *chan, 269 char *buf) 270 { 271 struct isl29501_private *isl29501 = iio_priv(indio_dev); 272 enum isl29501_register_name reg = private; 273 int ret; 274 u32 value, gain, coeff, exp; 275 276 switch (reg) { 277 case REG_GAIN: 278 case REG_GAIN_BIAS: 279 ret = isl29501_register_read(isl29501, reg, &gain); 280 if (ret < 0) 281 return ret; 282 283 value = gain; 284 break; 285 case REG_CALIB_PHASE_TEMP_A: 286 case REG_CALIB_PHASE_TEMP_B: 287 case REG_CALIB_PHASE_LIGHT_A: 288 case REG_CALIB_PHASE_LIGHT_B: 289 ret = isl29501_register_read(isl29501, REG_PHASE_EXP, &exp); 290 if (ret < 0) 291 return ret; 292 293 ret = isl29501_register_read(isl29501, reg, &coeff); 294 if (ret < 0) 295 return ret; 296 297 value = coeff << exp; 298 break; 299 default: 300 return -EINVAL; 301 } 302 303 return sprintf(buf, "%u\n", value); 304 } 305 306 static int isl29501_set_shadow_coeff(struct isl29501_private *isl29501, 307 enum isl29501_register_name reg, 308 unsigned int val) 309 { 310 enum isl29501_correction_coeff coeff; 311 312 switch (reg) { 313 case REG_CALIB_PHASE_TEMP_A: 314 coeff = COEFF_TEMP_A; 315 break; 316 case REG_CALIB_PHASE_TEMP_B: 317 coeff = COEFF_TEMP_B; 318 break; 319 case REG_CALIB_PHASE_LIGHT_A: 320 coeff = COEFF_LIGHT_A; 321 break; 322 case REG_CALIB_PHASE_LIGHT_B: 323 coeff = COEFF_LIGHT_B; 324 break; 325 default: 326 return -EINVAL; 327 } 328 isl29501->shadow_coeffs[coeff] = val; 329 330 return 0; 331 } 332 333 static int isl29501_write_coeff(struct isl29501_private *isl29501, 334 enum isl29501_correction_coeff coeff, 335 int val) 336 { 337 enum isl29501_register_name reg; 338 339 switch (coeff) { 340 case COEFF_TEMP_A: 341 reg = REG_CALIB_PHASE_TEMP_A; 342 break; 343 case COEFF_TEMP_B: 344 reg = REG_CALIB_PHASE_TEMP_B; 345 break; 346 case COEFF_LIGHT_A: 347 reg = REG_CALIB_PHASE_LIGHT_A; 348 break; 349 case COEFF_LIGHT_B: 350 reg = REG_CALIB_PHASE_LIGHT_B; 351 break; 352 default: 353 return -EINVAL; 354 } 355 356 return isl29501_register_write(isl29501, reg, val); 357 } 358 359 static unsigned int isl29501_find_corr_exp(unsigned int val, 360 unsigned int max_exp, 361 unsigned int max_mantissa) 362 { 363 unsigned int exp = 1; 364 365 /* 366 * Correction coefficients are represented under 367 * mantissa * 2^exponent form, where mantissa and exponent 368 * are stored in two separate registers of the sensor. 369 * 370 * Compute and return the lowest exponent such as: 371 * mantissa = value / 2^exponent 372 * 373 * where mantissa < max_mantissa. 374 */ 375 if (val <= max_mantissa) 376 return 0; 377 378 while ((val >> exp) > max_mantissa) { 379 exp++; 380 381 if (exp > max_exp) 382 return max_exp; 383 } 384 385 return exp; 386 } 387 388 static ssize_t isl29501_write_ext(struct iio_dev *indio_dev, 389 uintptr_t private, 390 const struct iio_chan_spec *chan, 391 const char *buf, size_t len) 392 { 393 struct isl29501_private *isl29501 = iio_priv(indio_dev); 394 enum isl29501_register_name reg = private; 395 unsigned int val; 396 int max_exp = 0; 397 int ret; 398 int i; 399 400 ret = kstrtouint(buf, 10, &val); 401 if (ret) 402 return ret; 403 404 switch (reg) { 405 case REG_GAIN_BIAS: 406 if (val > U16_MAX) 407 return -ERANGE; 408 409 ret = isl29501_register_write(isl29501, reg, val); 410 if (ret < 0) 411 return ret; 412 413 break; 414 case REG_CALIB_PHASE_TEMP_A: 415 case REG_CALIB_PHASE_TEMP_B: 416 case REG_CALIB_PHASE_LIGHT_A: 417 case REG_CALIB_PHASE_LIGHT_B: 418 419 if (val > (U8_MAX << ISL29501_MAX_EXP_VAL)) 420 return -ERANGE; 421 422 /* Store the correction coefficient under its exact form. */ 423 ret = isl29501_set_shadow_coeff(isl29501, reg, val); 424 if (ret < 0) 425 return ret; 426 427 /* 428 * Find the highest exponent needed to represent 429 * correction coefficients. 430 */ 431 for (i = 0; i < COEFF_MAX; i++) { 432 int corr; 433 int corr_exp; 434 435 corr = isl29501->shadow_coeffs[i]; 436 corr_exp = isl29501_find_corr_exp(corr, 437 ISL29501_MAX_EXP_VAL, 438 U8_MAX / 2); 439 dev_dbg(&isl29501->client->dev, 440 "found exp of corr(%d) = %d\n", corr, corr_exp); 441 442 max_exp = max(max_exp, corr_exp); 443 } 444 445 /* 446 * Represent every correction coefficient under 447 * mantissa * 2^max_exponent form and force the 448 * writing of those coefficients on the sensor. 449 */ 450 for (i = 0; i < COEFF_MAX; i++) { 451 int corr; 452 int mantissa; 453 454 corr = isl29501->shadow_coeffs[i]; 455 if (!corr) 456 continue; 457 458 mantissa = corr >> max_exp; 459 460 ret = isl29501_write_coeff(isl29501, i, mantissa); 461 if (ret < 0) 462 return ret; 463 } 464 465 ret = isl29501_register_write(isl29501, REG_PHASE_EXP, max_exp); 466 if (ret < 0) 467 return ret; 468 469 break; 470 default: 471 return -EINVAL; 472 } 473 474 return len; 475 } 476 477 #define _ISL29501_EXT_INFO(_name, _ident) { \ 478 .name = _name, \ 479 .read = isl29501_read_ext, \ 480 .write = isl29501_write_ext, \ 481 .private = _ident, \ 482 .shared = IIO_SEPARATE, \ 483 } 484 485 static const struct iio_chan_spec_ext_info isl29501_ext_info[] = { 486 _ISL29501_EXT_INFO("agc_gain", REG_GAIN), 487 _ISL29501_EXT_INFO("agc_gain_bias", REG_GAIN_BIAS), 488 _ISL29501_EXT_INFO("calib_phase_temp_a", REG_CALIB_PHASE_TEMP_A), 489 _ISL29501_EXT_INFO("calib_phase_temp_b", REG_CALIB_PHASE_TEMP_B), 490 _ISL29501_EXT_INFO("calib_phase_light_a", REG_CALIB_PHASE_LIGHT_A), 491 _ISL29501_EXT_INFO("calib_phase_light_b", REG_CALIB_PHASE_LIGHT_B), 492 { }, 493 }; 494 495 #define ISL29501_DISTANCE_SCAN_INDEX 0 496 #define ISL29501_TIMESTAMP_SCAN_INDEX 1 497 498 static const struct iio_chan_spec isl29501_channels[] = { 499 { 500 .type = IIO_PROXIMITY, 501 .scan_index = ISL29501_DISTANCE_SCAN_INDEX, 502 .info_mask_separate = 503 BIT(IIO_CHAN_INFO_RAW) | 504 BIT(IIO_CHAN_INFO_SCALE) | 505 BIT(IIO_CHAN_INFO_CALIBBIAS), 506 .scan_type = { 507 .sign = 'u', 508 .realbits = 16, 509 .storagebits = 16, 510 .endianness = IIO_CPU, 511 }, 512 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | 513 BIT(IIO_CHAN_INFO_SAMP_FREQ), 514 .ext_info = isl29501_ext_info, 515 }, 516 { 517 .type = IIO_PHASE, 518 .scan_index = -1, 519 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 520 BIT(IIO_CHAN_INFO_SCALE), 521 }, 522 { 523 .type = IIO_CURRENT, 524 .scan_index = -1, 525 .output = 1, 526 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 527 BIT(IIO_CHAN_INFO_SCALE), 528 }, 529 { 530 .type = IIO_TEMP, 531 .scan_index = -1, 532 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 533 BIT(IIO_CHAN_INFO_SCALE) | 534 BIT(IIO_CHAN_INFO_CALIBBIAS), 535 }, 536 { 537 .type = IIO_INTENSITY, 538 .scan_index = -1, 539 .modified = 1, 540 .channel2 = IIO_MOD_LIGHT_CLEAR, 541 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 542 BIT(IIO_CHAN_INFO_SCALE), 543 }, 544 IIO_CHAN_SOFT_TIMESTAMP(ISL29501_TIMESTAMP_SCAN_INDEX), 545 }; 546 547 static int isl29501_reset_registers(struct isl29501_private *isl29501) 548 { 549 int ret; 550 551 ret = i2c_smbus_write_byte_data(isl29501->client, 552 ISL29501_COMMAND_REGISTER, 553 ISL29501_RESET_ALL_REGISTERS); 554 if (ret < 0) { 555 dev_err(&isl29501->client->dev, 556 "cannot reset registers %d\n", ret); 557 return ret; 558 } 559 560 ret = i2c_smbus_write_byte_data(isl29501->client, 561 ISL29501_COMMAND_REGISTER, 562 ISL29501_RESET_INT_SM); 563 if (ret < 0) 564 dev_err(&isl29501->client->dev, 565 "cannot reset state machine %d\n", ret); 566 567 return ret; 568 } 569 570 static int isl29501_begin_acquisition(struct isl29501_private *isl29501) 571 { 572 int ret; 573 574 ret = i2c_smbus_write_byte_data(isl29501->client, 575 ISL29501_COMMAND_REGISTER, 576 ISL29501_EMUL_SAMPLE_START_PIN); 577 if (ret < 0) 578 dev_err(&isl29501->client->dev, 579 "cannot begin acquisition %d\n", ret); 580 581 return ret; 582 } 583 584 static IIO_CONST_ATTR_INT_TIME_AVAIL(ISL29501_INT_TIME_AVAILABLE); 585 static IIO_CONST_ATTR(out_current_scale_available, 586 ISL29501_CURRENT_SCALE_AVAILABLE); 587 588 static struct attribute *isl29501_attributes[] = { 589 &iio_const_attr_integration_time_available.dev_attr.attr, 590 &iio_const_attr_out_current_scale_available.dev_attr.attr, 591 NULL 592 }; 593 594 static const struct attribute_group isl29501_attribute_group = { 595 .attrs = isl29501_attributes, 596 }; 597 598 static const int isl29501_current_scale_table[][2] = { 599 {0, 3900}, {0, 7800}, {0, 11800}, {0, 15700}, 600 {0, 19600}, {0, 23500}, {0, 27500}, {0, 31400}, 601 {0, 35200}, {0, 39200}, {0, 43100}, {0, 47100}, 602 {0, 51000}, {0, 54900}, {0, 58800}, 603 }; 604 605 static const int isl29501_int_time[][2] = { 606 {0, 70}, /* 0.07 ms */ 607 {0, 140}, /* 0.14 ms */ 608 {0, 280}, /* 0.28 ms */ 609 {0, 570}, /* 0.57 ms */ 610 {0, 1140}, /* 1.14 ms */ 611 {0, 2280}, /* 2.28 ms */ 612 {0, 4550}, /* 4.55 ms */ 613 {0, 9100}, /* 9.11 ms */ 614 {0, 18200}, /* 18.2 ms */ 615 {0, 36400}, /* 36.4 ms */ 616 {0, 72810}, /* 72.81 ms */ 617 {0, 145610} /* 145.28 ms */ 618 }; 619 620 static int isl29501_get_raw(struct isl29501_private *isl29501, 621 const struct iio_chan_spec *chan, 622 int *raw) 623 { 624 int ret; 625 626 switch (chan->type) { 627 case IIO_PROXIMITY: 628 ret = isl29501_register_read(isl29501, REG_DISTANCE, raw); 629 if (ret < 0) 630 return ret; 631 632 return IIO_VAL_INT; 633 case IIO_INTENSITY: 634 ret = isl29501_register_read(isl29501, 635 REG_AMBIENT_LIGHT, 636 raw); 637 if (ret < 0) 638 return ret; 639 640 return IIO_VAL_INT; 641 case IIO_PHASE: 642 ret = isl29501_register_read(isl29501, REG_PHASE, raw); 643 if (ret < 0) 644 return ret; 645 646 return IIO_VAL_INT; 647 case IIO_CURRENT: 648 ret = isl29501_register_read(isl29501, REG_EMITTER_DAC, raw); 649 if (ret < 0) 650 return ret; 651 652 return IIO_VAL_INT; 653 case IIO_TEMP: 654 ret = isl29501_register_read(isl29501, REG_TEMPERATURE, raw); 655 if (ret < 0) 656 return ret; 657 658 return IIO_VAL_INT; 659 default: 660 return -EINVAL; 661 } 662 } 663 664 static int isl29501_get_scale(struct isl29501_private *isl29501, 665 const struct iio_chan_spec *chan, 666 int *val, int *val2) 667 { 668 int ret; 669 u32 current_scale; 670 671 switch (chan->type) { 672 case IIO_PROXIMITY: 673 /* distance = raw_distance * 33.31 / 65536 (m) */ 674 *val = 3331; 675 *val2 = 6553600; 676 677 return IIO_VAL_FRACTIONAL; 678 case IIO_PHASE: 679 /* phase = raw_phase * 2pi / 65536 (rad) */ 680 *val = 0; 681 *val2 = 95874; 682 683 return IIO_VAL_INT_PLUS_NANO; 684 case IIO_INTENSITY: 685 /* light = raw_light * 35 / 10000 (mA) */ 686 *val = 35; 687 *val2 = 10000; 688 689 return IIO_VAL_FRACTIONAL; 690 case IIO_CURRENT: 691 ret = isl29501_register_read(isl29501, 692 REG_DRIVER_RANGE, 693 ¤t_scale); 694 if (ret < 0) 695 return ret; 696 697 if (current_scale > ARRAY_SIZE(isl29501_current_scale_table)) 698 return -EINVAL; 699 700 if (!current_scale) { 701 *val = 0; 702 *val2 = 0; 703 return IIO_VAL_INT; 704 } 705 706 *val = isl29501_current_scale_table[current_scale - 1][0]; 707 *val2 = isl29501_current_scale_table[current_scale - 1][1]; 708 709 return IIO_VAL_INT_PLUS_MICRO; 710 case IIO_TEMP: 711 /* temperature = raw_temperature * 125 / 100000 (milli °C) */ 712 *val = 125; 713 *val2 = 100000; 714 715 return IIO_VAL_FRACTIONAL; 716 default: 717 return -EINVAL; 718 } 719 } 720 721 static int isl29501_get_calibbias(struct isl29501_private *isl29501, 722 const struct iio_chan_spec *chan, 723 int *bias) 724 { 725 switch (chan->type) { 726 case IIO_PROXIMITY: 727 return isl29501_register_read(isl29501, 728 REG_DISTANCE_BIAS, 729 bias); 730 case IIO_TEMP: 731 return isl29501_register_read(isl29501, 732 REG_TEMPERATURE_BIAS, 733 bias); 734 default: 735 return -EINVAL; 736 } 737 } 738 739 static int isl29501_get_inttime(struct isl29501_private *isl29501, 740 int *val, int *val2) 741 { 742 int ret; 743 u32 inttime; 744 745 ret = isl29501_register_read(isl29501, REG_INT_TIME, &inttime); 746 if (ret < 0) 747 return ret; 748 749 if (inttime >= ARRAY_SIZE(isl29501_int_time)) 750 return -EINVAL; 751 752 *val = isl29501_int_time[inttime][0]; 753 *val2 = isl29501_int_time[inttime][1]; 754 755 return IIO_VAL_INT_PLUS_MICRO; 756 } 757 758 static int isl29501_get_freq(struct isl29501_private *isl29501, 759 int *val, int *val2) 760 { 761 int ret; 762 int sample_time; 763 unsigned long long freq; 764 u32 temp; 765 766 ret = isl29501_register_read(isl29501, REG_SAMPLE_TIME, &sample_time); 767 if (ret < 0) 768 return ret; 769 770 /* freq = 1 / (0.000450 * (sample_time + 1) * 10^-6) */ 771 freq = 1000000ULL * 1000000ULL; 772 773 do_div(freq, 450 * (sample_time + 1)); 774 775 temp = do_div(freq, 1000000); 776 *val = freq; 777 *val2 = temp; 778 779 return IIO_VAL_INT_PLUS_MICRO; 780 } 781 782 static int isl29501_read_raw(struct iio_dev *indio_dev, 783 struct iio_chan_spec const *chan, int *val, 784 int *val2, long mask) 785 { 786 struct isl29501_private *isl29501 = iio_priv(indio_dev); 787 788 switch (mask) { 789 case IIO_CHAN_INFO_RAW: 790 return isl29501_get_raw(isl29501, chan, val); 791 case IIO_CHAN_INFO_SCALE: 792 return isl29501_get_scale(isl29501, chan, val, val2); 793 case IIO_CHAN_INFO_INT_TIME: 794 return isl29501_get_inttime(isl29501, val, val2); 795 case IIO_CHAN_INFO_SAMP_FREQ: 796 return isl29501_get_freq(isl29501, val, val2); 797 case IIO_CHAN_INFO_CALIBBIAS: 798 return isl29501_get_calibbias(isl29501, chan, val); 799 default: 800 return -EINVAL; 801 } 802 } 803 804 static int isl29501_set_raw(struct isl29501_private *isl29501, 805 const struct iio_chan_spec *chan, 806 int raw) 807 { 808 switch (chan->type) { 809 case IIO_CURRENT: 810 return isl29501_register_write(isl29501, REG_EMITTER_DAC, raw); 811 default: 812 return -EINVAL; 813 } 814 } 815 816 static int isl29501_set_inttime(struct isl29501_private *isl29501, 817 int val, int val2) 818 { 819 int i; 820 821 for (i = 0; i < ARRAY_SIZE(isl29501_int_time); i++) { 822 if (isl29501_int_time[i][0] == val && 823 isl29501_int_time[i][1] == val2) { 824 return isl29501_register_write(isl29501, 825 REG_INT_TIME, 826 i); 827 } 828 } 829 830 return -EINVAL; 831 } 832 833 static int isl29501_set_scale(struct isl29501_private *isl29501, 834 const struct iio_chan_spec *chan, 835 int val, int val2) 836 { 837 int i; 838 839 if (chan->type != IIO_CURRENT) 840 return -EINVAL; 841 842 for (i = 0; i < ARRAY_SIZE(isl29501_current_scale_table); i++) { 843 if (isl29501_current_scale_table[i][0] == val && 844 isl29501_current_scale_table[i][1] == val2) { 845 return isl29501_register_write(isl29501, 846 REG_DRIVER_RANGE, 847 i + 1); 848 } 849 } 850 851 return -EINVAL; 852 } 853 854 static int isl29501_set_calibbias(struct isl29501_private *isl29501, 855 const struct iio_chan_spec *chan, 856 int bias) 857 { 858 switch (chan->type) { 859 case IIO_PROXIMITY: 860 return isl29501_register_write(isl29501, 861 REG_DISTANCE_BIAS, 862 bias); 863 case IIO_TEMP: 864 return isl29501_register_write(isl29501, 865 REG_TEMPERATURE_BIAS, 866 bias); 867 default: 868 return -EINVAL; 869 } 870 } 871 872 static int isl29501_set_freq(struct isl29501_private *isl29501, 873 int val, int val2) 874 { 875 int freq; 876 unsigned long long sample_time; 877 878 /* sample_freq = 1 / (0.000450 * (sample_time + 1) * 10^-6) */ 879 freq = val * 1000000 + val2 % 1000000; 880 sample_time = 2222ULL * 1000000ULL; 881 do_div(sample_time, freq); 882 883 sample_time -= 1; 884 885 if (sample_time > 255) 886 return -ERANGE; 887 888 return isl29501_register_write(isl29501, REG_SAMPLE_TIME, sample_time); 889 } 890 891 static int isl29501_write_raw(struct iio_dev *indio_dev, 892 struct iio_chan_spec const *chan, 893 int val, int val2, long mask) 894 { 895 struct isl29501_private *isl29501 = iio_priv(indio_dev); 896 897 switch (mask) { 898 case IIO_CHAN_INFO_RAW: 899 return isl29501_set_raw(isl29501, chan, val); 900 case IIO_CHAN_INFO_INT_TIME: 901 return isl29501_set_inttime(isl29501, val, val2); 902 case IIO_CHAN_INFO_SAMP_FREQ: 903 return isl29501_set_freq(isl29501, val, val2); 904 case IIO_CHAN_INFO_SCALE: 905 return isl29501_set_scale(isl29501, chan, val, val2); 906 case IIO_CHAN_INFO_CALIBBIAS: 907 return isl29501_set_calibbias(isl29501, chan, val); 908 default: 909 return -EINVAL; 910 } 911 } 912 913 static const struct iio_info isl29501_info = { 914 .read_raw = &isl29501_read_raw, 915 .write_raw = &isl29501_write_raw, 916 .attrs = &isl29501_attribute_group, 917 }; 918 919 static int isl29501_init_chip(struct isl29501_private *isl29501) 920 { 921 int ret; 922 923 ret = i2c_smbus_read_byte_data(isl29501->client, ISL29501_DEVICE_ID); 924 if (ret < 0) { 925 dev_err(&isl29501->client->dev, "Error reading device id\n"); 926 return ret; 927 } 928 929 if (ret != ISL29501_ID) { 930 dev_err(&isl29501->client->dev, 931 "Wrong chip id, got %x expected %x\n", 932 ret, ISL29501_DEVICE_ID); 933 return -ENODEV; 934 } 935 936 ret = isl29501_reset_registers(isl29501); 937 if (ret < 0) 938 return ret; 939 940 return isl29501_begin_acquisition(isl29501); 941 } 942 943 static irqreturn_t isl29501_trigger_handler(int irq, void *p) 944 { 945 struct iio_poll_func *pf = p; 946 struct iio_dev *indio_dev = pf->indio_dev; 947 struct isl29501_private *isl29501 = iio_priv(indio_dev); 948 const unsigned long *active_mask = indio_dev->active_scan_mask; 949 u32 buffer[4] = {}; /* 1x16-bit + ts */ 950 951 if (test_bit(ISL29501_DISTANCE_SCAN_INDEX, active_mask)) 952 isl29501_register_read(isl29501, REG_DISTANCE, buffer); 953 954 iio_push_to_buffers_with_timestamp(indio_dev, buffer, pf->timestamp); 955 iio_trigger_notify_done(indio_dev->trig); 956 957 return IRQ_HANDLED; 958 } 959 960 static int isl29501_probe(struct i2c_client *client, 961 const struct i2c_device_id *id) 962 { 963 struct iio_dev *indio_dev; 964 struct isl29501_private *isl29501; 965 int ret; 966 967 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*isl29501)); 968 if (!indio_dev) 969 return -ENOMEM; 970 971 isl29501 = iio_priv(indio_dev); 972 973 i2c_set_clientdata(client, indio_dev); 974 isl29501->client = client; 975 976 mutex_init(&isl29501->lock); 977 978 ret = isl29501_init_chip(isl29501); 979 if (ret < 0) 980 return ret; 981 982 indio_dev->modes = INDIO_DIRECT_MODE; 983 indio_dev->dev.parent = &client->dev; 984 indio_dev->channels = isl29501_channels; 985 indio_dev->num_channels = ARRAY_SIZE(isl29501_channels); 986 indio_dev->name = client->name; 987 indio_dev->info = &isl29501_info; 988 989 ret = devm_iio_triggered_buffer_setup(&client->dev, indio_dev, 990 iio_pollfunc_store_time, 991 isl29501_trigger_handler, 992 NULL); 993 if (ret < 0) { 994 dev_err(&client->dev, "unable to setup iio triggered buffer\n"); 995 return ret; 996 } 997 998 return devm_iio_device_register(&client->dev, indio_dev); 999 } 1000 1001 static const struct i2c_device_id isl29501_id[] = { 1002 {"isl29501", 0}, 1003 {} 1004 }; 1005 1006 MODULE_DEVICE_TABLE(i2c, isl29501_id); 1007 1008 #if defined(CONFIG_OF) 1009 static const struct of_device_id isl29501_i2c_matches[] = { 1010 { .compatible = "renesas,isl29501" }, 1011 { } 1012 }; 1013 MODULE_DEVICE_TABLE(of, isl29501_i2c_matches); 1014 #endif 1015 1016 static struct i2c_driver isl29501_driver = { 1017 .driver = { 1018 .name = "isl29501", 1019 }, 1020 .id_table = isl29501_id, 1021 .probe = isl29501_probe, 1022 }; 1023 module_i2c_driver(isl29501_driver); 1024 1025 MODULE_AUTHOR("Mathieu Othacehe <m.othacehe@gmail.com>"); 1026 MODULE_DESCRIPTION("ISL29501 Time of Flight sensor driver"); 1027 MODULE_LICENSE("GPL v2"); 1028