projects/linux·blob master · refs

793 lines · 18.3 KiB

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