xref: /openbmc/linux/drivers/hwmon/pcf8591.c (revision 9b68f30b) 
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2001-2004 Aurelien Jarno <aurelien@aurel32.net>
4  * Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with
5  * the help of Jean Delvare <jdelvare@suse.de>
6  */
7 
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/slab.h>
13 #include <linux/i2c.h>
14 #include <linux/mutex.h>
15 #include <linux/err.h>
16 #include <linux/hwmon.h>
17 #include <linux/kstrtox.h>
18 
19 /* Insmod parameters */
20 
21 static int input_mode;
22 module_param(input_mode, int, 0);
23 MODULE_PARM_DESC(input_mode,
24 	"Analog input mode:\n"
25 	" 0 = four single ended inputs\n"
26 	" 1 = three differential inputs\n"
27 	" 2 = single ended and differential mixed\n"
28 	" 3 = two differential inputs\n");
29 
30 /*
31  * The PCF8591 control byte
32  *      7    6    5    4    3    2    1    0
33  *   |  0 |AOEF|   AIP   |  0 |AINC|  AICH   |
34  */
35 
36 /* Analog Output Enable Flag (analog output active if 1) */
37 #define PCF8591_CONTROL_AOEF		0x40
38 
39 /*
40  * Analog Input Programming
41  * 0x00 = four single ended inputs
42  * 0x10 = three differential inputs
43  * 0x20 = single ended and differential mixed
44  * 0x30 = two differential inputs
45  */
46 #define PCF8591_CONTROL_AIP_MASK	0x30
47 
48 /* Autoincrement Flag (switch on if 1) */
49 #define PCF8591_CONTROL_AINC		0x04
50 
51 /*
52  * Channel selection
53  * 0x00 = channel 0
54  * 0x01 = channel 1
55  * 0x02 = channel 2
56  * 0x03 = channel 3
57  */
58 #define PCF8591_CONTROL_AICH_MASK	0x03
59 
60 /* Initial values */
61 #define PCF8591_INIT_CONTROL	((input_mode << 4) | PCF8591_CONTROL_AOEF)
62 #define PCF8591_INIT_AOUT	0	/* DAC out = 0 */
63 
64 /* Conversions */
65 #define REG_TO_SIGNED(reg)	(((reg) & 0x80) ? ((reg) - 256) : (reg))
66 
67 struct pcf8591_data {
68 	struct device *hwmon_dev;
69 	struct mutex update_lock;
70 
71 	u8 control;
72 	u8 aout;
73 };
74 
75 static void pcf8591_init_client(struct i2c_client *client);
76 static int pcf8591_read_channel(struct device *dev, int channel);
77 
78 /* following are the sysfs callback functions */
79 #define show_in_channel(channel)					\
80 static ssize_t show_in##channel##_input(struct device *dev,		\
81 					struct device_attribute *attr,	\
82 					char *buf)			\
83 {									\
84 	return sprintf(buf, "%d\n", pcf8591_read_channel(dev, channel));\
85 }									\
86 static DEVICE_ATTR(in##channel##_input, S_IRUGO,			\
87 		   show_in##channel##_input, NULL);
88 
89 show_in_channel(0);
90 show_in_channel(1);
91 show_in_channel(2);
92 show_in_channel(3);
93 
94 static ssize_t out0_output_show(struct device *dev,
95 				struct device_attribute *attr, char *buf)
96 {
97 	struct pcf8591_data *data = i2c_get_clientdata(to_i2c_client(dev));
98 	return sprintf(buf, "%d\n", data->aout * 10);
99 }
100 
101 static ssize_t out0_output_store(struct device *dev,
102 				 struct device_attribute *attr,
103 				 const char *buf, size_t count)
104 {
105 	unsigned long val;
106 	struct i2c_client *client = to_i2c_client(dev);
107 	struct pcf8591_data *data = i2c_get_clientdata(client);
108 	int err;
109 
110 	err = kstrtoul(buf, 10, &val);
111 	if (err)
112 		return err;
113 
114 	val /= 10;
115 	if (val > 255)
116 		return -EINVAL;
117 
118 	data->aout = val;
119 	i2c_smbus_write_byte_data(client, data->control, data->aout);
120 	return count;
121 }
122 
123 static DEVICE_ATTR_RW(out0_output);
124 
125 static ssize_t out0_enable_show(struct device *dev,
126 				struct device_attribute *attr, char *buf)
127 {
128 	struct pcf8591_data *data = i2c_get_clientdata(to_i2c_client(dev));
129 	return sprintf(buf, "%u\n", !(!(data->control & PCF8591_CONTROL_AOEF)));
130 }
131 
132 static ssize_t out0_enable_store(struct device *dev,
133 				 struct device_attribute *attr,
134 				 const char *buf, size_t count)
135 {
136 	struct i2c_client *client = to_i2c_client(dev);
137 	struct pcf8591_data *data = i2c_get_clientdata(client);
138 	unsigned long val;
139 	int err;
140 
141 	err = kstrtoul(buf, 10, &val);
142 	if (err)
143 		return err;
144 
145 	mutex_lock(&data->update_lock);
146 	if (val)
147 		data->control |= PCF8591_CONTROL_AOEF;
148 	else
149 		data->control &= ~PCF8591_CONTROL_AOEF;
150 	i2c_smbus_write_byte(client, data->control);
151 	mutex_unlock(&data->update_lock);
152 	return count;
153 }
154 
155 static DEVICE_ATTR_RW(out0_enable);
156 
157 static struct attribute *pcf8591_attributes[] = {
158 	&dev_attr_out0_enable.attr,
159 	&dev_attr_out0_output.attr,
160 	&dev_attr_in0_input.attr,
161 	&dev_attr_in1_input.attr,
162 	NULL
163 };
164 
165 static const struct attribute_group pcf8591_attr_group = {
166 	.attrs = pcf8591_attributes,
167 };
168 
169 static struct attribute *pcf8591_attributes_opt[] = {
170 	&dev_attr_in2_input.attr,
171 	&dev_attr_in3_input.attr,
172 	NULL
173 };
174 
175 static const struct attribute_group pcf8591_attr_group_opt = {
176 	.attrs = pcf8591_attributes_opt,
177 };
178 
179 /*
180  * Real code
181  */
182 
183 static int pcf8591_probe(struct i2c_client *client)
184 {
185 	struct pcf8591_data *data;
186 	int err;
187 
188 	data = devm_kzalloc(&client->dev, sizeof(struct pcf8591_data),
189 			    GFP_KERNEL);
190 	if (!data)
191 		return -ENOMEM;
192 
193 	i2c_set_clientdata(client, data);
194 	mutex_init(&data->update_lock);
195 
196 	/* Initialize the PCF8591 chip */
197 	pcf8591_init_client(client);
198 
199 	/* Register sysfs hooks */
200 	err = sysfs_create_group(&client->dev.kobj, &pcf8591_attr_group);
201 	if (err)
202 		return err;
203 
204 	/* Register input2 if not in "two differential inputs" mode */
205 	if (input_mode != 3) {
206 		err = device_create_file(&client->dev, &dev_attr_in2_input);
207 		if (err)
208 			goto exit_sysfs_remove;
209 	}
210 
211 	/* Register input3 only in "four single ended inputs" mode */
212 	if (input_mode == 0) {
213 		err = device_create_file(&client->dev, &dev_attr_in3_input);
214 		if (err)
215 			goto exit_sysfs_remove;
216 	}
217 
218 	data->hwmon_dev = hwmon_device_register(&client->dev);
219 	if (IS_ERR(data->hwmon_dev)) {
220 		err = PTR_ERR(data->hwmon_dev);
221 		goto exit_sysfs_remove;
222 	}
223 
224 	return 0;
225 
226 exit_sysfs_remove:
227 	sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group_opt);
228 	sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group);
229 	return err;
230 }
231 
232 static void pcf8591_remove(struct i2c_client *client)
233 {
234 	struct pcf8591_data *data = i2c_get_clientdata(client);
235 
236 	hwmon_device_unregister(data->hwmon_dev);
237 	sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group_opt);
238 	sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group);
239 }
240 
241 /* Called when we have found a new PCF8591. */
242 static void pcf8591_init_client(struct i2c_client *client)
243 {
244 	struct pcf8591_data *data = i2c_get_clientdata(client);
245 	data->control = PCF8591_INIT_CONTROL;
246 	data->aout = PCF8591_INIT_AOUT;
247 
248 	i2c_smbus_write_byte_data(client, data->control, data->aout);
249 
250 	/*
251 	 * The first byte transmitted contains the conversion code of the
252 	 * previous read cycle. FLUSH IT!
253 	 */
254 	i2c_smbus_read_byte(client);
255 }
256 
257 static int pcf8591_read_channel(struct device *dev, int channel)
258 {
259 	u8 value;
260 	struct i2c_client *client = to_i2c_client(dev);
261 	struct pcf8591_data *data = i2c_get_clientdata(client);
262 
263 	mutex_lock(&data->update_lock);
264 
265 	if ((data->control & PCF8591_CONTROL_AICH_MASK) != channel) {
266 		data->control = (data->control & ~PCF8591_CONTROL_AICH_MASK)
267 			      | channel;
268 		i2c_smbus_write_byte(client, data->control);
269 
270 		/*
271 		 * The first byte transmitted contains the conversion code of
272 		 * the previous read cycle. FLUSH IT!
273 		 */
274 		i2c_smbus_read_byte(client);
275 	}
276 	value = i2c_smbus_read_byte(client);
277 
278 	mutex_unlock(&data->update_lock);
279 
280 	if ((channel == 2 && input_mode == 2) ||
281 	    (channel != 3 && (input_mode == 1 || input_mode == 3)))
282 		return 10 * REG_TO_SIGNED(value);
283 	else
284 		return 10 * value;
285 }
286 
287 static const struct i2c_device_id pcf8591_id[] = {
288 	{ "pcf8591", 0 },
289 	{ }
290 };
291 MODULE_DEVICE_TABLE(i2c, pcf8591_id);
292 
293 static struct i2c_driver pcf8591_driver = {
294 	.driver = {
295 		.name	= "pcf8591",
296 	},
297 	.probe_new	= pcf8591_probe,
298 	.remove		= pcf8591_remove,
299 	.id_table	= pcf8591_id,
300 };
301 
302 static int __init pcf8591_init(void)
303 {
304 	if (input_mode < 0 || input_mode > 3) {
305 		pr_warn("invalid input_mode (%d)\n", input_mode);
306 		input_mode = 0;
307 	}
308 	return i2c_add_driver(&pcf8591_driver);
309 }
310 
311 static void __exit pcf8591_exit(void)
312 {
313 	i2c_del_driver(&pcf8591_driver);
314 }
315 
316 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
317 MODULE_DESCRIPTION("PCF8591 driver");
318 MODULE_LICENSE("GPL");
319 
320 module_init(pcf8591_init);
321 module_exit(pcf8591_exit);
322