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