1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * BU27034 ROHM Ambient Light Sensor 4 * 5 * Copyright (c) 2023, ROHM Semiconductor. 6 * https://fscdn.rohm.com/en/products/databook/datasheet/ic/sensor/light/bu27034nuc-e.pdf 7 */ 8 9 #include <linux/bitfield.h> 10 #include <linux/bits.h> 11 #include <linux/device.h> 12 #include <linux/i2c.h> 13 #include <linux/module.h> 14 #include <linux/property.h> 15 #include <linux/regmap.h> 16 #include <linux/regulator/consumer.h> 17 #include <linux/units.h> 18 19 #include <linux/iio/buffer.h> 20 #include <linux/iio/iio.h> 21 #include <linux/iio/iio-gts-helper.h> 22 #include <linux/iio/kfifo_buf.h> 23 24 #define BU27034_REG_SYSTEM_CONTROL 0x40 25 #define BU27034_MASK_SW_RESET BIT(7) 26 #define BU27034_MASK_PART_ID GENMASK(5, 0) 27 #define BU27034_ID 0x19 28 #define BU27034_REG_MODE_CONTROL1 0x41 29 #define BU27034_MASK_MEAS_MODE GENMASK(2, 0) 30 31 #define BU27034_REG_MODE_CONTROL2 0x42 32 #define BU27034_MASK_D01_GAIN GENMASK(7, 3) 33 #define BU27034_MASK_D2_GAIN_HI GENMASK(7, 6) 34 #define BU27034_MASK_D2_GAIN_LO GENMASK(2, 0) 35 36 #define BU27034_REG_MODE_CONTROL3 0x43 37 #define BU27034_REG_MODE_CONTROL4 0x44 38 #define BU27034_MASK_MEAS_EN BIT(0) 39 #define BU27034_MASK_VALID BIT(7) 40 #define BU27034_REG_DATA0_LO 0x50 41 #define BU27034_REG_DATA1_LO 0x52 42 #define BU27034_REG_DATA2_LO 0x54 43 #define BU27034_REG_DATA2_HI 0x55 44 #define BU27034_REG_MANUFACTURER_ID 0x92 45 #define BU27034_REG_MAX BU27034_REG_MANUFACTURER_ID 46 47 /* 48 * The BU27034 does not have interrupt to trigger the data read when a 49 * measurement has finished. Hence we poll the VALID bit in a thread. We will 50 * try to wake the thread BU27034_MEAS_WAIT_PREMATURE_MS milliseconds before 51 * the expected sampling time to prevent the drifting. 52 * 53 * If we constantly wake up a bit too late we would eventually skip a sample. 54 * And because the sleep can't wake up _exactly_ at given time this would be 55 * inevitable even if the sensor clock would be perfectly phase-locked to CPU 56 * clock - which we can't say is the case. 57 * 58 * This is still fragile. No matter how big advance do we have, we will still 59 * risk of losing a sample because things can in a rainy-day scenario be 60 * delayed a lot. Yet, more we reserve the time for polling, more we also lose 61 * the performance by spending cycles polling the register. So, selecting this 62 * value is a balancing dance between severity of wasting CPU time and severity 63 * of losing samples. 64 * 65 * In most cases losing the samples is not _that_ crucial because light levels 66 * tend to change slowly. 67 * 68 * Other option that was pointed to me would be always sleeping 1/2 of the 69 * measurement time, checking the VALID bit and just sleeping again if the bit 70 * was not set. That should be pretty tolerant against missing samples due to 71 * the scheduling delays while also not wasting much of cycles for polling. 72 * Downside is that the time-stamps would be very inaccurate as the wake-up 73 * would not really be tied to the sensor toggling the valid bit. This would also 74 * result 'jumps' in the time-stamps when the delay drifted so that wake-up was 75 * performed during the consecutive wake-ups (Or, when sensor and CPU clocks 76 * were very different and scheduling the wake-ups was very close to given 77 * timeout - and when the time-outs were very close to the actual sensor 78 * sampling, Eg. once in a blue moon, two consecutive time-outs would occur 79 * without having a sample ready). 80 */ 81 #define BU27034_MEAS_WAIT_PREMATURE_MS 5 82 #define BU27034_DATA_WAIT_TIME_US 1000 83 #define BU27034_TOTAL_DATA_WAIT_TIME_US (BU27034_MEAS_WAIT_PREMATURE_MS * 1000) 84 85 #define BU27034_RETRY_LIMIT 18 86 87 enum { 88 BU27034_CHAN_ALS, 89 BU27034_CHAN_DATA0, 90 BU27034_CHAN_DATA1, 91 BU27034_CHAN_DATA2, 92 BU27034_NUM_CHANS 93 }; 94 95 static const unsigned long bu27034_scan_masks[] = { 96 GENMASK(BU27034_CHAN_DATA2, BU27034_CHAN_ALS), 0 97 }; 98 99 /* 100 * Available scales with gain 1x - 4096x, timings 55, 100, 200, 400 mS 101 * Time impacts to gain: 1x, 2x, 4x, 8x. 102 * 103 * => Max total gain is HWGAIN * gain by integration time (8 * 4096) = 32768 104 * 105 * Using NANO precision for scale we must use scale 64x corresponding gain 1x 106 * to avoid precision loss. (32x would result scale 976 562.5(nanos). 107 */ 108 #define BU27034_SCALE_1X 64 109 110 /* See the data sheet for the "Gain Setting" table */ 111 #define BU27034_GSEL_1X 0x00 /* 00000 */ 112 #define BU27034_GSEL_4X 0x08 /* 01000 */ 113 #define BU27034_GSEL_16X 0x0a /* 01010 */ 114 #define BU27034_GSEL_32X 0x0b /* 01011 */ 115 #define BU27034_GSEL_64X 0x0c /* 01100 */ 116 #define BU27034_GSEL_256X 0x18 /* 11000 */ 117 #define BU27034_GSEL_512X 0x19 /* 11001 */ 118 #define BU27034_GSEL_1024X 0x1a /* 11010 */ 119 #define BU27034_GSEL_2048X 0x1b /* 11011 */ 120 #define BU27034_GSEL_4096X 0x1c /* 11100 */ 121 122 /* Available gain settings */ 123 static const struct iio_gain_sel_pair bu27034_gains[] = { 124 GAIN_SCALE_GAIN(1, BU27034_GSEL_1X), 125 GAIN_SCALE_GAIN(4, BU27034_GSEL_4X), 126 GAIN_SCALE_GAIN(16, BU27034_GSEL_16X), 127 GAIN_SCALE_GAIN(32, BU27034_GSEL_32X), 128 GAIN_SCALE_GAIN(64, BU27034_GSEL_64X), 129 GAIN_SCALE_GAIN(256, BU27034_GSEL_256X), 130 GAIN_SCALE_GAIN(512, BU27034_GSEL_512X), 131 GAIN_SCALE_GAIN(1024, BU27034_GSEL_1024X), 132 GAIN_SCALE_GAIN(2048, BU27034_GSEL_2048X), 133 GAIN_SCALE_GAIN(4096, BU27034_GSEL_4096X), 134 }; 135 136 /* 137 * The IC has 5 modes for sampling time. 5 mS mode is exceptional as it limits 138 * the data collection to data0-channel only and cuts the supported range to 139 * 10 bit. It is not supported by the driver. 140 * 141 * "normal" modes are 55, 100, 200 and 400 mS modes - which do have direct 142 * multiplying impact to the register values (similar to gain). 143 * 144 * This means that if meas-mode is changed for example from 400 => 200, 145 * the scale is doubled. Eg, time impact to total gain is x1, x2, x4, x8. 146 */ 147 #define BU27034_MEAS_MODE_100MS 0 148 #define BU27034_MEAS_MODE_55MS 1 149 #define BU27034_MEAS_MODE_200MS 2 150 #define BU27034_MEAS_MODE_400MS 4 151 152 static const struct iio_itime_sel_mul bu27034_itimes[] = { 153 GAIN_SCALE_ITIME_US(400000, BU27034_MEAS_MODE_400MS, 8), 154 GAIN_SCALE_ITIME_US(200000, BU27034_MEAS_MODE_200MS, 4), 155 GAIN_SCALE_ITIME_US(100000, BU27034_MEAS_MODE_100MS, 2), 156 GAIN_SCALE_ITIME_US(55000, BU27034_MEAS_MODE_55MS, 1), 157 }; 158 159 #define BU27034_CHAN_DATA(_name, _ch2) \ 160 { \ 161 .type = IIO_INTENSITY, \ 162 .channel = BU27034_CHAN_##_name, \ 163 .channel2 = (_ch2), \ 164 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 165 BIT(IIO_CHAN_INFO_SCALE), \ 166 .info_mask_separate_available = BIT(IIO_CHAN_INFO_SCALE), \ 167 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME), \ 168 .info_mask_shared_by_all_available = \ 169 BIT(IIO_CHAN_INFO_INT_TIME), \ 170 .address = BU27034_REG_##_name##_LO, \ 171 .scan_index = BU27034_CHAN_##_name, \ 172 .scan_type = { \ 173 .sign = 'u', \ 174 .realbits = 16, \ 175 .storagebits = 16, \ 176 .endianness = IIO_LE, \ 177 }, \ 178 .indexed = 1, \ 179 } 180 181 static const struct iio_chan_spec bu27034_channels[] = { 182 { 183 .type = IIO_LIGHT, 184 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 185 BIT(IIO_CHAN_INFO_SCALE), 186 .channel = BU27034_CHAN_ALS, 187 .scan_index = BU27034_CHAN_ALS, 188 .scan_type = { 189 .sign = 'u', 190 .realbits = 32, 191 .storagebits = 32, 192 .endianness = IIO_CPU, 193 }, 194 }, 195 /* 196 * The BU27034 DATA0 and DATA1 channels are both on the visible light 197 * area (mostly). The data0 sensitivity peaks at 500nm, DATA1 at 600nm. 198 * These wave lengths are pretty much on the border of colours making 199 * these a poor candidates for R/G/B standardization. Hence they're both 200 * marked as clear channels 201 */ 202 BU27034_CHAN_DATA(DATA0, IIO_MOD_LIGHT_CLEAR), 203 BU27034_CHAN_DATA(DATA1, IIO_MOD_LIGHT_CLEAR), 204 BU27034_CHAN_DATA(DATA2, IIO_MOD_LIGHT_IR), 205 IIO_CHAN_SOFT_TIMESTAMP(4), 206 }; 207 208 struct bu27034_data { 209 struct regmap *regmap; 210 struct device *dev; 211 /* 212 * Protect gain and time during scale adjustment and data reading. 213 * Protect measurement enabling/disabling. 214 */ 215 struct mutex mutex; 216 struct iio_gts gts; 217 struct task_struct *task; 218 __le16 raw[3]; 219 struct { 220 u32 mlux; 221 __le16 channels[3]; 222 s64 ts __aligned(8); 223 } scan; 224 }; 225 226 struct bu27034_result { 227 u16 ch0; 228 u16 ch1; 229 u16 ch2; 230 }; 231 232 static const struct regmap_range bu27034_volatile_ranges[] = { 233 { 234 .range_min = BU27034_REG_MODE_CONTROL4, 235 .range_max = BU27034_REG_MODE_CONTROL4, 236 }, { 237 .range_min = BU27034_REG_DATA0_LO, 238 .range_max = BU27034_REG_DATA2_HI, 239 }, 240 }; 241 242 static const struct regmap_access_table bu27034_volatile_regs = { 243 .yes_ranges = &bu27034_volatile_ranges[0], 244 .n_yes_ranges = ARRAY_SIZE(bu27034_volatile_ranges), 245 }; 246 247 static const struct regmap_range bu27034_read_only_ranges[] = { 248 { 249 .range_min = BU27034_REG_DATA0_LO, 250 .range_max = BU27034_REG_DATA2_HI, 251 }, { 252 .range_min = BU27034_REG_MANUFACTURER_ID, 253 .range_max = BU27034_REG_MANUFACTURER_ID, 254 } 255 }; 256 257 static const struct regmap_access_table bu27034_ro_regs = { 258 .no_ranges = &bu27034_read_only_ranges[0], 259 .n_no_ranges = ARRAY_SIZE(bu27034_read_only_ranges), 260 }; 261 262 static const struct regmap_config bu27034_regmap = { 263 .reg_bits = 8, 264 .val_bits = 8, 265 .max_register = BU27034_REG_MAX, 266 .cache_type = REGCACHE_RBTREE, 267 .volatile_table = &bu27034_volatile_regs, 268 .wr_table = &bu27034_ro_regs, 269 }; 270 271 struct bu27034_gain_check { 272 int old_gain; 273 int new_gain; 274 int chan; 275 }; 276 277 static int bu27034_get_gain_sel(struct bu27034_data *data, int chan) 278 { 279 int ret, val; 280 281 switch (chan) { 282 case BU27034_CHAN_DATA0: 283 case BU27034_CHAN_DATA1: 284 { 285 int reg[] = { 286 [BU27034_CHAN_DATA0] = BU27034_REG_MODE_CONTROL2, 287 [BU27034_CHAN_DATA1] = BU27034_REG_MODE_CONTROL3, 288 }; 289 ret = regmap_read(data->regmap, reg[chan], &val); 290 if (ret) 291 return ret; 292 293 return FIELD_GET(BU27034_MASK_D01_GAIN, val); 294 } 295 case BU27034_CHAN_DATA2: 296 { 297 int d2_lo_bits = fls(BU27034_MASK_D2_GAIN_LO); 298 299 ret = regmap_read(data->regmap, BU27034_REG_MODE_CONTROL2, &val); 300 if (ret) 301 return ret; 302 303 /* 304 * The data2 channel gain is composed by 5 non continuous bits 305 * [7:6], [2:0]. Thus when we combine the 5-bit 'selector' 306 * from register value we must right shift the high bits by 3. 307 */ 308 return FIELD_GET(BU27034_MASK_D2_GAIN_HI, val) << d2_lo_bits | 309 FIELD_GET(BU27034_MASK_D2_GAIN_LO, val); 310 } 311 default: 312 return -EINVAL; 313 } 314 } 315 316 static int bu27034_get_gain(struct bu27034_data *data, int chan, int *gain) 317 { 318 int ret, sel; 319 320 ret = bu27034_get_gain_sel(data, chan); 321 if (ret < 0) 322 return ret; 323 324 sel = ret; 325 326 ret = iio_gts_find_gain_by_sel(&data->gts, sel); 327 if (ret < 0) { 328 dev_err(data->dev, "chan %u: unknown gain value 0x%x\n", chan, 329 sel); 330 331 return ret; 332 } 333 334 *gain = ret; 335 336 return 0; 337 } 338 339 static int bu27034_get_int_time(struct bu27034_data *data) 340 { 341 int ret, sel; 342 343 ret = regmap_read(data->regmap, BU27034_REG_MODE_CONTROL1, &sel); 344 if (ret) 345 return ret; 346 347 return iio_gts_find_int_time_by_sel(&data->gts, 348 sel & BU27034_MASK_MEAS_MODE); 349 } 350 351 static int _bu27034_get_scale(struct bu27034_data *data, int channel, int *val, 352 int *val2) 353 { 354 int gain, ret; 355 356 ret = bu27034_get_gain(data, channel, &gain); 357 if (ret) 358 return ret; 359 360 ret = bu27034_get_int_time(data); 361 if (ret < 0) 362 return ret; 363 364 return iio_gts_get_scale(&data->gts, gain, ret, val, val2); 365 } 366 367 static int bu27034_get_scale(struct bu27034_data *data, int channel, int *val, 368 int *val2) 369 { 370 int ret; 371 372 if (channel == BU27034_CHAN_ALS) { 373 *val = 0; 374 *val2 = 1000; 375 return IIO_VAL_INT_PLUS_MICRO; 376 } 377 378 mutex_lock(&data->mutex); 379 ret = _bu27034_get_scale(data, channel, val, val2); 380 mutex_unlock(&data->mutex); 381 if (ret) 382 return ret; 383 384 return IIO_VAL_INT_PLUS_NANO; 385 } 386 387 /* Caller should hold the lock to protect lux reading */ 388 static int bu27034_write_gain_sel(struct bu27034_data *data, int chan, int sel) 389 { 390 static const int reg[] = { 391 [BU27034_CHAN_DATA0] = BU27034_REG_MODE_CONTROL2, 392 [BU27034_CHAN_DATA1] = BU27034_REG_MODE_CONTROL3, 393 }; 394 int mask, val; 395 396 if (chan != BU27034_CHAN_DATA0 && chan != BU27034_CHAN_DATA1) 397 return -EINVAL; 398 399 val = FIELD_PREP(BU27034_MASK_D01_GAIN, sel); 400 401 mask = BU27034_MASK_D01_GAIN; 402 403 if (chan == BU27034_CHAN_DATA0) { 404 /* 405 * We keep the same gain for channel 2 as we set for channel 0 406 * We can't allow them to be individually controlled because 407 * setting one will impact also the other. Also, if we don't 408 * always update both gains we may result unsupported bit 409 * combinations. 410 * 411 * This is not nice but this is yet another place where the 412 * user space must be prepared to surprizes. Namely, see chan 2 413 * gain changed when chan 0 gain is changed. 414 * 415 * This is not fatal for most users though. I don't expect the 416 * channel 2 to be used in any generic cases - the intensity 417 * values provided by the sensor for IR area are not openly 418 * documented. Also, channel 2 is not used for visible light. 419 * 420 * So, if there is application which is written to utilize the 421 * channel 2 - then it is probably specifically targeted to this 422 * sensor and knows how to utilize those values. It is safe to 423 * hope such user can also cope with the gain changes. 424 */ 425 mask |= BU27034_MASK_D2_GAIN_LO; 426 427 /* 428 * The D2 gain bits are directly the lowest bits of selector. 429 * Just do add those bits to the value 430 */ 431 val |= sel & BU27034_MASK_D2_GAIN_LO; 432 } 433 434 return regmap_update_bits(data->regmap, reg[chan], mask, val); 435 } 436 437 static int bu27034_set_gain(struct bu27034_data *data, int chan, int gain) 438 { 439 int ret; 440 441 /* 442 * We don't allow setting channel 2 gain as it messes up the 443 * gain for channel 0 - which shares the high bits 444 */ 445 if (chan != BU27034_CHAN_DATA0 && chan != BU27034_CHAN_DATA1) 446 return -EINVAL; 447 448 ret = iio_gts_find_sel_by_gain(&data->gts, gain); 449 if (ret < 0) 450 return ret; 451 452 return bu27034_write_gain_sel(data, chan, ret); 453 } 454 455 /* Caller should hold the lock to protect data->int_time */ 456 static int bu27034_set_int_time(struct bu27034_data *data, int time) 457 { 458 int ret; 459 460 ret = iio_gts_find_sel_by_int_time(&data->gts, time); 461 if (ret < 0) 462 return ret; 463 464 return regmap_update_bits(data->regmap, BU27034_REG_MODE_CONTROL1, 465 BU27034_MASK_MEAS_MODE, ret); 466 } 467 468 /* 469 * We try to change the time in such way that the scale is maintained for 470 * given channels by adjusting gain so that it compensates the time change. 471 */ 472 static int bu27034_try_set_int_time(struct bu27034_data *data, int time_us) 473 { 474 struct bu27034_gain_check gains[] = { 475 { .chan = BU27034_CHAN_DATA0 }, 476 { .chan = BU27034_CHAN_DATA1 }, 477 }; 478 int numg = ARRAY_SIZE(gains); 479 int ret, int_time_old, i; 480 481 mutex_lock(&data->mutex); 482 ret = bu27034_get_int_time(data); 483 if (ret < 0) 484 goto unlock_out; 485 486 int_time_old = ret; 487 488 if (!iio_gts_valid_time(&data->gts, time_us)) { 489 dev_err(data->dev, "Unsupported integration time %u\n", 490 time_us); 491 ret = -EINVAL; 492 493 goto unlock_out; 494 } 495 496 if (time_us == int_time_old) { 497 ret = 0; 498 goto unlock_out; 499 } 500 501 for (i = 0; i < numg; i++) { 502 ret = bu27034_get_gain(data, gains[i].chan, &gains[i].old_gain); 503 if (ret) 504 goto unlock_out; 505 506 ret = iio_gts_find_new_gain_by_old_gain_time(&data->gts, 507 gains[i].old_gain, 508 int_time_old, time_us, 509 &gains[i].new_gain); 510 if (ret) { 511 int scale1, scale2; 512 bool ok; 513 514 _bu27034_get_scale(data, gains[i].chan, &scale1, &scale2); 515 dev_dbg(data->dev, 516 "chan %u, can't support time %u with scale %u %u\n", 517 gains[i].chan, time_us, scale1, scale2); 518 519 if (gains[i].new_gain < 0) 520 goto unlock_out; 521 522 /* 523 * If caller requests for integration time change and we 524 * can't support the scale - then the caller should be 525 * prepared to 'pick up the pieces and deal with the 526 * fact that the scale changed'. 527 */ 528 ret = iio_find_closest_gain_low(&data->gts, 529 gains[i].new_gain, &ok); 530 531 if (!ok) 532 dev_dbg(data->dev, 533 "optimal gain out of range for chan %u\n", 534 gains[i].chan); 535 536 if (ret < 0) { 537 dev_dbg(data->dev, 538 "Total gain increase. Risk of saturation"); 539 ret = iio_gts_get_min_gain(&data->gts); 540 if (ret < 0) 541 goto unlock_out; 542 } 543 dev_dbg(data->dev, "chan %u scale changed\n", 544 gains[i].chan); 545 gains[i].new_gain = ret; 546 dev_dbg(data->dev, "chan %u new gain %u\n", 547 gains[i].chan, gains[i].new_gain); 548 } 549 } 550 551 for (i = 0; i < numg; i++) { 552 ret = bu27034_set_gain(data, gains[i].chan, gains[i].new_gain); 553 if (ret) 554 goto unlock_out; 555 } 556 557 ret = bu27034_set_int_time(data, time_us); 558 559 unlock_out: 560 mutex_unlock(&data->mutex); 561 562 return ret; 563 } 564 565 static int bu27034_set_scale(struct bu27034_data *data, int chan, 566 int val, int val2) 567 { 568 int ret, time_sel, gain_sel, i; 569 bool found = false; 570 571 if (chan == BU27034_CHAN_DATA2) 572 return -EINVAL; 573 574 if (chan == BU27034_CHAN_ALS) { 575 if (val == 0 && val2 == 1000) 576 return 0; 577 578 return -EINVAL; 579 } 580 581 mutex_lock(&data->mutex); 582 ret = regmap_read(data->regmap, BU27034_REG_MODE_CONTROL1, &time_sel); 583 if (ret) 584 goto unlock_out; 585 586 ret = iio_gts_find_gain_sel_for_scale_using_time(&data->gts, time_sel, 587 val, val2 * 1000, &gain_sel); 588 if (ret) { 589 /* 590 * Could not support scale with given time. Need to change time. 591 * We still want to maintain the scale for all channels 592 */ 593 struct bu27034_gain_check gain; 594 int new_time_sel; 595 596 /* 597 * Populate information for the other channel which should also 598 * maintain the scale. (Due to the HW limitations the chan2 599 * gets the same gain as chan0, so we only need to explicitly 600 * set the chan 0 and 1). 601 */ 602 if (chan == BU27034_CHAN_DATA0) 603 gain.chan = BU27034_CHAN_DATA1; 604 else if (chan == BU27034_CHAN_DATA1) 605 gain.chan = BU27034_CHAN_DATA0; 606 607 ret = bu27034_get_gain(data, gain.chan, &gain.old_gain); 608 if (ret) 609 goto unlock_out; 610 611 /* 612 * Iterate through all the times to see if we find one which 613 * can support requested scale for requested channel, while 614 * maintaining the scale for other channels 615 */ 616 for (i = 0; i < data->gts.num_itime; i++) { 617 new_time_sel = data->gts.itime_table[i].sel; 618 619 if (new_time_sel == time_sel) 620 continue; 621 622 /* Can we provide requested scale with this time? */ 623 ret = iio_gts_find_gain_sel_for_scale_using_time( 624 &data->gts, new_time_sel, val, val2 * 1000, 625 &gain_sel); 626 if (ret) 627 continue; 628 629 /* Can the other channel(s) maintain scale? */ 630 ret = iio_gts_find_new_gain_sel_by_old_gain_time( 631 &data->gts, gain.old_gain, time_sel, 632 new_time_sel, &gain.new_gain); 633 if (!ret) { 634 /* Yes - we found suitable time */ 635 found = true; 636 break; 637 } 638 } 639 if (!found) { 640 dev_dbg(data->dev, 641 "Can't set scale maintaining other channels\n"); 642 ret = -EINVAL; 643 644 goto unlock_out; 645 } 646 647 ret = bu27034_set_gain(data, gain.chan, gain.new_gain); 648 if (ret) 649 goto unlock_out; 650 651 ret = regmap_update_bits(data->regmap, BU27034_REG_MODE_CONTROL1, 652 BU27034_MASK_MEAS_MODE, new_time_sel); 653 if (ret) 654 goto unlock_out; 655 } 656 657 ret = bu27034_write_gain_sel(data, chan, gain_sel); 658 unlock_out: 659 mutex_unlock(&data->mutex); 660 661 return ret; 662 } 663 664 /* 665 * for (D1/D0 < 0.87): 666 * lx = 0.004521097 * D1 - 0.002663996 * D0 + 667 * 0.00012213 * D1 * D1 / D0 668 * 669 * => 115.7400832 * ch1 / gain1 / mt - 670 * 68.1982976 * ch0 / gain0 / mt + 671 * 0.00012213 * 25600 * (ch1 / gain1 / mt) * 25600 * 672 * (ch1 /gain1 / mt) / (25600 * ch0 / gain0 / mt) 673 * 674 * A = 0.00012213 * 25600 * (ch1 /gain1 / mt) * 25600 * 675 * (ch1 /gain1 / mt) / (25600 * ch0 / gain0 / mt) 676 * => 0.00012213 * 25600 * (ch1 /gain1 / mt) * 677 * (ch1 /gain1 / mt) / (ch0 / gain0 / mt) 678 * => 0.00012213 * 25600 * (ch1 / gain1) * (ch1 /gain1 / mt) / 679 * (ch0 / gain0) 680 * => 0.00012213 * 25600 * (ch1 / gain1) * (ch1 /gain1 / mt) * 681 * gain0 / ch0 682 * => 3.126528 * ch1 * ch1 * gain0 / gain1 / gain1 / mt /ch0 683 * 684 * lx = (115.7400832 * ch1 / gain1 - 68.1982976 * ch0 / gain0) / 685 * mt + A 686 * => (115.7400832 * ch1 / gain1 - 68.1982976 * ch0 / gain0) / 687 * mt + 3.126528 * ch1 * ch1 * gain0 / gain1 / gain1 / mt / 688 * ch0 689 * 690 * => (115.7400832 * ch1 / gain1 - 68.1982976 * ch0 / gain0 + 691 * 3.126528 * ch1 * ch1 * gain0 / gain1 / gain1 / ch0) / 692 * mt 693 * 694 * For (0.87 <= D1/D0 < 1.00) 695 * lx = (0.001331* D0 + 0.0000354 * D1) * ((D1/D0 – 0.87) * (0.385) + 1) 696 * => (0.001331 * 256 * 100 * ch0 / gain0 / mt + 0.0000354 * 256 * 697 * 100 * ch1 / gain1 / mt) * ((D1/D0 - 0.87) * (0.385) + 1) 698 * => (34.0736 * ch0 / gain0 / mt + 0.90624 * ch1 / gain1 / mt) * 699 * ((D1/D0 - 0.87) * (0.385) + 1) 700 * => (34.0736 * ch0 / gain0 / mt + 0.90624 * ch1 / gain1 / mt) * 701 * (0.385 * D1/D0 - 0.66505) 702 * => (34.0736 * ch0 / gain0 / mt + 0.90624 * ch1 / gain1 / mt) * 703 * (0.385 * 256 * 100 * ch1 / gain1 / mt / (256 * 100 * ch0 / gain0 / mt) - 0.66505) 704 * => (34.0736 * ch0 / gain0 / mt + 0.90624 * ch1 / gain1 / mt) * 705 * (9856 * ch1 / gain1 / mt / (25600 * ch0 / gain0 / mt) + 0.66505) 706 * => 13.118336 * ch1 / (gain1 * mt) 707 * + 22.66064768 * ch0 / (gain0 * mt) 708 * + 8931.90144 * ch1 * ch1 * gain0 / 709 * (25600 * ch0 * gain1 * gain1 * mt) 710 * + 0.602694912 * ch1 / (gain1 * mt) 711 * 712 * => [0.3489024 * ch1 * ch1 * gain0 / (ch0 * gain1 * gain1) 713 * + 22.66064768 * ch0 / gain0 714 * + 13.721030912 * ch1 / gain1 715 * ] / mt 716 * 717 * For (D1/D0 >= 1.00) 718 * 719 * lx = (0.001331* D0 + 0.0000354 * D1) * ((D1/D0 – 2.0) * (-0.05) + 1) 720 * => (0.001331* D0 + 0.0000354 * D1) * (-0.05D1/D0 + 1.1) 721 * => (0.001331 * 256 * 100 * ch0 / gain0 / mt + 0.0000354 * 256 * 722 * 100 * ch1 / gain1 / mt) * (-0.05D1/D0 + 1.1) 723 * => (34.0736 * ch0 / gain0 / mt + 0.90624 * ch1 / gain1 / mt) * 724 * (-0.05 * 256 * 100 * ch1 / gain1 / mt / (256 * 100 * ch0 / gain0 / mt) + 1.1) 725 * => (34.0736 * ch0 / gain0 / mt + 0.90624 * ch1 / gain1 / mt) * 726 * (-1280 * ch1 / (gain1 * mt * 25600 * ch0 / gain0 / mt) + 1.1) 727 * => (34.0736 * ch0 * -1280 * ch1 * gain0 * mt /( gain0 * mt * gain1 * mt * 25600 * ch0) 728 * + 34.0736 * 1.1 * ch0 / (gain0 * mt) 729 * + 0.90624 * ch1 * -1280 * ch1 *gain0 * mt / (gain1 * mt *gain1 * mt * 25600 * ch0) 730 * + 1.1 * 0.90624 * ch1 / (gain1 * mt) 731 * => -43614.208 * ch1 / (gain1 * mt * 25600) 732 * + 37.48096 ch0 / (gain0 * mt) 733 * - 1159.9872 * ch1 * ch1 * gain0 / (gain1 * gain1 * mt * 25600 * ch0) 734 * + 0.996864 ch1 / (gain1 * mt) 735 * => [ 736 * - 0.045312 * ch1 * ch1 * gain0 / (gain1 * gain1 * ch0) 737 * - 0.706816 * ch1 / gain1 738 * + 37.48096 ch0 /gain0 739 * ] * mt 740 * 741 * 742 * So, the first case (D1/D0 < 0.87) can be computed to a form: 743 * 744 * lx = (3.126528 * ch1 * ch1 * gain0 / (ch0 * gain1 * gain1) + 745 * 115.7400832 * ch1 / gain1 + 746 * -68.1982976 * ch0 / gain0 747 * / mt 748 * 749 * Second case (0.87 <= D1/D0 < 1.00) goes to form: 750 * 751 * => [0.3489024 * ch1 * ch1 * gain0 / (ch0 * gain1 * gain1) + 752 * 13.721030912 * ch1 / gain1 + 753 * 22.66064768 * ch0 / gain0 754 * ] / mt 755 * 756 * Third case (D1/D0 >= 1.00) goes to form: 757 * => [-0.045312 * ch1 * ch1 * gain0 / (ch0 * gain1 * gain1) + 758 * -0.706816 * ch1 / gain1 + 759 * 37.48096 ch0 /(gain0 760 * ] / mt 761 * 762 * This can be unified to format: 763 * lx = [ 764 * A * ch1 * ch1 * gain0 / (ch0 * gain1 * gain1) + 765 * B * ch1 / gain1 + 766 * C * ch0 / gain0 767 * ] / mt 768 * 769 * For case 1: 770 * A = 3.126528, 771 * B = 115.7400832 772 * C = -68.1982976 773 * 774 * For case 2: 775 * A = 0.3489024 776 * B = 13.721030912 777 * C = 22.66064768 778 * 779 * For case 3: 780 * A = -0.045312 781 * B = -0.706816 782 * C = 37.48096 783 */ 784 785 struct bu27034_lx_coeff { 786 unsigned int A; 787 unsigned int B; 788 unsigned int C; 789 /* Indicate which of the coefficients above are negative */ 790 bool is_neg[3]; 791 }; 792 793 static inline u64 gain_mul_div_helper(u64 val, unsigned int gain, 794 unsigned int div) 795 { 796 /* 797 * Max gain for a channel is 4096. The max u64 (0xffffffffffffffffULL) 798 * divided by 4096 is 0xFFFFFFFFFFFFF (GENMASK_ULL(51, 0)) (floored). 799 * Thus, the 0xFFFFFFFFFFFFF is the largest value we can safely multiply 800 * with the gain, no matter what gain is set. 801 * 802 * So, multiplication with max gain may overflow if val is greater than 803 * 0xFFFFFFFFFFFFF (52 bits set).. 804 * 805 * If this is the case we divide first. 806 */ 807 if (val < GENMASK_ULL(51, 0)) { 808 val *= gain; 809 do_div(val, div); 810 } else { 811 do_div(val, div); 812 val *= gain; 813 } 814 815 return val; 816 } 817 818 static u64 bu27034_fixp_calc_t1_64bit(unsigned int coeff, unsigned int ch0, 819 unsigned int ch1, unsigned int gain0, 820 unsigned int gain1) 821 { 822 unsigned int helper; 823 u64 helper64; 824 825 helper64 = (u64)coeff * (u64)ch1 * (u64)ch1; 826 827 helper = gain1 * gain1; 828 if (helper > ch0) { 829 do_div(helper64, helper); 830 831 return gain_mul_div_helper(helper64, gain0, ch0); 832 } 833 834 do_div(helper64, ch0); 835 836 return gain_mul_div_helper(helper64, gain0, helper); 837 838 } 839 840 static u64 bu27034_fixp_calc_t1(unsigned int coeff, unsigned int ch0, 841 unsigned int ch1, unsigned int gain0, 842 unsigned int gain1) 843 { 844 unsigned int helper, tmp; 845 846 /* 847 * Here we could overflow even the 64bit value. Hence we 848 * multiply with gain0 only after the divisions - even though 849 * it may result loss of accuracy 850 */ 851 helper = coeff * ch1 * ch1; 852 tmp = helper * gain0; 853 854 helper = ch1 * ch1; 855 856 if (check_mul_overflow(helper, coeff, &helper)) 857 return bu27034_fixp_calc_t1_64bit(coeff, ch0, ch1, gain0, gain1); 858 859 if (check_mul_overflow(helper, gain0, &tmp)) 860 return bu27034_fixp_calc_t1_64bit(coeff, ch0, ch1, gain0, gain1); 861 862 return tmp / (gain1 * gain1) / ch0; 863 864 } 865 866 static u64 bu27034_fixp_calc_t23(unsigned int coeff, unsigned int ch, 867 unsigned int gain) 868 { 869 unsigned int helper; 870 u64 helper64; 871 872 if (!check_mul_overflow(coeff, ch, &helper)) 873 return helper / gain; 874 875 helper64 = (u64)coeff * (u64)ch; 876 do_div(helper64, gain); 877 878 return helper64; 879 } 880 881 static int bu27034_fixp_calc_lx(unsigned int ch0, unsigned int ch1, 882 unsigned int gain0, unsigned int gain1, 883 unsigned int meastime, int coeff_idx) 884 { 885 static const struct bu27034_lx_coeff coeff[] = { 886 { 887 .A = 31265280, /* 3.126528 */ 888 .B = 1157400832, /*115.7400832 */ 889 .C = 681982976, /* -68.1982976 */ 890 .is_neg = {false, false, true}, 891 }, { 892 .A = 3489024, /* 0.3489024 */ 893 .B = 137210309, /* 13.721030912 */ 894 .C = 226606476, /* 22.66064768 */ 895 /* All terms positive */ 896 }, { 897 .A = 453120, /* -0.045312 */ 898 .B = 7068160, /* -0.706816 */ 899 .C = 374809600, /* 37.48096 */ 900 .is_neg = {true, true, false}, 901 } 902 }; 903 const struct bu27034_lx_coeff *c = &coeff[coeff_idx]; 904 u64 res = 0, terms[3]; 905 int i; 906 907 if (coeff_idx >= ARRAY_SIZE(coeff)) 908 return -EINVAL; 909 910 terms[0] = bu27034_fixp_calc_t1(c->A, ch0, ch1, gain0, gain1); 911 terms[1] = bu27034_fixp_calc_t23(c->B, ch1, gain1); 912 terms[2] = bu27034_fixp_calc_t23(c->C, ch0, gain0); 913 914 /* First, add positive terms */ 915 for (i = 0; i < 3; i++) 916 if (!c->is_neg[i]) 917 res += terms[i]; 918 919 /* No positive term => zero lux */ 920 if (!res) 921 return 0; 922 923 /* Then, subtract negative terms (if any) */ 924 for (i = 0; i < 3; i++) 925 if (c->is_neg[i]) { 926 /* 927 * If the negative term is greater than positive - then 928 * the darkness has taken over and we are all doomed! Eh, 929 * I mean, then we can just return 0 lx and go out 930 */ 931 if (terms[i] >= res) 932 return 0; 933 934 res -= terms[i]; 935 } 936 937 meastime *= 10; 938 do_div(res, meastime); 939 940 return (int) res; 941 } 942 943 static bool bu27034_has_valid_sample(struct bu27034_data *data) 944 { 945 int ret, val; 946 947 ret = regmap_read(data->regmap, BU27034_REG_MODE_CONTROL4, &val); 948 if (ret) { 949 dev_err(data->dev, "Read failed %d\n", ret); 950 951 return false; 952 } 953 954 return val & BU27034_MASK_VALID; 955 } 956 957 /* 958 * Reading the register where VALID bit is clears this bit. (So does changing 959 * any gain / integration time configuration registers) The bit gets 960 * set when we have acquired new data. We use this bit to indicate data 961 * validity. 962 */ 963 static void bu27034_invalidate_read_data(struct bu27034_data *data) 964 { 965 bu27034_has_valid_sample(data); 966 } 967 968 static int bu27034_read_result(struct bu27034_data *data, int chan, int *res) 969 { 970 int reg[] = { 971 [BU27034_CHAN_DATA0] = BU27034_REG_DATA0_LO, 972 [BU27034_CHAN_DATA1] = BU27034_REG_DATA1_LO, 973 [BU27034_CHAN_DATA2] = BU27034_REG_DATA2_LO, 974 }; 975 int valid, ret; 976 __le16 val; 977 978 ret = regmap_read_poll_timeout(data->regmap, BU27034_REG_MODE_CONTROL4, 979 valid, (valid & BU27034_MASK_VALID), 980 BU27034_DATA_WAIT_TIME_US, 0); 981 if (ret) 982 return ret; 983 984 ret = regmap_bulk_read(data->regmap, reg[chan], &val, sizeof(val)); 985 if (ret) 986 return ret; 987 988 *res = le16_to_cpu(val); 989 990 return 0; 991 } 992 993 static int bu27034_get_result_unlocked(struct bu27034_data *data, __le16 *res, 994 int size) 995 { 996 int ret = 0, retry_cnt = 0; 997 998 retry: 999 /* Get new value from sensor if data is ready */ 1000 if (bu27034_has_valid_sample(data)) { 1001 ret = regmap_bulk_read(data->regmap, BU27034_REG_DATA0_LO, 1002 res, size); 1003 if (ret) 1004 return ret; 1005 1006 bu27034_invalidate_read_data(data); 1007 } else { 1008 /* No new data in sensor. Wait and retry */ 1009 retry_cnt++; 1010 1011 if (retry_cnt > BU27034_RETRY_LIMIT) { 1012 dev_err(data->dev, "No data from sensor\n"); 1013 1014 return -ETIMEDOUT; 1015 } 1016 1017 msleep(25); 1018 1019 goto retry; 1020 } 1021 1022 return ret; 1023 } 1024 1025 static int bu27034_meas_set(struct bu27034_data *data, bool en) 1026 { 1027 if (en) 1028 return regmap_set_bits(data->regmap, BU27034_REG_MODE_CONTROL4, 1029 BU27034_MASK_MEAS_EN); 1030 1031 return regmap_clear_bits(data->regmap, BU27034_REG_MODE_CONTROL4, 1032 BU27034_MASK_MEAS_EN); 1033 } 1034 1035 static int bu27034_get_single_result(struct bu27034_data *data, int chan, 1036 int *val) 1037 { 1038 int ret; 1039 1040 if (chan < BU27034_CHAN_DATA0 || chan > BU27034_CHAN_DATA2) 1041 return -EINVAL; 1042 1043 ret = bu27034_meas_set(data, true); 1044 if (ret) 1045 return ret; 1046 1047 ret = bu27034_get_int_time(data); 1048 if (ret < 0) 1049 return ret; 1050 1051 msleep(ret / 1000); 1052 1053 return bu27034_read_result(data, chan, val); 1054 } 1055 1056 /* 1057 * The formula given by vendor for computing luxes out of data0 and data1 1058 * (in open air) is as follows: 1059 * 1060 * Let's mark: 1061 * D0 = data0/ch0_gain/meas_time_ms * 25600 1062 * D1 = data1/ch1_gain/meas_time_ms * 25600 1063 * 1064 * Then: 1065 * if (D1/D0 < 0.87) 1066 * lx = (0.001331 * D0 + 0.0000354 * D1) * ((D1 / D0 - 0.87) * 3.45 + 1) 1067 * else if (D1/D0 < 1) 1068 * lx = (0.001331 * D0 + 0.0000354 * D1) * ((D1 / D0 - 0.87) * 0.385 + 1) 1069 * else 1070 * lx = (0.001331 * D0 + 0.0000354 * D1) * ((D1 / D0 - 2) * -0.05 + 1) 1071 * 1072 * We use it here. Users who have for example some colored lens 1073 * need to modify the calculation but I hope this gives a starting point for 1074 * those working with such devices. 1075 */ 1076 1077 static int bu27034_calc_mlux(struct bu27034_data *data, __le16 *res, int *val) 1078 { 1079 unsigned int gain0, gain1, meastime; 1080 unsigned int d1_d0_ratio_scaled; 1081 u16 ch0, ch1; 1082 u64 helper64; 1083 int ret; 1084 1085 /* 1086 * We return 0 lux if calculation fails. This should be reasonably 1087 * easy to spot from the buffers especially if raw-data channels show 1088 * valid values 1089 */ 1090 *val = 0; 1091 1092 ch0 = max_t(u16, 1, le16_to_cpu(res[0])); 1093 ch1 = max_t(u16, 1, le16_to_cpu(res[1])); 1094 1095 ret = bu27034_get_gain(data, BU27034_CHAN_DATA0, &gain0); 1096 if (ret) 1097 return ret; 1098 1099 ret = bu27034_get_gain(data, BU27034_CHAN_DATA1, &gain1); 1100 if (ret) 1101 return ret; 1102 1103 ret = bu27034_get_int_time(data); 1104 if (ret < 0) 1105 return ret; 1106 1107 meastime = ret; 1108 1109 d1_d0_ratio_scaled = (unsigned int)ch1 * (unsigned int)gain0 * 100; 1110 helper64 = (u64)ch1 * (u64)gain0 * 100LLU; 1111 1112 if (helper64 != d1_d0_ratio_scaled) { 1113 unsigned int div = (unsigned int)ch0 * gain1; 1114 1115 do_div(helper64, div); 1116 d1_d0_ratio_scaled = helper64; 1117 } else { 1118 d1_d0_ratio_scaled /= ch0 * gain1; 1119 } 1120 1121 if (d1_d0_ratio_scaled < 87) 1122 ret = bu27034_fixp_calc_lx(ch0, ch1, gain0, gain1, meastime, 0); 1123 else if (d1_d0_ratio_scaled < 100) 1124 ret = bu27034_fixp_calc_lx(ch0, ch1, gain0, gain1, meastime, 1); 1125 else 1126 ret = bu27034_fixp_calc_lx(ch0, ch1, gain0, gain1, meastime, 2); 1127 1128 if (ret < 0) 1129 return ret; 1130 1131 *val = ret; 1132 1133 return 0; 1134 1135 } 1136 1137 static int bu27034_get_mlux(struct bu27034_data *data, int chan, int *val) 1138 { 1139 __le16 res[3]; 1140 int ret; 1141 1142 ret = bu27034_meas_set(data, true); 1143 if (ret) 1144 return ret; 1145 1146 ret = bu27034_get_result_unlocked(data, &res[0], sizeof(res)); 1147 if (ret) 1148 return ret; 1149 1150 ret = bu27034_calc_mlux(data, res, val); 1151 if (ret) 1152 return ret; 1153 1154 ret = bu27034_meas_set(data, false); 1155 if (ret) 1156 dev_err(data->dev, "failed to disable measurement\n"); 1157 1158 return 0; 1159 } 1160 1161 static int bu27034_read_raw(struct iio_dev *idev, 1162 struct iio_chan_spec const *chan, 1163 int *val, int *val2, long mask) 1164 { 1165 struct bu27034_data *data = iio_priv(idev); 1166 int ret; 1167 1168 switch (mask) { 1169 case IIO_CHAN_INFO_INT_TIME: 1170 *val = bu27034_get_int_time(data); 1171 if (*val < 0) 1172 return *val; 1173 1174 return IIO_VAL_INT; 1175 1176 case IIO_CHAN_INFO_SCALE: 1177 return bu27034_get_scale(data, chan->channel, val, val2); 1178 1179 case IIO_CHAN_INFO_RAW: 1180 { 1181 int (*result_get)(struct bu27034_data *data, int chan, int *val); 1182 1183 if (chan->type == IIO_INTENSITY) 1184 result_get = bu27034_get_single_result; 1185 else if (chan->type == IIO_LIGHT) 1186 result_get = bu27034_get_mlux; 1187 else 1188 return -EINVAL; 1189 1190 /* Don't mess with measurement enabling while buffering */ 1191 ret = iio_device_claim_direct_mode(idev); 1192 if (ret) 1193 return ret; 1194 1195 mutex_lock(&data->mutex); 1196 /* 1197 * Reading one channel at a time is inefficient but we 1198 * don't care here. Buffered version should be used if 1199 * performance is an issue. 1200 */ 1201 ret = result_get(data, chan->channel, val); 1202 1203 mutex_unlock(&data->mutex); 1204 iio_device_release_direct_mode(idev); 1205 1206 if (ret) 1207 return ret; 1208 1209 return IIO_VAL_INT; 1210 } 1211 default: 1212 return -EINVAL; 1213 } 1214 } 1215 1216 static int bu27034_write_raw(struct iio_dev *idev, 1217 struct iio_chan_spec const *chan, 1218 int val, int val2, long mask) 1219 { 1220 struct bu27034_data *data = iio_priv(idev); 1221 int ret; 1222 1223 ret = iio_device_claim_direct_mode(idev); 1224 if (ret) 1225 return ret; 1226 1227 switch (mask) { 1228 case IIO_CHAN_INFO_SCALE: 1229 ret = bu27034_set_scale(data, chan->channel, val, val2); 1230 break; 1231 case IIO_CHAN_INFO_INT_TIME: 1232 ret = bu27034_try_set_int_time(data, val); 1233 break; 1234 default: 1235 ret = -EINVAL; 1236 break; 1237 } 1238 1239 iio_device_release_direct_mode(idev); 1240 1241 return ret; 1242 } 1243 1244 static int bu27034_read_avail(struct iio_dev *idev, 1245 struct iio_chan_spec const *chan, const int **vals, 1246 int *type, int *length, long mask) 1247 { 1248 struct bu27034_data *data = iio_priv(idev); 1249 1250 switch (mask) { 1251 case IIO_CHAN_INFO_INT_TIME: 1252 return iio_gts_avail_times(&data->gts, vals, type, length); 1253 case IIO_CHAN_INFO_SCALE: 1254 return iio_gts_all_avail_scales(&data->gts, vals, type, length); 1255 default: 1256 return -EINVAL; 1257 } 1258 } 1259 1260 static const struct iio_info bu27034_info = { 1261 .read_raw = &bu27034_read_raw, 1262 .write_raw = &bu27034_write_raw, 1263 .read_avail = &bu27034_read_avail, 1264 }; 1265 1266 static int bu27034_chip_init(struct bu27034_data *data) 1267 { 1268 int ret, sel; 1269 1270 /* Reset */ 1271 ret = regmap_update_bits(data->regmap, BU27034_REG_SYSTEM_CONTROL, 1272 BU27034_MASK_SW_RESET, BU27034_MASK_SW_RESET); 1273 if (ret) 1274 return dev_err_probe(data->dev, ret, "Sensor reset failed\n"); 1275 1276 msleep(1); 1277 /* 1278 * Read integration time here to ensure it is in regmap cache. We do 1279 * this to speed-up the int-time acquisition in the start of the buffer 1280 * handling thread where longer delays could make it more likely we end 1281 * up skipping a sample, and where the longer delays make timestamps 1282 * less accurate. 1283 */ 1284 ret = regmap_read(data->regmap, BU27034_REG_MODE_CONTROL1, &sel); 1285 if (ret) 1286 dev_err(data->dev, "reading integration time failed\n"); 1287 1288 return 0; 1289 } 1290 1291 static int bu27034_wait_for_data(struct bu27034_data *data) 1292 { 1293 int ret, val; 1294 1295 ret = regmap_read_poll_timeout(data->regmap, BU27034_REG_MODE_CONTROL4, 1296 val, val & BU27034_MASK_VALID, 1297 BU27034_DATA_WAIT_TIME_US, 1298 BU27034_TOTAL_DATA_WAIT_TIME_US); 1299 if (ret) { 1300 dev_err(data->dev, "data polling %s\n", 1301 !(val & BU27034_MASK_VALID) ? "timeout" : "fail"); 1302 1303 return ret; 1304 } 1305 1306 ret = regmap_bulk_read(data->regmap, BU27034_REG_DATA0_LO, 1307 &data->scan.channels[0], 1308 sizeof(data->scan.channels)); 1309 if (ret) 1310 return ret; 1311 1312 bu27034_invalidate_read_data(data); 1313 1314 return 0; 1315 } 1316 1317 static int bu27034_buffer_thread(void *arg) 1318 { 1319 struct iio_dev *idev = arg; 1320 struct bu27034_data *data; 1321 int wait_ms; 1322 1323 data = iio_priv(idev); 1324 1325 wait_ms = bu27034_get_int_time(data); 1326 wait_ms /= 1000; 1327 1328 wait_ms -= BU27034_MEAS_WAIT_PREMATURE_MS; 1329 1330 while (!kthread_should_stop()) { 1331 int ret; 1332 int64_t tstamp; 1333 1334 msleep(wait_ms); 1335 ret = bu27034_wait_for_data(data); 1336 if (ret) 1337 continue; 1338 1339 tstamp = iio_get_time_ns(idev); 1340 1341 if (test_bit(BU27034_CHAN_ALS, idev->active_scan_mask)) { 1342 int mlux; 1343 1344 ret = bu27034_calc_mlux(data, &data->scan.channels[0], 1345 &mlux); 1346 if (ret) 1347 dev_err(data->dev, "failed to calculate lux\n"); 1348 1349 /* 1350 * The maximum Milli lux value we get with gain 1x time 1351 * 55mS data ch0 = 0xffff ch1 = 0xffff fits in 26 bits 1352 * so there should be no problem returning int from 1353 * computations and casting it to u32 1354 */ 1355 data->scan.mlux = (u32)mlux; 1356 } 1357 iio_push_to_buffers_with_timestamp(idev, &data->scan, tstamp); 1358 } 1359 1360 return 0; 1361 } 1362 1363 static int bu27034_buffer_enable(struct iio_dev *idev) 1364 { 1365 struct bu27034_data *data = iio_priv(idev); 1366 struct task_struct *task; 1367 int ret; 1368 1369 mutex_lock(&data->mutex); 1370 ret = bu27034_meas_set(data, true); 1371 if (ret) 1372 goto unlock_out; 1373 1374 task = kthread_run(bu27034_buffer_thread, idev, 1375 "bu27034-buffering-%u", 1376 iio_device_id(idev)); 1377 if (IS_ERR(task)) { 1378 ret = PTR_ERR(task); 1379 goto unlock_out; 1380 } 1381 1382 data->task = task; 1383 1384 unlock_out: 1385 mutex_unlock(&data->mutex); 1386 1387 return ret; 1388 } 1389 1390 static int bu27034_buffer_disable(struct iio_dev *idev) 1391 { 1392 struct bu27034_data *data = iio_priv(idev); 1393 int ret; 1394 1395 mutex_lock(&data->mutex); 1396 if (data->task) { 1397 kthread_stop(data->task); 1398 data->task = NULL; 1399 } 1400 1401 ret = bu27034_meas_set(data, false); 1402 mutex_unlock(&data->mutex); 1403 1404 return ret; 1405 } 1406 1407 static const struct iio_buffer_setup_ops bu27034_buffer_ops = { 1408 .postenable = &bu27034_buffer_enable, 1409 .predisable = &bu27034_buffer_disable, 1410 }; 1411 1412 static int bu27034_probe(struct i2c_client *i2c) 1413 { 1414 struct device *dev = &i2c->dev; 1415 struct bu27034_data *data; 1416 struct regmap *regmap; 1417 struct iio_dev *idev; 1418 unsigned int part_id, reg; 1419 int ret; 1420 1421 regmap = devm_regmap_init_i2c(i2c, &bu27034_regmap); 1422 if (IS_ERR(regmap)) 1423 return dev_err_probe(dev, PTR_ERR(regmap), 1424 "Failed to initialize Regmap\n"); 1425 1426 idev = devm_iio_device_alloc(dev, sizeof(*data)); 1427 if (!idev) 1428 return -ENOMEM; 1429 1430 ret = devm_regulator_get_enable(dev, "vdd"); 1431 if (ret) 1432 return dev_err_probe(dev, ret, "Failed to get regulator\n"); 1433 1434 data = iio_priv(idev); 1435 1436 ret = regmap_read(regmap, BU27034_REG_SYSTEM_CONTROL, ®); 1437 if (ret) 1438 return dev_err_probe(dev, ret, "Failed to access sensor\n"); 1439 1440 part_id = FIELD_GET(BU27034_MASK_PART_ID, reg); 1441 1442 if (part_id != BU27034_ID) 1443 dev_warn(dev, "unknown device 0x%x\n", part_id); 1444 1445 ret = devm_iio_init_iio_gts(dev, BU27034_SCALE_1X, 0, bu27034_gains, 1446 ARRAY_SIZE(bu27034_gains), bu27034_itimes, 1447 ARRAY_SIZE(bu27034_itimes), &data->gts); 1448 if (ret) 1449 return ret; 1450 1451 mutex_init(&data->mutex); 1452 data->regmap = regmap; 1453 data->dev = dev; 1454 1455 idev->channels = bu27034_channels; 1456 idev->num_channels = ARRAY_SIZE(bu27034_channels); 1457 idev->name = "bu27034"; 1458 idev->info = &bu27034_info; 1459 1460 idev->modes = INDIO_DIRECT_MODE | INDIO_BUFFER_SOFTWARE; 1461 idev->available_scan_masks = bu27034_scan_masks; 1462 1463 ret = bu27034_chip_init(data); 1464 if (ret) 1465 return ret; 1466 1467 ret = devm_iio_kfifo_buffer_setup(dev, idev, &bu27034_buffer_ops); 1468 if (ret) 1469 return dev_err_probe(dev, ret, "buffer setup failed\n"); 1470 1471 ret = devm_iio_device_register(dev, idev); 1472 if (ret < 0) 1473 return dev_err_probe(dev, ret, 1474 "Unable to register iio device\n"); 1475 1476 return ret; 1477 } 1478 1479 static const struct of_device_id bu27034_of_match[] = { 1480 { .compatible = "rohm,bu27034" }, 1481 { } 1482 }; 1483 MODULE_DEVICE_TABLE(of, bu27034_of_match); 1484 1485 static struct i2c_driver bu27034_i2c_driver = { 1486 .driver = { 1487 .name = "bu27034-als", 1488 .of_match_table = bu27034_of_match, 1489 }, 1490 .probe_new = bu27034_probe, 1491 }; 1492 module_i2c_driver(bu27034_i2c_driver); 1493 1494 MODULE_LICENSE("GPL"); 1495 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>"); 1496 MODULE_DESCRIPTION("ROHM BU27034 ambient light sensor driver"); 1497 MODULE_IMPORT_NS(IIO_GTS_HELPER); 1498