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, fmt: "%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(s: buf, base: 10, res: &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, command: data->control, value: 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, fmt: "%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(s: buf, base: 10, res: &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, value: data->control); |
151 | mutex_unlock(lock: &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(dev: &client->dev, size: 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(kobj: &client->dev.kobj, grp: &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(device: &client->dev, entry: &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(device: &client->dev, entry: &dev_attr_in3_input); |
214 | if (err) |
215 | goto exit_sysfs_remove; |
216 | } |
217 | |
218 | data->hwmon_dev = hwmon_device_register(dev: &client->dev); |
219 | if (IS_ERR(ptr: data->hwmon_dev)) { |
220 | err = PTR_ERR(ptr: data->hwmon_dev); |
221 | goto exit_sysfs_remove; |
222 | } |
223 | |
224 | return 0; |
225 | |
226 | exit_sysfs_remove: |
227 | sysfs_remove_group(kobj: &client->dev.kobj, grp: &pcf8591_attr_group_opt); |
228 | sysfs_remove_group(kobj: &client->dev.kobj, grp: &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(dev: data->hwmon_dev); |
237 | sysfs_remove_group(kobj: &client->dev.kobj, grp: &pcf8591_attr_group_opt); |
238 | sysfs_remove_group(kobj: &client->dev.kobj, grp: &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, command: data->control, value: 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, value: 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(lock: &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 = 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(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 | |