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