1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * max44009.c - Support for MAX44009 Ambient Light Sensor
4 *
5 * Copyright (c) 2019 Robert Eshleman <bobbyeshleman@gmail.com>
6 *
7 * Datasheet: https://datasheets.maximintegrated.com/en/ds/MAX44009.pdf
8 *
9 * TODO: Support continuous mode and configuring from manual mode to
10 * automatic mode.
11 *
12 * Default I2C address: 0x4a
13 */
14
15 #include <linux/init.h>
16 #include <linux/kernel.h>
17 #include <linux/bits.h>
18 #include <linux/i2c.h>
19 #include <linux/iio/events.h>
20 #include <linux/iio/iio.h>
21 #include <linux/iio/sysfs.h>
22 #include <linux/interrupt.h>
23 #include <linux/module.h>
24 #include <linux/util_macros.h>
25
26 #define MAX44009_DRV_NAME "max44009"
27
28 /* Registers in datasheet order */
29 #define MAX44009_REG_INT_STATUS 0x0
30 #define MAX44009_REG_INT_EN 0x1
31 #define MAX44009_REG_CFG 0x2
32 #define MAX44009_REG_LUX_HI 0x3
33 #define MAX44009_REG_LUX_LO 0x4
34 #define MAX44009_REG_UPPER_THR 0x5
35 #define MAX44009_REG_LOWER_THR 0x6
36 #define MAX44009_REG_THR_TIMER 0x7
37
38 #define MAX44009_CFG_TIM_MASK GENMASK(2, 0)
39 #define MAX44009_CFG_MAN_MODE_MASK BIT(6)
40
41 /* The maximum rising threshold for the max44009 */
42 #define MAX44009_MAXIMUM_THRESHOLD 7520256
43
44 #define MAX44009_THRESH_EXP_MASK (0xf << 4)
45 #define MAX44009_THRESH_EXP_RSHIFT 4
46 #define MAX44009_THRESH_MANT_LSHIFT 4
47 #define MAX44009_THRESH_MANT_MASK 0xf
48
49 #define MAX44009_UPPER_THR_MINIMUM 15
50
51 /* The max44009 always scales raw readings by 0.045 and is non-configurable */
52 #define MAX44009_SCALE_NUMERATOR 45
53 #define MAX44009_SCALE_DENOMINATOR 1000
54
55 /* The fixed-point fractional multiplier for de-scaling threshold values */
56 #define MAX44009_FRACT_MULT 1000000
57
58 static const u32 max44009_int_time_ns_array[] = {
59 800000000,
60 400000000,
61 200000000,
62 100000000,
63 50000000, /* Manual mode only */
64 25000000, /* Manual mode only */
65 12500000, /* Manual mode only */
66 6250000, /* Manual mode only */
67 };
68
69 static const char max44009_int_time_str[] =
70 "0.8 "
71 "0.4 "
72 "0.2 "
73 "0.1 "
74 "0.05 "
75 "0.025 "
76 "0.0125 "
77 "0.00625";
78
79 struct max44009_data {
80 struct i2c_client *client;
81 struct mutex lock;
82 };
83
84 static const struct iio_event_spec max44009_event_spec[] = {
85 {
86 .type = IIO_EV_TYPE_THRESH,
87 .dir = IIO_EV_DIR_RISING,
88 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
89 BIT(IIO_EV_INFO_ENABLE),
90 },
91 {
92 .type = IIO_EV_TYPE_THRESH,
93 .dir = IIO_EV_DIR_FALLING,
94 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
95 BIT(IIO_EV_INFO_ENABLE),
96 },
97 };
98
99 static const struct iio_chan_spec max44009_channels[] = {
100 {
101 .type = IIO_LIGHT,
102 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
103 BIT(IIO_CHAN_INFO_INT_TIME),
104 .event_spec = max44009_event_spec,
105 .num_event_specs = ARRAY_SIZE(max44009_event_spec),
106 },
107 };
108
max44009_read_int_time(struct max44009_data * data)109 static int max44009_read_int_time(struct max44009_data *data)
110 {
111
112 int ret = i2c_smbus_read_byte_data(data->client, MAX44009_REG_CFG);
113
114 if (ret < 0)
115 return ret;
116
117 return max44009_int_time_ns_array[ret & MAX44009_CFG_TIM_MASK];
118 }
119
max44009_write_int_time(struct max44009_data * data,int val,int val2)120 static int max44009_write_int_time(struct max44009_data *data,
121 int val, int val2)
122 {
123 struct i2c_client *client = data->client;
124 int ret, int_time, config;
125 s64 ns;
126
127 ns = val * NSEC_PER_SEC + val2;
128 int_time = find_closest_descending(
129 ns,
130 max44009_int_time_ns_array,
131 ARRAY_SIZE(max44009_int_time_ns_array));
132
133 ret = i2c_smbus_read_byte_data(client, MAX44009_REG_CFG);
134 if (ret < 0)
135 return ret;
136
137 config = ret;
138 config &= int_time;
139
140 /*
141 * To set the integration time, the device must also be in manual
142 * mode.
143 */
144 config |= MAX44009_CFG_MAN_MODE_MASK;
145
146 return i2c_smbus_write_byte_data(client, MAX44009_REG_CFG, config);
147 }
148
max44009_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)149 static int max44009_write_raw(struct iio_dev *indio_dev,
150 struct iio_chan_spec const *chan, int val,
151 int val2, long mask)
152 {
153 struct max44009_data *data = iio_priv(indio_dev);
154 int ret;
155
156 if (mask == IIO_CHAN_INFO_INT_TIME && chan->type == IIO_LIGHT) {
157 mutex_lock(&data->lock);
158 ret = max44009_write_int_time(data, val, val2);
159 mutex_unlock(&data->lock);
160 return ret;
161 }
162 return -EINVAL;
163 }
164
max44009_write_raw_get_fmt(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,long mask)165 static int max44009_write_raw_get_fmt(struct iio_dev *indio_dev,
166 struct iio_chan_spec const *chan,
167 long mask)
168 {
169 return IIO_VAL_INT_PLUS_NANO;
170 }
171
max44009_lux_raw(u8 hi,u8 lo)172 static int max44009_lux_raw(u8 hi, u8 lo)
173 {
174 int mantissa;
175 int exponent;
176
177 /*
178 * The mantissa consists of the low nibble of the Lux High Byte
179 * and the low nibble of the Lux Low Byte.
180 */
181 mantissa = ((hi & 0xf) << 4) | (lo & 0xf);
182
183 /* The exponent byte is just the upper nibble of the Lux High Byte */
184 exponent = (hi >> 4) & 0xf;
185
186 /*
187 * The exponent value is base 2 to the power of the raw exponent byte.
188 */
189 exponent = 1 << exponent;
190
191 return exponent * mantissa;
192 }
193
194 #define MAX44009_READ_LUX_XFER_LEN (4)
195
max44009_read_lux_raw(struct max44009_data * data)196 static int max44009_read_lux_raw(struct max44009_data *data)
197 {
198 int ret;
199 u8 hireg = MAX44009_REG_LUX_HI;
200 u8 loreg = MAX44009_REG_LUX_LO;
201 u8 lo = 0;
202 u8 hi = 0;
203
204 struct i2c_msg msgs[] = {
205 {
206 .addr = data->client->addr,
207 .flags = 0,
208 .len = sizeof(hireg),
209 .buf = &hireg,
210 },
211 {
212 .addr = data->client->addr,
213 .flags = I2C_M_RD,
214 .len = sizeof(hi),
215 .buf = &hi,
216 },
217 {
218 .addr = data->client->addr,
219 .flags = 0,
220 .len = sizeof(loreg),
221 .buf = &loreg,
222 },
223 {
224 .addr = data->client->addr,
225 .flags = I2C_M_RD,
226 .len = sizeof(lo),
227 .buf = &lo,
228 }
229 };
230
231 /*
232 * Use i2c_transfer instead of smbus read because i2c_transfer
233 * does NOT use a stop bit between address write and data read.
234 * Using a stop bit causes disjoint upper/lower byte reads and
235 * reduces accuracy.
236 */
237 ret = i2c_transfer(data->client->adapter,
238 msgs, MAX44009_READ_LUX_XFER_LEN);
239
240 if (ret != MAX44009_READ_LUX_XFER_LEN)
241 return -EIO;
242
243 return max44009_lux_raw(hi, lo);
244 }
245
max44009_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)246 static int max44009_read_raw(struct iio_dev *indio_dev,
247 struct iio_chan_spec const *chan, int *val,
248 int *val2, long mask)
249 {
250 struct max44009_data *data = iio_priv(indio_dev);
251 int lux_raw;
252 int ret;
253
254 switch (mask) {
255 case IIO_CHAN_INFO_PROCESSED:
256 switch (chan->type) {
257 case IIO_LIGHT:
258 ret = max44009_read_lux_raw(data);
259 if (ret < 0)
260 return ret;
261 lux_raw = ret;
262
263 *val = lux_raw * MAX44009_SCALE_NUMERATOR;
264 *val2 = MAX44009_SCALE_DENOMINATOR;
265 return IIO_VAL_FRACTIONAL;
266 default:
267 return -EINVAL;
268 }
269 case IIO_CHAN_INFO_INT_TIME:
270 switch (chan->type) {
271 case IIO_LIGHT:
272 ret = max44009_read_int_time(data);
273 if (ret < 0)
274 return ret;
275
276 *val2 = ret;
277 *val = 0;
278 return IIO_VAL_INT_PLUS_NANO;
279 default:
280 return -EINVAL;
281 }
282 default:
283 return -EINVAL;
284 }
285 }
286
287 static IIO_CONST_ATTR(illuminance_integration_time_available,
288 max44009_int_time_str);
289
290 static struct attribute *max44009_attributes[] = {
291 &iio_const_attr_illuminance_integration_time_available.dev_attr.attr,
292 NULL,
293 };
294
295 static const struct attribute_group max44009_attribute_group = {
296 .attrs = max44009_attributes,
297 };
298
max44009_threshold_byte_from_fraction(int integral,int fractional)299 static int max44009_threshold_byte_from_fraction(int integral, int fractional)
300 {
301 int mantissa, exp;
302
303 if ((integral <= 0 && fractional <= 0) ||
304 integral > MAX44009_MAXIMUM_THRESHOLD ||
305 (integral == MAX44009_MAXIMUM_THRESHOLD && fractional != 0))
306 return -EINVAL;
307
308 /* Reverse scaling of fixed-point integral */
309 mantissa = integral * MAX44009_SCALE_DENOMINATOR;
310 mantissa /= MAX44009_SCALE_NUMERATOR;
311
312 /* Reverse scaling of fixed-point fractional */
313 mantissa += fractional / MAX44009_FRACT_MULT *
314 (MAX44009_SCALE_DENOMINATOR / MAX44009_SCALE_NUMERATOR);
315
316 for (exp = 0; mantissa > 0xff; exp++)
317 mantissa >>= 1;
318
319 mantissa >>= 4;
320 mantissa &= 0xf;
321 exp <<= 4;
322
323 return exp | mantissa;
324 }
325
max44009_get_thr_reg(enum iio_event_direction dir)326 static int max44009_get_thr_reg(enum iio_event_direction dir)
327 {
328 switch (dir) {
329 case IIO_EV_DIR_RISING:
330 return MAX44009_REG_UPPER_THR;
331 case IIO_EV_DIR_FALLING:
332 return MAX44009_REG_LOWER_THR;
333 default:
334 return -EINVAL;
335 }
336 }
337
max44009_write_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)338 static int max44009_write_event_value(struct iio_dev *indio_dev,
339 const struct iio_chan_spec *chan,
340 enum iio_event_type type,
341 enum iio_event_direction dir,
342 enum iio_event_info info,
343 int val, int val2)
344 {
345 struct max44009_data *data = iio_priv(indio_dev);
346 int reg, threshold;
347
348 if (info != IIO_EV_INFO_VALUE || chan->type != IIO_LIGHT)
349 return -EINVAL;
350
351 threshold = max44009_threshold_byte_from_fraction(val, val2);
352 if (threshold < 0)
353 return threshold;
354
355 reg = max44009_get_thr_reg(dir);
356 if (reg < 0)
357 return reg;
358
359 return i2c_smbus_write_byte_data(data->client, reg, threshold);
360 }
361
max44009_read_threshold(struct iio_dev * indio_dev,enum iio_event_direction dir)362 static int max44009_read_threshold(struct iio_dev *indio_dev,
363 enum iio_event_direction dir)
364 {
365 struct max44009_data *data = iio_priv(indio_dev);
366 int byte, reg;
367 int mantissa, exponent;
368
369 reg = max44009_get_thr_reg(dir);
370 if (reg < 0)
371 return reg;
372
373 byte = i2c_smbus_read_byte_data(data->client, reg);
374 if (byte < 0)
375 return byte;
376
377 mantissa = byte & MAX44009_THRESH_MANT_MASK;
378 mantissa <<= MAX44009_THRESH_MANT_LSHIFT;
379
380 /*
381 * To get the upper threshold, always adds the minimum upper threshold
382 * value to the shifted byte value (see datasheet).
383 */
384 if (dir == IIO_EV_DIR_RISING)
385 mantissa += MAX44009_UPPER_THR_MINIMUM;
386
387 /*
388 * Exponent is base 2 to the power of the threshold exponent byte
389 * value
390 */
391 exponent = byte & MAX44009_THRESH_EXP_MASK;
392 exponent >>= MAX44009_THRESH_EXP_RSHIFT;
393
394 return (1 << exponent) * mantissa;
395 }
396
max44009_read_event_value(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)397 static int max44009_read_event_value(struct iio_dev *indio_dev,
398 const struct iio_chan_spec *chan,
399 enum iio_event_type type,
400 enum iio_event_direction dir,
401 enum iio_event_info info,
402 int *val, int *val2)
403 {
404 int ret;
405 int threshold;
406
407 if (chan->type != IIO_LIGHT || type != IIO_EV_TYPE_THRESH)
408 return -EINVAL;
409
410 ret = max44009_read_threshold(indio_dev, dir);
411 if (ret < 0)
412 return ret;
413 threshold = ret;
414
415 *val = threshold * MAX44009_SCALE_NUMERATOR;
416 *val2 = MAX44009_SCALE_DENOMINATOR;
417
418 return IIO_VAL_FRACTIONAL;
419 }
420
max44009_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,int state)421 static int max44009_write_event_config(struct iio_dev *indio_dev,
422 const struct iio_chan_spec *chan,
423 enum iio_event_type type,
424 enum iio_event_direction dir,
425 int state)
426 {
427 struct max44009_data *data = iio_priv(indio_dev);
428 int ret;
429
430 if (chan->type != IIO_LIGHT || type != IIO_EV_TYPE_THRESH)
431 return -EINVAL;
432
433 ret = i2c_smbus_write_byte_data(data->client,
434 MAX44009_REG_INT_EN, state);
435 if (ret < 0)
436 return ret;
437
438 /*
439 * Set device to trigger interrupt immediately upon exceeding
440 * the threshold limit.
441 */
442 return i2c_smbus_write_byte_data(data->client,
443 MAX44009_REG_THR_TIMER, 0);
444 }
445
max44009_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)446 static int max44009_read_event_config(struct iio_dev *indio_dev,
447 const struct iio_chan_spec *chan,
448 enum iio_event_type type,
449 enum iio_event_direction dir)
450 {
451 struct max44009_data *data = iio_priv(indio_dev);
452
453 if (chan->type != IIO_LIGHT || type != IIO_EV_TYPE_THRESH)
454 return -EINVAL;
455
456 return i2c_smbus_read_byte_data(data->client, MAX44009_REG_INT_EN);
457 }
458
459 static const struct iio_info max44009_info = {
460 .read_raw = max44009_read_raw,
461 .write_raw = max44009_write_raw,
462 .write_raw_get_fmt = max44009_write_raw_get_fmt,
463 .read_event_value = max44009_read_event_value,
464 .read_event_config = max44009_read_event_config,
465 .write_event_value = max44009_write_event_value,
466 .write_event_config = max44009_write_event_config,
467 .attrs = &max44009_attribute_group,
468 };
469
max44009_threaded_irq_handler(int irq,void * p)470 static irqreturn_t max44009_threaded_irq_handler(int irq, void *p)
471 {
472 struct iio_dev *indio_dev = p;
473 struct max44009_data *data = iio_priv(indio_dev);
474 int ret;
475
476 ret = i2c_smbus_read_byte_data(data->client, MAX44009_REG_INT_STATUS);
477 if (ret) {
478 iio_push_event(indio_dev,
479 IIO_UNMOD_EVENT_CODE(IIO_LIGHT, 0,
480 IIO_EV_TYPE_THRESH,
481 IIO_EV_DIR_EITHER),
482 iio_get_time_ns(indio_dev));
483
484 return IRQ_HANDLED;
485 }
486
487 return IRQ_NONE;
488 }
489
max44009_probe(struct i2c_client * client)490 static int max44009_probe(struct i2c_client *client)
491 {
492 struct max44009_data *data;
493 struct iio_dev *indio_dev;
494 int ret;
495
496 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
497 if (!indio_dev)
498 return -ENOMEM;
499
500 data = iio_priv(indio_dev);
501 i2c_set_clientdata(client, indio_dev);
502 data->client = client;
503 indio_dev->info = &max44009_info;
504 indio_dev->modes = INDIO_DIRECT_MODE;
505 indio_dev->name = MAX44009_DRV_NAME;
506 indio_dev->channels = max44009_channels;
507 indio_dev->num_channels = ARRAY_SIZE(max44009_channels);
508 mutex_init(&data->lock);
509
510 /* Clear any stale interrupt bit */
511 ret = i2c_smbus_read_byte_data(client, MAX44009_REG_CFG);
512 if (ret < 0)
513 return ret;
514
515 if (client->irq > 0) {
516 ret = devm_request_threaded_irq(&client->dev, client->irq,
517 NULL,
518 max44009_threaded_irq_handler,
519 IRQF_TRIGGER_FALLING |
520 IRQF_ONESHOT | IRQF_SHARED,
521 "max44009_event",
522 indio_dev);
523 if (ret < 0)
524 return ret;
525 }
526
527 return devm_iio_device_register(&client->dev, indio_dev);
528 }
529
530 static const struct of_device_id max44009_of_match[] = {
531 { .compatible = "maxim,max44009" },
532 { }
533 };
534 MODULE_DEVICE_TABLE(of, max44009_of_match);
535
536 static const struct i2c_device_id max44009_id[] = {
537 { "max44009", 0 },
538 { }
539 };
540 MODULE_DEVICE_TABLE(i2c, max44009_id);
541
542 static struct i2c_driver max44009_driver = {
543 .driver = {
544 .name = MAX44009_DRV_NAME,
545 .of_match_table = max44009_of_match,
546 },
547 .probe = max44009_probe,
548 .id_table = max44009_id,
549 };
550 module_i2c_driver(max44009_driver);
551
552 MODULE_AUTHOR("Robert Eshleman <bobbyeshleman@gmail.com>");
553 MODULE_LICENSE("GPL v2");
554 MODULE_DESCRIPTION("MAX44009 ambient light sensor driver");
555