1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* tmp421.c
3 *
4 * Copyright (C) 2009 Andre Prendel <andre.prendel@gmx.de>
5 * Preliminary support by:
6 * Melvin Rook, Raymond Ng
7 */
8
9 /*
10 * Driver for the Texas Instruments TMP421 SMBus temperature sensor IC.
11 * Supported models: TMP421, TMP422, TMP423, TMP441, TMP442
12 */
13
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/slab.h>
17 #include <linux/jiffies.h>
18 #include <linux/i2c.h>
19 #include <linux/hwmon.h>
20 #include <linux/hwmon-sysfs.h>
21 #include <linux/err.h>
22 #include <linux/of.h>
23 #include <linux/sysfs.h>
24
25 /* Addresses to scan */
26 static const unsigned short normal_i2c[] = { 0x2a, 0x4c, 0x4d, 0x4e, 0x4f,
27 I2C_CLIENT_END };
28
29 enum chips { tmp421, tmp422, tmp423, tmp441, tmp442 };
30
31 #define MAX_CHANNELS 4
32 /* The TMP421 registers */
33 #define TMP421_STATUS_REG 0x08
34 #define TMP421_CONFIG_REG_1 0x09
35 #define TMP421_CONFIG_REG_2 0x0A
36 #define TMP421_CONFIG_REG_REN(x) (BIT(3 + (x)))
37 #define TMP421_CONFIG_REG_REN_MASK GENMASK(6, 3)
38 #define TMP421_CONVERSION_RATE_REG 0x0B
39 #define TMP421_N_FACTOR_REG_1 0x21
40 #define TMP421_MANUFACTURER_ID_REG 0xFE
41 #define TMP421_DEVICE_ID_REG 0xFF
42
43 static const u8 TMP421_TEMP_MSB[MAX_CHANNELS] = { 0x00, 0x01, 0x02, 0x03 };
44 static const u8 TMP421_TEMP_LSB[MAX_CHANNELS] = { 0x10, 0x11, 0x12, 0x13 };
45
46 /* Flags */
47 #define TMP421_CONFIG_SHUTDOWN 0x40
48 #define TMP421_CONFIG_RANGE 0x04
49
50 /* Manufacturer / Device ID's */
51 #define TMP421_MANUFACTURER_ID 0x55
52 #define TMP421_DEVICE_ID 0x21
53 #define TMP422_DEVICE_ID 0x22
54 #define TMP423_DEVICE_ID 0x23
55 #define TMP441_DEVICE_ID 0x41
56 #define TMP442_DEVICE_ID 0x42
57
58 static const struct i2c_device_id tmp421_id[] = {
59 { "tmp421", 2 },
60 { "tmp422", 3 },
61 { "tmp423", 4 },
62 { "tmp441", 2 },
63 { "tmp442", 3 },
64 { }
65 };
66 MODULE_DEVICE_TABLE(i2c, tmp421_id);
67
68 static const struct of_device_id __maybe_unused tmp421_of_match[] = {
69 {
70 .compatible = "ti,tmp421",
71 .data = (void *)2
72 },
73 {
74 .compatible = "ti,tmp422",
75 .data = (void *)3
76 },
77 {
78 .compatible = "ti,tmp423",
79 .data = (void *)4
80 },
81 {
82 .compatible = "ti,tmp441",
83 .data = (void *)2
84 },
85 {
86 .compatible = "ti,tmp442",
87 .data = (void *)3
88 },
89 { },
90 };
91 MODULE_DEVICE_TABLE(of, tmp421_of_match);
92
93 struct tmp421_channel {
94 const char *label;
95 bool enabled;
96 s16 temp;
97 };
98
99 struct tmp421_data {
100 struct i2c_client *client;
101 u32 temp_config[MAX_CHANNELS + 1];
102 struct hwmon_channel_info temp_info;
103 const struct hwmon_channel_info *info[2];
104 struct hwmon_chip_info chip;
105 bool valid;
106 unsigned long last_updated;
107 unsigned long channels;
108 u8 config;
109 struct tmp421_channel channel[MAX_CHANNELS];
110 };
111
temp_from_raw(u16 reg,bool extended)112 static int temp_from_raw(u16 reg, bool extended)
113 {
114 /* Mask out status bits */
115 int temp = reg & ~0xf;
116
117 if (extended)
118 temp = temp - 64 * 256;
119 else
120 temp = (s16)temp;
121
122 return DIV_ROUND_CLOSEST(temp * 1000, 256);
123 }
124
tmp421_update_device(struct tmp421_data * data)125 static int tmp421_update_device(struct tmp421_data *data)
126 {
127 struct i2c_client *client = data->client;
128 int ret = 0;
129 int i;
130
131 if (time_after(jiffies, data->last_updated + (HZ / 2)) ||
132 !data->valid) {
133 data->valid = false;
134 ret = i2c_smbus_read_byte_data(client, TMP421_CONFIG_REG_1);
135 if (ret < 0)
136 return ret;
137 data->config = ret;
138
139 for (i = 0; i < data->channels; i++) {
140 ret = i2c_smbus_read_byte_data(client, TMP421_TEMP_MSB[i]);
141 if (ret < 0)
142 return ret;
143 data->channel[i].temp = ret << 8;
144
145 ret = i2c_smbus_read_byte_data(client, TMP421_TEMP_LSB[i]);
146 if (ret < 0)
147 return ret;
148 data->channel[i].temp |= ret;
149 }
150 data->last_updated = jiffies;
151 data->valid = true;
152 }
153 return 0;
154 }
155
tmp421_enable_channels(struct tmp421_data * data)156 static int tmp421_enable_channels(struct tmp421_data *data)
157 {
158 int err;
159 struct i2c_client *client = data->client;
160 struct device *dev = &client->dev;
161 int old = i2c_smbus_read_byte_data(client, TMP421_CONFIG_REG_2);
162 int new, i;
163
164 if (old < 0) {
165 dev_err(dev, "error reading register, can't disable channels\n");
166 return old;
167 }
168
169 new = old & ~TMP421_CONFIG_REG_REN_MASK;
170 for (i = 0; i < data->channels; i++)
171 if (data->channel[i].enabled)
172 new |= TMP421_CONFIG_REG_REN(i);
173
174 if (new == old)
175 return 0;
176
177 err = i2c_smbus_write_byte_data(client, TMP421_CONFIG_REG_2, new);
178 if (err < 0)
179 dev_err(dev, "error writing register, can't disable channels\n");
180
181 return err;
182 }
183
tmp421_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)184 static int tmp421_read(struct device *dev, enum hwmon_sensor_types type,
185 u32 attr, int channel, long *val)
186 {
187 struct tmp421_data *tmp421 = dev_get_drvdata(dev);
188 int ret = 0;
189
190 ret = tmp421_update_device(tmp421);
191 if (ret)
192 return ret;
193
194 switch (attr) {
195 case hwmon_temp_input:
196 if (!tmp421->channel[channel].enabled)
197 return -ENODATA;
198 *val = temp_from_raw(tmp421->channel[channel].temp,
199 tmp421->config & TMP421_CONFIG_RANGE);
200 return 0;
201 case hwmon_temp_fault:
202 if (!tmp421->channel[channel].enabled)
203 return -ENODATA;
204 /*
205 * Any of OPEN or /PVLD bits indicate a hardware mulfunction
206 * and the conversion result may be incorrect
207 */
208 *val = !!(tmp421->channel[channel].temp & 0x03);
209 return 0;
210 case hwmon_temp_enable:
211 *val = tmp421->channel[channel].enabled;
212 return 0;
213 default:
214 return -EOPNOTSUPP;
215 }
216
217 }
218
tmp421_read_string(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,const char ** str)219 static int tmp421_read_string(struct device *dev, enum hwmon_sensor_types type,
220 u32 attr, int channel, const char **str)
221 {
222 struct tmp421_data *data = dev_get_drvdata(dev);
223
224 *str = data->channel[channel].label;
225
226 return 0;
227 }
228
tmp421_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)229 static int tmp421_write(struct device *dev, enum hwmon_sensor_types type,
230 u32 attr, int channel, long val)
231 {
232 struct tmp421_data *data = dev_get_drvdata(dev);
233 int ret;
234
235 switch (attr) {
236 case hwmon_temp_enable:
237 data->channel[channel].enabled = val;
238 ret = tmp421_enable_channels(data);
239 break;
240 default:
241 ret = -EOPNOTSUPP;
242 }
243
244 return ret;
245 }
246
tmp421_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)247 static umode_t tmp421_is_visible(const void *data, enum hwmon_sensor_types type,
248 u32 attr, int channel)
249 {
250 switch (attr) {
251 case hwmon_temp_fault:
252 case hwmon_temp_input:
253 case hwmon_temp_label:
254 return 0444;
255 case hwmon_temp_enable:
256 return 0644;
257 default:
258 return 0;
259 }
260 }
261
tmp421_init_client(struct tmp421_data * data)262 static int tmp421_init_client(struct tmp421_data *data)
263 {
264 int config, config_orig;
265 struct i2c_client *client = data->client;
266
267 /* Set the conversion rate to 2 Hz */
268 i2c_smbus_write_byte_data(client, TMP421_CONVERSION_RATE_REG, 0x05);
269
270 /* Start conversions (disable shutdown if necessary) */
271 config = i2c_smbus_read_byte_data(client, TMP421_CONFIG_REG_1);
272 if (config < 0) {
273 dev_err(&client->dev,
274 "Could not read configuration register (%d)\n", config);
275 return config;
276 }
277
278 config_orig = config;
279 config &= ~TMP421_CONFIG_SHUTDOWN;
280
281 if (config != config_orig) {
282 dev_info(&client->dev, "Enable monitoring chip\n");
283 i2c_smbus_write_byte_data(client, TMP421_CONFIG_REG_1, config);
284 }
285
286 return tmp421_enable_channels(data);
287 }
288
tmp421_detect(struct i2c_client * client,struct i2c_board_info * info)289 static int tmp421_detect(struct i2c_client *client,
290 struct i2c_board_info *info)
291 {
292 enum chips kind;
293 struct i2c_adapter *adapter = client->adapter;
294 static const char * const names[] = {
295 "TMP421", "TMP422", "TMP423",
296 "TMP441", "TMP442"
297 };
298 int addr = client->addr;
299 u8 reg;
300
301 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
302 return -ENODEV;
303
304 reg = i2c_smbus_read_byte_data(client, TMP421_MANUFACTURER_ID_REG);
305 if (reg != TMP421_MANUFACTURER_ID)
306 return -ENODEV;
307
308 reg = i2c_smbus_read_byte_data(client, TMP421_CONVERSION_RATE_REG);
309 if (reg & 0xf8)
310 return -ENODEV;
311
312 reg = i2c_smbus_read_byte_data(client, TMP421_STATUS_REG);
313 if (reg & 0x7f)
314 return -ENODEV;
315
316 reg = i2c_smbus_read_byte_data(client, TMP421_DEVICE_ID_REG);
317 switch (reg) {
318 case TMP421_DEVICE_ID:
319 kind = tmp421;
320 break;
321 case TMP422_DEVICE_ID:
322 if (addr == 0x2a)
323 return -ENODEV;
324 kind = tmp422;
325 break;
326 case TMP423_DEVICE_ID:
327 if (addr != 0x4c && addr != 0x4d)
328 return -ENODEV;
329 kind = tmp423;
330 break;
331 case TMP441_DEVICE_ID:
332 kind = tmp441;
333 break;
334 case TMP442_DEVICE_ID:
335 if (addr != 0x4c && addr != 0x4d)
336 return -ENODEV;
337 kind = tmp442;
338 break;
339 default:
340 return -ENODEV;
341 }
342
343 strscpy(info->type, tmp421_id[kind].name, I2C_NAME_SIZE);
344 dev_info(&adapter->dev, "Detected TI %s chip at 0x%02x\n",
345 names[kind], client->addr);
346
347 return 0;
348 }
349
tmp421_probe_child_from_dt(struct i2c_client * client,struct device_node * child,struct tmp421_data * data)350 static int tmp421_probe_child_from_dt(struct i2c_client *client,
351 struct device_node *child,
352 struct tmp421_data *data)
353
354 {
355 struct device *dev = &client->dev;
356 u32 i;
357 s32 val;
358 int err;
359
360 err = of_property_read_u32(child, "reg", &i);
361 if (err) {
362 dev_err(dev, "missing reg property of %pOFn\n", child);
363 return err;
364 }
365
366 if (i >= data->channels) {
367 dev_err(dev, "invalid reg %d of %pOFn\n", i, child);
368 return -EINVAL;
369 }
370
371 err = of_property_read_string(child, "label", &data->channel[i].label);
372 if (err == -ENODATA || err == -EILSEQ) {
373 dev_err(dev, "invalid label property in %pOFn\n", child);
374 return err;
375 }
376 if (data->channel[i].label)
377 data->temp_config[i] |= HWMON_T_LABEL;
378
379 data->channel[i].enabled = of_device_is_available(child);
380
381 err = of_property_read_s32(child, "ti,n-factor", &val);
382 if (!err) {
383 if (i == 0) {
384 dev_err(dev, "n-factor can't be set for internal channel\n");
385 return -EINVAL;
386 }
387
388 if (val > 127 || val < -128) {
389 dev_err(dev, "n-factor for channel %d invalid (%d)\n",
390 i, val);
391 return -EINVAL;
392 }
393 i2c_smbus_write_byte_data(client, TMP421_N_FACTOR_REG_1 + i - 1,
394 val);
395 }
396
397 return 0;
398 }
399
tmp421_probe_from_dt(struct i2c_client * client,struct tmp421_data * data)400 static int tmp421_probe_from_dt(struct i2c_client *client, struct tmp421_data *data)
401 {
402 struct device *dev = &client->dev;
403 const struct device_node *np = dev->of_node;
404 int err;
405
406 for_each_child_of_node_scoped(np, child) {
407 if (strcmp(child->name, "channel"))
408 continue;
409
410 err = tmp421_probe_child_from_dt(client, child, data);
411 if (err)
412 return err;
413 }
414
415 return 0;
416 }
417
418 static const struct hwmon_ops tmp421_ops = {
419 .is_visible = tmp421_is_visible,
420 .read = tmp421_read,
421 .read_string = tmp421_read_string,
422 .write = tmp421_write,
423 };
424
tmp421_probe(struct i2c_client * client)425 static int tmp421_probe(struct i2c_client *client)
426 {
427 struct device *dev = &client->dev;
428 struct device *hwmon_dev;
429 struct tmp421_data *data;
430 int i, err;
431
432 data = devm_kzalloc(dev, sizeof(struct tmp421_data), GFP_KERNEL);
433 if (!data)
434 return -ENOMEM;
435
436 data->channels = (unsigned long)i2c_get_match_data(client);
437 data->client = client;
438
439 for (i = 0; i < data->channels; i++) {
440 data->temp_config[i] = HWMON_T_INPUT | HWMON_T_FAULT | HWMON_T_ENABLE;
441 data->channel[i].enabled = true;
442 }
443
444 err = tmp421_probe_from_dt(client, data);
445 if (err)
446 return err;
447
448 err = tmp421_init_client(data);
449 if (err)
450 return err;
451
452 data->chip.ops = &tmp421_ops;
453 data->chip.info = data->info;
454
455 data->info[0] = &data->temp_info;
456
457 data->temp_info.type = hwmon_temp;
458 data->temp_info.config = data->temp_config;
459
460 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
461 data,
462 &data->chip,
463 NULL);
464 return PTR_ERR_OR_ZERO(hwmon_dev);
465 }
466
467 static struct i2c_driver tmp421_driver = {
468 .class = I2C_CLASS_HWMON,
469 .driver = {
470 .name = "tmp421",
471 .of_match_table = of_match_ptr(tmp421_of_match),
472 },
473 .probe = tmp421_probe,
474 .id_table = tmp421_id,
475 .detect = tmp421_detect,
476 .address_list = normal_i2c,
477 };
478
479 module_i2c_driver(tmp421_driver);
480
481 MODULE_AUTHOR("Andre Prendel <andre.prendel@gmx.de>");
482 MODULE_DESCRIPTION("Texas Instruments TMP421/422/423/441/442 temperature sensor driver");
483 MODULE_LICENSE("GPL");
484