Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / drivers / hwmon / tmp464.c
blob0f629c6d7695ea8136c67549da9f72b3e65767dc
1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /* Driver for the Texas Instruments TMP464 SMBus temperature sensor IC.
4 * Supported models: TMP464, TMP468
6 * Copyright (C) 2022 Agathe Porte <agathe.porte@nokia.com>
7 * Preliminary support by:
8 * Lionel Pouliquen <lionel.lp.pouliquen@nokia.com>
9 */
11 #include <linux/err.h>
12 #include <linux/hwmon.h>
13 #include <linux/i2c.h>
14 #include <linux/init.h>
15 #include <linux/module.h>
16 #include <linux/mutex.h>
17 #include <linux/of.h>
18 #include <linux/regmap.h>
19 #include <linux/slab.h>
21 /* Addresses to scan */
22 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, I2C_CLIENT_END };
24 #define TMP464_NUM_CHANNELS 5 /* chan 0 is internal, 1-4 are remote */
25 #define TMP468_NUM_CHANNELS 9 /* chan 0 is internal, 1-8 are remote */
27 #define MAX_CHANNELS 9
29 #define TMP464_TEMP_REG(channel) (channel)
30 #define TMP464_TEMP_OFFSET_REG(channel) (0x40 + ((channel) - 1) * 8)
31 #define TMP464_N_FACTOR_REG(channel) (0x41 + ((channel) - 1) * 8)
33 static const u8 TMP464_THERM_LIMIT[MAX_CHANNELS] = {
34 0x39, 0x42, 0x4A, 0x52, 0x5A, 0x62, 0x6a, 0x72, 0x7a };
35 static const u8 TMP464_THERM2_LIMIT[MAX_CHANNELS] = {
36 0x3A, 0x43, 0x4B, 0x53, 0x5B, 0x63, 0x6b, 0x73, 0x7b };
38 #define TMP464_THERM_STATUS_REG 0x21
39 #define TMP464_THERM2_STATUS_REG 0x22
40 #define TMP464_REMOTE_OPEN_REG 0x23
41 #define TMP464_CONFIG_REG 0x30
42 #define TMP464_TEMP_HYST_REG 0x38
43 #define TMP464_LOCK_REG 0xc4
45 /* Identification */
46 #define TMP464_MANUFACTURER_ID_REG 0xFE
47 #define TMP464_DEVICE_ID_REG 0xFF
49 /* Flags */
50 #define TMP464_CONFIG_SHUTDOWN BIT(5)
51 #define TMP464_CONFIG_RANGE 0x04
52 #define TMP464_CONFIG_REG_REN(x) (BIT(7 + (x)))
53 #define TMP464_CONFIG_REG_REN_MASK GENMASK(15, 7)
54 #define TMP464_CONFIG_CONVERSION_RATE_B0 2
55 #define TMP464_CONFIG_CONVERSION_RATE_B2 4
56 #define TMP464_CONFIG_CONVERSION_RATE_MASK GENMASK(TMP464_CONFIG_CONVERSION_RATE_B2, \
57 TMP464_CONFIG_CONVERSION_RATE_B0)
59 #define TMP464_UNLOCK_VAL 0xeb19
60 #define TMP464_LOCK_VAL 0x5ca6
61 #define TMP464_LOCKED 0x8000
63 /* Manufacturer / Device ID's */
64 #define TMP464_MANUFACTURER_ID 0x5449
65 #define TMP464_DEVICE_ID 0x1468
66 #define TMP468_DEVICE_ID 0x0468
68 static const struct i2c_device_id tmp464_id[] = {
69 { "tmp464", TMP464_NUM_CHANNELS },
70 { "tmp468", TMP468_NUM_CHANNELS },
71 { }
73 MODULE_DEVICE_TABLE(i2c, tmp464_id);
75 static const struct of_device_id __maybe_unused tmp464_of_match[] = {
77 .compatible = "ti,tmp464",
78 .data = (void *)TMP464_NUM_CHANNELS
81 .compatible = "ti,tmp468",
82 .data = (void *)TMP468_NUM_CHANNELS
84 {},
86 MODULE_DEVICE_TABLE(of, tmp464_of_match);
88 struct tmp464_channel {
89 const char *label;
90 bool enabled;
93 struct tmp464_data {
94 struct regmap *regmap;
95 struct mutex update_lock;
96 int channels;
97 s16 config_orig;
98 u16 open_reg;
99 unsigned long last_updated;
100 bool valid;
101 int update_interval;
102 struct tmp464_channel channel[MAX_CHANNELS];
105 static int temp_from_reg(s16 reg)
107 return DIV_ROUND_CLOSEST((reg >> 3) * 625, 10);
110 static s16 temp_to_limit_reg(long temp)
112 return DIV_ROUND_CLOSEST(temp, 500) << 6;
115 static s16 temp_to_offset_reg(long temp)
117 return DIV_ROUND_CLOSEST(temp * 10, 625) << 3;
120 static int tmp464_enable_channels(struct tmp464_data *data)
122 struct regmap *regmap = data->regmap;
123 u16 enable = 0;
124 int i;
126 for (i = 0; i < data->channels; i++)
127 if (data->channel[i].enabled)
128 enable |= TMP464_CONFIG_REG_REN(i);
130 return regmap_update_bits(regmap, TMP464_CONFIG_REG, TMP464_CONFIG_REG_REN_MASK, enable);
133 static int tmp464_chip_read(struct device *dev, u32 attr, int channel, long *val)
135 struct tmp464_data *data = dev_get_drvdata(dev);
137 switch (attr) {
138 case hwmon_chip_update_interval:
139 *val = data->update_interval;
140 return 0;
141 default:
142 return -EOPNOTSUPP;
146 static int tmp464_temp_read(struct device *dev, u32 attr, int channel, long *val)
148 struct tmp464_data *data = dev_get_drvdata(dev);
149 struct regmap *regmap = data->regmap;
150 unsigned int regs[2];
151 unsigned int regval;
152 u16 regvals[2];
153 int err = 0;
155 switch (attr) {
156 case hwmon_temp_max_alarm:
157 err = regmap_read(regmap, TMP464_THERM_STATUS_REG, &regval);
158 if (err < 0)
159 break;
160 *val = !!(regval & BIT(channel + 7));
161 break;
162 case hwmon_temp_crit_alarm:
163 err = regmap_read(regmap, TMP464_THERM2_STATUS_REG, &regval);
164 if (err < 0)
165 break;
166 *val = !!(regval & BIT(channel + 7));
167 break;
168 case hwmon_temp_fault:
170 * The chip clears TMP464_REMOTE_OPEN_REG after it is read
171 * and only updates it after the next measurement cycle is
172 * complete. That means we have to cache the value internally
173 * for one measurement cycle and report the cached value.
175 mutex_lock(&data->update_lock);
176 if (!data->valid || time_after(jiffies, data->last_updated +
177 msecs_to_jiffies(data->update_interval))) {
178 err = regmap_read(regmap, TMP464_REMOTE_OPEN_REG, &regval);
179 if (err < 0)
180 goto unlock;
181 data->open_reg = regval;
182 data->last_updated = jiffies;
183 data->valid = true;
185 *val = !!(data->open_reg & BIT(channel + 7));
186 unlock:
187 mutex_unlock(&data->update_lock);
188 break;
189 case hwmon_temp_max_hyst:
190 regs[0] = TMP464_THERM_LIMIT[channel];
191 regs[1] = TMP464_TEMP_HYST_REG;
192 err = regmap_multi_reg_read(regmap, regs, regvals, 2);
193 if (err < 0)
194 break;
195 *val = temp_from_reg(regvals[0] - regvals[1]);
196 break;
197 case hwmon_temp_max:
198 err = regmap_read(regmap, TMP464_THERM_LIMIT[channel], &regval);
199 if (err < 0)
200 break;
201 *val = temp_from_reg(regval);
202 break;
203 case hwmon_temp_crit_hyst:
204 regs[0] = TMP464_THERM2_LIMIT[channel];
205 regs[1] = TMP464_TEMP_HYST_REG;
206 err = regmap_multi_reg_read(regmap, regs, regvals, 2);
207 if (err < 0)
208 break;
209 *val = temp_from_reg(regvals[0] - regvals[1]);
210 break;
211 case hwmon_temp_crit:
212 err = regmap_read(regmap, TMP464_THERM2_LIMIT[channel], &regval);
213 if (err < 0)
214 break;
215 *val = temp_from_reg(regval);
216 break;
217 case hwmon_temp_offset:
218 err = regmap_read(regmap, TMP464_TEMP_OFFSET_REG(channel), &regval);
219 if (err < 0)
220 break;
221 *val = temp_from_reg(regval);
222 break;
223 case hwmon_temp_input:
224 if (!data->channel[channel].enabled) {
225 err = -ENODATA;
226 break;
228 err = regmap_read(regmap, TMP464_TEMP_REG(channel), &regval);
229 if (err < 0)
230 break;
231 *val = temp_from_reg(regval);
232 break;
233 case hwmon_temp_enable:
234 *val = data->channel[channel].enabled;
235 break;
236 default:
237 err = -EOPNOTSUPP;
238 break;
241 return err;
244 static int tmp464_read(struct device *dev, enum hwmon_sensor_types type,
245 u32 attr, int channel, long *val)
247 switch (type) {
248 case hwmon_chip:
249 return tmp464_chip_read(dev, attr, channel, val);
250 case hwmon_temp:
251 return tmp464_temp_read(dev, attr, channel, val);
252 default:
253 return -EOPNOTSUPP;
257 static int tmp464_read_string(struct device *dev, enum hwmon_sensor_types type,
258 u32 attr, int channel, const char **str)
260 struct tmp464_data *data = dev_get_drvdata(dev);
262 *str = data->channel[channel].label;
264 return 0;
267 static int tmp464_set_convrate(struct tmp464_data *data, long interval)
269 int rate;
272 * For valid rates, interval in milli-seconds can be calculated as
273 * interval = 125 << (7 - rate);
274 * or
275 * interval = (1 << (7 - rate)) * 125;
276 * The rate is therefore
277 * rate = 7 - __fls(interval / 125);
278 * and the rounded rate is
279 * rate = 7 - __fls(interval * 4 / (125 * 3));
280 * Use clamp_val() to avoid overflows, and to ensure valid input
281 * for __fls.
283 interval = clamp_val(interval, 125, 16000);
284 rate = 7 - __fls(interval * 4 / (125 * 3));
285 data->update_interval = 125 << (7 - rate);
287 return regmap_update_bits(data->regmap, TMP464_CONFIG_REG,
288 TMP464_CONFIG_CONVERSION_RATE_MASK,
289 rate << TMP464_CONFIG_CONVERSION_RATE_B0);
292 static int tmp464_chip_write(struct tmp464_data *data, u32 attr, int channel, long val)
294 switch (attr) {
295 case hwmon_chip_update_interval:
296 return tmp464_set_convrate(data, val);
297 default:
298 return -EOPNOTSUPP;
302 static int tmp464_temp_write(struct tmp464_data *data, u32 attr, int channel, long val)
304 struct regmap *regmap = data->regmap;
305 unsigned int regval;
306 int err = 0;
308 switch (attr) {
309 case hwmon_temp_max_hyst:
310 err = regmap_read(regmap, TMP464_THERM_LIMIT[0], &regval);
311 if (err < 0)
312 break;
313 val = clamp_val(val, -256000, 256000); /* prevent overflow/underflow */
314 val = clamp_val(temp_from_reg(regval) - val, 0, 255000);
315 err = regmap_write(regmap, TMP464_TEMP_HYST_REG,
316 DIV_ROUND_CLOSEST(val, 1000) << 7);
317 break;
318 case hwmon_temp_max:
319 val = temp_to_limit_reg(clamp_val(val, -255000, 255500));
320 err = regmap_write(regmap, TMP464_THERM_LIMIT[channel], val);
321 break;
322 case hwmon_temp_crit:
323 val = temp_to_limit_reg(clamp_val(val, -255000, 255500));
324 err = regmap_write(regmap, TMP464_THERM2_LIMIT[channel], val);
325 break;
326 case hwmon_temp_offset:
327 val = temp_to_offset_reg(clamp_val(val, -128000, 127937));
328 err = regmap_write(regmap, TMP464_TEMP_OFFSET_REG(channel), val);
329 break;
330 case hwmon_temp_enable:
331 data->channel[channel].enabled = !!val;
332 err = tmp464_enable_channels(data);
333 break;
334 default:
335 err = -EOPNOTSUPP;
336 break;
339 return err;
342 static int tmp464_write(struct device *dev, enum hwmon_sensor_types type,
343 u32 attr, int channel, long val)
345 struct tmp464_data *data = dev_get_drvdata(dev);
346 int err;
348 mutex_lock(&data->update_lock);
350 switch (type) {
351 case hwmon_chip:
352 err = tmp464_chip_write(data, attr, channel, val);
353 break;
354 case hwmon_temp:
355 err = tmp464_temp_write(data, attr, channel, val);
356 break;
357 default:
358 err = -EOPNOTSUPP;
359 break;
362 mutex_unlock(&data->update_lock);
364 return err;
367 static umode_t tmp464_is_visible(const void *_data, enum hwmon_sensor_types type,
368 u32 attr, int channel)
370 const struct tmp464_data *data = _data;
372 if (channel >= data->channels)
373 return 0;
375 if (type == hwmon_chip) {
376 if (attr == hwmon_chip_update_interval)
377 return 0644;
378 return 0;
381 switch (attr) {
382 case hwmon_temp_input:
383 case hwmon_temp_max_alarm:
384 case hwmon_temp_crit_alarm:
385 case hwmon_temp_crit_hyst:
386 return 0444;
387 case hwmon_temp_enable:
388 case hwmon_temp_max:
389 case hwmon_temp_crit:
390 return 0644;
391 case hwmon_temp_max_hyst:
392 if (!channel)
393 return 0644;
394 return 0444;
395 case hwmon_temp_label:
396 if (data->channel[channel].label)
397 return 0444;
398 return 0;
399 case hwmon_temp_fault:
400 if (channel)
401 return 0444;
402 return 0;
403 case hwmon_temp_offset:
404 if (channel)
405 return 0644;
406 return 0;
407 default:
408 return 0;
412 static void tmp464_restore_lock(void *regmap)
414 regmap_write(regmap, TMP464_LOCK_REG, TMP464_LOCK_VAL);
417 static void tmp464_restore_config(void *_data)
419 struct tmp464_data *data = _data;
421 regmap_write(data->regmap, TMP464_CONFIG_REG, data->config_orig);
424 static int tmp464_init_client(struct device *dev, struct tmp464_data *data)
426 struct regmap *regmap = data->regmap;
427 unsigned int regval;
428 int err;
430 err = regmap_read(regmap, TMP464_LOCK_REG, &regval);
431 if (err)
432 return err;
433 if (regval == TMP464_LOCKED) {
434 /* Explicitly unlock chip if it is locked */
435 err = regmap_write(regmap, TMP464_LOCK_REG, TMP464_UNLOCK_VAL);
436 if (err)
437 return err;
438 /* and lock it again when unloading the driver */
439 err = devm_add_action_or_reset(dev, tmp464_restore_lock, regmap);
440 if (err)
441 return err;
444 err = regmap_read(regmap, TMP464_CONFIG_REG, &regval);
445 if (err)
446 return err;
447 data->config_orig = regval;
448 err = devm_add_action_or_reset(dev, tmp464_restore_config, data);
449 if (err)
450 return err;
452 /* Default to 500 ms update interval */
453 err = regmap_update_bits(regmap, TMP464_CONFIG_REG,
454 TMP464_CONFIG_CONVERSION_RATE_MASK | TMP464_CONFIG_SHUTDOWN,
455 BIT(TMP464_CONFIG_CONVERSION_RATE_B0) |
456 BIT(TMP464_CONFIG_CONVERSION_RATE_B2));
457 if (err)
458 return err;
460 data->update_interval = 500;
462 return tmp464_enable_channels(data);
465 static int tmp464_detect(struct i2c_client *client,
466 struct i2c_board_info *info)
468 struct i2c_adapter *adapter = client->adapter;
469 char *name, *chip;
470 int reg;
472 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
473 return -ENODEV;
475 reg = i2c_smbus_read_word_swapped(client, TMP464_MANUFACTURER_ID_REG);
476 if (reg < 0)
477 return reg;
478 if (reg != TMP464_MANUFACTURER_ID)
479 return -ENODEV;
481 /* Check for "always return zero" bits */
482 reg = i2c_smbus_read_word_swapped(client, TMP464_THERM_STATUS_REG);
483 if (reg < 0)
484 return reg;
485 if (reg & 0x1f)
486 return -ENODEV;
487 reg = i2c_smbus_read_word_swapped(client, TMP464_THERM2_STATUS_REG);
488 if (reg < 0)
489 return reg;
490 if (reg & 0x1f)
491 return -ENODEV;
493 reg = i2c_smbus_read_word_swapped(client, TMP464_DEVICE_ID_REG);
494 if (reg < 0)
495 return reg;
496 switch (reg) {
497 case TMP464_DEVICE_ID:
498 name = "tmp464";
499 chip = "TMP464";
500 break;
501 case TMP468_DEVICE_ID:
502 name = "tmp468";
503 chip = "TMP468";
504 break;
505 default:
506 return -ENODEV;
509 strscpy(info->type, name, I2C_NAME_SIZE);
510 dev_info(&adapter->dev, "Detected TI %s chip at 0x%02x\n", chip, client->addr);
512 return 0;
515 static int tmp464_probe_child_from_dt(struct device *dev,
516 struct device_node *child,
517 struct tmp464_data *data)
520 struct regmap *regmap = data->regmap;
521 u32 channel;
522 s32 nfactor;
523 int err;
525 err = of_property_read_u32(child, "reg", &channel);
526 if (err) {
527 dev_err(dev, "missing reg property of %pOFn\n", child);
528 return err;
531 if (channel >= data->channels) {
532 dev_err(dev, "invalid reg %d of %pOFn\n", channel, child);
533 return -EINVAL;
536 of_property_read_string(child, "label", &data->channel[channel].label);
538 data->channel[channel].enabled = of_device_is_available(child);
540 err = of_property_read_s32(child, "ti,n-factor", &nfactor);
541 if (err && err != -EINVAL)
542 return err;
543 if (!err) {
544 if (channel == 0) {
545 dev_err(dev, "n-factor can't be set for internal channel\n");
546 return -EINVAL;
548 if (nfactor > 127 || nfactor < -128) {
549 dev_err(dev, "n-factor for channel %d invalid (%d)\n",
550 channel, nfactor);
551 return -EINVAL;
553 err = regmap_write(regmap, TMP464_N_FACTOR_REG(channel),
554 (nfactor << 8) & 0xff00);
555 if (err)
556 return err;
559 return 0;
562 static int tmp464_probe_from_dt(struct device *dev, struct tmp464_data *data)
564 const struct device_node *np = dev->of_node;
565 int err;
567 for_each_child_of_node_scoped(np, child) {
568 if (strcmp(child->name, "channel"))
569 continue;
571 err = tmp464_probe_child_from_dt(dev, child, data);
572 if (err)
573 return err;
576 return 0;
579 static const struct hwmon_ops tmp464_ops = {
580 .is_visible = tmp464_is_visible,
581 .read = tmp464_read,
582 .read_string = tmp464_read_string,
583 .write = tmp464_write,
586 static const struct hwmon_channel_info * const tmp464_info[] = {
587 HWMON_CHANNEL_INFO(chip,
588 HWMON_C_UPDATE_INTERVAL),
589 HWMON_CHANNEL_INFO(temp,
590 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST | HWMON_T_CRIT |
591 HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
592 HWMON_T_LABEL | HWMON_T_ENABLE,
593 HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST |
594 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM |
595 HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE,
596 HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST |
597 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM |
598 HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE,
599 HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST |
600 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM |
601 HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE,
602 HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST |
603 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM |
604 HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE,
605 HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST |
606 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM |
607 HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE,
608 HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST |
609 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM |
610 HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE,
611 HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST |
612 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM |
613 HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE,
614 HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST |
615 HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM |
616 HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE),
617 NULL
620 static const struct hwmon_chip_info tmp464_chip_info = {
621 .ops = &tmp464_ops,
622 .info = tmp464_info,
625 /* regmap */
627 static bool tmp464_is_volatile_reg(struct device *dev, unsigned int reg)
629 return (reg < TMP464_TEMP_REG(TMP468_NUM_CHANNELS) ||
630 reg == TMP464_THERM_STATUS_REG ||
631 reg == TMP464_THERM2_STATUS_REG ||
632 reg == TMP464_REMOTE_OPEN_REG);
635 static const struct regmap_config tmp464_regmap_config = {
636 .reg_bits = 8,
637 .val_bits = 16,
638 .max_register = TMP464_DEVICE_ID_REG,
639 .volatile_reg = tmp464_is_volatile_reg,
640 .val_format_endian = REGMAP_ENDIAN_BIG,
641 .cache_type = REGCACHE_MAPLE,
642 .use_single_read = true,
643 .use_single_write = true,
646 static int tmp464_probe(struct i2c_client *client)
648 struct device *dev = &client->dev;
649 struct device *hwmon_dev;
650 struct tmp464_data *data;
651 int i, err;
653 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
654 dev_err(&client->dev, "i2c functionality check failed\n");
655 return -ENODEV;
657 data = devm_kzalloc(dev, sizeof(struct tmp464_data), GFP_KERNEL);
658 if (!data)
659 return -ENOMEM;
661 mutex_init(&data->update_lock);
663 data->channels = (int)(unsigned long)i2c_get_match_data(client);
665 data->regmap = devm_regmap_init_i2c(client, &tmp464_regmap_config);
666 if (IS_ERR(data->regmap))
667 return PTR_ERR(data->regmap);
669 for (i = 0; i < data->channels; i++)
670 data->channel[i].enabled = true;
672 err = tmp464_init_client(dev, data);
673 if (err)
674 return err;
676 if (dev->of_node) {
677 err = tmp464_probe_from_dt(dev, data);
678 if (err)
679 return err;
682 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
683 data, &tmp464_chip_info, NULL);
684 return PTR_ERR_OR_ZERO(hwmon_dev);
687 static struct i2c_driver tmp464_driver = {
688 .class = I2C_CLASS_HWMON,
689 .driver = {
690 .name = "tmp464",
691 .of_match_table = of_match_ptr(tmp464_of_match),
693 .probe = tmp464_probe,
694 .id_table = tmp464_id,
695 .detect = tmp464_detect,
696 .address_list = normal_i2c,
699 module_i2c_driver(tmp464_driver);
701 MODULE_AUTHOR("Agathe Porte <agathe.porte@nokia.com>");
702 MODULE_DESCRIPTION("Texas Instruments TMP464 temperature sensor driver");
703 MODULE_LICENSE("GPL");