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