1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Copyright (C) 2011 Alexander Stein <alexander.stein@systec-electronic.com>
  4 *
  5 * The LM95245 is a sensor chip made by TI / National Semiconductor.
  6 * It reports up to two temperatures (its own plus an external one).
  7 *
  8 * This driver is based on lm95241.c
  9 */
 10
 11#include <linux/err.h>
 12#include <linux/init.h>
 13#include <linux/hwmon.h>
 14#include <linux/i2c.h>
 15#include <linux/module.h>
 16#include <linux/mutex.h>
 17#include <linux/regmap.h>
 18#include <linux/slab.h>
 19
 20static const unsigned short normal_i2c[] = {
 21	0x18, 0x19, 0x29, 0x4c, 0x4d, I2C_CLIENT_END };
 22
 23/* LM95245 registers */
 24/* general registers */
 25#define LM95245_REG_RW_CONFIG1		0x03
 26#define LM95245_REG_RW_CONVERS_RATE	0x04
 27#define LM95245_REG_W_ONE_SHOT		0x0F
 28
 29/* diode configuration */
 30#define LM95245_REG_RW_CONFIG2		0xBF
 31#define LM95245_REG_RW_REMOTE_OFFH	0x11
 32#define LM95245_REG_RW_REMOTE_OFFL	0x12
 33
 34/* status registers */
 35#define LM95245_REG_R_STATUS1		0x02
 36#define LM95245_REG_R_STATUS2		0x33
 37
 38/* limit registers */
 39#define LM95245_REG_RW_REMOTE_OS_LIMIT		0x07
 40#define LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT	0x20
 41#define LM95245_REG_RW_REMOTE_TCRIT_LIMIT	0x19
 42#define LM95245_REG_RW_COMMON_HYSTERESIS	0x21
 43
 44/* temperature signed */
 45#define LM95245_REG_R_LOCAL_TEMPH_S	0x00
 46#define LM95245_REG_R_LOCAL_TEMPL_S	0x30
 47#define LM95245_REG_R_REMOTE_TEMPH_S	0x01
 48#define LM95245_REG_R_REMOTE_TEMPL_S	0x10
 49/* temperature unsigned */
 50#define LM95245_REG_R_REMOTE_TEMPH_U	0x31
 51#define LM95245_REG_R_REMOTE_TEMPL_U	0x32
 52
 53/* id registers */
 54#define LM95245_REG_R_MAN_ID		0xFE
 55#define LM95245_REG_R_CHIP_ID		0xFF
 56
 57/* LM95245 specific bitfields */
 58#define CFG_STOP		0x40
 59#define CFG_REMOTE_TCRIT_MASK	0x10
 60#define CFG_REMOTE_OS_MASK	0x08
 61#define CFG_LOCAL_TCRIT_MASK	0x04
 62#define CFG_LOCAL_OS_MASK	0x02
 63
 64#define CFG2_OS_A0		0x40
 65#define CFG2_DIODE_FAULT_OS	0x20
 66#define CFG2_DIODE_FAULT_TCRIT	0x10
 67#define CFG2_REMOTE_TT		0x08
 68#define CFG2_REMOTE_FILTER_DIS	0x00
 69#define CFG2_REMOTE_FILTER_EN	0x06
 70
 71/* conversation rate in ms */
 72#define RATE_CR0063	0x00
 73#define RATE_CR0364	0x01
 74#define RATE_CR1000	0x02
 75#define RATE_CR2500	0x03
 76
 77#define STATUS1_ROS		0x10
 78#define STATUS1_DIODE_FAULT	0x04
 79#define STATUS1_RTCRIT		0x02
 80#define STATUS1_LOC		0x01
 81
 82#define MANUFACTURER_ID		0x01
 83#define LM95235_REVISION	0xB1
 84#define LM95245_REVISION	0xB3
 85
 86/* Client data (each client gets its own) */
 87struct lm95245_data {
 88	struct regmap *regmap;
 89	struct mutex update_lock;
 90	int interval;	/* in msecs */
 91};
 92
 93/* Conversions */
 94static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
 95{
 96	return val_h * 1000 + val_l * 1000 / 256;
 97}
 98
 99static int temp_from_reg_signed(u8 val_h, u8 val_l)
