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 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 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 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 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 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 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 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 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 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 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 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 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 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 bool 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 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 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 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" }, 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