1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * si1133.c - Support for Silabs SI1133 combined ambient 4 * light and UV index sensors 5 * 6 * Copyright 2018 Maxime Roussin-Belanger <maxime.roussinbelanger@gmail.com> 7 */ 8 9 #include <linux/delay.h> 10 #include <linux/i2c.h> 11 #include <linux/interrupt.h> 12 #include <linux/module.h> 13 #include <linux/regmap.h> 14 15 #include <linux/iio/iio.h> 16 #include <linux/iio/sysfs.h> 17 18 #include <linux/util_macros.h> 19 20 #define SI1133_REG_PART_ID 0x00 21 #define SI1133_REG_REV_ID 0x01 22 #define SI1133_REG_MFR_ID 0x02 23 #define SI1133_REG_INFO0 0x03 24 #define SI1133_REG_INFO1 0x04 25 26 #define SI1133_PART_ID 0x33 27 28 #define SI1133_REG_HOSTIN0 0x0A 29 #define SI1133_REG_COMMAND 0x0B 30 #define SI1133_REG_IRQ_ENABLE 0x0F 31 #define SI1133_REG_RESPONSE1 0x10 32 #define SI1133_REG_RESPONSE0 0x11 33 #define SI1133_REG_IRQ_STATUS 0x12 34 #define SI1133_REG_MEAS_RATE 0x1A 35 36 #define SI1133_IRQ_CHANNEL_ENABLE 0xF 37 38 #define SI1133_CMD_RESET_CTR 0x00 39 #define SI1133_CMD_RESET_SW 0x01 40 #define SI1133_CMD_FORCE 0x11 41 #define SI1133_CMD_START_AUTONOMOUS 0x13 42 #define SI1133_CMD_PARAM_SET 0x80 43 #define SI1133_CMD_PARAM_QUERY 0x40 44 #define SI1133_CMD_PARAM_MASK 0x3F 45 46 #define SI1133_CMD_ERR_MASK BIT(4) 47 #define SI1133_CMD_SEQ_MASK 0xF 48 #define SI1133_MAX_CMD_CTR 0xF 49 50 #define SI1133_PARAM_REG_CHAN_LIST 0x01 51 #define SI1133_PARAM_REG_ADCCONFIG(x) ((x) * 4) + 2 52 #define SI1133_PARAM_REG_ADCSENS(x) ((x) * 4) + 3 53 #define SI1133_PARAM_REG_ADCPOST(x) ((x) * 4) + 4 54 55 #define SI1133_ADCMUX_MASK 0x1F 56 57 #define SI1133_ADCCONFIG_DECIM_RATE(x) (x) << 5 58 59 #define SI1133_ADCSENS_SCALE_MASK 0x70 60 #define SI1133_ADCSENS_SCALE_SHIFT 4 61 #define SI1133_ADCSENS_HSIG_MASK BIT(7) 62 #define SI1133_ADCSENS_HSIG_SHIFT 7 63 #define SI1133_ADCSENS_HW_GAIN_MASK 0xF 64 #define SI1133_ADCSENS_NB_MEAS(x) fls(x) << SI1133_ADCSENS_SCALE_SHIFT 65 66 #define SI1133_ADCPOST_24BIT_EN BIT(6) 67 #define SI1133_ADCPOST_POSTSHIFT_BITQTY(x) (x & GENMASK(2, 0)) << 3 68 69 #define SI1133_PARAM_ADCMUX_SMALL_IR 0x0 70 #define SI1133_PARAM_ADCMUX_MED_IR 0x1 71 #define SI1133_PARAM_ADCMUX_LARGE_IR 0x2 72 #define SI1133_PARAM_ADCMUX_WHITE 0xB 73 #define SI1133_PARAM_ADCMUX_LARGE_WHITE 0xD 74 #define SI1133_PARAM_ADCMUX_UV 0x18 75 #define SI1133_PARAM_ADCMUX_UV_DEEP 0x19 76 77 #define SI1133_ERR_INVALID_CMD 0x0 78 #define SI1133_ERR_INVALID_LOCATION_CMD 0x1 79 #define SI1133_ERR_SATURATION_ADC_OR_OVERFLOW_ACCUMULATION 0x2 80 #define SI1133_ERR_OUTPUT_BUFFER_OVERFLOW 0x3 81 82 #define SI1133_COMPLETION_TIMEOUT_MS 500 83 84 #define SI1133_CMD_MINSLEEP_US_LOW 5000 85 #define SI1133_CMD_MINSLEEP_US_HIGH 7500 86 #define SI1133_CMD_TIMEOUT_MS 25 87 #define SI1133_CMD_LUX_TIMEOUT_MS 5000 88 #define SI1133_CMD_TIMEOUT_US SI1133_CMD_TIMEOUT_MS * 1000 89 90 #define SI1133_REG_HOSTOUT(x) (x) + 0x13 91 92 #define SI1133_MEASUREMENT_FREQUENCY 1250 93 94 #define SI1133_X_ORDER_MASK 0x0070 95 #define SI1133_Y_ORDER_MASK 0x0007 96 #define si1133_get_x_order(m) ((m) & SI1133_X_ORDER_MASK) >> 4 97 #define si1133_get_y_order(m) ((m) & SI1133_Y_ORDER_MASK) 98 99 #define SI1133_LUX_ADC_MASK 0xE 100 #define SI1133_ADC_THRESHOLD 16000 101 #define SI1133_INPUT_FRACTION_HIGH 7 102 #define SI1133_INPUT_FRACTION_LOW 15 103 #define SI1133_LUX_OUTPUT_FRACTION 12 104 #define SI1133_LUX_BUFFER_SIZE 9 105 #define SI1133_MEASURE_BUFFER_SIZE 3 106 107 #define SI1133_SIGN_BIT_INDEX 23 108 109 static const int si1133_scale_available[] = { 110 1, 2, 4, 8, 16, 32, 64, 128}; 111 112 static IIO_CONST_ATTR(scale_available, "1 2 4 8 16 32 64 128"); 113 114 static IIO_CONST_ATTR_INT_TIME_AVAIL("0.0244 0.0488 0.0975 0.195 0.390 0.780 " 115 "1.560 3.120 6.24 12.48 25.0 50.0"); 116 117 /* A.K.A. HW_GAIN in datasheet */ 118 enum si1133_int_time { 119 _24_4_us = 0, 120 _48_8_us = 1, 121 _97_5_us = 2, 122 _195_0_us = 3, 123 _390_0_us = 4, 124 _780_0_us = 5, 125 _1_560_0_us = 6, 126 _3_120_0_us = 7, 127 _6_240_0_us = 8, 128 _12_480_0_us = 9, 129 _25_ms = 10, 130 _50_ms = 11, 131 }; 132 133 /* Integration time in milliseconds, nanoseconds */ 134 static const int si1133_int_time_table[][2] = { 135 [_24_4_us] = {0, 24400}, 136 [_48_8_us] = {0, 48800}, 137 [_97_5_us] = {0, 97500}, 138 [_195_0_us] = {0, 195000}, 139 [_390_0_us] = {0, 390000}, 140 [_780_0_us] = {0, 780000}, 141 [_1_560_0_us] = {1, 560000}, 142 [_3_120_0_us] = {3, 120000}, 143 [_6_240_0_us] = {6, 240000}, 144 [_12_480_0_us] = {12, 480000}, 145 [_25_ms] = {25, 000000}, 146 [_50_ms] = {50, 000000}, 147 }; 148 149 static const struct regmap_range si1133_reg_ranges[] = { 150 regmap_reg_range(0x00, 0x02), 151 regmap_reg_range(0x0A, 0x0B), 152 regmap_reg_range(0x0F, 0x0F), 153 regmap_reg_range(0x10, 0x12), 154 regmap_reg_range(0x13, 0x2C), 155 }; 156 157 static const struct regmap_range si1133_reg_ro_ranges[] = { 158 regmap_reg_range(0x00, 0x02), 159 regmap_reg_range(0x10, 0x2C), 160 }; 161 162 static const struct regmap_range si1133_precious_ranges[] = { 163 regmap_reg_range(0x12, 0x12), 164 }; 165 166 static const struct regmap_access_table si1133_write_ranges_table = { 167 .yes_ranges = si1133_reg_ranges, 168 .n_yes_ranges = ARRAY_SIZE(si1133_reg_ranges), 169 .no_ranges = si1133_reg_ro_ranges, 170 .n_no_ranges = ARRAY_SIZE(si1133_reg_ro_ranges), 171 }; 172 173 static const struct regmap_access_table si1133_read_ranges_table = { 174 .yes_ranges = si1133_reg_ranges, 175 .n_yes_ranges = ARRAY_SIZE(si1133_reg_ranges), 176 }; 177 178 static const struct regmap_access_table si1133_precious_table = { 179 .yes_ranges = si1133_precious_ranges, 180 .n_yes_ranges = ARRAY_SIZE(si1133_precious_ranges), 181 }; 182 183 static const struct regmap_config si1133_regmap_config = { 184 .reg_bits = 8, 185 .val_bits = 8, 186 187 .max_register = 0x2C, 188 189 .wr_table = &si1133_write_ranges_table, 190 .rd_table = &si1133_read_ranges_table, 191 192 .precious_table = &si1133_precious_table, 193 }; 194 195 struct si1133_data { 196 struct regmap *regmap; 197 struct i2c_client *client; 198 199 /* Lock protecting one command at a time can be processed */ 200 struct mutex mutex; 201 202 int rsp_seq; 203 u8 scan_mask; 204 u8 adc_sens[6]; 205 u8 adc_config[6]; 206 207 struct completion completion; 208 }; 209 210 struct si1133_coeff { 211 s16 info; 212 u16 mag; 213 }; 214 215 struct si1133_lux_coeff { 216 struct si1133_coeff coeff_high[4]; 217 struct si1133_coeff coeff_low[9]; 218 }; 219 220 static const struct si1133_lux_coeff lux_coeff = { 221 { 222 { 0, 209}, 223 { 1665, 93}, 224 { 2064, 65}, 225 {-2671, 234} 226 }, 227 { 228 { 0, 0}, 229 { 1921, 29053}, 230 {-1022, 36363}, 231 { 2320, 20789}, 232 { -367, 57909}, 233 {-1774, 38240}, 234 { -608, 46775}, 235 {-1503, 51831}, 236 {-1886, 58928} 237 } 238 }; 239 240 static int si1133_calculate_polynomial_inner(s32 input, u8 fraction, u16 mag, 241 s8 shift) 242 { 243 return ((input << fraction) / mag) << shift; 244 } 245 246 static int si1133_calculate_output(s32 x, s32 y, u8 x_order, u8 y_order, 247 u8 input_fraction, s8 sign, 248 const struct si1133_coeff *coeffs) 249 { 250 s8 shift; 251 int x1 = 1; 252 int x2 = 1; 253 int y1 = 1; 254 int y2 = 1; 255 256 shift = ((u16)coeffs->info & 0xFF00) >> 8; 257 shift ^= 0xFF; 258 shift += 1; 259 shift = -shift; 260 261 if (x_order > 0) { 262 x1 = si1133_calculate_polynomial_inner(x, input_fraction, 263 coeffs->mag, shift); 264 if (x_order > 1) 265 x2 = x1; 266 } 267 268 if (y_order > 0) { 269 y1 = si1133_calculate_polynomial_inner(y, input_fraction, 270 coeffs->mag, shift); 271 if (y_order > 1) 272 y2 = y1; 273 } 274 275 return sign * x1 * x2 * y1 * y2; 276 } 277 278 /* 279 * The algorithm is from: 280 * https://siliconlabs.github.io/Gecko_SDK_Doc/efm32zg/html/si1133_8c_source.html#l00716 281 */ 282 static int si1133_calc_polynomial(s32 x, s32 y, u8 input_fraction, u8 num_coeff, 283 const struct si1133_coeff *coeffs) 284 { 285 u8 x_order, y_order; 286 u8 counter; 287 s8 sign; 288 int output = 0; 289 290 for (counter = 0; counter < num_coeff; counter++) { 291 if (coeffs->info < 0) 292 sign = -1; 293 else 294 sign = 1; 295 296 x_order = si1133_get_x_order(coeffs->info); 297 y_order = si1133_get_y_order(coeffs->info); 298 299 if ((x_order == 0) && (y_order == 0)) 300 output += 301 sign * coeffs->mag << SI1133_LUX_OUTPUT_FRACTION; 302 else 303 output += si1133_calculate_output(x, y, x_order, 304 y_order, 305 input_fraction, sign, 306 coeffs); 307 coeffs++; 308 } 309 310 return abs(output); 311 } 312 313 static int si1133_cmd_reset_sw(struct si1133_data *data) 314 { 315 struct device *dev = &data->client->dev; 316 unsigned int resp; 317 unsigned long timeout; 318 int err; 319 320 err = regmap_write(data->regmap, SI1133_REG_COMMAND, 321 SI1133_CMD_RESET_SW); 322 if (err) 323 return err; 324 325 timeout = jiffies + msecs_to_jiffies(SI1133_CMD_TIMEOUT_MS); 326 while (true) { 327 err = regmap_read(data->regmap, SI1133_REG_RESPONSE0, &resp); 328 if (err == -ENXIO) { 329 usleep_range(SI1133_CMD_MINSLEEP_US_LOW, 330 SI1133_CMD_MINSLEEP_US_HIGH); 331 continue; 332 } 333 334 if ((resp & SI1133_MAX_CMD_CTR) == SI1133_MAX_CMD_CTR) 335 break; 336 337 if (time_after(jiffies, timeout)) { 338 dev_warn(dev, "Timeout on reset ctr resp: %d\n", resp); 339 return -ETIMEDOUT; 340 } 341 } 342 343 if (!err) 344 data->rsp_seq = SI1133_MAX_CMD_CTR; 345 346 return err; 347 } 348 349 static int si1133_parse_response_err(struct device *dev, u32 resp, u8 cmd) 350 { 351 resp &= 0xF; 352 353 switch (resp) { 354 case SI1133_ERR_OUTPUT_BUFFER_OVERFLOW: 355 dev_warn(dev, "Output buffer overflow: %#02hhx\n", cmd); 356 return -EOVERFLOW; 357 case SI1133_ERR_SATURATION_ADC_OR_OVERFLOW_ACCUMULATION: 358 dev_warn(dev, "Saturation of the ADC or overflow of accumulation: %#02hhx\n", 359 cmd); 360 return -EOVERFLOW; 361 case SI1133_ERR_INVALID_LOCATION_CMD: 362 dev_warn(dev, 363 "Parameter access to an invalid location: %#02hhx\n", 364 cmd); 365 return -EINVAL; 366 case SI1133_ERR_INVALID_CMD: 367 dev_warn(dev, "Invalid command %#02hhx\n", cmd); 368 return -EINVAL; 369 default: 370 dev_warn(dev, "Unknown error %#02hhx\n", cmd); 371 return -EINVAL; 372 } 373 } 374 375 static int si1133_cmd_reset_counter(struct si1133_data *data) 376 { 377 int err = regmap_write(data->regmap, SI1133_REG_COMMAND, 378 SI1133_CMD_RESET_CTR); 379 if (err) 380 return err; 381 382 data->rsp_seq = 0; 383 384 return 0; 385 } 386 387 static int si1133_command(struct si1133_data *data, u8 cmd) 388 { 389 struct device *dev = &data->client->dev; 390 u32 resp; 391 int err; 392 int expected_seq; 393 394 mutex_lock(&data->mutex); 395 396 expected_seq = (data->rsp_seq + 1) & SI1133_MAX_CMD_CTR; 397 398 if (cmd == SI1133_CMD_FORCE) 399 reinit_completion(&data->completion); 400 401 err = regmap_write(data->regmap, SI1133_REG_COMMAND, cmd); 402 if (err) { 403 dev_warn(dev, "Failed to write command %#02hhx, ret=%d\n", cmd, 404 err); 405 goto out; 406 } 407 408 if (cmd == SI1133_CMD_FORCE) { 409 /* wait for irq */ 410 if (!wait_for_completion_timeout(&data->completion, 411 msecs_to_jiffies(SI1133_COMPLETION_TIMEOUT_MS))) { 412 err = -ETIMEDOUT; 413 goto out; 414 } 415 err = regmap_read(data->regmap, SI1133_REG_RESPONSE0, &resp); 416 if (err) 417 goto out; 418 } else { 419 err = regmap_read_poll_timeout(data->regmap, 420 SI1133_REG_RESPONSE0, resp, 421 (resp & SI1133_CMD_SEQ_MASK) == 422 expected_seq || 423 (resp & SI1133_CMD_ERR_MASK), 424 SI1133_CMD_MINSLEEP_US_LOW, 425 SI1133_CMD_TIMEOUT_MS * 1000); 426 if (err) { 427 dev_warn(dev, 428 "Failed to read command %#02hhx, ret=%d\n", 429 cmd, err); 430 goto out; 431 } 432 } 433 434 if (resp & SI1133_CMD_ERR_MASK) { 435 err = si1133_parse_response_err(dev, resp, cmd); 436 si1133_cmd_reset_counter(data); 437 } else { 438 data->rsp_seq = expected_seq; 439 } 440 441 out: 442 mutex_unlock(&data->mutex); 443 444 return err; 445 } 446 447 static int si1133_param_set(struct si1133_data *data, u8 param, u32 value) 448 { 449 int err = regmap_write(data->regmap, SI1133_REG_HOSTIN0, value); 450 451 if (err) 452 return err; 453 454 return si1133_command(data, SI1133_CMD_PARAM_SET | 455 (param & SI1133_CMD_PARAM_MASK)); 456 } 457 458 static int si1133_param_query(struct si1133_data *data, u8 param, u32 *result) 459 { 460 int err = si1133_command(data, SI1133_CMD_PARAM_QUERY | 461 (param & SI1133_CMD_PARAM_MASK)); 462 if (err) 463 return err; 464 465 return regmap_read(data->regmap, SI1133_REG_RESPONSE1, result); 466 } 467 468 #define SI1133_CHANNEL(_ch, _type) \ 469 .type = _type, \ 470 .channel = _ch, \ 471 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 472 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_INT_TIME) | \ 473 BIT(IIO_CHAN_INFO_SCALE) | \ 474 BIT(IIO_CHAN_INFO_HARDWAREGAIN), \ 475 476 static const struct iio_chan_spec si1133_channels[] = { 477 { 478 .type = IIO_LIGHT, 479 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), 480 .channel = 0, 481 }, 482 { 483 SI1133_CHANNEL(SI1133_PARAM_ADCMUX_WHITE, IIO_INTENSITY) 484 .channel2 = IIO_MOD_LIGHT_BOTH, 485 }, 486 { 487 SI1133_CHANNEL(SI1133_PARAM_ADCMUX_LARGE_WHITE, IIO_INTENSITY) 488 .channel2 = IIO_MOD_LIGHT_BOTH, 489 .extend_name = "large", 490 }, 491 { 492 SI1133_CHANNEL(SI1133_PARAM_ADCMUX_SMALL_IR, IIO_INTENSITY) 493 .extend_name = "small", 494 .modified = 1, 495 .channel2 = IIO_MOD_LIGHT_IR, 496 }, 497 { 498 SI1133_CHANNEL(SI1133_PARAM_ADCMUX_MED_IR, IIO_INTENSITY) 499 .modified = 1, 500 .channel2 = IIO_MOD_LIGHT_IR, 501 }, 502 { 503 SI1133_CHANNEL(SI1133_PARAM_ADCMUX_LARGE_IR, IIO_INTENSITY) 504 .extend_name = "large", 505 .modified = 1, 506 .channel2 = IIO_MOD_LIGHT_IR, 507 }, 508 { 509 SI1133_CHANNEL(SI1133_PARAM_ADCMUX_UV, IIO_UVINDEX) 510 }, 511 { 512 SI1133_CHANNEL(SI1133_PARAM_ADCMUX_UV_DEEP, IIO_UVINDEX) 513 .modified = 1, 514 .channel2 = IIO_MOD_LIGHT_DUV, 515 } 516 }; 517 518 static int si1133_get_int_time_index(int milliseconds, int nanoseconds) 519 { 520 int i; 521 522 for (i = 0; i < ARRAY_SIZE(si1133_int_time_table); i++) { 523 if (milliseconds == si1133_int_time_table[i][0] && 524 nanoseconds == si1133_int_time_table[i][1]) 525 return i; 526 } 527 return -EINVAL; 528 } 529 530 static int si1133_set_integration_time(struct si1133_data *data, u8 adc, 531 int milliseconds, int nanoseconds) 532 { 533 int index; 534 535 index = si1133_get_int_time_index(milliseconds, nanoseconds); 536 if (index < 0) 537 return index; 538 539 data->adc_sens[adc] &= 0xF0; 540 data->adc_sens[adc] |= index; 541 542 return si1133_param_set(data, SI1133_PARAM_REG_ADCSENS(0), 543 data->adc_sens[adc]); 544 } 545 546 static int si1133_set_chlist(struct si1133_data *data, u8 scan_mask) 547 { 548 /* channel list already set, no need to reprogram */ 549 if (data->scan_mask == scan_mask) 550 return 0; 551 552 data->scan_mask = scan_mask; 553 554 return si1133_param_set(data, SI1133_PARAM_REG_CHAN_LIST, scan_mask); 555 } 556 557 static int si1133_chan_set_adcconfig(struct si1133_data *data, u8 adc, 558 u8 adc_config) 559 { 560 int err; 561 562 err = si1133_param_set(data, SI1133_PARAM_REG_ADCCONFIG(adc), 563 adc_config); 564 if (err) 565 return err; 566 567 data->adc_config[adc] = adc_config; 568 569 return 0; 570 } 571 572 static int si1133_update_adcconfig(struct si1133_data *data, uint8_t adc, 573 u8 mask, u8 shift, u8 value) 574 { 575 u32 adc_config; 576 int err; 577 578 err = si1133_param_query(data, SI1133_PARAM_REG_ADCCONFIG(adc), 579 &adc_config); 580 if (err) 581 return err; 582 583 adc_config &= ~mask; 584 adc_config |= (value << shift); 585 586 return si1133_chan_set_adcconfig(data, adc, adc_config); 587 } 588 589 static int si1133_set_adcmux(struct si1133_data *data, u8 adc, u8 mux) 590 { 591 if ((mux & data->adc_config[adc]) == mux) 592 return 0; /* mux already set to correct value */ 593 594 return si1133_update_adcconfig(data, adc, SI1133_ADCMUX_MASK, 0, mux); 595 } 596 597 static int si1133_force_measurement(struct si1133_data *data) 598 { 599 return si1133_command(data, SI1133_CMD_FORCE); 600 } 601 602 static int si1133_bulk_read(struct si1133_data *data, u8 start_reg, u8 length, 603 u8 *buffer) 604 { 605 int err; 606 607 err = si1133_force_measurement(data); 608 if (err) 609 return err; 610 611 return regmap_bulk_read(data->regmap, start_reg, buffer, length); 612 } 613 614 static int si1133_measure(struct si1133_data *data, 615 struct iio_chan_spec const *chan, 616 int *val) 617 { 618 int err; 619 620 u8 buffer[SI1133_MEASURE_BUFFER_SIZE]; 621 622 err = si1133_set_adcmux(data, 0, chan->channel); 623 if (err) 624 return err; 625 626 /* Deactivate lux measurements if they were active */ 627 err = si1133_set_chlist(data, BIT(0)); 628 if (err) 629 return err; 630 631 err = si1133_bulk_read(data, SI1133_REG_HOSTOUT(0), sizeof(buffer), 632 buffer); 633 if (err) 634 return err; 635 636 *val = sign_extend32((buffer[0] << 16) | (buffer[1] << 8) | buffer[2], 637 SI1133_SIGN_BIT_INDEX); 638 639 return err; 640 } 641 642 static irqreturn_t si1133_threaded_irq_handler(int irq, void *private) 643 { 644 struct iio_dev *iio_dev = private; 645 struct si1133_data *data = iio_priv(iio_dev); 646 u32 irq_status; 647 int err; 648 649 err = regmap_read(data->regmap, SI1133_REG_IRQ_STATUS, &irq_status); 650 if (err) { 651 dev_err_ratelimited(&iio_dev->dev, "Error reading IRQ\n"); 652 goto out; 653 } 654 655 if (irq_status != data->scan_mask) 656 return IRQ_NONE; 657 658 out: 659 complete(&data->completion); 660 661 return IRQ_HANDLED; 662 } 663 664 static int si1133_scale_to_swgain(int scale_integer, int scale_fractional) 665 { 666 scale_integer = find_closest(scale_integer, si1133_scale_available, 667 ARRAY_SIZE(si1133_scale_available)); 668 if (scale_integer < 0 || 669 scale_integer > ARRAY_SIZE(si1133_scale_available) || 670 scale_fractional != 0) 671 return -EINVAL; 672 673 return scale_integer; 674 } 675 676 static int si1133_chan_set_adcsens(struct si1133_data *data, u8 adc, 677 u8 adc_sens) 678 { 679 int err; 680 681 err = si1133_param_set(data, SI1133_PARAM_REG_ADCSENS(adc), adc_sens); 682 if (err) 683 return err; 684 685 data->adc_sens[adc] = adc_sens; 686 687 return 0; 688 } 689 690 static int si1133_update_adcsens(struct si1133_data *data, u8 mask, 691 u8 shift, u8 value) 692 { 693 int err; 694 u32 adc_sens; 695 696 err = si1133_param_query(data, SI1133_PARAM_REG_ADCSENS(0), 697 &adc_sens); 698 if (err) 699 return err; 700 701 adc_sens &= ~mask; 702 adc_sens |= (value << shift); 703 704 return si1133_chan_set_adcsens(data, 0, adc_sens); 705 } 706 707 static int si1133_get_lux(struct si1133_data *data, int *val) 708 { 709 int err; 710 int lux; 711 s32 high_vis; 712 s32 low_vis; 713 s32 ir; 714 u8 buffer[SI1133_LUX_BUFFER_SIZE]; 715 716 /* Activate lux channels */ 717 err = si1133_set_chlist(data, SI1133_LUX_ADC_MASK); 718 if (err) 719 return err; 720 721 err = si1133_bulk_read(data, SI1133_REG_HOSTOUT(0), 722 SI1133_LUX_BUFFER_SIZE, buffer); 723 if (err) 724 return err; 725 726 high_vis = 727 sign_extend32((buffer[0] << 16) | (buffer[1] << 8) | buffer[2], 728 SI1133_SIGN_BIT_INDEX); 729 730 low_vis = 731 sign_extend32((buffer[3] << 16) | (buffer[4] << 8) | buffer[5], 732 SI1133_SIGN_BIT_INDEX); 733 734 ir = sign_extend32((buffer[6] << 16) | (buffer[7] << 8) | buffer[8], 735 SI1133_SIGN_BIT_INDEX); 736 737 if (high_vis > SI1133_ADC_THRESHOLD || ir > SI1133_ADC_THRESHOLD) 738 lux = si1133_calc_polynomial(high_vis, ir, 739 SI1133_INPUT_FRACTION_HIGH, 740 ARRAY_SIZE(lux_coeff.coeff_high), 741 &lux_coeff.coeff_high[0]); 742 else 743 lux = si1133_calc_polynomial(low_vis, ir, 744 SI1133_INPUT_FRACTION_LOW, 745 ARRAY_SIZE(lux_coeff.coeff_low), 746 &lux_coeff.coeff_low[0]); 747 748 *val = lux >> SI1133_LUX_OUTPUT_FRACTION; 749 750 return err; 751 } 752 753 static int si1133_read_raw(struct iio_dev *iio_dev, 754 struct iio_chan_spec const *chan, 755 int *val, int *val2, long mask) 756 { 757 struct si1133_data *data = iio_priv(iio_dev); 758 u8 adc_sens = data->adc_sens[0]; 759 int err; 760 761 switch (mask) { 762 case IIO_CHAN_INFO_PROCESSED: 763 switch (chan->type) { 764 case IIO_LIGHT: 765 err = si1133_get_lux(data, val); 766 if (err) 767 return err; 768 769 return IIO_VAL_INT; 770 default: 771 return -EINVAL; 772 } 773 case IIO_CHAN_INFO_RAW: 774 switch (chan->type) { 775 case IIO_INTENSITY: 776 case IIO_UVINDEX: 777 err = si1133_measure(data, chan, val); 778 if (err) 779 return err; 780 781 return IIO_VAL_INT; 782 default: 783 return -EINVAL; 784 } 785 case IIO_CHAN_INFO_INT_TIME: 786 switch (chan->type) { 787 case IIO_INTENSITY: 788 case IIO_UVINDEX: 789 adc_sens &= SI1133_ADCSENS_HW_GAIN_MASK; 790 791 *val = si1133_int_time_table[adc_sens][0]; 792 *val2 = si1133_int_time_table[adc_sens][1]; 793 return IIO_VAL_INT_PLUS_MICRO; 794 default: 795 return -EINVAL; 796 } 797 case IIO_CHAN_INFO_SCALE: 798 switch (chan->type) { 799 case IIO_INTENSITY: 800 case IIO_UVINDEX: 801 adc_sens &= SI1133_ADCSENS_SCALE_MASK; 802 adc_sens >>= SI1133_ADCSENS_SCALE_SHIFT; 803 804 *val = BIT(adc_sens); 805 806 return IIO_VAL_INT; 807 default: 808 return -EINVAL; 809 } 810 case IIO_CHAN_INFO_HARDWAREGAIN: 811 switch (chan->type) { 812 case IIO_INTENSITY: 813 case IIO_UVINDEX: 814 adc_sens >>= SI1133_ADCSENS_HSIG_SHIFT; 815 816 *val = adc_sens; 817 818 return IIO_VAL_INT; 819 default: 820 return -EINVAL; 821 } 822 default: 823 return -EINVAL; 824 } 825 } 826 827 static int si1133_write_raw(struct iio_dev *iio_dev, 828 struct iio_chan_spec const *chan, 829 int val, int val2, long mask) 830 { 831 struct si1133_data *data = iio_priv(iio_dev); 832 833 switch (mask) { 834 case IIO_CHAN_INFO_SCALE: 835 switch (chan->type) { 836 case IIO_INTENSITY: 837 case IIO_UVINDEX: 838 val = si1133_scale_to_swgain(val, val2); 839 if (val < 0) 840 return val; 841 842 return si1133_update_adcsens(data, 843 SI1133_ADCSENS_SCALE_MASK, 844 SI1133_ADCSENS_SCALE_SHIFT, 845 val); 846 default: 847 return -EINVAL; 848 } 849 case IIO_CHAN_INFO_INT_TIME: 850 return si1133_set_integration_time(data, 0, val, val2); 851 case IIO_CHAN_INFO_HARDWAREGAIN: 852 switch (chan->type) { 853 case IIO_INTENSITY: 854 case IIO_UVINDEX: 855 if (val != 0 && val != 1) 856 return -EINVAL; 857 858 return si1133_update_adcsens(data, 859 SI1133_ADCSENS_HSIG_MASK, 860 SI1133_ADCSENS_HSIG_SHIFT, 861 val); 862 default: 863 return -EINVAL; 864 } 865 default: 866 return -EINVAL; 867 } 868 } 869 870 static struct attribute *si1133_attributes[] = { 871 &iio_const_attr_integration_time_available.dev_attr.attr, 872 &iio_const_attr_scale_available.dev_attr.attr, 873 NULL, 874 }; 875 876 static const struct attribute_group si1133_attribute_group = { 877 .attrs = si1133_attributes, 878 }; 879 880 static const struct iio_info si1133_info = { 881 .read_raw = si1133_read_raw, 882 .write_raw = si1133_write_raw, 883 .attrs = &si1133_attribute_group, 884 }; 885 886 /* 887 * si1133_init_lux_channels - Configure 3 different channels(adc) (1,2 and 3) 888 * The channel configuration for the lux measurement was taken from : 889 * https://siliconlabs.github.io/Gecko_SDK_Doc/efm32zg/html/si1133_8c_source.html#l00578 890 * 891 * Reserved the channel 0 for the other raw measurements 892 */ 893 static int si1133_init_lux_channels(struct si1133_data *data) 894 { 895 int err; 896 897 err = si1133_chan_set_adcconfig(data, 1, 898 SI1133_ADCCONFIG_DECIM_RATE(1) | 899 SI1133_PARAM_ADCMUX_LARGE_WHITE); 900 if (err) 901 return err; 902 903 err = si1133_param_set(data, SI1133_PARAM_REG_ADCPOST(1), 904 SI1133_ADCPOST_24BIT_EN | 905 SI1133_ADCPOST_POSTSHIFT_BITQTY(0)); 906 if (err) 907 return err; 908 err = si1133_chan_set_adcsens(data, 1, SI1133_ADCSENS_HSIG_MASK | 909 SI1133_ADCSENS_NB_MEAS(64) | _48_8_us); 910 if (err) 911 return err; 912 913 err = si1133_chan_set_adcconfig(data, 2, 914 SI1133_ADCCONFIG_DECIM_RATE(1) | 915 SI1133_PARAM_ADCMUX_LARGE_WHITE); 916 if (err) 917 return err; 918 919 err = si1133_param_set(data, SI1133_PARAM_REG_ADCPOST(2), 920 SI1133_ADCPOST_24BIT_EN | 921 SI1133_ADCPOST_POSTSHIFT_BITQTY(2)); 922 if (err) 923 return err; 924 925 err = si1133_chan_set_adcsens(data, 2, SI1133_ADCSENS_HSIG_MASK | 926 SI1133_ADCSENS_NB_MEAS(1) | _3_120_0_us); 927 if (err) 928 return err; 929 930 err = si1133_chan_set_adcconfig(data, 3, 931 SI1133_ADCCONFIG_DECIM_RATE(1) | 932 SI1133_PARAM_ADCMUX_MED_IR); 933 if (err) 934 return err; 935 936 err = si1133_param_set(data, SI1133_PARAM_REG_ADCPOST(3), 937 SI1133_ADCPOST_24BIT_EN | 938 SI1133_ADCPOST_POSTSHIFT_BITQTY(2)); 939 if (err) 940 return err; 941 942 return si1133_chan_set_adcsens(data, 3, SI1133_ADCSENS_HSIG_MASK | 943 SI1133_ADCSENS_NB_MEAS(64) | _48_8_us); 944 } 945 946 static int si1133_initialize(struct si1133_data *data) 947 { 948 int err; 949 950 err = si1133_cmd_reset_sw(data); 951 if (err) 952 return err; 953 954 /* Turn off autonomous mode */ 955 err = si1133_param_set(data, SI1133_REG_MEAS_RATE, 0); 956 if (err) 957 return err; 958 959 err = si1133_init_lux_channels(data); 960 if (err) 961 return err; 962 963 return regmap_write(data->regmap, SI1133_REG_IRQ_ENABLE, 964 SI1133_IRQ_CHANNEL_ENABLE); 965 } 966 967 static int si1133_validate_ids(struct iio_dev *iio_dev) 968 { 969 struct si1133_data *data = iio_priv(iio_dev); 970 971 unsigned int part_id, rev_id, mfr_id; 972 int err; 973 974 err = regmap_read(data->regmap, SI1133_REG_PART_ID, &part_id); 975 if (err) 976 return err; 977 978 err = regmap_read(data->regmap, SI1133_REG_REV_ID, &rev_id); 979 if (err) 980 return err; 981 982 err = regmap_read(data->regmap, SI1133_REG_MFR_ID, &mfr_id); 983 if (err) 984 return err; 985 986 dev_info(&iio_dev->dev, 987 "Device ID part %#02hhx rev %#02hhx mfr %#02hhx\n", 988 part_id, rev_id, mfr_id); 989 if (part_id != SI1133_PART_ID) { 990 dev_err(&iio_dev->dev, 991 "Part ID mismatch got %#02hhx, expected %#02x\n", 992 part_id, SI1133_PART_ID); 993 return -ENODEV; 994 } 995 996 return 0; 997 } 998 999 static int si1133_probe(struct i2c_client *client, 1000 const struct i2c_device_id *id) 1001 { 1002 struct si1133_data *data; 1003 struct iio_dev *iio_dev; 1004 int err; 1005 1006 iio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1007 if (!iio_dev) 1008 return -ENOMEM; 1009 1010 data = iio_priv(iio_dev); 1011 1012 init_completion(&data->completion); 1013 1014 data->regmap = devm_regmap_init_i2c(client, &si1133_regmap_config); 1015 if (IS_ERR(data->regmap)) { 1016 err = PTR_ERR(data->regmap); 1017 dev_err(&client->dev, "Failed to initialise regmap: %d\n", err); 1018 return err; 1019 } 1020 1021 i2c_set_clientdata(client, iio_dev); 1022 data->client = client; 1023 1024 iio_dev->dev.parent = &client->dev; 1025 iio_dev->name = id->name; 1026 iio_dev->channels = si1133_channels; 1027 iio_dev->num_channels = ARRAY_SIZE(si1133_channels); 1028 iio_dev->info = &si1133_info; 1029 iio_dev->modes = INDIO_DIRECT_MODE; 1030 1031 mutex_init(&data->mutex); 1032 1033 err = si1133_validate_ids(iio_dev); 1034 if (err) 1035 return err; 1036 1037 err = si1133_initialize(data); 1038 if (err) { 1039 dev_err(&client->dev, 1040 "Error when initializing chip: %d\n", err); 1041 return err; 1042 } 1043 1044 if (!client->irq) { 1045 dev_err(&client->dev, 1046 "Required interrupt not provided, cannot proceed\n"); 1047 return -EINVAL; 1048 } 1049 1050 err = devm_request_threaded_irq(&client->dev, client->irq, 1051 NULL, 1052 si1133_threaded_irq_handler, 1053 IRQF_ONESHOT | IRQF_SHARED, 1054 client->name, iio_dev); 1055 if (err) { 1056 dev_warn(&client->dev, "Request irq %d failed: %i\n", 1057 client->irq, err); 1058 return err; 1059 } 1060 1061 return devm_iio_device_register(&client->dev, iio_dev); 1062 } 1063 1064 static const struct i2c_device_id si1133_ids[] = { 1065 { "si1133", 0 }, 1066 { } 1067 }; 1068 MODULE_DEVICE_TABLE(i2c, si1133_ids); 1069 1070 static struct i2c_driver si1133_driver = { 1071 .driver = { 1072 .name = "si1133", 1073 }, 1074 .probe = si1133_probe, 1075 .id_table = si1133_ids, 1076 }; 1077 1078 module_i2c_driver(si1133_driver); 1079 1080 MODULE_AUTHOR("Maxime Roussin-Belanger <maxime.roussinbelanger@gmail.com>"); 1081 MODULE_DESCRIPTION("Silabs SI1133, UV index sensor and ambient light sensor driver"); 1082 MODULE_LICENSE("GPL"); 1083