1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * An hwmon driver for the Analog Devices AD7414
4  *
5  * Copyright 2006 Stefan Roese <sr at denx.de>, DENX Software Engineering
6  *
7  * Copyright (c) 2008 PIKA Technologies
8  *   Sean MacLennan <smaclennan@pikatech.com>
9  *
10  * Copyright (c) 2008 Spansion Inc.
11  *   Frank Edelhaeuser <frank.edelhaeuser at spansion.com>
12  *   (converted to "new style" I2C driver model, removed checkpatch.pl warnings)
13  *
14  * Based on ad7418.c
15  * Copyright 2006 Tower Technologies, Alessandro Zummo <a.zummo at towertech.it>
16  */
17 
18 #include <linux/module.h>
19 #include <linux/jiffies.h>
20 #include <linux/i2c.h>
21 #include <linux/hwmon.h>
22 #include <linux/hwmon-sysfs.h>
23 #include <linux/err.h>
24 #include <linux/mutex.h>
25 #include <linux/sysfs.h>
26 #include <linux/slab.h>
27 
28 
29 /* AD7414 registers */
30 #define AD7414_REG_TEMP		0x00
31 #define AD7414_REG_CONF		0x01
32 #define AD7414_REG_T_HIGH	0x02
33 #define AD7414_REG_T_LOW	0x03
34 
35 static u8 AD7414_REG_LIMIT[] = { AD7414_REG_T_HIGH, AD7414_REG_T_LOW };
36 
37 struct ad7414_data {
38 	struct i2c_client	*client;
39 	struct mutex		lock;	/* atomic read data updates */
40 	bool			valid;	/* true if following fields are valid */
41 	unsigned long		next_update;	/* In jiffies */
42 	s16			temp_input;	/* Register values */
43 	s8			temps[ARRAY_SIZE(AD7414_REG_LIMIT)];
44 };
45 
46 /* REG: (0.25C/bit, two's complement) << 6 */
ad7414_temp_from_reg(s16 reg)47 static inline int ad7414_temp_from_reg(s16 reg)
48 {
49 	/*
50 	 * use integer division instead of equivalent right shift to
51 	 * guarantee arithmetic shift and preserve the sign
52 	 */
53 	return ((int)reg / 64) * 250;
54 }
55 
ad7414_read(struct i2c_client * client,u8 reg)56 static inline int ad7414_read(struct i2c_client *client, u8 reg)
57 {
58 	if (reg == AD7414_REG_TEMP)
59 		return i2c_smbus_read_word_swapped(client, reg);
60 	else
61 		return i2c_smbus_read_byte_data(client, reg);
62 }
63 
ad7414_write(struct i2c_client * client,u8 reg,u8 value)64 static inline int ad7414_write(struct i2c_client *client, u8 reg, u8 value)
65 {
66 	return i2c_smbus_write_byte_data(client, reg, value);
67 }
68 
ad7414_update_device(struct device * dev)69 static struct ad7414_data *ad7414_update_device(struct device *dev)
70 {
71 	struct ad7414_data *data = dev_get_drvdata(dev);
72 	struct i2c_client *client = data->client;
73 
74 	mutex_lock(&data->lock);
75 
76 	if (time_after(jiffies, data->next_update) || !data->valid) {
77 		int value, i;
78 
79 		dev_dbg(&client->dev, "starting ad7414 update\n");
80 
81 		value = ad7414_read(client, AD7414_REG_TEMP);
82 		if (value < 0)
83 			dev_dbg(&client->dev, "AD7414_REG_TEMP err %d\n",
84 				value);
85 		else
86 			data->temp_input = value;
87 
88 		for (i = 0; i < ARRAY_SIZE(AD7414_REG_LIMIT); ++i) {
89 			value = ad7414_read(client, AD7414_REG_LIMIT[i]);
90 			if (value < 0)
91 				dev_dbg(&client->dev, "AD7414 reg %d err %d\n",
92 					AD7414_REG_LIMIT[i], value);
93 			else
94 				data->temps[i] = value;
95 		}
96 
97 		data->next_update = jiffies + HZ + HZ / 2;
98 		data->valid = true;
99 	}
100 
101 	mutex_unlock(&data->lock);
102 
103 	return data;
104 }
105 
temp_input_show(struct device * dev,struct device_attribute * attr,char * buf)106 static ssize_t temp_input_show(struct device *dev,
107 			       struct device_attribute *attr, char *buf)
108 {
109 	struct ad7414_data *data = ad7414_update_device(dev);
110 	return sprintf(buf, "%d\n", ad7414_temp_from_reg(data->temp_input));
111 }
112 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp_input, 0);
113 
max_min_show(struct device * dev,struct device_attribute * attr,char * buf)114 static ssize_t max_min_show(struct device *dev, struct device_attribute *attr,
115 			    char *buf)
116 {
117 	int index = to_sensor_dev_attr(attr)->index;
118 	struct ad7414_data *data = ad7414_update_device(dev);
119 	return sprintf(buf, "%d\n", data->temps[index] * 1000);
120 }
121 
max_min_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)122 static ssize_t max_min_store(struct device *dev,
123 			     struct device_attribute *attr, const char *buf,
124 			     size_t count)
125 {
126 	struct ad7414_data *data = dev_get_drvdata(dev);
127 	struct i2c_client *client = data->client;
128 	int index = to_sensor_dev_attr(attr)->index;
129 	u8 reg = AD7414_REG_LIMIT[index];
130 	long temp;
131 	int ret = kstrtol(buf, 10, &temp);
132 
133 	if (ret < 0)
134 		return ret;
135 
136 	temp = clamp_val(temp, -40000, 85000);
137 	temp = (temp + (temp < 0 ? -500 : 500)) / 1000;
138 
139 	mutex_lock(&data->lock);
140 	data->temps[index] = temp;
141 	ad7414_write(client, reg, temp);
142 	mutex_unlock(&data->lock);
143 	return count;
144 }
145 
146 static SENSOR_DEVICE_ATTR_RW(temp1_max, max_min, 0);
147 static SENSOR_DEVICE_ATTR_RW(temp1_min, max_min, 1);
148 
alarm_show(struct device * dev,struct device_attribute * attr,char * buf)149 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
150 			  char *buf)
151 {
152 	int bitnr = to_sensor_dev_attr(attr)->index;
153 	struct ad7414_data *data = ad7414_update_device(dev);
154 	int value = (data->temp_input >> bitnr) & 1;
155 	return sprintf(buf, "%d\n", value);
156 }
157 
158 static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, alarm, 3);
159 static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 4);
160 
161 static struct attribute *ad7414_attrs[] = {
162 	&sensor_dev_attr_temp1_input.dev_attr.attr,
163 	&sensor_dev_attr_temp1_max.dev_attr.attr,
164 	&sensor_dev_attr_temp1_min.dev_attr.attr,
165 	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
166 	&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
167 	NULL
168 };
169 
170 ATTRIBUTE_GROUPS(ad7414);
171 
ad7414_probe(struct i2c_client * client)172 static int ad7414_probe(struct i2c_client *client)
173 {
174 	struct device *dev = &client->dev;
175 	struct ad7414_data *data;
176 	struct device *hwmon_dev;
177 	int conf;
178 
179 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
180 				     I2C_FUNC_SMBUS_READ_WORD_DATA))
181 		return -EOPNOTSUPP;
182 
183 	data = devm_kzalloc(dev, sizeof(struct ad7414_data), GFP_KERNEL);
184 	if (!data)
185 		return -ENOMEM;
186 
187 	data->client = client;
188 	mutex_init(&data->lock);
189 
190 	dev_info(&client->dev, "chip found\n");
191 
192 	/* Make sure the chip is powered up. */
193 	conf = i2c_smbus_read_byte_data(client, AD7414_REG_CONF);
194 	if (conf < 0)
195 		dev_warn(dev, "ad7414_probe unable to read config register.\n");
196 	else {
197 		conf &= ~(1 << 7);
198 		i2c_smbus_write_byte_data(client, AD7414_REG_CONF, conf);
199 	}
200 
201 	hwmon_dev = devm_hwmon_device_register_with_groups(dev,
202 							   client->name,
203 							   data, ad7414_groups);
204 	return PTR_ERR_OR_ZERO(hwmon_dev);
205 }
206 
207 static const struct i2c_device_id ad7414_id[] = {
208 	{ "ad7414", 0 },
209 	{}
210 };
211 MODULE_DEVICE_TABLE(i2c, ad7414_id);
212 
213 static const struct of_device_id __maybe_unused ad7414_of_match[] = {
214 	{ .compatible = "ad,ad7414" },
215 	{ },
216 };
217 MODULE_DEVICE_TABLE(of, ad7414_of_match);
218 
219 static struct i2c_driver ad7414_driver = {
220 	.driver = {
221 		.name	= "ad7414",
222 		.of_match_table = of_match_ptr(ad7414_of_match),
223 	},
224 	.probe_new = ad7414_probe,
225 	.id_table = ad7414_id,
226 };
227 
228 module_i2c_driver(ad7414_driver);
229 
230 MODULE_AUTHOR("Stefan Roese <sr at denx.de>, "
231 	      "Frank Edelhaeuser <frank.edelhaeuser at spansion.com>");
232 
233 MODULE_DESCRIPTION("AD7414 driver");
234 MODULE_LICENSE("GPL");
235