100{
101	if (val_h & 0x80)
102		return (val_h - 0x100) * 1000;
103	return temp_from_reg_unsigned(val_h, val_l);
104}
105
106static int lm95245_read_conversion_rate(struct lm95245_data *data)
107{
108	unsigned int rate;
109	int ret;
110
111	ret = regmap_read(data->regmap, LM95245_REG_RW_CONVERS_RATE, &rate);
112	if (ret < 0)
113		return ret;
114
115	switch (rate) {
116	case RATE_CR0063:
117		data->interval = 63;
118		break;
119	case RATE_CR0364:
120		data->interval = 364;
121		break;
122	case RATE_CR1000:
123		data->interval = 1000;
124		break;
125	case RATE_CR2500:
126	default:
127		data->interval = 2500;
128		break;
129	}
130	return 0;
131}
132
133static int lm95245_set_conversion_rate(struct lm95245_data *data, long interval)
134{
135	int ret, rate;
136
137	if (interval <= 63) {
138		interval = 63;
139		rate = RATE_CR0063;
140	} else if (interval <= 364) {
141		interval = 364;
142		rate = RATE_CR0364;
143	} else if (interval <= 1000) {
144		interval = 1000;
145		rate = RATE_CR1000;
146	} else {
147		interval = 2500;
148		rate = RATE_CR2500;
149	}
150
151	ret = regmap_write(data->regmap, LM95245_REG_RW_CONVERS_RATE, rate);
152	if (ret < 0)
153		return ret;
154
155	data->interval = interval;
156	return 0;
157}
158
159static int lm95245_read_temp(struct device *dev, u32 attr, int channel,
160			     long *val)
161{
162	struct lm95245_data *data = dev_get_drvdata(dev);
163	struct regmap *regmap = data->regmap;
164	int ret, regl, regh, regvall, regvalh;
 
 
 
165
166	switch (attr) {
167	case hwmon_temp_input:
168		regl = channel ? LM95245_REG_R_REMOTE_TEMPL_S :
169				 LM95245_REG_R_LOCAL_TEMPL_S;
170		regh = channel ? LM95245_REG_R_REMOTE_TEMPH_S :
171				 LM95245_REG_R_LOCAL_TEMPH_S;
172		ret = regmap_read(regmap, regl, &regvall);
173		if (ret < 0)
174			return ret;
175		ret = regmap_read(regmap, regh, &regvalh);
176		if (ret < 0)
177			return ret;
178		/*
179		 * Local temp is always signed.
180		 * Remote temp has both signed and unsigned data.
181		 * Use signed calculation for remote if signed bit is set
182		 * or if reported temperature is below signed limit.
183		 */
184		if (!channel || (regvalh & 0x80) || regvalh < 0x7f) {
185			*val = temp_from_reg_signed(regvalh, regvall);
186			return 0;
187		}
188		ret = regmap_read(regmap, LM95245_REG_R_REMOTE_TEMPL_U,
189				  &regvall);
190		if (ret < 0)
191			return ret;
192		ret = regmap_read(regmap, LM95245_REG_R_REMOTE_TEMPH_U,
193				  &regvalh);
194		if (ret < 0)
195			return ret;
196		*val = temp_from_reg_unsigned(regvalh, regvall);
197		return 0;
198	case hwmon_temp_max:
199		ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT,
200				  &regvalh);
201		if (ret < 0)
202			return ret;
203		*val = regvalh * 1000;
204		return 0;
205	case hwmon_temp_crit:
206		regh = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
207				 LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
208		ret = regmap_read(regmap, regh, &regvalh);
209		if (ret < 0)
210			return ret;
211		*val = regvalh * 1000;
212		return 0;
213	case hwmon_temp_max_hyst:
214		ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT,
215				  &regvalh);
 
