]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/hwmon/ad7418.c
Merge branch 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jdelv...
[karo-tx-linux.git] / drivers / hwmon / ad7418.c
1 /*
2  * An hwmon driver for the Analog Devices AD7416/17/18
3  * Copyright (C) 2006-07 Tower Technologies
4  *
5  * Author: Alessandro Zummo <a.zummo@towertech.it>
6  *
7  * Based on lm75.c
8  * Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License,
12  * as published by the Free Software Foundation - version 2.
13  */
14
15 #include <linux/module.h>
16 #include <linux/jiffies.h>
17 #include <linux/i2c.h>
18 #include <linux/hwmon.h>
19 #include <linux/hwmon-sysfs.h>
20 #include <linux/err.h>
21 #include <linux/mutex.h>
22 #include <linux/delay.h>
23 #include <linux/slab.h>
24
25 #include "lm75.h"
26
27 #define DRV_VERSION "0.4"
28
29 enum chips { ad7416, ad7417, ad7418 };
30
31 /* AD7418 registers */
32 #define AD7418_REG_TEMP_IN      0x00
33 #define AD7418_REG_CONF         0x01
34 #define AD7418_REG_TEMP_HYST    0x02
35 #define AD7418_REG_TEMP_OS      0x03
36 #define AD7418_REG_ADC          0x04
37 #define AD7418_REG_CONF2        0x05
38
39 #define AD7418_REG_ADC_CH(x)    ((x) << 5)
40 #define AD7418_CH_TEMP          AD7418_REG_ADC_CH(0)
41
42 static const u8 AD7418_REG_TEMP[] = { AD7418_REG_TEMP_IN,
43                                         AD7418_REG_TEMP_HYST,
44                                         AD7418_REG_TEMP_OS };
45
46 struct ad7418_data {
47         struct device           *hwmon_dev;
48         struct attribute_group  attrs;
49         enum chips              type;
50         struct mutex            lock;
51         int                     adc_max;        /* number of ADC channels */
52         char                    valid;
53         unsigned long           last_updated;   /* In jiffies */
54         s16                     temp[3];        /* Register values */
55         u16                     in[4];
56 };
57
58 static int ad7418_probe(struct i2c_client *client,
59                         const struct i2c_device_id *id);
60 static int ad7418_remove(struct i2c_client *client);
61
62 static const struct i2c_device_id ad7418_id[] = {
63         { "ad7416", ad7416 },
64         { "ad7417", ad7417 },
65         { "ad7418", ad7418 },
66         { }
67 };
68 MODULE_DEVICE_TABLE(i2c, ad7418_id);
69
70 static struct i2c_driver ad7418_driver = {
71         .driver = {
72                 .name   = "ad7418",
73         },
74         .probe          = ad7418_probe,
75         .remove         = ad7418_remove,
76         .id_table       = ad7418_id,
77 };
78
79 static void ad7418_init_client(struct i2c_client *client)
80 {
81         struct ad7418_data *data = i2c_get_clientdata(client);
82
83         int reg = i2c_smbus_read_byte_data(client, AD7418_REG_CONF);
84         if (reg < 0) {
85                 dev_err(&client->dev, "cannot read configuration register\n");
86         } else {
87                 dev_info(&client->dev, "configuring for mode 1\n");
88                 i2c_smbus_write_byte_data(client, AD7418_REG_CONF, reg & 0xfe);
89
90                 if (data->type == ad7417 || data->type == ad7418)
91                         i2c_smbus_write_byte_data(client,
92                                                 AD7418_REG_CONF2, 0x00);
93         }
94 }
95
96 static struct ad7418_data *ad7418_update_device(struct device *dev)
97 {
98         struct i2c_client *client = to_i2c_client(dev);
99         struct ad7418_data *data = i2c_get_clientdata(client);
100
101         mutex_lock(&data->lock);
102
103         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
104                 || !data->valid) {
105                 u8 cfg;
106                 int i, ch;
107
108                 /* read config register and clear channel bits */
109                 cfg = i2c_smbus_read_byte_data(client, AD7418_REG_CONF);
110                 cfg &= 0x1F;
111
112                 i2c_smbus_write_byte_data(client, AD7418_REG_CONF,
113                                                 cfg | AD7418_CH_TEMP);
114                 udelay(30);
115
116                 for (i = 0; i < 3; i++) {
117                         data->temp[i] =
118                                 i2c_smbus_read_word_swapped(client,
119                                                 AD7418_REG_TEMP[i]);
120                 }
121
122                 for (i = 0, ch = 4; i < data->adc_max; i++, ch--) {
123                         i2c_smbus_write_byte_data(client,
124                                         AD7418_REG_CONF,
125                                         cfg | AD7418_REG_ADC_CH(ch));
126
127                         udelay(15);
128                         data->in[data->adc_max - 1 - i] =
129                                 i2c_smbus_read_word_swapped(client,
130                                                 AD7418_REG_ADC);
131                 }
132
133                 /* restore old configuration value */
134                 i2c_smbus_write_word_swapped(client, AD7418_REG_CONF, cfg);
135
136                 data->last_updated = jiffies;
137                 data->valid = 1;
138         }
139
140         mutex_unlock(&data->lock);
141
142         return data;
143 }
144
145 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
146                         char *buf)
147 {
148         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
149         struct ad7418_data *data = ad7418_update_device(dev);
150         return sprintf(buf, "%d\n",
151                 LM75_TEMP_FROM_REG(data->temp[attr->index]));
152 }
153
154 static ssize_t show_adc(struct device *dev, struct device_attribute *devattr,
155                         char *buf)
156 {
157         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
158         struct ad7418_data *data = ad7418_update_device(dev);
159
160         return sprintf(buf, "%d\n",
161                 ((data->in[attr->index] >> 6) * 2500 + 512) / 1024);
162 }
163
164 static ssize_t set_temp(struct device *dev, struct device_attribute *devattr,
165                         const char *buf, size_t count)
166 {
167         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
168         struct i2c_client *client = to_i2c_client(dev);
169         struct ad7418_data *data = i2c_get_clientdata(client);
170         long temp;
171         int ret = kstrtol(buf, 10, &temp);
172
173         if (ret < 0)
174                 return ret;
175
176         mutex_lock(&data->lock);
177         data->temp[attr->index] = LM75_TEMP_TO_REG(temp);
178         i2c_smbus_write_word_swapped(client,
179                                      AD7418_REG_TEMP[attr->index],
180                                      data->temp[attr->index]);
181         mutex_unlock(&data->lock);
182         return count;
183 }
184
185 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
186 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
187                                 show_temp, set_temp, 1);
188 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
189                                 show_temp, set_temp, 2);
190
191 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_adc, NULL, 0);
192 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_adc, NULL, 1);
193 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_adc, NULL, 2);
194 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_adc, NULL, 3);
195
196 static struct attribute *ad7416_attributes[] = {
197         &sensor_dev_attr_temp1_max.dev_attr.attr,
198         &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
199         &sensor_dev_attr_temp1_input.dev_attr.attr,
200         NULL
201 };
202
203 static struct attribute *ad7417_attributes[] = {
204         &sensor_dev_attr_temp1_max.dev_attr.attr,
205         &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
206         &sensor_dev_attr_temp1_input.dev_attr.attr,
207         &sensor_dev_attr_in1_input.dev_attr.attr,
208         &sensor_dev_attr_in2_input.dev_attr.attr,
209         &sensor_dev_attr_in3_input.dev_attr.attr,
210         &sensor_dev_attr_in4_input.dev_attr.attr,
211         NULL
212 };
213
214 static struct attribute *ad7418_attributes[] = {
215         &sensor_dev_attr_temp1_max.dev_attr.attr,
216         &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
217         &sensor_dev_attr_temp1_input.dev_attr.attr,
218         &sensor_dev_attr_in1_input.dev_attr.attr,
219         NULL
220 };
221
222 static int ad7418_probe(struct i2c_client *client,
223                          const struct i2c_device_id *id)
224 {
225         struct i2c_adapter *adapter = client->adapter;
226         struct ad7418_data *data;
227         int err;
228
229         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
230                                         I2C_FUNC_SMBUS_WORD_DATA))
231                 return -EOPNOTSUPP;
232
233         data = devm_kzalloc(&client->dev, sizeof(struct ad7418_data),
234                             GFP_KERNEL);
235         if (!data)
236                 return -ENOMEM;
237
238         i2c_set_clientdata(client, data);
239
240         mutex_init(&data->lock);
241         data->type = id->driver_data;
242
243         switch (data->type) {
244         case ad7416:
245                 data->adc_max = 0;
246                 data->attrs.attrs = ad7416_attributes;
247                 break;
248
249         case ad7417:
250                 data->adc_max = 4;
251                 data->attrs.attrs = ad7417_attributes;
252                 break;
253
254         case ad7418:
255                 data->adc_max = 1;
256                 data->attrs.attrs = ad7418_attributes;
257                 break;
258         }
259
260         dev_info(&client->dev, "%s chip found\n", client->name);
261
262         /* Initialize the AD7418 chip */
263         ad7418_init_client(client);
264
265         /* Register sysfs hooks */
266         err = sysfs_create_group(&client->dev.kobj, &data->attrs);
267         if (err)
268                 return err;
269
270         data->hwmon_dev = hwmon_device_register(&client->dev);
271         if (IS_ERR(data->hwmon_dev)) {
272                 err = PTR_ERR(data->hwmon_dev);
273                 goto exit_remove;
274         }
275
276         return 0;
277
278 exit_remove:
279         sysfs_remove_group(&client->dev.kobj, &data->attrs);
280         return err;
281 }
282
283 static int ad7418_remove(struct i2c_client *client)
284 {
285         struct ad7418_data *data = i2c_get_clientdata(client);
286         hwmon_device_unregister(data->hwmon_dev);
287         sysfs_remove_group(&client->dev.kobj, &data->attrs);
288         return 0;
289 }
290
291 module_i2c_driver(ad7418_driver);
292
293 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
294 MODULE_DESCRIPTION("AD7416/17/18 driver");
295 MODULE_LICENSE("GPL");
296 MODULE_VERSION(DRV_VERSION);