1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * mcp9600.c - Support for Microchip MCP9600 thermocouple EMF converter
4 *
5 * Copyright (c) 2022 Andrew Hepp
6 * Author: <andrew.hepp@ahepp.dev>
7 */
8
9 #include <linux/bitfield.h>
10 #include <linux/bitops.h>
11 #include <linux/bits.h>
12 #include <linux/err.h>
13 #include <linux/i2c.h>
14 #include <linux/init.h>
15 #include <linux/interrupt.h>
16 #include <linux/irq.h>
17 #include <linux/math.h>
18 #include <linux/minmax.h>
19 #include <linux/module.h>
20
21 #include <linux/iio/events.h>
22 #include <linux/iio/iio.h>
23
24 #include <dt-bindings/iio/temperature/thermocouple.h>
25
26 /* MCP9600 registers */
27 #define MCP9600_HOT_JUNCTION 0x00
28 #define MCP9600_COLD_JUNCTION 0x02
29 #define MCP9600_STATUS 0x04
30 #define MCP9600_STATUS_ALERT(x) BIT(x)
31 #define MCP9600_SENSOR_CFG 0x05
32 #define MCP9600_SENSOR_TYPE_MASK GENMASK(6, 4)
33 #define MCP9600_ALERT_CFG1 0x08
34 #define MCP9600_ALERT_CFG(x) (MCP9600_ALERT_CFG1 + (x - 1))
35 #define MCP9600_ALERT_CFG_ENABLE BIT(0)
36 #define MCP9600_ALERT_CFG_ACTIVE_HIGH BIT(2)
37 #define MCP9600_ALERT_CFG_FALLING BIT(3)
38 #define MCP9600_ALERT_CFG_COLD_JUNCTION BIT(4)
39 #define MCP9600_ALERT_HYSTERESIS1 0x0c
40 #define MCP9600_ALERT_HYSTERESIS(x) (MCP9600_ALERT_HYSTERESIS1 + (x - 1))
41 #define MCP9600_ALERT_LIMIT1 0x10
42 #define MCP9600_ALERT_LIMIT(x) (MCP9600_ALERT_LIMIT1 + (x - 1))
43 #define MCP9600_ALERT_LIMIT_MASK GENMASK(15, 2)
44 #define MCP9600_DEVICE_ID 0x20
45
46 /* MCP9600 device id value */
47 #define MCP9600_DEVICE_ID_MCP9600 0x40
48 #define MCP9600_DEVICE_ID_MCP9601 0x41
49
50 #define MCP9600_ALERT_COUNT 4
51
52 #define MCP9600_MIN_TEMP_HOT_JUNCTION_MICRO -200000000
53 #define MCP9600_MAX_TEMP_HOT_JUNCTION_MICRO 1800000000
54
55 #define MCP9600_MIN_TEMP_COLD_JUNCTION_MICRO -40000000
56 #define MCP9600_MAX_TEMP_COLD_JUNCTION_MICRO 125000000
57
58 enum mcp9600_alert {
59 MCP9600_ALERT1,
60 MCP9600_ALERT2,
61 MCP9600_ALERT3,
62 MCP9600_ALERT4
63 };
64
65 static const char * const mcp9600_alert_name[MCP9600_ALERT_COUNT] = {
66 [MCP9600_ALERT1] = "alert1",
67 [MCP9600_ALERT2] = "alert2",
68 [MCP9600_ALERT3] = "alert3",
69 [MCP9600_ALERT4] = "alert4",
70 };
71
72 /* Map between dt-bindings enum and the chip's type value */
73 static const unsigned int mcp9600_type_map[] = {
74 [THERMOCOUPLE_TYPE_K] = 0,
75 [THERMOCOUPLE_TYPE_J] = 1,
76 [THERMOCOUPLE_TYPE_T] = 2,
77 [THERMOCOUPLE_TYPE_N] = 3,
78 [THERMOCOUPLE_TYPE_S] = 4,
79 [THERMOCOUPLE_TYPE_E] = 5,
80 [THERMOCOUPLE_TYPE_B] = 6,
81 [THERMOCOUPLE_TYPE_R] = 7,
82 };
83
84 /* Map thermocouple type to a char for iio info in sysfs */
85 static const int mcp9600_tc_types[] = {
86 [THERMOCOUPLE_TYPE_K] = 'K',
87 [THERMOCOUPLE_TYPE_J] = 'J',
88 [THERMOCOUPLE_TYPE_T] = 'T',
89 [THERMOCOUPLE_TYPE_N] = 'N',
90 [THERMOCOUPLE_TYPE_S] = 'S',
91 [THERMOCOUPLE_TYPE_E] = 'E',
92 [THERMOCOUPLE_TYPE_B] = 'B',
93 [THERMOCOUPLE_TYPE_R] = 'R',
94 };
95
96 static const struct iio_event_spec mcp9600_events[] = {
97 {
98 .type = IIO_EV_TYPE_THRESH,
99 .dir = IIO_EV_DIR_RISING,
100 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
101 BIT(IIO_EV_INFO_VALUE) |
102 BIT(IIO_EV_INFO_HYSTERESIS),
103 },
104 {
105 .type = IIO_EV_TYPE_THRESH,
106 .dir = IIO_EV_DIR_FALLING,
107 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
108 BIT(IIO_EV_INFO_VALUE) |
109 BIT(IIO_EV_INFO_HYSTERESIS),
110 },
111 };
112
113 struct mcp_chip_info {
114 u8 chip_id;
115 const char *chip_name;
116 };
117
118 struct mcp9600_data {
119 struct i2c_client *client;
120 u32 thermocouple_type;
121 };
122
mcp9600_config(struct mcp9600_data * data)123 static int mcp9600_config(struct mcp9600_data *data)
124 {
125 struct i2c_client *client = data->client;
126 int ret;
127 u8 cfg;
128
129 cfg = FIELD_PREP(MCP9600_SENSOR_TYPE_MASK,
130 mcp9600_type_map[data->thermocouple_type]);
131
132 ret = i2c_smbus_write_byte_data(client, MCP9600_SENSOR_CFG, cfg);
133 if (ret < 0) {
134 dev_err(&client->dev, "Failed to set sensor configuration\n");
135 return ret;
136 }
137
138 return 0;
139 }
140
141 #define MCP9600_CHANNELS(hj_num_ev, hj_ev_spec_off, cj_num_ev, cj_ev_spec_off) \
142 { \
143 { \
144 .type = IIO_TEMP, \
145 .address = MCP9600_HOT_JUNCTION, \
146 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
147 BIT(IIO_CHAN_INFO_THERMOCOUPLE_TYPE) | \
148 BIT(IIO_CHAN_INFO_SCALE), \
149 .event_spec = &mcp9600_events[hj_ev_spec_off], \
150 .num_event_specs = hj_num_ev, \
151 }, \
152 { \
153 .type = IIO_TEMP, \
154 .address = MCP9600_COLD_JUNCTION, \
155 .channel2 = IIO_MOD_TEMP_AMBIENT, \
156 .modified = 1, \
157 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
158 BIT(IIO_CHAN_INFO_SCALE), \
159 .event_spec = &mcp9600_events[cj_ev_spec_off], \
160 .num_event_specs = cj_num_ev, \
161 }, \
162 }
163
164 static const struct iio_chan_spec mcp9600_channels[][2] = {
165 MCP9600_CHANNELS(0, 0, 0, 0), /* Alerts: - - - - */
166 MCP9600_CHANNELS(1, 0, 0, 0), /* Alerts: 1 - - - */
167 MCP9600_CHANNELS(1, 1, 0, 0), /* Alerts: - 2 - - */
168 MCP9600_CHANNELS(2, 0, 0, 0), /* Alerts: 1 2 - - */
169 MCP9600_CHANNELS(0, 0, 1, 0), /* Alerts: - - 3 - */
170 MCP9600_CHANNELS(1, 0, 1, 0), /* Alerts: 1 - 3 - */
171 MCP9600_CHANNELS(1, 1, 1, 0), /* Alerts: - 2 3 - */
172 MCP9600_CHANNELS(2, 0, 1, 0), /* Alerts: 1 2 3 - */
173 MCP9600_CHANNELS(0, 0, 1, 1), /* Alerts: - - - 4 */
174 MCP9600_CHANNELS(1, 0, 1, 1), /* Alerts: 1 - - 4 */
175 MCP9600_CHANNELS(1, 1, 1, 1), /* Alerts: - 2 - 4 */
176 MCP9600_CHANNELS(2, 0, 1, 1), /* Alerts: 1 2 - 4 */
177 MCP9600_CHANNELS(0, 0, 2, 0), /* Alerts: - - 3 4 */
178 MCP9600_CHANNELS(1, 0, 2, 0), /* Alerts: 1 - 3 4 */
179 MCP9600_CHANNELS(1, 1, 2, 0), /* Alerts: - 2 3 4 */
180 MCP9600_CHANNELS(2, 0, 2, 0), /* Alerts: 1 2 3 4 */
181 };
182
mcp9600_read(struct mcp9600_data * data,struct iio_chan_spec const * chan,int * val)183 static int mcp9600_read(struct mcp9600_data *data,
184 struct iio_chan_spec const *chan, int *val)
185 {
186 int ret;
187
188 ret = i2c_smbus_read_word_swapped(data->client, chan->address);
189
190 if (ret < 0)
191 return ret;
192
193 *val = sign_extend32(ret, 15);
194
195 return 0;
196 }
197
mcp9600_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)198 static int mcp9600_read_raw(struct iio_dev *indio_dev,
199 struct iio_chan_spec const *chan, int *val,
200 int *val2, long mask)
201 {
202 struct mcp9600_data *data = iio_priv(indio_dev);
203 int ret;
204
205 switch (mask) {
206 case IIO_CHAN_INFO_RAW:
207 ret = mcp9600_read(data, chan, val);
208 if (ret)
209 return ret;
210 return IIO_VAL_INT;
211 case IIO_CHAN_INFO_SCALE:
212 *val = 62;
213 *val2 = 500000;
214 return IIO_VAL_INT_PLUS_MICRO;
215 case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
216 *val = mcp9600_tc_types[data->thermocouple_type];
217 return IIO_VAL_CHAR;
218 default:
219 return -EINVAL;
220 }
221 }
222
mcp9600_get_alert_index(int channel2,enum iio_event_direction dir)223 static int mcp9600_get_alert_index(int channel2, enum iio_event_direction dir)
224 {
225 if (channel2 == IIO_MOD_TEMP_AMBIENT) {
226 if (dir == IIO_EV_DIR_RISING)
227 return MCP9600_ALERT3;
228 else
229 return MCP9600_ALERT4;
230 } else {
231 if (dir == IIO_EV_DIR_RISING)
232 return MCP9600_ALERT1;
233 else
234 return MCP9600_ALERT2;
235 }
236 }
237
mcp9600_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)238 static int mcp9600_read_event_config(struct iio_dev *indio_dev,
239 const struct iio_chan_spec *chan,
240 enum iio_event_type type,
241 enum iio_event_direction dir)
242 {
243 struct mcp9600_data *data = iio_priv(indio_dev);
244 struct i2c_client *client = data->client;
245 int i, ret;
246
247 i = mcp9600_get_alert_index(chan->channel2, dir);
248 ret = i2c_smbus_read_byte_data(client, MCP9600_ALERT_CFG(i + 1));
249 if (ret < 0)
250 return ret;
251
252 return FIELD_GET(MCP9600_ALERT_CFG_ENABLE, ret);
253 }
254
mcp9600_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)255 static int mcp9600_write_event_config(struct iio_dev *indio_dev,
256 const struct iio_chan_spec *chan,
257 enum iio_event_type type,
258 enum iio_event_direction dir,
259 bool state)
260 {
261 struct mcp9600_data *data = iio_priv(indio_dev);
262 struct i2c_client *client = data->client;
263 int i, ret;
264
265 i = mcp9600_get_alert_index(chan->channel2, dir);
266 ret = i2c_smbus_read_byte_data(client, MCP9600_ALERT_CFG(i + 1));
267 if (ret < 0)
268 return ret;
269
270 if (state)
271 ret |= MCP9600_ALERT_CFG_ENABLE;
272 else
273 ret &= ~MCP9600_ALERT_CFG_ENABLE;
274
275 return i2c_smbus_write_byte_data(client, MCP9600_ALERT_CFG(i + 1), ret);
276 }
277
mcp9600_read_thresh(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)278 static int mcp9600_read_thresh(struct iio_dev *indio_dev,
279 const struct iio_chan_spec *chan,
280 enum iio_event_type type,
281 enum iio_event_direction dir,
282 enum iio_event_info info, int *val, int *val2)
283 {
284 struct mcp9600_data *data = iio_priv(indio_dev);
285 struct i2c_client *client = data->client;
286 s32 ret;
287 int i;
288
289 i = mcp9600_get_alert_index(chan->channel2, dir);
290 switch (info) {
291 case IIO_EV_INFO_VALUE:
292 ret = i2c_smbus_read_word_swapped(client, MCP9600_ALERT_LIMIT(i + 1));
293 if (ret < 0)
294 return ret;
295 /*
296 * Temperature is stored in two’s complement format in
297 * bits(15:2), LSB is 0.25 degree celsius.
298 */
299 *val = FIELD_GET_SIGNED(MCP9600_ALERT_LIMIT_MASK, ret);
300 *val2 = 4;
301 return IIO_VAL_FRACTIONAL;
302 case IIO_EV_INFO_HYSTERESIS:
303 ret = i2c_smbus_read_byte_data(client, MCP9600_ALERT_HYSTERESIS(i + 1));
304 if (ret < 0)
305 return ret;
306
307 *val = ret;
308 return IIO_VAL_INT;
309 default:
310 return -EINVAL;
311 }
312 }
313
mcp9600_write_thresh(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)314 static int mcp9600_write_thresh(struct iio_dev *indio_dev,
315 const struct iio_chan_spec *chan,
316 enum iio_event_type type,
317 enum iio_event_direction dir,
318 enum iio_event_info info, int val, int val2)
319 {
320 struct mcp9600_data *data = iio_priv(indio_dev);
321 struct i2c_client *client = data->client;
322 int s_val, i;
323 s16 thresh;
324 u8 hyst;
325
326 i = mcp9600_get_alert_index(chan->channel2, dir);
327 switch (info) {
328 case IIO_EV_INFO_VALUE:
329 /* Scale value to include decimal part into calculations */
330 s_val = (val < 0) ? ((val * 1000000) - val2) :
331 ((val * 1000000) + val2);
332 if (chan->channel2 == IIO_MOD_TEMP_AMBIENT) {
333 s_val = max(s_val, MCP9600_MIN_TEMP_COLD_JUNCTION_MICRO);
334 s_val = min(s_val, MCP9600_MAX_TEMP_COLD_JUNCTION_MICRO);
335 } else {
336 s_val = max(s_val, MCP9600_MIN_TEMP_HOT_JUNCTION_MICRO);
337 s_val = min(s_val, MCP9600_MAX_TEMP_HOT_JUNCTION_MICRO);
338 }
339
340 /*
341 * Shift length 4 bits = 2(15:2) + 2(0.25 LSB), temperature is
342 * stored in two’s complement format.
343 */
344 thresh = (s16)(s_val / (1000000 >> 4));
345 return i2c_smbus_write_word_swapped(client,
346 MCP9600_ALERT_LIMIT(i + 1),
347 thresh);
348 case IIO_EV_INFO_HYSTERESIS:
349 hyst = min(abs(val), 255);
350 return i2c_smbus_write_byte_data(client,
351 MCP9600_ALERT_HYSTERESIS(i + 1),
352 hyst);
353 default:
354 return -EINVAL;
355 }
356 }
357
358 static const struct iio_info mcp9600_info = {
359 .read_raw = mcp9600_read_raw,
360 .read_event_config = mcp9600_read_event_config,
361 .write_event_config = mcp9600_write_event_config,
362 .read_event_value = mcp9600_read_thresh,
363 .write_event_value = mcp9600_write_thresh,
364 };
365
mcp9600_alert_handler(void * private,enum mcp9600_alert alert,enum iio_modifier mod,enum iio_event_direction dir)366 static irqreturn_t mcp9600_alert_handler(void *private,
367 enum mcp9600_alert alert,
368 enum iio_modifier mod,
369 enum iio_event_direction dir)
370 {
371 struct iio_dev *indio_dev = private;
372 struct mcp9600_data *data = iio_priv(indio_dev);
373 int ret;
374
375 ret = i2c_smbus_read_byte_data(data->client, MCP9600_STATUS);
376 if (ret < 0)
377 return IRQ_HANDLED;
378
379 if (!(ret & MCP9600_STATUS_ALERT(alert)))
380 return IRQ_NONE;
381
382 iio_push_event(indio_dev,
383 IIO_MOD_EVENT_CODE(IIO_TEMP, 0, mod, IIO_EV_TYPE_THRESH,
384 dir),
385 iio_get_time_ns(indio_dev));
386
387 return IRQ_HANDLED;
388 }
389
mcp9600_alert1_handler(int irq,void * private)390 static irqreturn_t mcp9600_alert1_handler(int irq, void *private)
391 {
392 return mcp9600_alert_handler(private, MCP9600_ALERT1, IIO_NO_MOD,
393 IIO_EV_DIR_RISING);
394 }
395
mcp9600_alert2_handler(int irq,void * private)396 static irqreturn_t mcp9600_alert2_handler(int irq, void *private)
397 {
398 return mcp9600_alert_handler(private, MCP9600_ALERT2, IIO_NO_MOD,
399 IIO_EV_DIR_FALLING);
400 }
401
mcp9600_alert3_handler(int irq,void * private)402 static irqreturn_t mcp9600_alert3_handler(int irq, void *private)
403 {
404 return mcp9600_alert_handler(private, MCP9600_ALERT3,
405 IIO_MOD_TEMP_AMBIENT, IIO_EV_DIR_RISING);
406 }
407
mcp9600_alert4_handler(int irq,void * private)408 static irqreturn_t mcp9600_alert4_handler(int irq, void *private)
409 {
410 return mcp9600_alert_handler(private, MCP9600_ALERT4,
411 IIO_MOD_TEMP_AMBIENT, IIO_EV_DIR_FALLING);
412 }
413
414 static irqreturn_t (*mcp9600_alert_handler_func[MCP9600_ALERT_COUNT]) (int, void *) = {
415 mcp9600_alert1_handler,
416 mcp9600_alert2_handler,
417 mcp9600_alert3_handler,
418 mcp9600_alert4_handler,
419 };
420
mcp9600_probe_alerts(struct iio_dev * indio_dev)421 static int mcp9600_probe_alerts(struct iio_dev *indio_dev)
422 {
423 struct mcp9600_data *data = iio_priv(indio_dev);
424 struct i2c_client *client = data->client;
425 struct device *dev = &client->dev;
426 struct fwnode_handle *fwnode = dev_fwnode(dev);
427 unsigned int irq_type;
428 int ret, irq, i;
429 u8 val, ch_sel;
430
431 /*
432 * alert1: hot junction, rising temperature
433 * alert2: hot junction, falling temperature
434 * alert3: cold junction, rising temperature
435 * alert4: cold junction, falling temperature
436 */
437 ch_sel = 0;
438 for (i = 0; i < MCP9600_ALERT_COUNT; i++) {
439 irq = fwnode_irq_get_byname(fwnode, mcp9600_alert_name[i]);
440 if (irq <= 0)
441 continue;
442
443 val = 0;
444 irq_type = irq_get_trigger_type(irq);
445 if (irq_type == IRQ_TYPE_EDGE_RISING)
446 val |= MCP9600_ALERT_CFG_ACTIVE_HIGH;
447
448 if (i == MCP9600_ALERT2 || i == MCP9600_ALERT4)
449 val |= MCP9600_ALERT_CFG_FALLING;
450
451 if (i == MCP9600_ALERT3 || i == MCP9600_ALERT4)
452 val |= MCP9600_ALERT_CFG_COLD_JUNCTION;
453
454 ret = i2c_smbus_write_byte_data(client,
455 MCP9600_ALERT_CFG(i + 1),
456 val);
457 if (ret < 0)
458 return ret;
459
460 ret = devm_request_threaded_irq(dev, irq, NULL,
461 mcp9600_alert_handler_func[i],
462 IRQF_ONESHOT, "mcp9600",
463 indio_dev);
464 if (ret)
465 return ret;
466
467 ch_sel |= BIT(i);
468 }
469
470 return ch_sel;
471 }
472
mcp9600_probe(struct i2c_client * client)473 static int mcp9600_probe(struct i2c_client *client)
474 {
475 struct device *dev = &client->dev;
476 const struct mcp_chip_info *chip_info;
477 struct iio_dev *indio_dev;
478 struct mcp9600_data *data;
479 int ch_sel, dev_id, ret;
480
481 chip_info = i2c_get_match_data(client);
482 if (!chip_info)
483 return dev_err_probe(dev, -ENODEV,
484 "No chip-info found for device\n");
485
486 dev_id = i2c_smbus_read_byte_data(client, MCP9600_DEVICE_ID);
487 if (dev_id < 0)
488 return dev_err_probe(dev, dev_id, "Failed to read device ID\n");
489
490 switch (dev_id) {
491 case MCP9600_DEVICE_ID_MCP9600:
492 case MCP9600_DEVICE_ID_MCP9601:
493 if (dev_id != chip_info->chip_id)
494 dev_warn(dev,
495 "Expected id %02x, but device responded with %02x\n",
496 chip_info->chip_id, dev_id);
497 break;
498
499 default:
500 dev_warn(dev, "Unknown id %x, using %x\n", dev_id,
501 chip_info->chip_id);
502 }
503
504 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
505 if (!indio_dev)
506 return -ENOMEM;
507
508 data = iio_priv(indio_dev);
509 data->client = client;
510
511 /* Accept type from dt with default of Type-K. */
512 data->thermocouple_type = THERMOCOUPLE_TYPE_K;
513 ret = device_property_read_u32(dev, "thermocouple-type",
514 &data->thermocouple_type);
515 if (ret && ret != -EINVAL)
516 return dev_err_probe(dev, ret,
517 "Error reading thermocouple-type property\n");
518
519 if (data->thermocouple_type >= ARRAY_SIZE(mcp9600_type_map))
520 return dev_err_probe(dev, -EINVAL,
521 "Invalid thermocouple-type property %u.\n",
522 data->thermocouple_type);
523
524 /* Set initial config. */
525 ret = mcp9600_config(data);
526 if (ret)
527 return ret;
528
529 ch_sel = mcp9600_probe_alerts(indio_dev);
530 if (ch_sel < 0)
531 return ch_sel;
532
533 indio_dev->info = &mcp9600_info;
534 indio_dev->name = chip_info->chip_name;
535 indio_dev->modes = INDIO_DIRECT_MODE;
536 indio_dev->channels = mcp9600_channels[ch_sel];
537 indio_dev->num_channels = ARRAY_SIZE(mcp9600_channels[ch_sel]);
538
539 return devm_iio_device_register(dev, indio_dev);
540 }
541
542 static const struct mcp_chip_info mcp9600_chip_info = {
543 .chip_id = MCP9600_DEVICE_ID_MCP9600,
544 .chip_name = "mcp9600",
545 };
546
547 static const struct mcp_chip_info mcp9601_chip_info = {
548 .chip_id = MCP9600_DEVICE_ID_MCP9601,
549 .chip_name = "mcp9601",
550 };
551
552 static const struct i2c_device_id mcp9600_id[] = {
553 { .name = "mcp9600", .driver_data = (kernel_ulong_t)&mcp9600_chip_info },
554 { .name = "mcp9601", .driver_data = (kernel_ulong_t)&mcp9601_chip_info },
555 { }
556 };
557 MODULE_DEVICE_TABLE(i2c, mcp9600_id);
558
559 static const struct of_device_id mcp9600_of_match[] = {
560 { .compatible = "microchip,mcp9600", .data = &mcp9600_chip_info },
561 { .compatible = "microchip,mcp9601", .data = &mcp9601_chip_info },
562 { }
563 };
564 MODULE_DEVICE_TABLE(of, mcp9600_of_match);
565
566 static struct i2c_driver mcp9600_driver = {
567 .driver = {
568 .name = "mcp9600",
569 .of_match_table = mcp9600_of_match,
570 },
571 .probe = mcp9600_probe,
572 .id_table = mcp9600_id
573 };
574 module_i2c_driver(mcp9600_driver);
575
576 MODULE_AUTHOR("Dimitri Fedrau <dima.fedrau@gmail.com>");
577 MODULE_AUTHOR("Andrew Hepp <andrew.hepp@ahepp.dev>");
578 MODULE_DESCRIPTION("Microchip MCP9600 thermocouple EMF converter driver");
579 MODULE_LICENSE("GPL");
580