216		if (ret < 0)
217			return ret;
218		ret = regmap_read(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
219				  &regvall);
220		if (ret < 0)
221			return ret;
222		*val = (regvalh - regvall) * 1000;
223		return 0;
224	case hwmon_temp_crit_hyst:
225		regh = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
226				 LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
227		ret = regmap_read(regmap, regh, &regvalh);
228		if (ret < 0)
229			return ret;
230		ret = regmap_read(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
231				  &regvall);
232		if (ret < 0)
233			return ret;
234		*val = (regvalh - regvall) * 1000;
235		return 0;
236	case hwmon_temp_type:
237		ret = regmap_read(regmap, LM95245_REG_RW_CONFIG2, &regvalh);
238		if (ret < 0)
239			return ret;
240		*val = (regvalh & CFG2_REMOTE_TT) ? 1 : 2;
241		return 0;
242	case hwmon_temp_offset:
243		ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OFFL,
244				  &regvall);
245		if (ret < 0)
246			return ret;
247		ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OFFH,
248				  &regvalh);
249		if (ret < 0)
250			return ret;
251		*val = temp_from_reg_signed(regvalh, regvall);
252		return 0;
253	case hwmon_temp_max_alarm:
254		ret = regmap_read(regmap, LM95245_REG_R_STATUS1, &regvalh);
255		if (ret < 0)
256			return ret;
257		*val = !!(regvalh & STATUS1_ROS);
258		return 0;
259	case hwmon_temp_crit_alarm:
260		ret = regmap_read(regmap, LM95245_REG_R_STATUS1, &regvalh);
261		if (ret < 0)
262			return ret;
263		*val = !!(regvalh & (channel ? STATUS1_RTCRIT : STATUS1_LOC));
264		return 0;
265	case hwmon_temp_fault:
266		ret = regmap_read(regmap, LM95245_REG_R_STATUS1, &regvalh);
267		if (ret < 0)
268			return ret;
269		*val = !!(regvalh & STATUS1_DIODE_FAULT);
270		return 0;
271	default:
272		return -EOPNOTSUPP;
273	}
274}
275
276static int lm95245_write_temp(struct device *dev, u32 attr, int channel,
277			      long val)
278{
279	struct lm95245_data *data = dev_get_drvdata(dev);
280	struct regmap *regmap = data->regmap;
281	unsigned int regval;
 
282	int ret, reg;
283
284	switch (attr) {
285	case hwmon_temp_max:
286		val = clamp_val(val / 1000, 0, 255);
287		ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT, val);
288		return ret;
289	case hwmon_temp_crit:
290		reg = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
291				LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
292		val = clamp_val(val / 1000, 0, channel ? 255 : 127);
293		ret = regmap_write(regmap, reg, val);
294		return ret;
295	case hwmon_temp_crit_hyst:
296		mutex_lock(&data->update_lock);
297		ret = regmap_read(regmap, LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT,
298				  &regval);
299		if (ret < 0) {
300			mutex_unlock(&data->update_lock);
301			return ret;
302		}
303		/* Clamp to reasonable range to prevent overflow */
304		val = clamp_val(val, -1000000, 1000000);
305		val = regval - val / 1000;
306		val = clamp_val(val, 0, 31);
307		ret = regmap_write(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
308				   val);
309		mutex_unlock(&data->update_lock);
310		return ret;
311	case hwmon_temp_offset:
312		val = clamp_val(val, -128000, 127875);
313		val = val * 256 / 1000;
314		mutex_lock(&data->update_lock);
315		ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OFFL,
316				   val & 0xe0);
317		if (ret < 0) {
318			mutex_unlock(&data->update_lock);
319			return ret;
320		}
321		ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OFFH,
322				   (val >> 8) & 0xff);
323		mutex_unlock(&data->update_lock);
324		return ret;
325	case hwmon_temp_type:
326		if (val != 1 && val != 2)
327			return -EINVAL;
328		ret = regmap_update_bits(regmap, LM95245_REG_RW_CONFIG2,
329					 CFG2_REMOTE_TT,
330					 val == 1 ? CFG2_REMOTE_TT : 0);
331		return ret;
332	default:
333		return -EOPNOTSUPP;
334	}
335}
336
337static int lm95245_read_chip(struct device *dev, u32 attr, int channel,
338			     long *val)
339{
340	struct lm95245_data *data = dev_get_drvdata(dev);
341
342	switch (attr) {
343	case hwmon_chip_update_interval:
344		*val = data->interval;
345		return 0;
346	default:
347		return -EOPNOTSUPP;
348	}
349}
350
351static int lm95245_write_chip(struct device *dev, u32 attr, int channel,
352			      long val)
353{
354	struct lm95245_data *data = dev_get_drvdata(dev);
355	int ret;
356
357	switch (attr) {
358	case hwmon_chip_update_interval:
359		mutex_lock(&data->update_lock);
360		ret = lm95245_set_conversion_rate(data, val);
361		mutex_unlock(&data->update_lock);
362		return ret;
363	default:
364		return -EOPNOTSUPP;
365	}
366}
367
368static int lm95245_read(struct device *dev, enum hwmon_sensor_types type,
369			u32 attr, int channel, long *val)
370{
371	switch (type) {
372	case hwmon_chip:
373		return lm95245_read_chip(dev, attr, channel, val);
374	case hwmon_temp:
375		return lm95245_read_temp(dev, attr, channel, val);
376	default:
377		return -EOPNOTSUPP;
378	}
379}
380
381static int lm95245_write(struct device *dev, enum hwmon_sensor_types type,
382			 u32 attr, int channel, long val)
383{
384	switch (type) {
385	case hwmon_chip:
386		return lm95245_write_chip(dev, attr, channel, val);
387	case hwmon_temp:
388		return lm95245_write_temp(dev, attr, channel, val);
389	default:
390		return -EOPNOTSUPP;
391	}
392}
393
394static umode_t lm95245_temp_is_visible(const void *data, u32 attr, int channel)
395{
396	switch (attr) {
397	case hwmon_temp_input:
398	case hwmon_temp_max_alarm:
399	case hwmon_temp_max_hyst:
400	case hwmon_temp_crit_alarm:
401	case hwmon_temp_fault:
402		return 0444;
403	case hwmon_temp_type:
404	case hwmon_temp_max:
405	case hwmon_temp_crit:
406	case hwmon_temp_offset:
407		return 0644;
408	case hwmon_temp_crit_hyst:
409		return (channel == 0) ? 0644 : 0444;
410	default:
411		return 0;
412	}
413}
414
415static umode_t lm95245_is_visible(const void *data,
416				  enum hwmon_sensor_types type,
417				  u32 attr, int channel)
418{
419	switch (type) {
420	case hwmon_chip:
421		switch (attr) {
422		case hwmon_chip_update_interval:
423			return 0644;
424		default:
425			return 0;
426		}
427	case hwmon_temp:
428		return lm95245_temp_is_visible(data, attr, channel);
429	default:
430		return 0;
431	}
432}
433
434/* Return 0 if detection is successful, -ENODEV otherwise */
435static int lm95245_detect(struct i2c_client *new_client,
436			  struct i2c_board_info *info)
437{
438	struct i2c_adapter *adapter = new_client->adapter;
439	int address = new_client->addr;
440	const char *name;
441	int rev, id;
442
443	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
444		return -ENODEV;
445
446	id = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_MAN_ID);
447	if (id != MANUFACTURER_ID)
448		return -ENODEV;
449
450	rev = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_CHIP_ID);
451	switch (rev) {
452	case LM95235_REVISION:
453		if (address != 0x18 && address != 0x29 && address != 0x4c)
454			return -ENODEV;
455		name = "lm95235";
456		break;
457	case LM95245_REVISION:
458		name = "lm95245";
459		break;
460	default:
461		return -ENODEV;
462	}
463
464	strscpy(info->type, name, I2C_NAME_SIZE);
465	return 0;
466}
467
468static int lm95245_init_client(struct lm95245_data *data)
469{
470	int ret;
471
472	ret = lm95245_read_conversion_rate(data);
473	if (ret < 0)
474		return ret;
475
476	return regmap_update_bits(data->regmap, LM95245_REG_RW_CONFIG1,
477				  CFG_STOP, 0);
478}
479
480static bool lm95245_is_writeable_reg(struct device *dev, unsigned int reg)
481{
482	switch (reg) {
483	case LM95245_REG_RW_CONFIG1:
484	case LM95245_REG_RW_CONVERS_RATE:
485	case LM95245_REG_W_ONE_SHOT:
486	case LM95245_REG_RW_CONFIG2:
487	case LM95245_REG_RW_REMOTE_OFFH:
488	case LM95245_REG_RW_REMOTE_OFFL:
489	case LM95245_REG_RW_REMOTE_OS_LIMIT:
490	case LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT:
491	case LM95245_REG_RW_REMOTE_TCRIT_LIMIT:
492	case LM95245_REG_RW_COMMON_HYSTERESIS:
493		return true;
494	default:
495		return false;
496	}
497}
498
499static bool lm95245_is_volatile_reg(struct device *dev, unsigned int reg)
500{
501	switch (reg) {
502	case LM95245_REG_R_STATUS1:
503	case LM95245_REG_R_STATUS2:
504	case LM95245_REG_R_LOCAL_TEMPH_S:
505	case LM95245_REG_R_LOCAL_TEMPL_S:
506	case LM95245_REG_R_REMOTE_TEMPH_S:
507	case LM95245_REG_R_REMOTE_TEMPL_S:
508	case LM95245_REG_R_REMOTE_TEMPH_U:
509	case LM95245_REG_R_REMOTE_TEMPL_U:
510		return true;
511	default:
512		return false;
513	}
514}
515
516static const struct regmap_config lm95245_regmap_config = {
517	.reg_bits = 8,
518	.val_bits = 8,
519	.writeable_reg = lm95245_is_writeable_reg,
520	.volatile_reg = lm95245_is_volatile_reg,
521	.cache_type = REGCACHE_MAPLE,
522	.use_single_read = true,
523	.use_single_write = true,
524};
525
526static const struct hwmon_channel_info * const lm95245_info[] = {
527	HWMON_CHANNEL_INFO(chip,
528			   HWMON_C_UPDATE_INTERVAL),
529	HWMON_CHANNEL_INFO(temp,
530			   HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_HYST |
531			   HWMON_T_CRIT_ALARM,
532			   HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST |
533			   HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_FAULT |
534			   HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
535			   HWMON_T_TYPE | HWMON_T_OFFSET),
536	NULL
537};
538
539static const struct hwmon_ops lm95245_hwmon_ops = {
540	.is_visible = lm95245_is_visible,
541	.read = lm95245_read,
542	.write = lm95245_write,
543};
544
545static const struct hwmon_chip_info lm95245_chip_info = {
546	.ops = &lm95245_hwmon_ops,
547	.info = lm95245_info,
548};
549
550static int lm95245_probe(struct i2c_client *client)
551{
552	struct device *dev = &client->dev;
553	struct lm95245_data *data;
554	struct device *hwmon_dev;
555	int ret;
556
557	data = devm_kzalloc(dev, sizeof(struct lm95245_data), GFP_KERNEL);
558	if (!data)
559		return -ENOMEM;
560
561	data->regmap = devm_regmap_init_i2c(client, &lm95245_regmap_config);
562	if (IS_ERR(data->regmap))
563		return PTR_ERR(data->regmap);
564
565	mutex_init(&data->update_lock);
566
567	/* Initialize the LM95245 chip */
568	ret = lm95245_init_client(data);
569	if (ret < 0)
570		return ret;
571
572	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
573							 data,
574							 &lm95245_chip_info,
575							 NULL);
576	return PTR_ERR_OR_ZERO(hwmon_dev);
577}
578
579/* Driver data (common to all clients) */
580static const struct i2c_device_id lm95245_id[] = {
581	{ "lm95235", 0 },
582	{ "lm95245", 0 },
583	{ }
584};
585MODULE_DEVICE_TABLE(i2c, lm95245_id);
586
587static const struct of_device_id __maybe_unused lm95245_of_match[] = {
588	{ .compatible = "national,lm95235" },
589	{ .compatible = "national,lm95245" },
590	{ },
591};
592MODULE_DEVICE_TABLE(of, lm95245_of_match);
593
594static struct i2c_driver lm95245_driver = {
595	.class		= I2C_CLASS_HWMON,
596	.driver = {
597		.name	= "lm95245",
598		.of_match_table = of_match_ptr(lm95245_of_match),
599	},
600	.probe		= lm95245_probe,
601	.id_table	= lm95245_id,
602	.detect		= lm95245_detect,
603	.address_list	= normal_i2c,
604};
605
606module_i2c_driver(lm95245_driver);
607
608MODULE_AUTHOR("Alexander Stein <alexander.stein@systec-electronic.com>");
609MODULE_DESCRIPTION("LM95235/LM95245 sensor driver");
610MODULE_LICENSE("GPL");

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Copyright (C) 2011 Alexander Stein <alexander.stein@systec-electronic.com>
  4 *
  5 * The LM95245 is a sensor chip made by TI / National Semiconductor.
  6 * It reports up to two temperatures (its own plus an external one).
  7 *
  8 * This driver is based on lm95241.c
  9 */
 10
 11#include <linux/err.h>
 12#include <linux/init.h>
 13#include <linux/hwmon.h>
 14#include <linux/i2c.h>
 15#include <linux/module.h>
 16#include <linux/mutex.h>
 17#include <linux/regmap.h>
 18#include <linux/slab.h>
 19
 20static const unsigned short normal_i2c[] = {
 21	0x18, 0x19, 0x29, 0x4c, 0x4d, I2C_CLIENT_END };
 22
 23/* LM95245 registers */
 24/* general registers */
 25#define LM95245_REG_RW_CONFIG1		0x03
 26#define LM95245_REG_RW_CONVERS_RATE	0x04
 27#define LM95245_REG_W_ONE_SHOT		0x0F
 28
 29/* diode configuration */
 30#define LM95245_REG_RW_CONFIG2		0xBF
 31#define LM95245_REG_RW_REMOTE_OFFH	0x11
 32#define LM95245_REG_RW_REMOTE_OFFL	0x12
 33
 34/* status registers */
 35#define LM95245_REG_R_STATUS1		0x02
 36#define LM95245_REG_R_STATUS2		0x33
 37
 38/* limit registers */
 39#define LM95245_REG_RW_REMOTE_OS_LIMIT		0x07
 40#define LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT	0x20
 41#define LM95245_REG_RW_REMOTE_TCRIT_LIMIT	0x19
 42#define LM95245_REG_RW_COMMON_HYSTERESIS	0x21
 43
 44/* temperature signed */
 45#define LM95245_REG_R_LOCAL_TEMPH_S	0x00
 46#define LM95245_REG_R_LOCAL_TEMPL_S	0x30
 47#define LM95245_REG_R_REMOTE_TEMPH_S	0x01
 48#define LM95245_REG_R_REMOTE_TEMPL_S	0x10
 49/* temperature unsigned */
 50#define LM95245_REG_R_REMOTE_TEMPH_U	0x31
 51#define LM95245_REG_R_REMOTE_TEMPL_U	0x32
 52
 53/* id registers */
 54#define LM95245_REG_R_MAN_ID		0xFE
 55#define LM95245_REG_R_CHIP_ID		0xFF
 56
 57/* LM95245 specific bitfields */
 58#define CFG_STOP		0x40
 59#define CFG_REMOTE_TCRIT_MASK	0x10
 60#define CFG_REMOTE_OS_MASK	0x08
 61#define CFG_LOCAL_TCRIT_MASK	0x04
 62#define CFG_LOCAL_OS_MASK	0x02
 63
 64#define CFG2_OS_A0		0x40
 65#define CFG2_DIODE_FAULT_OS	0x20
 66#define CFG2_DIODE_FAULT_TCRIT	0x10
 67#define CFG2_REMOTE_TT		0x08
 68#define CFG2_REMOTE_FILTER_DIS	0x00
 69#define CFG2_REMOTE_FILTER_EN	0x06
 70
 71/* conversation rate in ms */
 72#define RATE_CR0063	0x00
 73#define RATE_CR0364	0x01
 74#define RATE_CR1000	0x02
 75#define RATE_CR2500	0x03
 76
 77#define STATUS1_ROS		0x10
 78#define STATUS1_DIODE_FAULT	0x04
 79#define STATUS1_RTCRIT		0x02
 80#define STATUS1_LOC		0x01
 81
 82#define MANUFACTURER_ID		0x01
 83#define LM95235_REVISION	0xB1
 84#define LM95245_REVISION	0xB3
 85
 86/* Client data (each client gets its own) */
 87struct lm95245_data {
 88	struct regmap *regmap;
 89	struct mutex update_lock;
 90	int interval;	/* in msecs */
 91};
 92
 93/* Conversions */
 94static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
 95{
 96	return val_h * 1000 + val_l * 1000 / 256;
 97}
 98
 99static int temp_from_reg_signed(u8 val_h, u8 val_l)
