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