1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * cc2.c - Support for the Amphenol ChipCap 2 relative humidity, temperature sensor 4 * 5 * Part numbers supported: 6 * CC2D23, CC2D23S, CC2D25, CC2D25S, CC2D33, CC2D33S, CC2D35, CC2D35S 7 * 8 * Author: Javier Carrasco <javier.carrasco.cruz@gmail.com> 9 * 10 * Datasheet and application notes: 11 * https://www.amphenol-sensors.com/en/telaire/humidity/527-humidity-sensors/3095-chipcap-2 12 */ 13 14 #include <linux/bitfield.h> 15 #include <linux/bits.h> 16 #include <linux/cleanup.h> 17 #include <linux/completion.h> 18 #include <linux/delay.h> 19 #include <linux/hwmon.h> 20 #include <linux/i2c.h> 21 #include <linux/interrupt.h> 22 #include <linux/irq.h> 23 #include <linux/module.h> 24 #include <linux/regulator/consumer.h> 25 #include <linux/mod_devicetable.h> 26 #include <linux/property.h> 27 28 #define CC2_START_CM 0xA0 29 #define CC2_START_NOM 0x80 30 #define CC2_R_ALARM_H_ON 0x18 31 #define CC2_R_ALARM_H_OFF 0x19 32 #define CC2_R_ALARM_L_ON 0x1A 33 #define CC2_R_ALARM_L_OFF 0x1B 34 #define CC2_RW_OFFSET 0x40 35 #define CC2_W_ALARM_H_ON (CC2_R_ALARM_H_ON + CC2_RW_OFFSET) 36 #define CC2_W_ALARM_H_OFF (CC2_R_ALARM_H_OFF + CC2_RW_OFFSET) 37 #define CC2_W_ALARM_L_ON (CC2_R_ALARM_L_ON + CC2_RW_OFFSET) 38 #define CC2_W_ALARM_L_OFF (CC2_R_ALARM_L_OFF + CC2_RW_OFFSET) 39 40 #define CC2_STATUS_FIELD GENMASK(7, 6) 41 #define CC2_STATUS_VALID_DATA 0x00 42 #define CC2_STATUS_STALE_DATA 0x01 43 #define CC2_STATUS_CMD_MODE 0x02 44 45 #define CC2_RESPONSE_FIELD GENMASK(1, 0) 46 #define CC2_RESPONSE_BUSY 0x00 47 #define CC2_RESPONSE_ACK 0x01 48 #define CC2_RESPONSE_NACK 0x02 49 50 #define CC2_ERR_CORR_EEPROM BIT(2) 51 #define CC2_ERR_UNCORR_EEPROM BIT(3) 52 #define CC2_ERR_RAM_PARITY BIT(4) 53 #define CC2_ERR_CONFIG_LOAD BIT(5) 54 55 #define CC2_EEPROM_SIZE 10 56 #define CC2_EEPROM_DATA_LEN 3 57 #define CC2_MEASUREMENT_DATA_LEN 4 58 59 #define CC2_RH_DATA_FIELD GENMASK(13, 0) 60 61 /* ensure clean off -> on transitions */ 62 #define CC2_POWER_CYCLE_MS 80 63 64 #define CC2_STARTUP_TO_DATA_MS 55 65 #define CC2_RESP_START_CM_US 100 66 #define CC2_RESP_EEPROM_R_US 100 67 #define CC2_RESP_EEPROM_W_MS 12 68 #define CC2_STARTUP_TIME_US 1250 69 70 #define CC2_RH_MAX (100 * 1000U) 71 72 #define CC2_CM_RETRIES 5 73 74 struct cc2_rh_alarm_info { 75 bool low_alarm; 76 bool high_alarm; 77 bool low_alarm_visible; 78 bool high_alarm_visible; 79 }; 80 81 struct cc2_data { 82 struct cc2_rh_alarm_info rh_alarm; 83 struct completion complete; 84 struct device *hwmon; 85 struct i2c_client *client; 86 struct regulator *regulator; 87 const char *name; 88 const char *label; 89 int irq_ready; 90 int irq_low; 91 int irq_high; 92 bool process_irqs; 93 }; 94 95 enum cc2_chan_addr { 96 CC2_CHAN_TEMP = 0, 97 CC2_CHAN_HUMIDITY, 98 }; 99 100 /* %RH as a per cent mille from a register value */ 101 static long cc2_rh_convert(u16 data) 102 { 103 unsigned long tmp = (data & CC2_RH_DATA_FIELD) * CC2_RH_MAX; 104 105 return tmp / ((1 << 14) - 1); 106 } 107 108 /* convert %RH to a register value */ 109 static u16 cc2_rh_to_reg(long data) 110 { 111 return data * ((1 << 14) - 1) / CC2_RH_MAX; 112 } 113 114 /* temperature in milli degrees celsius from a register value */ 115 static long cc2_temp_convert(u16 data) 116 { 117 unsigned long tmp = ((data >> 2) * 165 * 1000U) / ((1 << 14) - 1); 118 119 return tmp - 40 * 1000U; 120 } 121 122 static int cc2_enable(struct cc2_data *data) 123 { 124 int ret; 125 126 /* exclusive regulator, check in case a disable failed */ 127 if (regulator_is_enabled(data->regulator)) 128 return 0; 129 130 /* clear any pending completion */ 131 try_wait_for_completion(&data->complete); 132 133 ret = regulator_enable(data->regulator); 134 if (ret < 0) 135 return ret; 136 137 usleep_range(CC2_STARTUP_TIME_US, CC2_STARTUP_TIME_US + 125); 138 139 data->process_irqs = true; 140 141 return 0; 142 } 143 144 static void cc2_disable(struct cc2_data *data) 145 { 146 int err; 147 148 /* ignore alarms triggered by voltage toggling when powering up */ 149 data->process_irqs = false; 150 151 /* exclusive regulator, check in case an enable failed */ 152 if (regulator_is_enabled(data->regulator)) { 153 err = regulator_disable(data->regulator); 154 if (err) 155 dev_dbg(&data->client->dev, "Failed to disable device"); 156 } 157 } 158 159 static int cc2_cmd_response_diagnostic(struct device *dev, u8 status) 160 { 161 int resp; 162 163 if (FIELD_GET(CC2_STATUS_FIELD, status) != CC2_STATUS_CMD_MODE) { 164 dev_dbg(dev, "Command sent out of command window\n"); 165 return -ETIMEDOUT; 166 } 167 168 resp = FIELD_GET(CC2_RESPONSE_FIELD, status); 169 switch (resp) { 170 case CC2_RESPONSE_ACK: 171 return 0; 172 case CC2_RESPONSE_BUSY: 173 return -EBUSY; 174 case CC2_RESPONSE_NACK: 175 if (resp & CC2_ERR_CORR_EEPROM) 176 dev_dbg(dev, "Command failed: corrected EEPROM\n"); 177 if (resp & CC2_ERR_UNCORR_EEPROM) 178 dev_dbg(dev, "Command failed: uncorrected EEPROM\n"); 179 if (resp & CC2_ERR_RAM_PARITY) 180 dev_dbg(dev, "Command failed: RAM parity\n"); 181 if (resp & CC2_ERR_RAM_PARITY) 182 dev_dbg(dev, "Command failed: configuration error\n"); 183 return -ENODATA; 184 default: 185 dev_dbg(dev, "Unknown command reply\n"); 186 return -EINVAL; 187 } 188 } 189 190 static int cc2_read_command_status(struct i2c_client *client) 191 { 192 u8 status; 193 int ret; 194 195 ret = i2c_master_recv(client, &status, 1); 196 if (ret != 1) { 197 ret = ret < 0 ? ret : -EIO; 198 return ret; 199 } 200 201 return cc2_cmd_response_diagnostic(&client->dev, status); 202 } 203 204 /* 205 * The command mode is only accessible after sending the START_CM command in the 206 * first 10 ms after power-up. Only in case the command window is missed, 207 * CC2_CM_RETRIES retries are attempted before giving up and returning an error. 208 */ 209 static int cc2_command_mode_start(struct cc2_data *data) 210 { 211 unsigned long timeout; 212 int i, ret; 213 214 for (i = 0; i < CC2_CM_RETRIES; i++) { 215 ret = cc2_enable(data); 216 if (ret < 0) 217 return ret; 218 219 ret = i2c_smbus_write_word_data(data->client, CC2_START_CM, 0); 220 if (ret < 0) 221 return ret; 222 223 if (data->irq_ready > 0) { 224 timeout = usecs_to_jiffies(2 * CC2_RESP_START_CM_US); 225 ret = wait_for_completion_timeout(&data->complete, 226 timeout); 227 if (!ret) 228 return -ETIMEDOUT; 229 } else { 230 usleep_range(CC2_RESP_START_CM_US, 231 2 * CC2_RESP_START_CM_US); 232 } 233 ret = cc2_read_command_status(data->client); 234 if (ret != -ETIMEDOUT || i == CC2_CM_RETRIES) 235 break; 236 237 /* command window missed, prepare for a retry */ 238 cc2_disable(data); 239 msleep(CC2_POWER_CYCLE_MS); 240 } 241 242 return ret; 243 } 244 245 /* Sending a Start_NOM command finishes the command mode immediately with no 246 * reply and the device enters normal operation mode 247 */ 248 static int cc2_command_mode_finish(struct cc2_data *data) 249 { 250 int ret; 251 252 ret = i2c_smbus_write_word_data(data->client, CC2_START_NOM, 0); 253 if (ret < 0) 254 return ret; 255 256 return 0; 257 } 258 259 static int cc2_write_reg(struct cc2_data *data, u8 reg, u16 val) 260 { 261 unsigned long timeout; 262 int ret; 263 264 ret = cc2_command_mode_start(data); 265 if (ret < 0) 266 goto disable; 267 268 cpu_to_be16s(&val); 269 ret = i2c_smbus_write_word_data(data->client, reg, val); 270 if (ret < 0) 271 goto disable; 272 273 if (data->irq_ready > 0) { 274 timeout = msecs_to_jiffies(2 * CC2_RESP_EEPROM_W_MS); 275 ret = wait_for_completion_timeout(&data->complete, timeout); 276 if (!ret) { 277 ret = -ETIMEDOUT; 278 goto disable; 279 } 280 } else { 281 msleep(CC2_RESP_EEPROM_W_MS); 282 } 283 284 ret = cc2_read_command_status(data->client); 285 286 disable: 287 cc2_disable(data); 288 289 return ret; 290 } 291 292 static int cc2_read_reg(struct cc2_data *data, u8 reg, u16 *val) 293 { 294 u8 buf[CC2_EEPROM_DATA_LEN]; 295 unsigned long timeout; 296 int ret; 297 298 ret = cc2_command_mode_start(data); 299 if (ret < 0) 300 return ret; 301 302 ret = i2c_smbus_write_word_data(data->client, reg, 0); 303 if (ret < 0) 304 return ret; 305 306 if (data->irq_ready > 0) { 307 timeout = usecs_to_jiffies(2 * CC2_RESP_EEPROM_R_US); 308 ret = wait_for_completion_timeout(&data->complete, timeout); 309 if (!ret) 310 return -ETIMEDOUT; 311 312 } else { 313 usleep_range(CC2_RESP_EEPROM_R_US, CC2_RESP_EEPROM_R_US + 10); 314 } 315 ret = i2c_master_recv(data->client, buf, CC2_EEPROM_DATA_LEN); 316 if (ret != CC2_EEPROM_DATA_LEN) 317 return ret < 0 ? ret : -EIO; 318 319 *val = be16_to_cpup((__be16 *)&buf[1]); 320 321 return cc2_read_command_status(data->client); 322 } 323 324 static int cc2_get_reg_val(struct cc2_data *data, u8 reg, long *val) 325 { 326 u16 reg_val; 327 int ret; 328 329 ret = cc2_read_reg(data, reg, ®_val); 330 if (!ret) 331 *val = cc2_rh_convert(reg_val); 332 333 cc2_disable(data); 334 335 return ret; 336 } 337 338 static int cc2_data_fetch(struct i2c_client *client, 339 enum hwmon_sensor_types type, long *val) 340 { 341 u8 data[CC2_MEASUREMENT_DATA_LEN]; 342 u8 status; 343 int ret; 344 345 ret = i2c_master_recv(client, data, CC2_MEASUREMENT_DATA_LEN); 346 if (ret != CC2_MEASUREMENT_DATA_LEN) { 347 ret = ret < 0 ? ret : -EIO; 348 return ret; 349 } 350 status = FIELD_GET(CC2_STATUS_FIELD, data[0]); 351 if (status == CC2_STATUS_STALE_DATA) 352 return -EBUSY; 353 354 if (status != CC2_STATUS_VALID_DATA) 355 return -EIO; 356 357 switch (type) { 358 case hwmon_humidity: 359 *val = cc2_rh_convert(be16_to_cpup((__be16 *)&data[0])); 360 break; 361 case hwmon_temp: 362 *val = cc2_temp_convert(be16_to_cpup((__be16 *)&data[2])); 363 break; 364 default: 365 return -EINVAL; 366 } 367 368 return 0; 369 } 370 371 static int cc2_read_measurement(struct cc2_data *data, 372 enum hwmon_sensor_types type, long *val) 373 { 374 unsigned long timeout; 375 int ret; 376 377 if (data->irq_ready > 0) { 378 timeout = msecs_to_jiffies(CC2_STARTUP_TO_DATA_MS * 2); 379 ret = wait_for_completion_timeout(&data->complete, timeout); 380 if (!ret) 381 return -ETIMEDOUT; 382 383 } else { 384 msleep(CC2_STARTUP_TO_DATA_MS); 385 } 386 387 ret = cc2_data_fetch(data->client, type, val); 388 389 return ret; 390 } 391 392 /* 393 * A measurement requires enabling the device, waiting for the automatic 394 * measurement to finish, reading the measurement data and disabling the device 395 * again. 396 */ 397 static int cc2_measurement(struct cc2_data *data, enum hwmon_sensor_types type, 398 long *val) 399 { 400 int ret; 401 402 ret = cc2_enable(data); 403 if (ret) 404 return ret; 405 406 ret = cc2_read_measurement(data, type, val); 407 408 cc2_disable(data); 409 410 return ret; 411 } 412 413 /* 414 * In order to check alarm status, the corresponding ALARM_OFF (hysteresis) 415 * register must be read and a new measurement must be carried out to trigger 416 * the alarm signals. Given that the device carries out a measurement after 417 * exiting the command mode, there is no need to force two power-up sequences. 418 * Instead, a NOM command is sent and the device is disabled after the 419 * measurement is read. 420 */ 421 static int cc2_read_hyst_and_measure(struct cc2_data *data, u8 reg, 422 long *hyst, long *measurement) 423 { 424 u16 reg_val; 425 int ret; 426 427 ret = cc2_read_reg(data, reg, ®_val); 428 if (ret) 429 goto disable; 430 431 *hyst = cc2_rh_convert(reg_val); 432 433 ret = cc2_command_mode_finish(data); 434 if (ret) 435 goto disable; 436 437 ret = cc2_read_measurement(data, hwmon_humidity, measurement); 438 439 disable: 440 cc2_disable(data); 441 442 return ret; 443 } 444 445 static umode_t cc2_is_visible(const void *data, enum hwmon_sensor_types type, 446 u32 attr, int channel) 447 { 448 const struct cc2_data *cc2 = data; 449 450 switch (type) { 451 case hwmon_humidity: 452 switch (attr) { 453 case hwmon_humidity_input: 454 return 0444; 455 case hwmon_humidity_label: 456 return cc2->label ? 0444 : 0; 457 case hwmon_humidity_min_alarm: 458 return cc2->rh_alarm.low_alarm_visible ? 0444 : 0; 459 case hwmon_humidity_max_alarm: 460 return cc2->rh_alarm.high_alarm_visible ? 0444 : 0; 461 case hwmon_humidity_min: 462 case hwmon_humidity_min_hyst: 463 return cc2->rh_alarm.low_alarm_visible ? 0644 : 0; 464 case hwmon_humidity_max: 465 case hwmon_humidity_max_hyst: 466 return cc2->rh_alarm.high_alarm_visible ? 0644 : 0; 467 default: 468 return 0; 469 } 470 case hwmon_temp: 471 switch (attr) { 472 case hwmon_temp_input: 473 return 0444; 474 case hwmon_temp_label: 475 return cc2->label ? 0444 : 0; 476 default: 477 return 0; 478 } 479 default: 480 break; 481 } 482 483 return 0; 484 } 485 486 static irqreturn_t cc2_ready_interrupt(int irq, void *data) 487 { 488 struct cc2_data *cc2 = data; 489 490 if (cc2->process_irqs) 491 complete(&cc2->complete); 492 493 return IRQ_HANDLED; 494 } 495 496 static irqreturn_t cc2_low_interrupt(int irq, void *data) 497 { 498 struct cc2_data *cc2 = data; 499 500 if (cc2->process_irqs) { 501 hwmon_notify_event(cc2->hwmon, hwmon_humidity, 502 hwmon_humidity_min_alarm, CC2_CHAN_HUMIDITY); 503 cc2->rh_alarm.low_alarm = true; 504 } 505 506 return IRQ_HANDLED; 507 } 508 509 static irqreturn_t cc2_high_interrupt(int irq, void *data) 510 { 511 struct cc2_data *cc2 = data; 512 513 if (cc2->process_irqs) { 514 hwmon_notify_event(cc2->hwmon, hwmon_humidity, 515 hwmon_humidity_max_alarm, CC2_CHAN_HUMIDITY); 516 cc2->rh_alarm.high_alarm = true; 517 } 518 519 return IRQ_HANDLED; 520 } 521 522 static int cc2_humidity_min_alarm_status(struct cc2_data *data, long *val) 523 { 524 long measurement, min_hyst; 525 int ret; 526 527 ret = cc2_read_hyst_and_measure(data, CC2_R_ALARM_L_OFF, &min_hyst, 528 &measurement); 529 if (ret < 0) 530 return ret; 531 532 if (data->rh_alarm.low_alarm) { 533 *val = (measurement < min_hyst) ? 1 : 0; 534 data->rh_alarm.low_alarm = *val; 535 } else { 536 *val = 0; 537 } 538 539 return 0; 540 } 541 542 static int cc2_humidity_max_alarm_status(struct cc2_data *data, long *val) 543 { 544 long measurement, max_hyst; 545 int ret; 546 547 ret = cc2_read_hyst_and_measure(data, CC2_R_ALARM_H_OFF, &max_hyst, 548 &measurement); 549 if (ret < 0) 550 return ret; 551 552 if (data->rh_alarm.high_alarm) { 553 *val = (measurement > max_hyst) ? 1 : 0; 554 data->rh_alarm.high_alarm = *val; 555 } else { 556 *val = 0; 557 } 558 559 return 0; 560 } 561 562 static int cc2_read_string(struct device *dev, enum hwmon_sensor_types type, 563 u32 attr, int channel, const char **str) 564 { 565 struct cc2_data *data = dev_get_drvdata(dev); 566 567 *str = data->label; 568 569 return 0; 570 } 571 572 static int cc2_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, 573 int channel, long *val) 574 { 575 struct cc2_data *data = dev_get_drvdata(dev); 576 577 switch (type) { 578 case hwmon_temp: 579 return cc2_measurement(data, type, val); 580 case hwmon_humidity: 581 switch (attr) { 582 case hwmon_humidity_input: 583 return cc2_measurement(data, type, val); 584 case hwmon_humidity_min: 585 return cc2_get_reg_val(data, CC2_R_ALARM_L_ON, val); 586 case hwmon_humidity_min_hyst: 587 return cc2_get_reg_val(data, CC2_R_ALARM_L_OFF, val); 588 case hwmon_humidity_max: 589 return cc2_get_reg_val(data, CC2_R_ALARM_H_ON, val); 590 case hwmon_humidity_max_hyst: 591 return cc2_get_reg_val(data, CC2_R_ALARM_H_OFF, val); 592 case hwmon_humidity_min_alarm: 593 return cc2_humidity_min_alarm_status(data, val); 594 case hwmon_humidity_max_alarm: 595 return cc2_humidity_max_alarm_status(data, val); 596 default: 597 return -EOPNOTSUPP; 598 } 599 default: 600 return -EOPNOTSUPP; 601 } 602 } 603 604 static int cc2_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, 605 int channel, long val) 606 { 607 struct cc2_data *data = dev_get_drvdata(dev); 608 u16 arg; 609 u8 cmd; 610 611 if (type != hwmon_humidity) 612 return -EOPNOTSUPP; 613 614 if (val < 0 || val > CC2_RH_MAX) 615 return -EINVAL; 616 617 switch (attr) { 618 case hwmon_humidity_min: 619 cmd = CC2_W_ALARM_L_ON; 620 arg = cc2_rh_to_reg(val); 621 return cc2_write_reg(data, cmd, arg); 622 case hwmon_humidity_min_hyst: 623 cmd = CC2_W_ALARM_L_OFF; 624 arg = cc2_rh_to_reg(val); 625 return cc2_write_reg(data, cmd, arg); 626 case hwmon_humidity_max: 627 cmd = CC2_W_ALARM_H_ON; 628 arg = cc2_rh_to_reg(val); 629 return cc2_write_reg(data, cmd, arg); 630 case hwmon_humidity_max_hyst: 631 cmd = CC2_W_ALARM_H_OFF; 632 arg = cc2_rh_to_reg(val); 633 return cc2_write_reg(data, cmd, arg); 634 default: 635 return -EOPNOTSUPP; 636 } 637 } 638 639 static int cc2_request_ready_irq(struct cc2_data *data, struct device *dev) 640 { 641 int ret = 0; 642 643 data->irq_ready = fwnode_irq_get_byname(dev_fwnode(dev), "ready"); 644 if (data->irq_ready > 0) { 645 init_completion(&data->complete); 646 ret = devm_request_threaded_irq(dev, data->irq_ready, NULL, 647 cc2_ready_interrupt, 648 IRQF_ONESHOT | 649 IRQF_TRIGGER_RISING, 650 dev_name(dev), data); 651 } 652 653 return ret; 654 } 655 656 static int cc2_request_alarm_irqs(struct cc2_data *data, struct device *dev) 657 { 658 int ret = 0; 659 660 data->irq_low = fwnode_irq_get_byname(dev_fwnode(dev), "low"); 661 if (data->irq_low > 0) { 662 ret = devm_request_threaded_irq(dev, data->irq_low, NULL, 663 cc2_low_interrupt, 664 IRQF_ONESHOT | 665 IRQF_TRIGGER_RISING, 666 dev_name(dev), data); 667 if (ret) 668 return ret; 669 670 data->rh_alarm.low_alarm_visible = true; 671 } 672 673 data->irq_high = fwnode_irq_get_byname(dev_fwnode(dev), "high"); 674 if (data->irq_high > 0) { 675 ret = devm_request_threaded_irq(dev, data->irq_high, NULL, 676 cc2_high_interrupt, 677 IRQF_ONESHOT | 678 IRQF_TRIGGER_RISING, 679 dev_name(dev), data); 680 if (ret) 681 return ret; 682 683 data->rh_alarm.high_alarm_visible = true; 684 } 685 686 return ret; 687 } 688 689 static const struct hwmon_channel_info *cc2_info[] = { 690 HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT | HWMON_T_LABEL), 691 HWMON_CHANNEL_INFO(humidity, HWMON_H_INPUT | HWMON_H_LABEL | 692 HWMON_H_MIN | HWMON_H_MAX | 693 HWMON_H_MIN_HYST | HWMON_H_MAX_HYST | 694 HWMON_H_MIN_ALARM | HWMON_H_MAX_ALARM), 695 NULL 696 }; 697 698 static const struct hwmon_ops cc2_hwmon_ops = { 699 .is_visible = cc2_is_visible, 700 .read = cc2_read, 701 .read_string = cc2_read_string, 702 .write = cc2_write, 703 }; 704 705 static const struct hwmon_chip_info cc2_chip_info = { 706 .ops = &cc2_hwmon_ops, 707 .info = cc2_info, 708 }; 709 710 static int cc2_probe(struct i2c_client *client) 711 { 712 struct cc2_data *data; 713 struct device *dev = &client->dev; 714 int ret; 715 716 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 717 return -EOPNOTSUPP; 718 719 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 720 if (!data) 721 return -ENOMEM; 722 723 i2c_set_clientdata(client, data); 724 725 data->client = client; 726 727 data->regulator = devm_regulator_get_exclusive(dev, "vdd"); 728 if (IS_ERR(data->regulator)) 729 return dev_err_probe(dev, PTR_ERR(data->regulator), 730 "Failed to get regulator\n"); 731 732 device_property_read_string(dev, "label", &data->label); 733 734 ret = cc2_request_ready_irq(data, dev); 735 if (ret) 736 return dev_err_probe(dev, ret, "Failed to request ready irq\n"); 737 738 ret = cc2_request_alarm_irqs(data, dev); 739 if (ret) 740 return dev_err_probe(dev, ret, "Failed to request alarm irqs\n"); 741 742 data->hwmon = devm_hwmon_device_register_with_info(dev, client->name, 743 data, &cc2_chip_info, 744 NULL); 745 if (IS_ERR(data->hwmon)) 746 return dev_err_probe(dev, PTR_ERR(data->hwmon), 747 "Failed to register hwmon device\n"); 748 749 return 0; 750 } 751 752 static void cc2_remove(struct i2c_client *client) 753 { 754 struct cc2_data *data = i2c_get_clientdata(client); 755 756 cc2_disable(data); 757 } 758 759 static const struct i2c_device_id cc2_id[] = { 760 { .name = "cc2d23" }, 761 { .name = "cc2d23s" }, 762 { .name = "cc2d25" }, 763 { .name = "cc2d25s" }, 764 { .name = "cc2d33" }, 765 { .name = "cc2d33s" }, 766 { .name = "cc2d35" }, 767 { .name = "cc2d35s" }, 768 { } 769 }; 770 MODULE_DEVICE_TABLE(i2c, cc2_id); 771 772 static const struct of_device_id cc2_of_match[] = { 773 { .compatible = "amphenol,cc2d23" }, 774 { .compatible = "amphenol,cc2d23s" }, 775 { .compatible = "amphenol,cc2d25" }, 776 { .compatible = "amphenol,cc2d25s" }, 777 { .compatible = "amphenol,cc2d33" }, 778 { .compatible = "amphenol,cc2d33s" }, 779 { .compatible = "amphenol,cc2d35" }, 780 { .compatible = "amphenol,cc2d35s" }, 781 { }, 782 }; 783 MODULE_DEVICE_TABLE(of, cc2_of_match); 784 785 static struct i2c_driver cc2_driver = { 786 .driver = { 787 .name = "cc2d23", 788 .of_match_table = cc2_of_match, 789 }, 790 .probe = cc2_probe, 791 .remove = cc2_remove, 792 .id_table = cc2_id, 793 }; 794 module_i2c_driver(cc2_driver); 795 796 MODULE_AUTHOR("Javier Carrasco <javier.carrasco.cruz@gamil.com>"); 797 MODULE_DESCRIPTION("Amphenol ChipCap 2 humidity and temperature sensor driver"); 798 MODULE_LICENSE("GPL"); 799