Commit | Line | Data |
---|---|---|
60994698 RS |
1 | /* |
2 | * ds620.c - Support for temperature sensor and thermostat DS620 | |
3 | * | |
4 | * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de> | |
5 | * | |
6 | * based on ds1621.c by Christian W. Zuckschwerdt <zany@triq.net> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
21 | */ | |
22 | ||
23 | #include <linux/module.h> | |
24 | #include <linux/init.h> | |
25 | #include <linux/slab.h> | |
26 | #include <linux/jiffies.h> | |
27 | #include <linux/i2c.h> | |
28 | #include <linux/hwmon.h> | |
29 | #include <linux/hwmon-sysfs.h> | |
30 | #include <linux/err.h> | |
31 | #include <linux/mutex.h> | |
32 | #include <linux/sysfs.h> | |
33 | #include <linux/i2c/ds620.h> | |
34 | ||
35 | /* | |
36 | * Many DS620 constants specified below | |
37 | * 15 14 13 12 11 10 09 08 | |
38 | * |Done|NVB |THF |TLF |R1 |R0 |AUTOC|1SHOT| | |
39 | * | |
40 | * 07 06 05 04 03 02 01 00 | |
41 | * |PO2 |PO1 |A2 |A1 |A0 | | | | | |
42 | */ | |
43 | #define DS620_REG_CONFIG_DONE 0x8000 | |
44 | #define DS620_REG_CONFIG_NVB 0x4000 | |
45 | #define DS620_REG_CONFIG_THF 0x2000 | |
46 | #define DS620_REG_CONFIG_TLF 0x1000 | |
47 | #define DS620_REG_CONFIG_R1 0x0800 | |
48 | #define DS620_REG_CONFIG_R0 0x0400 | |
49 | #define DS620_REG_CONFIG_AUTOC 0x0200 | |
50 | #define DS620_REG_CONFIG_1SHOT 0x0100 | |
51 | #define DS620_REG_CONFIG_PO2 0x0080 | |
52 | #define DS620_REG_CONFIG_PO1 0x0040 | |
53 | #define DS620_REG_CONFIG_A2 0x0020 | |
54 | #define DS620_REG_CONFIG_A1 0x0010 | |
55 | #define DS620_REG_CONFIG_A0 0x0008 | |
56 | ||
57 | /* The DS620 registers */ | |
58 | static const u8 DS620_REG_TEMP[3] = { | |
59 | 0xAA, /* input, word, RO */ | |
60 | 0xA2, /* min, word, RW */ | |
61 | 0xA0, /* max, word, RW */ | |
62 | }; | |
63 | ||
64 | #define DS620_REG_CONF 0xAC /* word, RW */ | |
65 | #define DS620_COM_START 0x51 /* no data */ | |
66 | #define DS620_COM_STOP 0x22 /* no data */ | |
67 | ||
68 | /* Each client has this additional data */ | |
69 | struct ds620_data { | |
70 | struct device *hwmon_dev; | |
71 | struct mutex update_lock; | |
72 | char valid; /* !=0 if following fields are valid */ | |
73 | unsigned long last_updated; /* In jiffies */ | |
74 | ||
cc41d586 | 75 | s16 temp[3]; /* Register values, word */ |
60994698 RS |
76 | }; |
77 | ||
60994698 RS |
78 | static void ds620_init_client(struct i2c_client *client) |
79 | { | |
a8b3a3a5 | 80 | struct ds620_platform_data *ds620_info = dev_get_platdata(&client->dev); |
60994698 RS |
81 | u16 conf, new_conf; |
82 | ||
83 | new_conf = conf = | |
90f4102c | 84 | i2c_smbus_read_word_swapped(client, DS620_REG_CONF); |
60994698 RS |
85 | |
86 | /* switch to continuous conversion mode */ | |
87 | new_conf &= ~DS620_REG_CONFIG_1SHOT; | |
88 | /* already high at power-on, but don't trust the BIOS! */ | |
89 | new_conf |= DS620_REG_CONFIG_PO2; | |
90 | /* thermostat mode according to platform data */ | |
91 | if (ds620_info && ds620_info->pomode == 1) | |
92 | new_conf &= ~DS620_REG_CONFIG_PO1; /* PO_LOW */ | |
93 | else if (ds620_info && ds620_info->pomode == 2) | |
94 | new_conf |= DS620_REG_CONFIG_PO1; /* PO_HIGH */ | |
95 | else | |
96 | new_conf &= ~DS620_REG_CONFIG_PO2; /* always low */ | |
97 | /* with highest precision */ | |
98 | new_conf |= DS620_REG_CONFIG_R1 | DS620_REG_CONFIG_R0; | |
99 | ||
100 | if (conf != new_conf) | |
90f4102c | 101 | i2c_smbus_write_word_swapped(client, DS620_REG_CONF, new_conf); |
60994698 RS |
102 | |
103 | /* start conversion */ | |
104 | i2c_smbus_write_byte(client, DS620_COM_START); | |
105 | } | |
106 | ||
107 | static struct ds620_data *ds620_update_client(struct device *dev) | |
108 | { | |
109 | struct i2c_client *client = to_i2c_client(dev); | |
110 | struct ds620_data *data = i2c_get_clientdata(client); | |
111 | struct ds620_data *ret = data; | |
112 | ||
113 | mutex_lock(&data->update_lock); | |
114 | ||
115 | if (time_after(jiffies, data->last_updated + HZ + HZ / 2) | |
116 | || !data->valid) { | |
117 | int i; | |
118 | int res; | |
119 | ||
120 | dev_dbg(&client->dev, "Starting ds620 update\n"); | |
121 | ||
122 | for (i = 0; i < ARRAY_SIZE(data->temp); i++) { | |
90f4102c JD |
123 | res = i2c_smbus_read_word_swapped(client, |
124 | DS620_REG_TEMP[i]); | |
60994698 RS |
125 | if (res < 0) { |
126 | ret = ERR_PTR(res); | |
127 | goto abort; | |
128 | } | |
129 | ||
130 | data->temp[i] = res; | |
131 | } | |
132 | ||
133 | data->last_updated = jiffies; | |
134 | data->valid = 1; | |
135 | } | |
136 | abort: | |
137 | mutex_unlock(&data->update_lock); | |
138 | ||
139 | return ret; | |
140 | } | |
141 | ||
142 | static ssize_t show_temp(struct device *dev, struct device_attribute *da, | |
143 | char *buf) | |
144 | { | |
145 | struct sensor_device_attribute *attr = to_sensor_dev_attr(da); | |
146 | struct ds620_data *data = ds620_update_client(dev); | |
147 | ||
148 | if (IS_ERR(data)) | |
149 | return PTR_ERR(data); | |
150 | ||
151 | return sprintf(buf, "%d\n", ((data->temp[attr->index] / 8) * 625) / 10); | |
152 | } | |
153 | ||
154 | static ssize_t set_temp(struct device *dev, struct device_attribute *da, | |
155 | const char *buf, size_t count) | |
156 | { | |
157 | int res; | |
158 | long val; | |
159 | ||
160 | struct sensor_device_attribute *attr = to_sensor_dev_attr(da); | |
161 | struct i2c_client *client = to_i2c_client(dev); | |
162 | struct ds620_data *data = i2c_get_clientdata(client); | |
163 | ||
179c4fdb | 164 | res = kstrtol(buf, 10, &val); |
60994698 RS |
165 | |
166 | if (res) | |
167 | return res; | |
168 | ||
169 | val = (val * 10 / 625) * 8; | |
170 | ||
171 | mutex_lock(&data->update_lock); | |
172 | data->temp[attr->index] = val; | |
90f4102c JD |
173 | i2c_smbus_write_word_swapped(client, DS620_REG_TEMP[attr->index], |
174 | data->temp[attr->index]); | |
60994698 RS |
175 | mutex_unlock(&data->update_lock); |
176 | return count; | |
177 | } | |
178 | ||
179 | static ssize_t show_alarm(struct device *dev, struct device_attribute *da, | |
180 | char *buf) | |
181 | { | |
182 | struct sensor_device_attribute *attr = to_sensor_dev_attr(da); | |
183 | struct ds620_data *data = ds620_update_client(dev); | |
184 | struct i2c_client *client = to_i2c_client(dev); | |
185 | u16 conf, new_conf; | |
186 | int res; | |
187 | ||
188 | if (IS_ERR(data)) | |
189 | return PTR_ERR(data); | |
190 | ||
191 | /* reset alarms if necessary */ | |
90f4102c | 192 | res = i2c_smbus_read_word_swapped(client, DS620_REG_CONF); |
60994698 RS |
193 | if (res < 0) |
194 | return res; | |
195 | ||
90f4102c | 196 | new_conf = conf = res; |
60994698 RS |
197 | new_conf &= ~attr->index; |
198 | if (conf != new_conf) { | |
90f4102c JD |
199 | res = i2c_smbus_write_word_swapped(client, DS620_REG_CONF, |
200 | new_conf); | |
60994698 RS |
201 | if (res < 0) |
202 | return res; | |
203 | } | |
204 | ||
205 | return sprintf(buf, "%d\n", !!(conf & attr->index)); | |
206 | } | |
207 | ||
208 | static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); | |
209 | static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp, set_temp, 1); | |
210 | static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp, set_temp, 2); | |
211 | static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, | |
212 | DS620_REG_CONFIG_TLF); | |
213 | static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, | |
214 | DS620_REG_CONFIG_THF); | |
215 | ||
216 | static struct attribute *ds620_attributes[] = { | |
217 | &sensor_dev_attr_temp1_input.dev_attr.attr, | |
218 | &sensor_dev_attr_temp1_min.dev_attr.attr, | |
219 | &sensor_dev_attr_temp1_max.dev_attr.attr, | |
220 | &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, | |
221 | &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, | |
222 | NULL | |
223 | }; | |
224 | ||
225 | static const struct attribute_group ds620_group = { | |
226 | .attrs = ds620_attributes, | |
227 | }; | |
228 | ||
229 | static int ds620_probe(struct i2c_client *client, | |
230 | const struct i2c_device_id *id) | |
231 | { | |
232 | struct ds620_data *data; | |
233 | int err; | |
234 | ||
3aa9d1df GR |
235 | data = devm_kzalloc(&client->dev, sizeof(struct ds620_data), |
236 | GFP_KERNEL); | |
237 | if (!data) | |
238 | return -ENOMEM; | |
60994698 RS |
239 | |
240 | i2c_set_clientdata(client, data); | |
241 | mutex_init(&data->update_lock); | |
242 | ||
243 | /* Initialize the DS620 chip */ | |
244 | ds620_init_client(client); | |
245 | ||
246 | /* Register sysfs hooks */ | |
247 | err = sysfs_create_group(&client->dev.kobj, &ds620_group); | |
248 | if (err) | |
3aa9d1df | 249 | return err; |
60994698 RS |
250 | |
251 | data->hwmon_dev = hwmon_device_register(&client->dev); | |
252 | if (IS_ERR(data->hwmon_dev)) { | |
253 | err = PTR_ERR(data->hwmon_dev); | |
254 | goto exit_remove_files; | |
255 | } | |
256 | ||
257 | dev_info(&client->dev, "temperature sensor found\n"); | |
258 | ||
259 | return 0; | |
260 | ||
261 | exit_remove_files: | |
262 | sysfs_remove_group(&client->dev.kobj, &ds620_group); | |
60994698 RS |
263 | return err; |
264 | } | |
265 | ||
266 | static int ds620_remove(struct i2c_client *client) | |
267 | { | |
268 | struct ds620_data *data = i2c_get_clientdata(client); | |
269 | ||
270 | hwmon_device_unregister(data->hwmon_dev); | |
271 | sysfs_remove_group(&client->dev.kobj, &ds620_group); | |
272 | ||
60994698 RS |
273 | return 0; |
274 | } | |
275 | ||
276 | static const struct i2c_device_id ds620_id[] = { | |
277 | {"ds620", 0}, | |
278 | {} | |
279 | }; | |
280 | ||
281 | MODULE_DEVICE_TABLE(i2c, ds620_id); | |
282 | ||
283 | /* This is the driver that will be inserted */ | |
284 | static struct i2c_driver ds620_driver = { | |
285 | .class = I2C_CLASS_HWMON, | |
286 | .driver = { | |
287 | .name = "ds620", | |
288 | }, | |
289 | .probe = ds620_probe, | |
290 | .remove = ds620_remove, | |
291 | .id_table = ds620_id, | |
292 | }; | |
293 | ||
f0967eea | 294 | module_i2c_driver(ds620_driver); |
60994698 RS |
295 | |
296 | MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>"); | |
297 | MODULE_DESCRIPTION("DS620 driver"); | |
298 | MODULE_LICENSE("GPL"); |