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