1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * si1145.c - Support for Silabs SI1132 and SI1141/2/3/5/6/7 combined ambient 4 * light, UV index and proximity sensors 5 * 6 * Copyright 2014-16 Peter Meerwald-Stadler <pmeerw@pmeerw.net> 7 * Copyright 2016 Crestez Dan Leonard <leonard.crestez@intel.com> 8 * 9 * SI1132 (7-bit I2C slave address 0x60) 10 * SI1141/2/3 (7-bit I2C slave address 0x5a) 11 * SI1145/6/6 (7-bit I2C slave address 0x60) 12 */ 13 14 #include <linux/module.h> 15 #include <linux/i2c.h> 16 #include <linux/err.h> 17 #include <linux/slab.h> 18 #include <linux/delay.h> 19 #include <linux/irq.h> 20 21 #include <linux/iio/iio.h> 22 #include <linux/iio/sysfs.h> 23 #include <linux/iio/trigger.h> 24 #include <linux/iio/trigger_consumer.h> 25 #include <linux/iio/triggered_buffer.h> 26 #include <linux/iio/buffer.h> 27 #include <linux/util_macros.h> 28 29 #define SI1145_REG_PART_ID 0x00 30 #define SI1145_REG_REV_ID 0x01 31 #define SI1145_REG_SEQ_ID 0x02 32 #define SI1145_REG_INT_CFG 0x03 33 #define SI1145_REG_IRQ_ENABLE 0x04 34 #define SI1145_REG_IRQ_MODE 0x05 35 #define SI1145_REG_HW_KEY 0x07 36 #define SI1145_REG_MEAS_RATE 0x08 37 #define SI1145_REG_PS_LED21 0x0f 38 #define SI1145_REG_PS_LED3 0x10 39 #define SI1145_REG_UCOEF1 0x13 40 #define SI1145_REG_UCOEF2 0x14 41 #define SI1145_REG_UCOEF3 0x15 42 #define SI1145_REG_UCOEF4 0x16 43 #define SI1145_REG_PARAM_WR 0x17 44 #define SI1145_REG_COMMAND 0x18 45 #define SI1145_REG_RESPONSE 0x20 46 #define SI1145_REG_IRQ_STATUS 0x21 47 #define SI1145_REG_ALSVIS_DATA 0x22 48 #define SI1145_REG_ALSIR_DATA 0x24 49 #define SI1145_REG_PS1_DATA 0x26 50 #define SI1145_REG_PS2_DATA 0x28 51 #define SI1145_REG_PS3_DATA 0x2a 52 #define SI1145_REG_AUX_DATA 0x2c 53 #define SI1145_REG_PARAM_RD 0x2e 54 #define SI1145_REG_CHIP_STAT 0x30 55 56 #define SI1145_UCOEF1_DEFAULT 0x7b 57 #define SI1145_UCOEF2_DEFAULT 0x6b 58 #define SI1145_UCOEF3_DEFAULT 0x01 59 #define SI1145_UCOEF4_DEFAULT 0x00 60 61 /* Helper to figure out PS_LED register / shift per channel */ 62 #define SI1145_PS_LED_REG(ch) \ 63 (((ch) == 2) ? SI1145_REG_PS_LED3 : SI1145_REG_PS_LED21) 64 #define SI1145_PS_LED_SHIFT(ch) \ 65 (((ch) == 1) ? 4 : 0) 66 67 /* Parameter offsets */ 68 #define SI1145_PARAM_CHLIST 0x01 69 #define SI1145_PARAM_PSLED12_SELECT 0x02 70 #define SI1145_PARAM_PSLED3_SELECT 0x03 71 #define SI1145_PARAM_PS_ENCODING 0x05 72 #define SI1145_PARAM_ALS_ENCODING 0x06 73 #define SI1145_PARAM_PS1_ADC_MUX 0x07 74 #define SI1145_PARAM_PS2_ADC_MUX 0x08 75 #define SI1145_PARAM_PS3_ADC_MUX 0x09 76 #define SI1145_PARAM_PS_ADC_COUNTER 0x0a 77 #define SI1145_PARAM_PS_ADC_GAIN 0x0b 78 #define SI1145_PARAM_PS_ADC_MISC 0x0c 79 #define SI1145_PARAM_ALS_ADC_MUX 0x0d 80 #define SI1145_PARAM_ALSIR_ADC_MUX 0x0e 81 #define SI1145_PARAM_AUX_ADC_MUX 0x0f 82 #define SI1145_PARAM_ALSVIS_ADC_COUNTER 0x10 83 #define SI1145_PARAM_ALSVIS_ADC_GAIN 0x11 84 #define SI1145_PARAM_ALSVIS_ADC_MISC 0x12 85 #define SI1145_PARAM_LED_RECOVERY 0x1c 86 #define SI1145_PARAM_ALSIR_ADC_COUNTER 0x1d 87 #define SI1145_PARAM_ALSIR_ADC_GAIN 0x1e 88 #define SI1145_PARAM_ALSIR_ADC_MISC 0x1f 89 #define SI1145_PARAM_ADC_OFFSET 0x1a 90 91 /* Channel enable masks for CHLIST parameter */ 92 #define SI1145_CHLIST_EN_PS1 BIT(0) 93 #define SI1145_CHLIST_EN_PS2 BIT(1) 94 #define SI1145_CHLIST_EN_PS3 BIT(2) 95 #define SI1145_CHLIST_EN_ALSVIS BIT(4) 96 #define SI1145_CHLIST_EN_ALSIR BIT(5) 97 #define SI1145_CHLIST_EN_AUX BIT(6) 98 #define SI1145_CHLIST_EN_UV BIT(7) 99 100 /* Proximity measurement mode for ADC_MISC parameter */ 101 #define SI1145_PS_ADC_MODE_NORMAL BIT(2) 102 /* Signal range mask for ADC_MISC parameter */ 103 #define SI1145_ADC_MISC_RANGE BIT(5) 104 105 /* Commands for REG_COMMAND */ 106 #define SI1145_CMD_NOP 0x00 107 #define SI1145_CMD_RESET 0x01 108 #define SI1145_CMD_PS_FORCE 0x05 109 #define SI1145_CMD_ALS_FORCE 0x06 110 #define SI1145_CMD_PSALS_FORCE 0x07 111 #define SI1145_CMD_PS_PAUSE 0x09 112 #define SI1145_CMD_ALS_PAUSE 0x0a 113 #define SI1145_CMD_PSALS_PAUSE 0x0b 114 #define SI1145_CMD_PS_AUTO 0x0d 115 #define SI1145_CMD_ALS_AUTO 0x0e 116 #define SI1145_CMD_PSALS_AUTO 0x0f 117 #define SI1145_CMD_PARAM_QUERY 0x80 118 #define SI1145_CMD_PARAM_SET 0xa0 119 120 #define SI1145_RSP_INVALID_SETTING 0x80 121 #define SI1145_RSP_COUNTER_MASK 0x0F 122 123 /* Minimum sleep after each command to ensure it's received */ 124 #define SI1145_COMMAND_MINSLEEP_MS 5 125 /* Return -ETIMEDOUT after this long */ 126 #define SI1145_COMMAND_TIMEOUT_MS 25 127 128 /* Interrupt configuration masks for INT_CFG register */ 129 #define SI1145_INT_CFG_OE BIT(0) /* enable interrupt */ 130 #define SI1145_INT_CFG_MODE BIT(1) /* auto reset interrupt pin */ 131 132 /* Interrupt enable masks for IRQ_ENABLE register */ 133 #define SI1145_MASK_ALL_IE (BIT(4) | BIT(3) | BIT(2) | BIT(0)) 134 135 #define SI1145_MUX_TEMP 0x65 136 #define SI1145_MUX_VDD 0x75 137 138 /* Proximity LED current; see Table 2 in datasheet */ 139 #define SI1145_LED_CURRENT_45mA 0x04 140 141 enum { 142 SI1132, 143 SI1141, 144 SI1142, 145 SI1143, 146 SI1145, 147 SI1146, 148 SI1147, 149 }; 150 151 struct si1145_part_info { 152 u8 part; 153 const struct iio_info *iio_info; 154 const struct iio_chan_spec *channels; 155 unsigned int num_channels; 156 unsigned int num_leds; 157 bool uncompressed_meas_rate; 158 }; 159 160 /** 161 * struct si1145_data - si1145 chip state data 162 * @client: I2C client 163 * @lock: mutex to protect shared state. 164 * @cmdlock: Low-level mutex to protect command execution only 165 * @rsp_seq: Next expected response number or -1 if counter reset required 166 * @scan_mask: Saved scan mask to avoid duplicate set_chlist 167 * @autonomous: If automatic measurements are active (for buffer support) 168 * @part_info: Part information 169 * @trig: Pointer to iio trigger 170 * @meas_rate: Value of MEAS_RATE register. Only set in HW in auto mode 171 * @buffer: Used to pack data read from sensor. 172 */ 173 struct si1145_data { 174 struct i2c_client *client; 175 struct mutex lock; 176 struct mutex cmdlock; 177 int rsp_seq; 178 const struct si1145_part_info *part_info; 179 unsigned long scan_mask; 180 bool autonomous; 181 struct iio_trigger *trig; 182 int meas_rate; 183 /* 184 * Ensure timestamp will be naturally aligned if present. 185 * Maximum buffer size (may be only partly used if not all 186 * channels are enabled): 187 * 6*2 bytes channels data + 4 bytes alignment + 188 * 8 bytes timestamp 189 */ 190 u8 buffer[24] __aligned(8); 191 }; 192 193 /* 194 * __si1145_command_reset() - Send CMD_NOP and wait for response 0 195 * 196 * Does not modify data->rsp_seq 197 * 198 * Return: 0 on success and -errno on error. 199 */ 200 static int __si1145_command_reset(struct si1145_data *data) 201 { 202 struct device *dev = &data->client->dev; 203 unsigned long stop_jiffies; 204 int ret; 205 206 ret = i2c_smbus_write_byte_data(data->client, SI1145_REG_COMMAND, 207 SI1145_CMD_NOP); 208 if (ret < 0) 209 return ret; 210 msleep(SI1145_COMMAND_MINSLEEP_MS); 211 212 stop_jiffies = jiffies + SI1145_COMMAND_TIMEOUT_MS * HZ / 1000; 213 while (true) { 214 ret = i2c_smbus_read_byte_data(data->client, 215 SI1145_REG_RESPONSE); 216 if (ret <= 0) 217 return ret; 218 if (time_after(jiffies, stop_jiffies)) { 219 dev_warn(dev, "timeout on reset\n"); 220 return -ETIMEDOUT; 221 } 222 msleep(SI1145_COMMAND_MINSLEEP_MS); 223 continue; 224 } 225 } 226 227 /* 228 * si1145_command() - Execute a command and poll the response register 229 * 230 * All conversion overflows are reported as -EOVERFLOW 231 * INVALID_SETTING is reported as -EINVAL 232 * Timeouts are reported as -ETIMEDOUT 233 * 234 * Return: 0 on success or -errno on failure 235 */ 236 static int si1145_command(struct si1145_data *data, u8 cmd) 237 { 238 struct device *dev = &data->client->dev; 239 unsigned long stop_jiffies; 240 int ret; 241 242 mutex_lock(&data->cmdlock); 243 244 if (data->rsp_seq < 0) { 245 ret = __si1145_command_reset(data); 246 if (ret < 0) { 247 dev_err(dev, "failed to reset command counter, ret=%d\n", 248 ret); 249 goto out; 250 } 251 data->rsp_seq = 0; 252 } 253 254 ret = i2c_smbus_write_byte_data(data->client, SI1145_REG_COMMAND, cmd); 255 if (ret) { 256 dev_warn(dev, "failed to write command, ret=%d\n", ret); 257 goto out; 258 } 259 /* Sleep a little to ensure the command is received */ 260 msleep(SI1145_COMMAND_MINSLEEP_MS); 261 262 stop_jiffies = jiffies + SI1145_COMMAND_TIMEOUT_MS * HZ / 1000; 263 while (true) { 264 ret = i2c_smbus_read_byte_data(data->client, 265 SI1145_REG_RESPONSE); 266 if (ret < 0) { 267 dev_warn(dev, "failed to read response, ret=%d\n", ret); 268 break; 269 } 270 271 if ((ret & ~SI1145_RSP_COUNTER_MASK) == 0) { 272 if (ret == data->rsp_seq) { 273 if (time_after(jiffies, stop_jiffies)) { 274 dev_warn(dev, "timeout on command %#02hhx\n", 275 cmd); 276 ret = -ETIMEDOUT; 277 break; 278 } 279 msleep(SI1145_COMMAND_MINSLEEP_MS); 280 continue; 281 } 282 if (ret == ((data->rsp_seq + 1) & 283 SI1145_RSP_COUNTER_MASK)) { 284 data->rsp_seq = ret; 285 ret = 0; 286 break; 287 } 288 dev_warn(dev, "unexpected response counter %d instead of %d\n", 289 ret, (data->rsp_seq + 1) & 290 SI1145_RSP_COUNTER_MASK); 291 ret = -EIO; 292 } else { 293 if (ret == SI1145_RSP_INVALID_SETTING) { 294 dev_warn(dev, "INVALID_SETTING error on command %#02hhx\n", 295 cmd); 296 ret = -EINVAL; 297 } else { 298 /* All overflows are treated identically */ 299 dev_dbg(dev, "overflow, ret=%d, cmd=%#02hhx\n", 300 ret, cmd); 301 ret = -EOVERFLOW; 302 } 303 } 304 305 /* Force a counter reset next time */ 306 data->rsp_seq = -1; 307 break; 308 } 309 310 out: 311 mutex_unlock(&data->cmdlock); 312 313 return ret; 314 } 315 316 static int si1145_param_update(struct si1145_data *data, u8 op, u8 param, 317 u8 value) 318 { 319 int ret; 320 321 ret = i2c_smbus_write_byte_data(data->client, 322 SI1145_REG_PARAM_WR, value); 323 if (ret < 0) 324 return ret; 325 326 return si1145_command(data, op | (param & 0x1F)); 327 } 328 329 static int si1145_param_set(struct si1145_data *data, u8 param, u8 value) 330 { 331 return si1145_param_update(data, SI1145_CMD_PARAM_SET, param, value); 332 } 333 334 /* Set param. Returns negative errno or current value */ 335 static int si1145_param_query(struct si1145_data *data, u8 param) 336 { 337 int ret; 338 339 ret = si1145_command(data, SI1145_CMD_PARAM_QUERY | (param & 0x1F)); 340 if (ret < 0) 341 return ret; 342 343 return i2c_smbus_read_byte_data(data->client, SI1145_REG_PARAM_RD); 344 } 345 346 /* Expand 8 bit compressed value to 16 bit, see Silabs AN498 */ 347 static u16 si1145_uncompress(u8 x) 348 { 349 u16 result = 0; 350 u8 exponent = 0; 351 352 if (x < 8) 353 return 0; 354 355 exponent = (x & 0xf0) >> 4; 356 result = 0x10 | (x & 0x0f); 357 358 if (exponent >= 4) 359 return result << (exponent - 4); 360 return result >> (4 - exponent); 361 } 362 363 /* Compress 16 bit value to 8 bit, see Silabs AN498 */ 364 static u8 si1145_compress(u16 x) 365 { 366 u32 exponent = 0; 367 u32 significand = 0; 368 u32 tmp = x; 369 370 if (x == 0x0000) 371 return 0x00; 372 if (x == 0x0001) 373 return 0x08; 374 375 while (1) { 376 tmp >>= 1; 377 exponent += 1; 378 if (tmp == 1) 379 break; 380 } 381 382 if (exponent < 5) { 383 significand = x << (4 - exponent); 384 return (exponent << 4) | (significand & 0xF); 385 } 386 387 significand = x >> (exponent - 5); 388 if (significand & 1) { 389 significand += 2; 390 if (significand & 0x0040) { 391 exponent += 1; 392 significand >>= 1; 393 } 394 } 395 396 return (exponent << 4) | ((significand >> 1) & 0xF); 397 } 398 399 /* Write meas_rate in hardware */ 400 static int si1145_set_meas_rate(struct si1145_data *data, int interval) 401 { 402 if (data->part_info->uncompressed_meas_rate) 403 return i2c_smbus_write_word_data(data->client, 404 SI1145_REG_MEAS_RATE, interval); 405 else 406 return i2c_smbus_write_byte_data(data->client, 407 SI1145_REG_MEAS_RATE, interval); 408 } 409 410 static int si1145_read_samp_freq(struct si1145_data *data, int *val, int *val2) 411 { 412 *val = 32000; 413 if (data->part_info->uncompressed_meas_rate) 414 *val2 = data->meas_rate; 415 else 416 *val2 = si1145_uncompress(data->meas_rate); 417 return IIO_VAL_FRACTIONAL; 418 } 419 420 /* Set the samp freq in driver private data */ 421 static int si1145_store_samp_freq(struct si1145_data *data, int val) 422 { 423 int ret = 0; 424 int meas_rate; 425 426 if (val <= 0 || val > 32000) 427 return -ERANGE; 428 meas_rate = 32000 / val; 429 430 mutex_lock(&data->lock); 431 if (data->autonomous) { 432 ret = si1145_set_meas_rate(data, meas_rate); 433 if (ret) 434 goto out; 435 } 436 if (data->part_info->uncompressed_meas_rate) 437 data->meas_rate = meas_rate; 438 else 439 data->meas_rate = si1145_compress(meas_rate); 440 441 out: 442 mutex_unlock(&data->lock); 443 444 return ret; 445 } 446 447 static irqreturn_t si1145_trigger_handler(int irq, void *private) 448 { 449 struct iio_poll_func *pf = private; 450 struct iio_dev *indio_dev = pf->indio_dev; 451 struct si1145_data *data = iio_priv(indio_dev); 452 int i, j = 0; 453 int ret; 454 u8 irq_status = 0; 455 456 if (!data->autonomous) { 457 ret = si1145_command(data, SI1145_CMD_PSALS_FORCE); 458 if (ret < 0 && ret != -EOVERFLOW) 459 goto done; 460 } else { 461 irq_status = ret = i2c_smbus_read_byte_data(data->client, 462 SI1145_REG_IRQ_STATUS); 463 if (ret < 0) 464 goto done; 465 if (!(irq_status & SI1145_MASK_ALL_IE)) 466 goto done; 467 } 468 469 for_each_set_bit(i, indio_dev->active_scan_mask, 470 indio_dev->masklength) { 471 int run = 1; 472 473 while (i + run < indio_dev->masklength) { 474 if (!test_bit(i + run, indio_dev->active_scan_mask)) 475 break; 476 if (indio_dev->channels[i + run].address != 477 indio_dev->channels[i].address + 2 * run) 478 break; 479 run++; 480 } 481 482 ret = i2c_smbus_read_i2c_block_data_or_emulated( 483 data->client, indio_dev->channels[i].address, 484 sizeof(u16) * run, &data->buffer[j]); 485 if (ret < 0) 486 goto done; 487 j += run * sizeof(u16); 488 i += run - 1; 489 } 490 491 if (data->autonomous) { 492 ret = i2c_smbus_write_byte_data(data->client, 493 SI1145_REG_IRQ_STATUS, 494 irq_status & SI1145_MASK_ALL_IE); 495 if (ret < 0) 496 goto done; 497 } 498 499 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer, 500 iio_get_time_ns(indio_dev)); 501 502 done: 503 iio_trigger_notify_done(indio_dev->trig); 504 return IRQ_HANDLED; 505 } 506 507 static int si1145_set_chlist(struct iio_dev *indio_dev, unsigned long scan_mask) 508 { 509 struct si1145_data *data = iio_priv(indio_dev); 510 u8 reg = 0, mux; 511 int ret; 512 int i; 513 514 /* channel list already set, no need to reprogram */ 515 if (data->scan_mask == scan_mask) 516 return 0; 517 518 for_each_set_bit(i, &scan_mask, indio_dev->masklength) { 519 switch (indio_dev->channels[i].address) { 520 case SI1145_REG_ALSVIS_DATA: 521 reg |= SI1145_CHLIST_EN_ALSVIS; 522 break; 523 case SI1145_REG_ALSIR_DATA: 524 reg |= SI1145_CHLIST_EN_ALSIR; 525 break; 526 case SI1145_REG_PS1_DATA: 527 reg |= SI1145_CHLIST_EN_PS1; 528 break; 529 case SI1145_REG_PS2_DATA: 530 reg |= SI1145_CHLIST_EN_PS2; 531 break; 532 case SI1145_REG_PS3_DATA: 533 reg |= SI1145_CHLIST_EN_PS3; 534 break; 535 case SI1145_REG_AUX_DATA: 536 switch (indio_dev->channels[i].type) { 537 case IIO_UVINDEX: 538 reg |= SI1145_CHLIST_EN_UV; 539 break; 540 default: 541 reg |= SI1145_CHLIST_EN_AUX; 542 if (indio_dev->channels[i].type == IIO_TEMP) 543 mux = SI1145_MUX_TEMP; 544 else 545 mux = SI1145_MUX_VDD; 546 ret = si1145_param_set(data, 547 SI1145_PARAM_AUX_ADC_MUX, mux); 548 if (ret < 0) 549 return ret; 550 551 break; 552 } 553 } 554 } 555 556 data->scan_mask = scan_mask; 557 ret = si1145_param_set(data, SI1145_PARAM_CHLIST, reg); 558 559 return ret < 0 ? ret : 0; 560 } 561 562 static int si1145_measure(struct iio_dev *indio_dev, 563 struct iio_chan_spec const *chan) 564 { 565 struct si1145_data *data = iio_priv(indio_dev); 566 u8 cmd; 567 int ret; 568 569 ret = si1145_set_chlist(indio_dev, BIT(chan->scan_index)); 570 if (ret < 0) 571 return ret; 572 573 cmd = (chan->type == IIO_PROXIMITY) ? SI1145_CMD_PS_FORCE : 574 SI1145_CMD_ALS_FORCE; 575 ret = si1145_command(data, cmd); 576 if (ret < 0 && ret != -EOVERFLOW) 577 return ret; 578 579 return i2c_smbus_read_word_data(data->client, chan->address); 580 } 581 582 /* 583 * Conversion between iio scale and ADC_GAIN values 584 * These could be further adjusted but proximity/intensity are dimensionless 585 */ 586 static const int si1145_proximity_scale_available[] = { 587 128, 64, 32, 16, 8, 4}; 588 static const int si1145_intensity_scale_available[] = { 589 128, 64, 32, 16, 8, 4, 2, 1}; 590 static IIO_CONST_ATTR(in_proximity_scale_available, 591 "128 64 32 16 8 4"); 592 static IIO_CONST_ATTR(in_intensity_scale_available, 593 "128 64 32 16 8 4 2 1"); 594 static IIO_CONST_ATTR(in_intensity_ir_scale_available, 595 "128 64 32 16 8 4 2 1"); 596 597 static int si1145_scale_from_adcgain(int regval) 598 { 599 return 128 >> regval; 600 } 601 602 static int si1145_proximity_adcgain_from_scale(int val, int val2) 603 { 604 val = find_closest_descending(val, si1145_proximity_scale_available, 605 ARRAY_SIZE(si1145_proximity_scale_available)); 606 if (val < 0 || val > 5 || val2 != 0) 607 return -EINVAL; 608 609 return val; 610 } 611 612 static int si1145_intensity_adcgain_from_scale(int val, int val2) 613 { 614 val = find_closest_descending(val, si1145_intensity_scale_available, 615 ARRAY_SIZE(si1145_intensity_scale_available)); 616 if (val < 0 || val > 7 || val2 != 0) 617 return -EINVAL; 618 619 return val; 620 } 621 622 static int si1145_read_raw(struct iio_dev *indio_dev, 623 struct iio_chan_spec const *chan, 624 int *val, int *val2, long mask) 625 { 626 struct si1145_data *data = iio_priv(indio_dev); 627 int ret; 628 u8 reg; 629 630 switch (mask) { 631 case IIO_CHAN_INFO_RAW: 632 switch (chan->type) { 633 case IIO_INTENSITY: 634 case IIO_PROXIMITY: 635 case IIO_VOLTAGE: 636 case IIO_TEMP: 637 case IIO_UVINDEX: 638 ret = iio_device_claim_direct_mode(indio_dev); 639 if (ret) 640 return ret; 641 ret = si1145_measure(indio_dev, chan); 642 iio_device_release_direct_mode(indio_dev); 643 644 if (ret < 0) 645 return ret; 646 647 *val = ret; 648 649 return IIO_VAL_INT; 650 case IIO_CURRENT: 651 ret = i2c_smbus_read_byte_data(data->client, 652 SI1145_PS_LED_REG(chan->channel)); 653 if (ret < 0) 654 return ret; 655 656 *val = (ret >> SI1145_PS_LED_SHIFT(chan->channel)) 657 & 0x0f; 658 659 return IIO_VAL_INT; 660 default: 661 return -EINVAL; 662 } 663 case IIO_CHAN_INFO_SCALE: 664 switch (chan->type) { 665 case IIO_PROXIMITY: 666 reg = SI1145_PARAM_PS_ADC_GAIN; 667 break; 668 case IIO_INTENSITY: 669 if (chan->channel2 == IIO_MOD_LIGHT_IR) 670 reg = SI1145_PARAM_ALSIR_ADC_GAIN; 671 else 672 reg = SI1145_PARAM_ALSVIS_ADC_GAIN; 673 break; 674 case IIO_TEMP: 675 *val = 28; 676 *val2 = 571429; 677 return IIO_VAL_INT_PLUS_MICRO; 678 case IIO_UVINDEX: 679 *val = 0; 680 *val2 = 10000; 681 return IIO_VAL_INT_PLUS_MICRO; 682 default: 683 return -EINVAL; 684 } 685 686 ret = si1145_param_query(data, reg); 687 if (ret < 0) 688 return ret; 689 690 *val = si1145_scale_from_adcgain(ret & 0x07); 691 692 return IIO_VAL_INT; 693 case IIO_CHAN_INFO_OFFSET: 694 switch (chan->type) { 695 case IIO_TEMP: 696 /* 697 * -ADC offset - ADC counts @ 25°C - 698 * 35 * ADC counts / °C 699 */ 700 *val = -256 - 11136 + 25 * 35; 701 return IIO_VAL_INT; 702 default: 703 /* 704 * All ADC measurements have are by default offset 705 * by -256 706 * See AN498 5.6.3 707 */ 708 ret = si1145_param_query(data, SI1145_PARAM_ADC_OFFSET); 709 if (ret < 0) 710 return ret; 711 *val = -si1145_uncompress(ret); 712 return IIO_VAL_INT; 713 } 714 case IIO_CHAN_INFO_SAMP_FREQ: 715 return si1145_read_samp_freq(data, val, val2); 716 default: 717 return -EINVAL; 718 } 719 } 720 721 static int si1145_write_raw(struct iio_dev *indio_dev, 722 struct iio_chan_spec const *chan, 723 int val, int val2, long mask) 724 { 725 struct si1145_data *data = iio_priv(indio_dev); 726 u8 reg1, reg2, shift; 727 int ret; 728 729 switch (mask) { 730 case IIO_CHAN_INFO_SCALE: 731 switch (chan->type) { 732 case IIO_PROXIMITY: 733 val = si1145_proximity_adcgain_from_scale(val, val2); 734 if (val < 0) 735 return val; 736 reg1 = SI1145_PARAM_PS_ADC_GAIN; 737 reg2 = SI1145_PARAM_PS_ADC_COUNTER; 738 break; 739 case IIO_INTENSITY: 740 val = si1145_intensity_adcgain_from_scale(val, val2); 741 if (val < 0) 742 return val; 743 if (chan->channel2 == IIO_MOD_LIGHT_IR) { 744 reg1 = SI1145_PARAM_ALSIR_ADC_GAIN; 745 reg2 = SI1145_PARAM_ALSIR_ADC_COUNTER; 746 } else { 747 reg1 = SI1145_PARAM_ALSVIS_ADC_GAIN; 748 reg2 = SI1145_PARAM_ALSVIS_ADC_COUNTER; 749 } 750 break; 751 default: 752 return -EINVAL; 753 } 754 755 ret = iio_device_claim_direct_mode(indio_dev); 756 if (ret) 757 return ret; 758 759 ret = si1145_param_set(data, reg1, val); 760 if (ret < 0) { 761 iio_device_release_direct_mode(indio_dev); 762 return ret; 763 } 764 /* Set recovery period to one's complement of gain */ 765 ret = si1145_param_set(data, reg2, (~val & 0x07) << 4); 766 iio_device_release_direct_mode(indio_dev); 767 return ret; 768 case IIO_CHAN_INFO_RAW: 769 if (chan->type != IIO_CURRENT) 770 return -EINVAL; 771 772 if (val < 0 || val > 15 || val2 != 0) 773 return -EINVAL; 774 775 reg1 = SI1145_PS_LED_REG(chan->channel); 776 shift = SI1145_PS_LED_SHIFT(chan->channel); 777 778 ret = iio_device_claim_direct_mode(indio_dev); 779 if (ret) 780 return ret; 781 782 ret = i2c_smbus_read_byte_data(data->client, reg1); 783 if (ret < 0) { 784 iio_device_release_direct_mode(indio_dev); 785 return ret; 786 } 787 ret = i2c_smbus_write_byte_data(data->client, reg1, 788 (ret & ~(0x0f << shift)) | 789 ((val & 0x0f) << shift)); 790 iio_device_release_direct_mode(indio_dev); 791 return ret; 792 case IIO_CHAN_INFO_SAMP_FREQ: 793 return si1145_store_samp_freq(data, val); 794 default: 795 return -EINVAL; 796 } 797 } 798 799 #define SI1145_ST { \ 800 .sign = 'u', \ 801 .realbits = 16, \ 802 .storagebits = 16, \ 803 .endianness = IIO_LE, \ 804 } 805 806 #define SI1145_INTENSITY_CHANNEL(_si) { \ 807 .type = IIO_INTENSITY, \ 808 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 809 BIT(IIO_CHAN_INFO_OFFSET) | \ 810 BIT(IIO_CHAN_INFO_SCALE), \ 811 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 812 .scan_type = SI1145_ST, \ 813 .scan_index = _si, \ 814 .address = SI1145_REG_ALSVIS_DATA, \ 815 } 816 817 #define SI1145_INTENSITY_IR_CHANNEL(_si) { \ 818 .type = IIO_INTENSITY, \ 819 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 820 BIT(IIO_CHAN_INFO_OFFSET) | \ 821 BIT(IIO_CHAN_INFO_SCALE), \ 822 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 823 .modified = 1, \ 824 .channel2 = IIO_MOD_LIGHT_IR, \ 825 .scan_type = SI1145_ST, \ 826 .scan_index = _si, \ 827 .address = SI1145_REG_ALSIR_DATA, \ 828 } 829 830 #define SI1145_TEMP_CHANNEL(_si) { \ 831 .type = IIO_TEMP, \ 832 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 833 BIT(IIO_CHAN_INFO_OFFSET) | \ 834 BIT(IIO_CHAN_INFO_SCALE), \ 835 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 836 .scan_type = SI1145_ST, \ 837 .scan_index = _si, \ 838 .address = SI1145_REG_AUX_DATA, \ 839 } 840 841 #define SI1145_UV_CHANNEL(_si) { \ 842 .type = IIO_UVINDEX, \ 843 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 844 BIT(IIO_CHAN_INFO_SCALE), \ 845 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 846 .scan_type = SI1145_ST, \ 847 .scan_index = _si, \ 848 .address = SI1145_REG_AUX_DATA, \ 849 } 850 851 #define SI1145_PROXIMITY_CHANNEL(_si, _ch) { \ 852 .type = IIO_PROXIMITY, \ 853 .indexed = 1, \ 854 .channel = _ch, \ 855 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 856 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 857 BIT(IIO_CHAN_INFO_OFFSET), \ 858 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 859 .scan_type = SI1145_ST, \ 860 .scan_index = _si, \ 861 .address = SI1145_REG_PS1_DATA + _ch * 2, \ 862 } 863 864 #define SI1145_VOLTAGE_CHANNEL(_si) { \ 865 .type = IIO_VOLTAGE, \ 866 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 867 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 868 .scan_type = SI1145_ST, \ 869 .scan_index = _si, \ 870 .address = SI1145_REG_AUX_DATA, \ 871 } 872 873 #define SI1145_CURRENT_CHANNEL(_ch) { \ 874 .type = IIO_CURRENT, \ 875 .indexed = 1, \ 876 .channel = _ch, \ 877 .output = 1, \ 878 .scan_index = -1, \ 879 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 880 } 881 882 static const struct iio_chan_spec si1132_channels[] = { 883 SI1145_INTENSITY_CHANNEL(0), 884 SI1145_INTENSITY_IR_CHANNEL(1), 885 SI1145_TEMP_CHANNEL(2), 886 SI1145_VOLTAGE_CHANNEL(3), 887 SI1145_UV_CHANNEL(4), 888 IIO_CHAN_SOFT_TIMESTAMP(6), 889 }; 890 891 static const struct iio_chan_spec si1141_channels[] = { 892 SI1145_INTENSITY_CHANNEL(0), 893 SI1145_INTENSITY_IR_CHANNEL(1), 894 SI1145_PROXIMITY_CHANNEL(2, 0), 895 SI1145_TEMP_CHANNEL(3), 896 SI1145_VOLTAGE_CHANNEL(4), 897 IIO_CHAN_SOFT_TIMESTAMP(5), 898 SI1145_CURRENT_CHANNEL(0), 899 }; 900 901 static const struct iio_chan_spec si1142_channels[] = { 902 SI1145_INTENSITY_CHANNEL(0), 903 SI1145_INTENSITY_IR_CHANNEL(1), 904 SI1145_PROXIMITY_CHANNEL(2, 0), 905 SI1145_PROXIMITY_CHANNEL(3, 1), 906 SI1145_TEMP_CHANNEL(4), 907 SI1145_VOLTAGE_CHANNEL(5), 908 IIO_CHAN_SOFT_TIMESTAMP(6), 909 SI1145_CURRENT_CHANNEL(0), 910 SI1145_CURRENT_CHANNEL(1), 911 }; 912 913 static const struct iio_chan_spec si1143_channels[] = { 914 SI1145_INTENSITY_CHANNEL(0), 915 SI1145_INTENSITY_IR_CHANNEL(1), 916 SI1145_PROXIMITY_CHANNEL(2, 0), 917 SI1145_PROXIMITY_CHANNEL(3, 1), 918 SI1145_PROXIMITY_CHANNEL(4, 2), 919 SI1145_TEMP_CHANNEL(5), 920 SI1145_VOLTAGE_CHANNEL(6), 921 IIO_CHAN_SOFT_TIMESTAMP(7), 922 SI1145_CURRENT_CHANNEL(0), 923 SI1145_CURRENT_CHANNEL(1), 924 SI1145_CURRENT_CHANNEL(2), 925 }; 926 927 static const struct iio_chan_spec si1145_channels[] = { 928 SI1145_INTENSITY_CHANNEL(0), 929 SI1145_INTENSITY_IR_CHANNEL(1), 930 SI1145_PROXIMITY_CHANNEL(2, 0), 931 SI1145_TEMP_CHANNEL(3), 932 SI1145_VOLTAGE_CHANNEL(4), 933 SI1145_UV_CHANNEL(5), 934 IIO_CHAN_SOFT_TIMESTAMP(6), 935 SI1145_CURRENT_CHANNEL(0), 936 }; 937 938 static const struct iio_chan_spec si1146_channels[] = { 939 SI1145_INTENSITY_CHANNEL(0), 940 SI1145_INTENSITY_IR_CHANNEL(1), 941 SI1145_TEMP_CHANNEL(2), 942 SI1145_VOLTAGE_CHANNEL(3), 943 SI1145_UV_CHANNEL(4), 944 SI1145_PROXIMITY_CHANNEL(5, 0), 945 SI1145_PROXIMITY_CHANNEL(6, 1), 946 IIO_CHAN_SOFT_TIMESTAMP(7), 947 SI1145_CURRENT_CHANNEL(0), 948 SI1145_CURRENT_CHANNEL(1), 949 }; 950 951 static const struct iio_chan_spec si1147_channels[] = { 952 SI1145_INTENSITY_CHANNEL(0), 953 SI1145_INTENSITY_IR_CHANNEL(1), 954 SI1145_PROXIMITY_CHANNEL(2, 0), 955 SI1145_PROXIMITY_CHANNEL(3, 1), 956 SI1145_PROXIMITY_CHANNEL(4, 2), 957 SI1145_TEMP_CHANNEL(5), 958 SI1145_VOLTAGE_CHANNEL(6), 959 SI1145_UV_CHANNEL(7), 960 IIO_CHAN_SOFT_TIMESTAMP(8), 961 SI1145_CURRENT_CHANNEL(0), 962 SI1145_CURRENT_CHANNEL(1), 963 SI1145_CURRENT_CHANNEL(2), 964 }; 965 966 static struct attribute *si1132_attributes[] = { 967 &iio_const_attr_in_intensity_scale_available.dev_attr.attr, 968 &iio_const_attr_in_intensity_ir_scale_available.dev_attr.attr, 969 NULL, 970 }; 971 972 static struct attribute *si114x_attributes[] = { 973 &iio_const_attr_in_intensity_scale_available.dev_attr.attr, 974 &iio_const_attr_in_intensity_ir_scale_available.dev_attr.attr, 975 &iio_const_attr_in_proximity_scale_available.dev_attr.attr, 976 NULL, 977 }; 978 979 static const struct attribute_group si1132_attribute_group = { 980 .attrs = si1132_attributes, 981 }; 982 983 static const struct attribute_group si114x_attribute_group = { 984 .attrs = si114x_attributes, 985 }; 986 987 988 static const struct iio_info si1132_info = { 989 .read_raw = si1145_read_raw, 990 .write_raw = si1145_write_raw, 991 .attrs = &si1132_attribute_group, 992 }; 993 994 static const struct iio_info si114x_info = { 995 .read_raw = si1145_read_raw, 996 .write_raw = si1145_write_raw, 997 .attrs = &si114x_attribute_group, 998 }; 999 1000 #define SI1145_PART(id, iio_info, chans, leds, uncompressed_meas_rate) \ 1001 {id, iio_info, chans, ARRAY_SIZE(chans), leds, uncompressed_meas_rate} 1002 1003 static const struct si1145_part_info si1145_part_info[] = { 1004 [SI1132] = SI1145_PART(0x32, &si1132_info, si1132_channels, 0, true), 1005 [SI1141] = SI1145_PART(0x41, &si114x_info, si1141_channels, 1, false), 1006 [SI1142] = SI1145_PART(0x42, &si114x_info, si1142_channels, 2, false), 1007 [SI1143] = SI1145_PART(0x43, &si114x_info, si1143_channels, 3, false), 1008 [SI1145] = SI1145_PART(0x45, &si114x_info, si1145_channels, 1, true), 1009 [SI1146] = SI1145_PART(0x46, &si114x_info, si1146_channels, 2, true), 1010 [SI1147] = SI1145_PART(0x47, &si114x_info, si1147_channels, 3, true), 1011 }; 1012 1013 static int si1145_initialize(struct si1145_data *data) 1014 { 1015 struct i2c_client *client = data->client; 1016 int ret; 1017 1018 ret = i2c_smbus_write_byte_data(client, SI1145_REG_COMMAND, 1019 SI1145_CMD_RESET); 1020 if (ret < 0) 1021 return ret; 1022 msleep(SI1145_COMMAND_TIMEOUT_MS); 1023 1024 /* Hardware key, magic value */ 1025 ret = i2c_smbus_write_byte_data(client, SI1145_REG_HW_KEY, 0x17); 1026 if (ret < 0) 1027 return ret; 1028 msleep(SI1145_COMMAND_TIMEOUT_MS); 1029 1030 /* Turn off autonomous mode */ 1031 ret = si1145_set_meas_rate(data, 0); 1032 if (ret < 0) 1033 return ret; 1034 1035 /* Initialize sampling freq to 10 Hz */ 1036 ret = si1145_store_samp_freq(data, 10); 1037 if (ret < 0) 1038 return ret; 1039 1040 /* Set LED currents to 45 mA; have 4 bits, see Table 2 in datasheet */ 1041 switch (data->part_info->num_leds) { 1042 case 3: 1043 ret = i2c_smbus_write_byte_data(client, 1044 SI1145_REG_PS_LED3, 1045 SI1145_LED_CURRENT_45mA); 1046 if (ret < 0) 1047 return ret; 1048 fallthrough; 1049 case 2: 1050 ret = i2c_smbus_write_byte_data(client, 1051 SI1145_REG_PS_LED21, 1052 (SI1145_LED_CURRENT_45mA << 4) | 1053 SI1145_LED_CURRENT_45mA); 1054 break; 1055 case 1: 1056 ret = i2c_smbus_write_byte_data(client, 1057 SI1145_REG_PS_LED21, 1058 SI1145_LED_CURRENT_45mA); 1059 break; 1060 default: 1061 ret = 0; 1062 break; 1063 } 1064 if (ret < 0) 1065 return ret; 1066 1067 /* Set normal proximity measurement mode */ 1068 ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_MISC, 1069 SI1145_PS_ADC_MODE_NORMAL); 1070 if (ret < 0) 1071 return ret; 1072 1073 ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_GAIN, 0x01); 1074 if (ret < 0) 1075 return ret; 1076 1077 /* ADC_COUNTER should be one complement of ADC_GAIN */ 1078 ret = si1145_param_set(data, SI1145_PARAM_PS_ADC_COUNTER, 0x06 << 4); 1079 if (ret < 0) 1080 return ret; 1081 1082 /* Set ALS visible measurement mode */ 1083 ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_MISC, 1084 SI1145_ADC_MISC_RANGE); 1085 if (ret < 0) 1086 return ret; 1087 1088 ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_GAIN, 0x03); 1089 if (ret < 0) 1090 return ret; 1091 1092 ret = si1145_param_set(data, SI1145_PARAM_ALSVIS_ADC_COUNTER, 1093 0x04 << 4); 1094 if (ret < 0) 1095 return ret; 1096 1097 /* Set ALS IR measurement mode */ 1098 ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_MISC, 1099 SI1145_ADC_MISC_RANGE); 1100 if (ret < 0) 1101 return ret; 1102 1103 ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_GAIN, 0x01); 1104 if (ret < 0) 1105 return ret; 1106 1107 ret = si1145_param_set(data, SI1145_PARAM_ALSIR_ADC_COUNTER, 1108 0x06 << 4); 1109 if (ret < 0) 1110 return ret; 1111 1112 /* 1113 * Initialize UCOEF to default values in datasheet 1114 * These registers are normally zero on reset 1115 */ 1116 if (data->part_info == &si1145_part_info[SI1132] || 1117 data->part_info == &si1145_part_info[SI1145] || 1118 data->part_info == &si1145_part_info[SI1146] || 1119 data->part_info == &si1145_part_info[SI1147]) { 1120 ret = i2c_smbus_write_byte_data(data->client, 1121 SI1145_REG_UCOEF1, 1122 SI1145_UCOEF1_DEFAULT); 1123 if (ret < 0) 1124 return ret; 1125 ret = i2c_smbus_write_byte_data(data->client, 1126 SI1145_REG_UCOEF2, SI1145_UCOEF2_DEFAULT); 1127 if (ret < 0) 1128 return ret; 1129 ret = i2c_smbus_write_byte_data(data->client, 1130 SI1145_REG_UCOEF3, SI1145_UCOEF3_DEFAULT); 1131 if (ret < 0) 1132 return ret; 1133 ret = i2c_smbus_write_byte_data(data->client, 1134 SI1145_REG_UCOEF4, SI1145_UCOEF4_DEFAULT); 1135 if (ret < 0) 1136 return ret; 1137 } 1138 1139 return 0; 1140 } 1141 1142 /* 1143 * Program the channels we want to measure with CMD_PSALS_AUTO. No need for 1144 * _postdisable as we stop with CMD_PSALS_PAUSE; single measurement (direct) 1145 * mode reprograms the channels list anyway... 1146 */ 1147 static int si1145_buffer_preenable(struct iio_dev *indio_dev) 1148 { 1149 struct si1145_data *data = iio_priv(indio_dev); 1150 int ret; 1151 1152 mutex_lock(&data->lock); 1153 ret = si1145_set_chlist(indio_dev, *indio_dev->active_scan_mask); 1154 mutex_unlock(&data->lock); 1155 1156 return ret; 1157 } 1158 1159 static bool si1145_validate_scan_mask(struct iio_dev *indio_dev, 1160 const unsigned long *scan_mask) 1161 { 1162 struct si1145_data *data = iio_priv(indio_dev); 1163 unsigned int count = 0; 1164 int i; 1165 1166 /* Check that at most one AUX channel is enabled */ 1167 for_each_set_bit(i, scan_mask, data->part_info->num_channels) { 1168 if (indio_dev->channels[i].address == SI1145_REG_AUX_DATA) 1169 count++; 1170 } 1171 1172 return count <= 1; 1173 } 1174 1175 static const struct iio_buffer_setup_ops si1145_buffer_setup_ops = { 1176 .preenable = si1145_buffer_preenable, 1177 .validate_scan_mask = si1145_validate_scan_mask, 1178 }; 1179 1180 /* 1181 * si1145_trigger_set_state() - Set trigger state 1182 * 1183 * When not using triggers interrupts are disabled and measurement rate is 1184 * set to zero in order to minimize power consumption. 1185 */ 1186 static int si1145_trigger_set_state(struct iio_trigger *trig, bool state) 1187 { 1188 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 1189 struct si1145_data *data = iio_priv(indio_dev); 1190 int err = 0, ret; 1191 1192 mutex_lock(&data->lock); 1193 1194 if (state) { 1195 data->autonomous = true; 1196 err = i2c_smbus_write_byte_data(data->client, 1197 SI1145_REG_INT_CFG, SI1145_INT_CFG_OE); 1198 if (err < 0) 1199 goto disable; 1200 err = i2c_smbus_write_byte_data(data->client, 1201 SI1145_REG_IRQ_ENABLE, SI1145_MASK_ALL_IE); 1202 if (err < 0) 1203 goto disable; 1204 err = si1145_set_meas_rate(data, data->meas_rate); 1205 if (err < 0) 1206 goto disable; 1207 err = si1145_command(data, SI1145_CMD_PSALS_AUTO); 1208 if (err < 0) 1209 goto disable; 1210 } else { 1211 disable: 1212 /* Disable as much as possible skipping errors */ 1213 ret = si1145_command(data, SI1145_CMD_PSALS_PAUSE); 1214 if (ret < 0 && !err) 1215 err = ret; 1216 ret = si1145_set_meas_rate(data, 0); 1217 if (ret < 0 && !err) 1218 err = ret; 1219 ret = i2c_smbus_write_byte_data(data->client, 1220 SI1145_REG_IRQ_ENABLE, 0); 1221 if (ret < 0 && !err) 1222 err = ret; 1223 ret = i2c_smbus_write_byte_data(data->client, 1224 SI1145_REG_INT_CFG, 0); 1225 if (ret < 0 && !err) 1226 err = ret; 1227 data->autonomous = false; 1228 } 1229 1230 mutex_unlock(&data->lock); 1231 return err; 1232 } 1233 1234 static const struct iio_trigger_ops si1145_trigger_ops = { 1235 .set_trigger_state = si1145_trigger_set_state, 1236 }; 1237 1238 static int si1145_probe_trigger(struct iio_dev *indio_dev) 1239 { 1240 struct si1145_data *data = iio_priv(indio_dev); 1241 struct i2c_client *client = data->client; 1242 struct iio_trigger *trig; 1243 int ret; 1244 1245 trig = devm_iio_trigger_alloc(&client->dev, 1246 "%s-dev%d", indio_dev->name, indio_dev->id); 1247 if (!trig) 1248 return -ENOMEM; 1249 1250 trig->ops = &si1145_trigger_ops; 1251 iio_trigger_set_drvdata(trig, indio_dev); 1252 1253 ret = devm_request_irq(&client->dev, client->irq, 1254 iio_trigger_generic_data_rdy_poll, 1255 IRQF_TRIGGER_FALLING, 1256 "si1145_irq", 1257 trig); 1258 if (ret < 0) { 1259 dev_err(&client->dev, "irq request failed\n"); 1260 return ret; 1261 } 1262 1263 ret = devm_iio_trigger_register(&client->dev, trig); 1264 if (ret) 1265 return ret; 1266 1267 data->trig = trig; 1268 indio_dev->trig = iio_trigger_get(data->trig); 1269 1270 return 0; 1271 } 1272 1273 static int si1145_probe(struct i2c_client *client, 1274 const struct i2c_device_id *id) 1275 { 1276 struct si1145_data *data; 1277 struct iio_dev *indio_dev; 1278 u8 part_id, rev_id, seq_id; 1279 int ret; 1280 1281 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 1282 if (!indio_dev) 1283 return -ENOMEM; 1284 1285 data = iio_priv(indio_dev); 1286 i2c_set_clientdata(client, indio_dev); 1287 data->client = client; 1288 data->part_info = &si1145_part_info[id->driver_data]; 1289 1290 part_id = ret = i2c_smbus_read_byte_data(data->client, 1291 SI1145_REG_PART_ID); 1292 if (ret < 0) 1293 return ret; 1294 rev_id = ret = i2c_smbus_read_byte_data(data->client, 1295 SI1145_REG_REV_ID); 1296 if (ret < 0) 1297 return ret; 1298 seq_id = ret = i2c_smbus_read_byte_data(data->client, 1299 SI1145_REG_SEQ_ID); 1300 if (ret < 0) 1301 return ret; 1302 dev_info(&client->dev, "device ID part %#02hhx rev %#02hhx seq %#02hhx\n", 1303 part_id, rev_id, seq_id); 1304 if (part_id != data->part_info->part) { 1305 dev_err(&client->dev, "part ID mismatch got %#02hhx, expected %#02x\n", 1306 part_id, data->part_info->part); 1307 return -ENODEV; 1308 } 1309 1310 indio_dev->name = id->name; 1311 indio_dev->channels = data->part_info->channels; 1312 indio_dev->num_channels = data->part_info->num_channels; 1313 indio_dev->info = data->part_info->iio_info; 1314 indio_dev->modes = INDIO_DIRECT_MODE; 1315 1316 mutex_init(&data->lock); 1317 mutex_init(&data->cmdlock); 1318 1319 ret = si1145_initialize(data); 1320 if (ret < 0) 1321 return ret; 1322 1323 ret = devm_iio_triggered_buffer_setup(&client->dev, 1324 indio_dev, NULL, 1325 si1145_trigger_handler, &si1145_buffer_setup_ops); 1326 if (ret < 0) 1327 return ret; 1328 1329 if (client->irq) { 1330 ret = si1145_probe_trigger(indio_dev); 1331 if (ret < 0) 1332 return ret; 1333 } else { 1334 dev_info(&client->dev, "no irq, using polling\n"); 1335 } 1336 1337 return devm_iio_device_register(&client->dev, indio_dev); 1338 } 1339 1340 static const struct i2c_device_id si1145_ids[] = { 1341 { "si1132", SI1132 }, 1342 { "si1141", SI1141 }, 1343 { "si1142", SI1142 }, 1344 { "si1143", SI1143 }, 1345 { "si1145", SI1145 }, 1346 { "si1146", SI1146 }, 1347 { "si1147", SI1147 }, 1348 { } 1349 }; 1350 MODULE_DEVICE_TABLE(i2c, si1145_ids); 1351 1352 static struct i2c_driver si1145_driver = { 1353 .driver = { 1354 .name = "si1145", 1355 }, 1356 .probe = si1145_probe, 1357 .id_table = si1145_ids, 1358 }; 1359 1360 module_i2c_driver(si1145_driver); 1361 1362 MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>"); 1363 MODULE_DESCRIPTION("Silabs SI1132 and SI1141/2/3/5/6/7 proximity, ambient light and UV index sensor driver"); 1364 MODULE_LICENSE("GPL"); 1365