100{
101	if (val_h & 0x80)
102		return (val_h - 0x100) * 1000;
103	return temp_from_reg_unsigned(val_h, val_l);
104}
105
106static int lm95245_read_conversion_rate(struct lm95245_data *data)
107{
108	unsigned int rate;
109	int ret;
110
111	ret = regmap_read(data->regmap, LM95245_REG_RW_CONVERS_RATE, &rate);
112	if (ret < 0)
113		return ret;
114
115	switch (rate) {
116	case RATE_CR0063:
117		data->interval = 63;
118		break;
119	case RATE_CR0364:
120		data->interval = 364;
121		break;
122	case RATE_CR1000:
123		data->interval = 1000;
124		break;
125	case RATE_CR2500:
126	default:
127		data->interval = 2500;
128		break;
129	}
130	return 0;
131}
132
133static int lm95245_set_conversion_rate(struct lm95245_data *data, long interval)
134{
135	int ret, rate;
136
137	if (interval <= 63) {
138		interval = 63;
139		rate = RATE_CR0063;
140	} else if (interval <= 364) {
141		interval = 364;
142		rate = RATE_CR0364;
143	} else if (interval <= 1000) {
144		interval = 1000;
145		rate = RATE_CR1000;
146	} else {
147		interval = 2500;
148		rate = RATE_CR2500;
149	}
150
151	ret = regmap_write(data->regmap, LM95245_REG_RW_CONVERS_RATE, rate);
152	if (ret < 0)
153		return ret;
154
155	data->interval = interval;
156	return 0;
157}
158
159static int lm95245_read_temp(struct device *dev, u32 attr, int channel,
160			     long *val)
161{
162	struct lm95245_data *data = dev_get_drvdata(dev);
163	struct regmap *regmap = data->regmap;
164	unsigned int regs[2];
165	unsigned int regval;
166	u8 regvals[2];
167	int ret;
168
169	switch (attr) {
170	case hwmon_temp_input:
171		regs[0] = channel ? LM95245_REG_R_REMOTE_TEMPL_S :
172				    LM95245_REG_R_LOCAL_TEMPL_S;
173		regs[1] = channel ? LM95245_REG_R_REMOTE_TEMPH_S :
174				    LM95245_REG_R_LOCAL_TEMPH_S;
175		ret = regmap_multi_reg_read(regmap, regs, regvals, 2);
 
 
 
176		if (ret < 0)
177			return ret;
178		/*
179		 * Local temp is always signed.
180		 * Remote temp has both signed and unsigned data.
181		 * Use signed calculation for remote if signed bit is set
182		 * or if reported temperature is below signed limit.
183		 */
184		if (!channel || (regvals[1] & 0x80) || regvals[1] < 0x7f) {
185			*val = temp_from_reg_signed(regvals[1], regvals[0]);
186			return 0;
187		}
188		ret = regmap_bulk_read(regmap, LM95245_REG_R_REMOTE_TEMPH_U, regvals, 2);
189		if (ret)
 
 
 
 
 
190			return ret;
191		*val = temp_from_reg_unsigned(regvals[0], regvals[1]);
192		return 0;
193	case hwmon_temp_max:
194		ret = regmap_read(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT,
195				  &regval);
196		if (ret < 0)
197			return ret;
198		*val = regval * 1000;
199		return 0;
200	case hwmon_temp_crit:
201		regs[0] = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
202				    LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
203		ret = regmap_read(regmap, regs[0], &regval);
204		if (ret < 0)
205			return ret;
206		*val = regval * 1000;
207		return 0;
208	case hwmon_temp_max_hyst:
209		regs[0] = LM95245_REG_RW_REMOTE_OS_LIMIT;
210		regs[1] = LM95245_REG_RW_COMMON_HYSTERESIS;
211		ret = regmap_multi_reg_read(regmap, regs, regvals, 2);
212		if (ret < 0)
213			return ret;
214		*val = (regvals[0] - regvals[1]) * 1000;
 
 
 
 
215		return 0;
216	case hwmon_temp_crit_hyst:
217		regs[0] = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
218				    LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
219		regs[1] = LM95245_REG_RW_COMMON_HYSTERESIS;
220
221		ret = regmap_multi_reg_read(regmap, regs, regvals, 2);
 
 
222		if (ret < 0)
223			return ret;
224		*val = (regvals[0] - regvals[1]) * 1000;
225		return 0;
226	case hwmon_temp_type:
227		ret = regmap_read(regmap, LM95245_REG_RW_CONFIG2, &regval);
228		if (ret < 0)
229			return ret;
230		*val = (regval & CFG2_REMOTE_TT) ? 1 : 2;
231		return 0;
232	case hwmon_temp_offset:
233		ret = regmap_bulk_read(regmap, LM95245_REG_RW_REMOTE_OFFH, regvals, 2);
 
 
 
 
 
234		if (ret < 0)
235			return ret;
236		*val = temp_from_reg_signed(regvals[0], regvals[1]);
237		return 0;
238	case hwmon_temp_max_alarm:
239		ret = regmap_read(regmap, LM95245_REG_R_STATUS1, &regval);
240		if (ret < 0)
241			return ret;
242		*val = !!(regval & STATUS1_ROS);
243		return 0;
244	case hwmon_temp_crit_alarm:
245		ret = regmap_read(regmap, LM95245_REG_R_STATUS1, &regval);
246		if (ret < 0)
247			return ret;
248		*val = !!(regval & (channel ? STATUS1_RTCRIT : STATUS1_LOC));
249		return 0;
250	case hwmon_temp_fault:
251		ret = regmap_read(regmap, LM95245_REG_R_STATUS1, &regval);
252		if (ret < 0)
253			return ret;
254		*val = !!(regval & STATUS1_DIODE_FAULT);
255		return 0;
256	default:
257		return -EOPNOTSUPP;
258	}
259}
260
261static int lm95245_write_temp(struct device *dev, u32 attr, int channel,
262			      long val)
263{
264	struct lm95245_data *data = dev_get_drvdata(dev);
265	struct regmap *regmap = data->regmap;
266	unsigned int regval;
267	u8 regvals[2];
268	int ret, reg;
269
270	switch (attr) {
271	case hwmon_temp_max:
272		val = clamp_val(val / 1000, 0, 255);
273		ret = regmap_write(regmap, LM95245_REG_RW_REMOTE_OS_LIMIT, val);
274		return ret;
275	case hwmon_temp_crit:
276		reg = channel ? LM95245_REG_RW_REMOTE_TCRIT_LIMIT :
277				LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT;
278		val = clamp_val(val / 1000, 0, channel ? 255 : 127);
279		ret = regmap_write(regmap, reg, val);
280		return ret;
281	case hwmon_temp_crit_hyst:
282		mutex_lock(&data->update_lock);
283		ret = regmap_read(regmap, LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT,
284				  &regval);
285		if (ret < 0) {
286			mutex_unlock(&data->update_lock);
287			return ret;
288		}
289		/* Clamp to reasonable range to prevent overflow */
290		val = clamp_val(val, -1000000, 1000000);
291		val = regval - val / 1000;
292		val = clamp_val(val, 0, 31);
293		ret = regmap_write(regmap, LM95245_REG_RW_COMMON_HYSTERESIS,
294				   val);
295		mutex_unlock(&data->update_lock);
296		return ret;
297	case hwmon_temp_offset:
298		val = clamp_val(val, -128000, 127875);
299		val = val * 256 / 1000;
300		regvals[0] = val >> 8;
301		regvals[1] = val & 0xe0;
302
303		ret = regmap_bulk_write(regmap, LM95245_REG_RW_REMOTE_OFFH, regvals, 2);
 
 
 
 
 
 
304		return ret;
305	case hwmon_temp_type:
306		if (val != 1 && val != 2)
307			return -EINVAL;
308		ret = regmap_update_bits(regmap, LM95245_REG_RW_CONFIG2,
309					 CFG2_REMOTE_TT,
310					 val == 1 ? CFG2_REMOTE_TT : 0);
311		return ret;
312	default:
313		return -EOPNOTSUPP;
314	}
315}
316
317static int lm95245_read_chip(struct device *dev, u32 attr, int channel,
318			     long *val)
319{
320	struct lm95245_data *data = dev_get_drvdata(dev);
321
322	switch (attr) {
323	case hwmon_chip_update_interval:
324		*val = data->interval;
325		return 0;
326	default:
327		return -EOPNOTSUPP;
328	}
329}
330
331static int lm95245_write_chip(struct device *dev, u32 attr, int channel,
332			      long val)
333{
334	struct lm95245_data *data = dev_get_drvdata(dev);
335	int ret;
336
337	switch (attr) {
338	case hwmon_chip_update_interval:
339		mutex_lock(&data->update_lock);
340		ret = lm95245_set_conversion_rate(data, val);
341		mutex_unlock(&data->update_lock);
342		return ret;
343	default:
344		return -EOPNOTSUPP;
345	}
346}
347
348static int lm95245_read(struct device *dev, enum hwmon_sensor_types type,
349			u32 attr, int channel, long *val)
350{
351	switch (type) {
352	case hwmon_chip:
353		return lm95245_read_chip(dev, attr, channel, val);
354	case hwmon_temp:
355		return lm95245_read_temp(dev, attr, channel, val);
356	default:
357		return -EOPNOTSUPP;
358	}
359}
360
361static int lm95245_write(struct device *dev, enum hwmon_sensor_types type,
362			 u32 attr, int channel, long val)
363{
364	switch (type) {
365	case hwmon_chip:
366		return lm95245_write_chip(dev, attr, channel, val);
367	case hwmon_temp:
368		return lm95245_write_temp(dev, attr, channel, val);
369	default:
370		return -EOPNOTSUPP;
371	}
372}
373
374static umode_t lm95245_temp_is_visible(const void *data, u32 attr, int channel)
375{
376	switch (attr) {
377	case hwmon_temp_input:
378	case hwmon_temp_max_alarm:
379	case hwmon_temp_max_hyst:
380	case hwmon_temp_crit_alarm:
381	case hwmon_temp_fault:
382		return 0444;
383	case hwmon_temp_type:
384	case hwmon_temp_max:
385	case hwmon_temp_crit:
386	case hwmon_temp_offset:
387		return 0644;
388	case hwmon_temp_crit_hyst:
389		return (channel == 0) ? 0644 : 0444;
390	default:
391		return 0;
392	}
393}
394
395static umode_t lm95245_is_visible(const void *data,
396				  enum hwmon_sensor_types type,
397				  u32 attr, int channel)
398{
399	switch (type) {
400	case hwmon_chip:
401		switch (attr) {
402		case hwmon_chip_update_interval:
403			return 0644;
404		default:
405			return 0;
406		}
407	case hwmon_temp:
408		return lm95245_temp_is_visible(data, attr, channel);
409	default:
410		return 0;
411	}
412}
413
414/* Return 0 if detection is successful, -ENODEV otherwise */
415static int lm95245_detect(struct i2c_client *new_client,
416			  struct i2c_board_info *info)
417{
418	struct i2c_adapter *adapter = new_client->adapter;
419	int address = new_client->addr;
420	const char *name;
421	int rev, id;
422
423	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
424		return -ENODEV;
425
426	id = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_MAN_ID);
427	if (id != MANUFACTURER_ID)
428		return -ENODEV;
429
430	rev = i2c_smbus_read_byte_data(new_client, LM95245_REG_R_CHIP_ID);
431	switch (rev) {
432	case LM95235_REVISION:
433		if (address != 0x18 && address != 0x29 && address != 0x4c)
434			return -ENODEV;
435		name = "lm95235";
436		break;
437	case LM95245_REVISION:
438		name = "lm95245";
439		break;
440	default:
441		return -ENODEV;
442	}
443
444	strscpy(info->type, name, I2C_NAME_SIZE);
445	return 0;
446}
447
448static int lm95245_init_client(struct lm95245_data *data)
449{
450	int ret;
451
452	ret = lm95245_read_conversion_rate(data);
453	if (ret < 0)
454		return ret;
455
456	return regmap_update_bits(data->regmap, LM95245_REG_RW_CONFIG1,
457				  CFG_STOP, 0);
458}
459
460static bool lm95245_is_writeable_reg(struct device *dev, unsigned int reg)
461{
462	switch (reg) {
463	case LM95245_REG_RW_CONFIG1:
464	case LM95245_REG_RW_CONVERS_RATE:
465	case LM95245_REG_W_ONE_SHOT:
466	case LM95245_REG_RW_CONFIG2:
467	case LM95245_REG_RW_REMOTE_OFFH:
468	case LM95245_REG_RW_REMOTE_OFFL:
469	case LM95245_REG_RW_REMOTE_OS_LIMIT:
470	case LM95245_REG_RW_LOCAL_OS_TCRIT_LIMIT:
471	case LM95245_REG_RW_REMOTE_TCRIT_LIMIT:
472	case LM95245_REG_RW_COMMON_HYSTERESIS:
473		return true;
474	default:
475		return false;
476	}
477}
478
479static bool lm95245_is_volatile_reg(struct device *dev, unsigned int reg)
480{
481	switch (reg) {
482	case LM95245_REG_R_STATUS1:
483	case LM95245_REG_R_STATUS2:
484	case LM95245_REG_R_LOCAL_TEMPH_S:
485	case LM95245_REG_R_LOCAL_TEMPL_S:
486	case LM95245_REG_R_REMOTE_TEMPH_S:
487	case LM95245_REG_R_REMOTE_TEMPL_S:
488	case LM95245_REG_R_REMOTE_TEMPH_U:
489	case LM95245_REG_R_REMOTE_TEMPL_U:
490		return true;
491	default:
492		return false;
493	}
494}
495
496static const struct regmap_config lm95245_regmap_config = {
497	.reg_bits = 8,
498	.val_bits = 8,
499	.writeable_reg = lm95245_is_writeable_reg,
500	.volatile_reg = lm95245_is_volatile_reg,
501	.cache_type = REGCACHE_MAPLE,
502	.use_single_read = true,
503	.use_single_write = true,
504};
505
506static const struct hwmon_channel_info * const lm95245_info[] = {
507	HWMON_CHANNEL_INFO(chip,
508			   HWMON_C_UPDATE_INTERVAL),
509	HWMON_CHANNEL_INFO(temp,
510			   HWMON_T_INPUT | HWMON_T_CRIT | HWMON_T_CRIT_HYST |
511			   HWMON_T_CRIT_ALARM,
512			   HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MAX_HYST |
513			   HWMON_T_CRIT | HWMON_T_CRIT_HYST | HWMON_T_FAULT |
514			   HWMON_T_MAX_ALARM | HWMON_T_CRIT_ALARM |
515			   HWMON_T_TYPE | HWMON_T_OFFSET),
516	NULL
517};
518
519static const struct hwmon_ops lm95245_hwmon_ops = {
520	.is_visible = lm95245_is_visible,
521	.read = lm95245_read,
522	.write = lm95245_write,
523};
524
525static const struct hwmon_chip_info lm95245_chip_info = {
526	.ops = &lm95245_hwmon_ops,
527	.info = lm95245_info,
528};
529
530static int lm95245_probe(struct i2c_client *client)
531{
532	struct device *dev = &client->dev;
533	struct lm95245_data *data;
534	struct device *hwmon_dev;
535	int ret;
536
537	data = devm_kzalloc(dev, sizeof(struct lm95245_data), GFP_KERNEL);
538	if (!data)
539		return -ENOMEM;
540
541	data->regmap = devm_regmap_init_i2c(client, &lm95245_regmap_config);
542	if (IS_ERR(data->regmap))
543		return PTR_ERR(data->regmap);
544
545	mutex_init(&data->update_lock);
546
547	/* Initialize the LM95245 chip */
548	ret = lm95245_init_client(data);
549	if (ret < 0)
550		return ret;
551
552	hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
553							 data,
554							 &lm95245_chip_info,
555							 NULL);
556	return PTR_ERR_OR_ZERO(hwmon_dev);
557}
558
559/* Driver data (common to all clients) */
560static const struct i2c_device_id lm95245_id[] = {
561	{ "lm95235" },
562	{ "lm95245" },
563	{ }
564};
565MODULE_DEVICE_TABLE(i2c, lm95245_id);
566
567static const struct of_device_id __maybe_unused lm95245_of_match[] = {
568	{ .compatible = "national,lm95235" },
569	{ .compatible = "national,lm95245" },
570	{ },
571};
572MODULE_DEVICE_TABLE(of, lm95245_of_match);
573
574static struct i2c_driver lm95245_driver = {
575	.class		= I2C_CLASS_HWMON,
576	.driver = {
577		.name	= "lm95245",
578		.of_match_table = of_match_ptr(lm95245_of_match),
579	},
580	.probe		= lm95245_probe,
581	.id_table	= lm95245_id,
582	.detect		= lm95245_detect,
583	.address_list	= normal_i2c,
584};
585
586module_i2c_driver(lm95245_driver);
587
588MODULE_AUTHOR("Alexander Stein <alexander.stein@systec-electronic.com>");
589MODULE_DESCRIPTION("LM95235/LM95245 sensor driver");
590MODULE_LICENSE("GPL");