1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | |
3 | /* Driver for the Texas Instruments TMP464 SMBus temperature sensor IC. |
4 | * Supported models: TMP464, TMP468 |
5 | |
6 | * Copyright (C) 2022 Agathe Porte <agathe.porte@nokia.com> |
7 | * Preliminary support by: |
8 | * Lionel Pouliquen <lionel.lp.pouliquen@nokia.com> |
9 | */ |
10 | |
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> |
20 | |
21 | /* Addresses to scan */ |
22 | static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, I2C_CLIENT_END }; |
23 | |
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 */ |
26 | |
27 | #define MAX_CHANNELS 9 |
28 | |
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) |
32 | |
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 }; |
37 | |
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 |
44 | |
45 | /* Identification */ |
46 | #define TMP464_MANUFACTURER_ID_REG 0xFE |
47 | #define TMP464_DEVICE_ID_REG 0xFF |
48 | |
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) |
58 | |
59 | #define TMP464_UNLOCK_VAL 0xeb19 |
60 | #define TMP464_LOCK_VAL 0x5ca6 |
61 | #define TMP464_LOCKED 0x8000 |
62 | |
63 | /* Manufacturer / Device ID's */ |
64 | #define TMP464_MANUFACTURER_ID 0x5449 |
65 | #define TMP464_DEVICE_ID 0x1468 |
66 | #define TMP468_DEVICE_ID 0x0468 |
67 | |
68 | static const struct i2c_device_id tmp464_id[] = { |
69 | { "tmp464" , TMP464_NUM_CHANNELS }, |
70 | { "tmp468" , TMP468_NUM_CHANNELS }, |
71 | { } |
72 | }; |
73 | MODULE_DEVICE_TABLE(i2c, tmp464_id); |
74 | |
75 | static const struct of_device_id __maybe_unused tmp464_of_match[] = { |
76 | { |
77 | .compatible = "ti,tmp464" , |
78 | .data = (void *)TMP464_NUM_CHANNELS |
79 | }, |
80 | { |
81 | .compatible = "ti,tmp468" , |
82 | .data = (void *)TMP468_NUM_CHANNELS |
83 | }, |
84 | {}, |
85 | }; |
86 | MODULE_DEVICE_TABLE(of, tmp464_of_match); |
87 | |
88 | struct tmp464_channel { |
89 | const char *label; |
90 | bool enabled; |
91 | }; |
92 | |
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]; |
103 | }; |
104 | |
105 | static int temp_from_reg(s16 reg) |
106 | { |
107 | return DIV_ROUND_CLOSEST((reg >> 3) * 625, 10); |
108 | } |
109 | |
110 | static s16 temp_to_limit_reg(long temp) |
111 | { |
112 | return DIV_ROUND_CLOSEST(temp, 500) << 6; |
113 | } |
114 | |
115 | static s16 temp_to_offset_reg(long temp) |
116 | { |
117 | return DIV_ROUND_CLOSEST(temp * 10, 625) << 3; |
118 | } |
119 | |
120 | static int tmp464_enable_channels(struct tmp464_data *data) |
121 | { |
122 | struct regmap *regmap = data->regmap; |
123 | u16 enable = 0; |
124 | int i; |
125 | |
126 | for (i = 0; i < data->channels; i++) |
127 | if (data->channel[i].enabled) |
128 | enable |= TMP464_CONFIG_REG_REN(i); |
129 | |
130 | return regmap_update_bits(map: regmap, TMP464_CONFIG_REG, TMP464_CONFIG_REG_REN_MASK, val: enable); |
131 | } |
132 | |
133 | static int tmp464_chip_read(struct device *dev, u32 attr, int channel, long *val) |
134 | { |
135 | struct tmp464_data *data = dev_get_drvdata(dev); |
136 | |
137 | switch (attr) { |
138 | case hwmon_chip_update_interval: |
139 | *val = data->update_interval; |
140 | return 0; |
141 | default: |
142 | return -EOPNOTSUPP; |
143 | } |
144 | } |
145 | |
146 | static int tmp464_temp_read(struct device *dev, u32 attr, int channel, long *val) |
147 | { |
148 | struct tmp464_data *data = dev_get_drvdata(dev); |
149 | struct regmap *regmap = data->regmap; |
150 | unsigned int regval, regval2; |
151 | int err = 0; |
152 | |
153 | mutex_lock(&data->update_lock); |
154 | |
155 | switch (attr) { |
156 | case hwmon_temp_max_alarm: |
157 | err = regmap_read(map: regmap, TMP464_THERM_STATUS_REG, val: ®val); |
158 | if (err < 0) |
159 | break; |
160 | *val = !!(regval & BIT(channel + 7)); |
161 | break; |
162 | case hwmon_temp_crit_alarm: |
163 | err = regmap_read(map: regmap, TMP464_THERM2_STATUS_REG, val: ®val); |
164 | if (err < 0) |
165 | break; |
166 | *val = !!(regval & BIT(channel + 7)); |
167 | break; |
168 | case hwmon_temp_fault: |
169 | /* |
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. |
174 | */ |
175 | if (!data->valid || time_after(jiffies, data->last_updated + |
176 | msecs_to_jiffies(data->update_interval))) { |
177 | err = regmap_read(map: regmap, TMP464_REMOTE_OPEN_REG, val: ®val); |
178 | if (err < 0) |
179 | break; |
180 | data->open_reg = regval; |
181 | data->last_updated = jiffies; |
182 | data->valid = true; |
183 | } |
184 | *val = !!(data->open_reg & BIT(channel + 7)); |
185 | break; |
186 | case hwmon_temp_max_hyst: |
187 | err = regmap_read(map: regmap, reg: TMP464_THERM_LIMIT[channel], val: ®val); |
188 | if (err < 0) |
189 | break; |
190 | err = regmap_read(map: regmap, TMP464_TEMP_HYST_REG, val: ®val2); |
191 | if (err < 0) |
192 | break; |
193 | regval -= regval2; |
194 | *val = temp_from_reg(reg: regval); |
195 | break; |
196 | case hwmon_temp_max: |
197 | err = regmap_read(map: regmap, reg: TMP464_THERM_LIMIT[channel], val: ®val); |
198 | if (err < 0) |
199 | break; |
200 | *val = temp_from_reg(reg: regval); |
201 | break; |
202 | case hwmon_temp_crit_hyst: |
203 | err = regmap_read(map: regmap, reg: TMP464_THERM2_LIMIT[channel], val: ®val); |
204 | if (err < 0) |
205 | break; |
206 | err = regmap_read(map: regmap, TMP464_TEMP_HYST_REG, val: ®val2); |
207 | if (err < 0) |
208 | break; |
209 | regval -= regval2; |
210 | *val = temp_from_reg(reg: regval); |
211 | break; |
212 | case hwmon_temp_crit: |
213 | err = regmap_read(map: regmap, reg: TMP464_THERM2_LIMIT[channel], val: ®val); |
214 | if (err < 0) |
215 | break; |
216 | *val = temp_from_reg(reg: regval); |
217 | break; |
218 | case hwmon_temp_offset: |
219 | err = regmap_read(map: regmap, TMP464_TEMP_OFFSET_REG(channel), val: ®val); |
220 | if (err < 0) |
221 | break; |
222 | *val = temp_from_reg(reg: regval); |
223 | break; |
224 | case hwmon_temp_input: |
225 | if (!data->channel[channel].enabled) { |
226 | err = -ENODATA; |
227 | break; |
228 | } |
229 | err = regmap_read(map: regmap, TMP464_TEMP_REG(channel), val: ®val); |
230 | if (err < 0) |
231 | break; |
232 | *val = temp_from_reg(reg: regval); |
233 | break; |
234 | case hwmon_temp_enable: |
235 | *val = data->channel[channel].enabled; |
236 | break; |
237 | default: |
238 | err = -EOPNOTSUPP; |
239 | break; |
240 | } |
241 | |
242 | mutex_unlock(lock: &data->update_lock); |
243 | |
244 | return err; |
245 | } |
246 | |
247 | static int tmp464_read(struct device *dev, enum hwmon_sensor_types type, |
248 | u32 attr, int channel, long *val) |
249 | { |
250 | switch (type) { |
251 | case hwmon_chip: |
252 | return tmp464_chip_read(dev, attr, channel, val); |
253 | case hwmon_temp: |
254 | return tmp464_temp_read(dev, attr, channel, val); |
255 | default: |
256 | return -EOPNOTSUPP; |
257 | } |
258 | } |
259 | |
260 | static int tmp464_read_string(struct device *dev, enum hwmon_sensor_types type, |
261 | u32 attr, int channel, const char **str) |
262 | { |
263 | struct tmp464_data *data = dev_get_drvdata(dev); |
264 | |
265 | *str = data->channel[channel].label; |
266 | |
267 | return 0; |
268 | } |
269 | |
270 | static int tmp464_set_convrate(struct tmp464_data *data, long interval) |
271 | { |
272 | int rate; |
273 | |
274 | /* |
275 | * For valid rates, interval in milli-seconds can be calculated as |
276 | * interval = 125 << (7 - rate); |
277 | * or |
278 | * interval = (1 << (7 - rate)) * 125; |
279 | * The rate is therefore |
280 | * rate = 7 - __fls(interval / 125); |
281 | * and the rounded rate is |
282 | * rate = 7 - __fls(interval * 4 / (125 * 3)); |
283 | * Use clamp_val() to avoid overflows, and to ensure valid input |
284 | * for __fls. |
285 | */ |
286 | interval = clamp_val(interval, 125, 16000); |
287 | rate = 7 - __fls(word: interval * 4 / (125 * 3)); |
288 | data->update_interval = 125 << (7 - rate); |
289 | |
290 | return regmap_update_bits(map: data->regmap, TMP464_CONFIG_REG, |
291 | TMP464_CONFIG_CONVERSION_RATE_MASK, |
292 | val: rate << TMP464_CONFIG_CONVERSION_RATE_B0); |
293 | } |
294 | |
295 | static int tmp464_chip_write(struct tmp464_data *data, u32 attr, int channel, long val) |
296 | { |
297 | switch (attr) { |
298 | case hwmon_chip_update_interval: |
299 | return tmp464_set_convrate(data, interval: val); |
300 | default: |
301 | return -EOPNOTSUPP; |
302 | } |
303 | } |
304 | |
305 | static int tmp464_temp_write(struct tmp464_data *data, u32 attr, int channel, long val) |
306 | { |
307 | struct regmap *regmap = data->regmap; |
308 | unsigned int regval; |
309 | int err = 0; |
310 | |
311 | switch (attr) { |
312 | case hwmon_temp_max_hyst: |
313 | err = regmap_read(map: regmap, reg: TMP464_THERM_LIMIT[0], val: ®val); |
314 | if (err < 0) |
315 | break; |
316 | val = clamp_val(val, -256000, 256000); /* prevent overflow/underflow */ |
317 | val = clamp_val(temp_from_reg(regval) - val, 0, 255000); |
318 | err = regmap_write(map: regmap, TMP464_TEMP_HYST_REG, |
319 | DIV_ROUND_CLOSEST(val, 1000) << 7); |
320 | break; |
321 | case hwmon_temp_max: |
322 | val = temp_to_limit_reg(clamp_val(val, -255000, 255500)); |
323 | err = regmap_write(map: regmap, reg: TMP464_THERM_LIMIT[channel], val); |
324 | break; |
325 | case hwmon_temp_crit: |
326 | val = temp_to_limit_reg(clamp_val(val, -255000, 255500)); |
327 | err = regmap_write(map: regmap, reg: TMP464_THERM2_LIMIT[channel], val); |
328 | break; |
329 | case hwmon_temp_offset: |
330 | val = temp_to_offset_reg(clamp_val(val, -128000, 127937)); |
331 | err = regmap_write(map: regmap, TMP464_TEMP_OFFSET_REG(channel), val); |
332 | break; |
333 | case hwmon_temp_enable: |
334 | data->channel[channel].enabled = !!val; |
335 | err = tmp464_enable_channels(data); |
336 | break; |
337 | default: |
338 | err = -EOPNOTSUPP; |
339 | break; |
340 | } |
341 | |
342 | return err; |
343 | } |
344 | |
345 | static int tmp464_write(struct device *dev, enum hwmon_sensor_types type, |
346 | u32 attr, int channel, long val) |
347 | { |
348 | struct tmp464_data *data = dev_get_drvdata(dev); |
349 | int err; |
350 | |
351 | mutex_lock(&data->update_lock); |
352 | |
353 | switch (type) { |
354 | case hwmon_chip: |
355 | err = tmp464_chip_write(data, attr, channel, val); |
356 | break; |
357 | case hwmon_temp: |
358 | err = tmp464_temp_write(data, attr, channel, val); |
359 | break; |
360 | default: |
361 | err = -EOPNOTSUPP; |
362 | break; |
363 | } |
364 | |
365 | mutex_unlock(lock: &data->update_lock); |
366 | |
367 | return err; |
368 | } |
369 | |
370 | static umode_t tmp464_is_visible(const void *_data, enum hwmon_sensor_types type, |
371 | u32 attr, int channel) |
372 | { |
373 | const struct tmp464_data *data = _data; |
374 | |
375 | if (channel >= data->channels) |
376 | return 0; |
377 | |
378 | if (type == hwmon_chip) { |
379 | if (attr == hwmon_chip_update_interval) |
380 | return 0644; |
381 | return 0; |
382 | } |
383 | |
384 | switch (attr) { |
385 | case hwmon_temp_input: |
386 | case hwmon_temp_max_alarm: |
387 | case hwmon_temp_crit_alarm: |
388 | case hwmon_temp_crit_hyst: |
389 | return 0444; |
390 | case hwmon_temp_enable: |
391 | case hwmon_temp_max: |
392 | case hwmon_temp_crit: |
393 | return 0644; |
394 | case hwmon_temp_max_hyst: |
395 | if (!channel) |
396 | return 0644; |
397 | return 0444; |
398 | case hwmon_temp_label: |
399 | if (data->channel[channel].label) |
400 | return 0444; |
401 | return 0; |
402 | case hwmon_temp_fault: |
403 | if (channel) |
404 | return 0444; |
405 | return 0; |
406 | case hwmon_temp_offset: |
407 | if (channel) |
408 | return 0644; |
409 | return 0; |
410 | default: |
411 | return 0; |
412 | } |
413 | } |
414 | |
415 | static void tmp464_restore_lock(void *regmap) |
416 | { |
417 | regmap_write(map: regmap, TMP464_LOCK_REG, TMP464_LOCK_VAL); |
418 | } |
419 | |
420 | static void tmp464_restore_config(void *_data) |
421 | { |
422 | struct tmp464_data *data = _data; |
423 | |
424 | regmap_write(map: data->regmap, TMP464_CONFIG_REG, val: data->config_orig); |
425 | } |
426 | |
427 | static int tmp464_init_client(struct device *dev, struct tmp464_data *data) |
428 | { |
429 | struct regmap *regmap = data->regmap; |
430 | unsigned int regval; |
431 | int err; |
432 | |
433 | err = regmap_read(map: regmap, TMP464_LOCK_REG, val: ®val); |
434 | if (err) |
435 | return err; |
436 | if (regval == TMP464_LOCKED) { |
437 | /* Explicitly unlock chip if it is locked */ |
438 | err = regmap_write(map: regmap, TMP464_LOCK_REG, TMP464_UNLOCK_VAL); |
439 | if (err) |
440 | return err; |
441 | /* and lock it again when unloading the driver */ |
442 | err = devm_add_action_or_reset(dev, tmp464_restore_lock, regmap); |
443 | if (err) |
444 | return err; |
445 | } |
446 | |
447 | err = regmap_read(map: regmap, TMP464_CONFIG_REG, val: ®val); |
448 | if (err) |
449 | return err; |
450 | data->config_orig = regval; |
451 | err = devm_add_action_or_reset(dev, tmp464_restore_config, data); |
452 | if (err) |
453 | return err; |
454 | |
455 | /* Default to 500 ms update interval */ |
456 | err = regmap_update_bits(map: regmap, TMP464_CONFIG_REG, |
457 | TMP464_CONFIG_CONVERSION_RATE_MASK | TMP464_CONFIG_SHUTDOWN, |
458 | BIT(TMP464_CONFIG_CONVERSION_RATE_B0) | |
459 | BIT(TMP464_CONFIG_CONVERSION_RATE_B2)); |
460 | if (err) |
461 | return err; |
462 | |
463 | data->update_interval = 500; |
464 | |
465 | return tmp464_enable_channels(data); |
466 | } |
467 | |
468 | static int tmp464_detect(struct i2c_client *client, |
469 | struct i2c_board_info *info) |
470 | { |
471 | struct i2c_adapter *adapter = client->adapter; |
472 | char *name, *chip; |
473 | int reg; |
474 | |
475 | if (!i2c_check_functionality(adap: adapter, I2C_FUNC_SMBUS_WORD_DATA)) |
476 | return -ENODEV; |
477 | |
478 | reg = i2c_smbus_read_word_swapped(client, TMP464_MANUFACTURER_ID_REG); |
479 | if (reg < 0) |
480 | return reg; |
481 | if (reg != TMP464_MANUFACTURER_ID) |
482 | return -ENODEV; |
483 | |
484 | /* Check for "always return zero" bits */ |
485 | reg = i2c_smbus_read_word_swapped(client, TMP464_THERM_STATUS_REG); |
486 | if (reg < 0) |
487 | return reg; |
488 | if (reg & 0x1f) |
489 | return -ENODEV; |
490 | reg = i2c_smbus_read_word_swapped(client, TMP464_THERM2_STATUS_REG); |
491 | if (reg < 0) |
492 | return reg; |
493 | if (reg & 0x1f) |
494 | return -ENODEV; |
495 | |
496 | reg = i2c_smbus_read_word_swapped(client, TMP464_DEVICE_ID_REG); |
497 | if (reg < 0) |
498 | return reg; |
499 | switch (reg) { |
500 | case TMP464_DEVICE_ID: |
501 | name = "tmp464" ; |
502 | chip = "TMP464" ; |
503 | break; |
504 | case TMP468_DEVICE_ID: |
505 | name = "tmp468" ; |
506 | chip = "TMP468" ; |
507 | break; |
508 | default: |
509 | return -ENODEV; |
510 | } |
511 | |
512 | strscpy(info->type, name, I2C_NAME_SIZE); |
513 | dev_info(&adapter->dev, "Detected TI %s chip at 0x%02x\n" , chip, client->addr); |
514 | |
515 | return 0; |
516 | } |
517 | |
518 | static int tmp464_probe_child_from_dt(struct device *dev, |
519 | struct device_node *child, |
520 | struct tmp464_data *data) |
521 | |
522 | { |
523 | struct regmap *regmap = data->regmap; |
524 | u32 channel; |
525 | s32 nfactor; |
526 | int err; |
527 | |
528 | err = of_property_read_u32(np: child, propname: "reg" , out_value: &channel); |
529 | if (err) { |
530 | dev_err(dev, "missing reg property of %pOFn\n" , child); |
531 | return err; |
532 | } |
533 | |
534 | if (channel >= data->channels) { |
535 | dev_err(dev, "invalid reg %d of %pOFn\n" , channel, child); |
536 | return -EINVAL; |
537 | } |
538 | |
539 | of_property_read_string(np: child, propname: "label" , out_string: &data->channel[channel].label); |
540 | |
541 | data->channel[channel].enabled = of_device_is_available(device: child); |
542 | |
543 | err = of_property_read_s32(np: child, propname: "ti,n-factor" , out_value: &nfactor); |
544 | if (err && err != -EINVAL) |
545 | return err; |
546 | if (!err) { |
547 | if (channel == 0) { |
548 | dev_err(dev, "n-factor can't be set for internal channel\n" ); |
549 | return -EINVAL; |
550 | } |
551 | if (nfactor > 127 || nfactor < -128) { |
552 | dev_err(dev, "n-factor for channel %d invalid (%d)\n" , |
553 | channel, nfactor); |
554 | return -EINVAL; |
555 | } |
556 | err = regmap_write(map: regmap, TMP464_N_FACTOR_REG(channel), |
557 | val: (nfactor << 8) & 0xff00); |
558 | if (err) |
559 | return err; |
560 | } |
561 | |
562 | return 0; |
563 | } |
564 | |
565 | static int tmp464_probe_from_dt(struct device *dev, struct tmp464_data *data) |
566 | { |
567 | const struct device_node *np = dev->of_node; |
568 | struct device_node *child; |
569 | int err; |
570 | |
571 | for_each_child_of_node(np, child) { |
572 | if (strcmp(child->name, "channel" )) |
573 | continue; |
574 | |
575 | err = tmp464_probe_child_from_dt(dev, child, data); |
576 | if (err) { |
577 | of_node_put(node: child); |
578 | return err; |
579 | } |
580 | } |
581 | |
582 | return 0; |
583 | } |
584 | |
585 | static const struct hwmon_ops tmp464_ops = { |
586 | .is_visible = tmp464_is_visible, |
587 | .read = tmp464_read, |
588 | .read_string = tmp464_read_string, |
589 | .write = tmp464_write, |
590 | }; |
591 | |
592 | static const struct hwmon_channel_info * const tmp464_info[] = { |
593 | HWMON_CHANNEL_INFO(chip, |
594 | HWMON_C_UPDATE_INTERVAL), |
595 | HWMON_CHANNEL_INFO(temp, |
596 | HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST | HWMON_T_CRIT | |
597 | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM | |
598 | 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 | HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST | |
618 | HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM | |
619 | HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE, |
620 | HWMON_T_INPUT | HWMON_T_OFFSET | HWMON_T_MAX | HWMON_T_MAX_HYST | |
621 | HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_MAX_ALARM | |
622 | HWMON_T_CRIT_ALARM | HWMON_T_FAULT | HWMON_T_LABEL | HWMON_T_ENABLE), |
623 | NULL |
624 | }; |
625 | |
626 | static const struct hwmon_chip_info tmp464_chip_info = { |
627 | .ops = &tmp464_ops, |
628 | .info = tmp464_info, |
629 | }; |
630 | |
631 | /* regmap */ |
632 | |
633 | static bool tmp464_is_volatile_reg(struct device *dev, unsigned int reg) |
634 | { |
635 | return (reg < TMP464_TEMP_REG(TMP468_NUM_CHANNELS) || |
636 | reg == TMP464_THERM_STATUS_REG || |
637 | reg == TMP464_THERM2_STATUS_REG || |
638 | reg == TMP464_REMOTE_OPEN_REG); |
639 | } |
640 | |
641 | static const struct regmap_config tmp464_regmap_config = { |
642 | .reg_bits = 8, |
643 | .val_bits = 16, |
644 | .max_register = TMP464_DEVICE_ID_REG, |
645 | .volatile_reg = tmp464_is_volatile_reg, |
646 | .val_format_endian = REGMAP_ENDIAN_BIG, |
647 | .cache_type = REGCACHE_MAPLE, |
648 | .use_single_read = true, |
649 | .use_single_write = true, |
650 | }; |
651 | |
652 | static int tmp464_probe(struct i2c_client *client) |
653 | { |
654 | struct device *dev = &client->dev; |
655 | struct device *hwmon_dev; |
656 | struct tmp464_data *data; |
657 | int i, err; |
658 | |
659 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) { |
660 | dev_err(&client->dev, "i2c functionality check failed\n" ); |
661 | return -ENODEV; |
662 | } |
663 | data = devm_kzalloc(dev, size: sizeof(struct tmp464_data), GFP_KERNEL); |
664 | if (!data) |
665 | return -ENOMEM; |
666 | |
667 | mutex_init(&data->update_lock); |
668 | |
669 | if (dev->of_node) |
670 | data->channels = (int)(unsigned long)of_device_get_match_data(dev: &client->dev); |
671 | else |
672 | data->channels = i2c_match_id(id: tmp464_id, client)->driver_data; |
673 | |
674 | data->regmap = devm_regmap_init_i2c(client, &tmp464_regmap_config); |
675 | if (IS_ERR(ptr: data->regmap)) |
676 | return PTR_ERR(ptr: data->regmap); |
677 | |
678 | for (i = 0; i < data->channels; i++) |
679 | data->channel[i].enabled = true; |
680 | |
681 | err = tmp464_init_client(dev, data); |
682 | if (err) |
683 | return err; |
684 | |
685 | if (dev->of_node) { |
686 | err = tmp464_probe_from_dt(dev, data); |
687 | if (err) |
688 | return err; |
689 | } |
690 | |
691 | hwmon_dev = devm_hwmon_device_register_with_info(dev, name: client->name, |
692 | drvdata: data, info: &tmp464_chip_info, NULL); |
693 | return PTR_ERR_OR_ZERO(ptr: hwmon_dev); |
694 | } |
695 | |
696 | static struct i2c_driver tmp464_driver = { |
697 | .class = I2C_CLASS_HWMON, |
698 | .driver = { |
699 | .name = "tmp464" , |
700 | .of_match_table = of_match_ptr(tmp464_of_match), |
701 | }, |
702 | .probe = tmp464_probe, |
703 | .id_table = tmp464_id, |
704 | .detect = tmp464_detect, |
705 | .address_list = normal_i2c, |
706 | }; |
707 | |
708 | module_i2c_driver(tmp464_driver); |
709 | |
710 | MODULE_AUTHOR("Agathe Porte <agathe.porte@nokia.com>" ); |
711 | MODULE_DESCRIPTION("Texas Instruments TMP464 temperature sensor driver" ); |
712 | MODULE_LICENSE("GPL" ); |
713 | |