1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37#include <linux/module.h>
38#include <linux/init.h>
39#include <linux/slab.h>
40#include <linux/jiffies.h>
41#include <linux/i2c.h>
42#include <linux/hwmon.h>
43#include <linux/hwmon-sysfs.h>
44#include <linux/err.h>
45#include <linux/mutex.h>
46#include <linux/sysfs.h>
47#include <linux/kernel.h>
48
49
50enum chips { ds1621, ds1625, ds1631, ds1721, ds1731 };
51
52
53static int polarity = -1;
54module_param(polarity, int, 0);
55MODULE_PARM_DESC(polarity, "Output's polarity: 0 = active high, 1 = active low");
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80#define DS1621_REG_CONFIG_NVB 0x10
81#define DS1621_REG_CONFIG_RESOL 0x0C
82#define DS1621_REG_CONFIG_POLARITY 0x02
83#define DS1621_REG_CONFIG_1SHOT 0x01
84#define DS1621_REG_CONFIG_DONE 0x80
85
86#define DS1621_REG_CONFIG_RESOL_SHIFT 2
87
88
89static const unsigned short ds1721_convrates[] = {
90 94,
91 188,
92 375,
93 750,
94};
95
96#define DS1621_CONVERSION_MAX 750
97#define DS1625_CONVERSION_MAX 500
98
99#define DS1621_TEMP_MAX 125000
100#define DS1621_TEMP_MIN (-55000)
101
102
103static const u8 DS1621_REG_TEMP[3] = {
104 0xAA,
105 0xA2,
106 0xA1,
107};
108#define DS1621_REG_CONF 0xAC
109#define DS1621_COM_START 0xEE
110#define DS1721_COM_START 0x51
111#define DS1621_COM_STOP 0x22
112
113
114#define DS1621_ALARM_TEMP_HIGH 0x40
115#define DS1621_ALARM_TEMP_LOW 0x20
116
117
118#define ALARMS_FROM_REG(val) ((val) & \
119 (DS1621_ALARM_TEMP_HIGH | DS1621_ALARM_TEMP_LOW))
120
121
122struct ds1621_data {
123 struct device *hwmon_dev;
124 struct mutex update_lock;
125 char valid;
126 unsigned long last_updated;
127 enum chips kind;
128
129 u16 temp[3];
130 u8 conf;
131 u8 zbits;
132
133 u16 update_interval;
134};
135
136static inline int DS1621_TEMP_FROM_REG(u16 reg)
137{
138 return DIV_ROUND_CLOSEST(((s16)reg / 16) * 625, 10);
139}
140
141
142
143
144
145
146
147static inline u16 DS1621_TEMP_TO_REG(long temp, u8 zbits)
148{
149 temp = clamp_val(temp, DS1621_TEMP_MIN, DS1621_TEMP_MAX);
150 temp = DIV_ROUND_CLOSEST(temp * (1 << (8 - zbits)), 1000) << zbits;
151 return temp;
152}
153
154static void ds1621_init_client(struct i2c_client *client)
155{
156 u8 conf, new_conf, sreg, resol;
157 struct ds1621_data *data = i2c_get_clientdata(client);
158
159 new_conf = conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF);
160
161 new_conf &= ~DS1621_REG_CONFIG_1SHOT;
162
163
164 if (polarity == 0)
165 new_conf &= ~DS1621_REG_CONFIG_POLARITY;
166 else if (polarity == 1)
167 new_conf |= DS1621_REG_CONFIG_POLARITY;
168
169 if (conf != new_conf)
170 i2c_smbus_write_byte_data(client, DS1621_REG_CONF, new_conf);
171
172 switch (data->kind) {
173 case ds1625:
174 data->update_interval = DS1625_CONVERSION_MAX;
175 data->zbits = 7;
176 sreg = DS1621_COM_START;
177 break;
178 case ds1631:
179 case ds1721:
180 case ds1731:
181 resol = (new_conf & DS1621_REG_CONFIG_RESOL) >>
182 DS1621_REG_CONFIG_RESOL_SHIFT;
183 data->update_interval = ds1721_convrates[resol];
184 data->zbits = 7 - resol;
185 sreg = DS1721_COM_START;
186 break;
187 default:
188 data->update_interval = DS1621_CONVERSION_MAX;
189 data->zbits = 7;
190 sreg = DS1621_COM_START;
191 break;
192 }
193
194
195 i2c_smbus_write_byte(client, sreg);
196}
197
198static struct ds1621_data *ds1621_update_client(struct device *dev)
199{
200 struct i2c_client *client = to_i2c_client(dev);
201 struct ds1621_data *data = i2c_get_clientdata(client);
202 u8 new_conf;
203
204 mutex_lock(&data->update_lock);
205
206 if (time_after(jiffies, data->last_updated + data->update_interval) ||
207 !data->valid) {
208 int i;
209
210 dev_dbg(&client->dev, "Starting ds1621 update\n");
211
212 data->conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF);
213
214 for (i = 0; i < ARRAY_SIZE(data->temp); i++)
215 data->temp[i] = i2c_smbus_read_word_swapped(client,
216 DS1621_REG_TEMP[i]);
217
218
219 new_conf = data->conf;
220 if (data->temp[0] > data->temp[1])
221 new_conf &= ~DS1621_ALARM_TEMP_LOW;
222 if (data->temp[0] < data->temp[2])
223 new_conf &= ~DS1621_ALARM_TEMP_HIGH;
224 if (data->conf != new_conf)
225 i2c_smbus_write_byte_data(client, DS1621_REG_CONF,
226 new_conf);
227
228 data->last_updated = jiffies;
229 data->valid = 1;
230 }
231
232 mutex_unlock(&data->update_lock);
233
234 return data;
235}
236
237static ssize_t show_temp(struct device *dev, struct device_attribute *da,
238 char *buf)
239{
240 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
241 struct ds1621_data *data = ds1621_update_client(dev);
242 return sprintf(buf, "%d\n",
243 DS1621_TEMP_FROM_REG(data->temp[attr->index]));
244}
245
246static ssize_t set_temp(struct device *dev, struct device_attribute *da,
247 const char *buf, size_t count)
248{
249 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
250 struct i2c_client *client = to_i2c_client(dev);
251 struct ds1621_data *data = i2c_get_clientdata(client);
252 long val;
253 int err;
254
255 err = kstrtol(buf, 10, &val);
256 if (err)
257 return err;
258
259 mutex_lock(&data->update_lock);
260 data->temp[attr->index] = DS1621_TEMP_TO_REG(val, data->zbits);
261 i2c_smbus_write_word_swapped(client, DS1621_REG_TEMP[attr->index],
262 data->temp[attr->index]);
263 mutex_unlock(&data->update_lock);
264 return count;
265}
266
267static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
268 char *buf)
269{
270 struct ds1621_data *data = ds1621_update_client(dev);
271 return sprintf(buf, "%d\n", ALARMS_FROM_REG(data->conf));
272}
273
274static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
275 char *buf)
276{
277 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
278 struct ds1621_data *data = ds1621_update_client(dev);
279 return sprintf(buf, "%d\n", !!(data->conf & attr->index));
280}
281
282static ssize_t show_convrate(struct device *dev, struct device_attribute *da,
283 char *buf)
284{
285 struct i2c_client *client = to_i2c_client(dev);
286 struct ds1621_data *data = i2c_get_clientdata(client);
287 return scnprintf(buf, PAGE_SIZE, "%hu\n", data->update_interval);
288}
289
290static ssize_t set_convrate(struct device *dev, struct device_attribute *da,
291 const char *buf, size_t count)
292{
293 struct i2c_client *client = to_i2c_client(dev);
294 struct ds1621_data *data = i2c_get_clientdata(client);
295 unsigned long convrate;
296 s32 err;
297 int resol = 0;
298
299 err = kstrtoul(buf, 10, &convrate);
300 if (err)
301 return err;
302
303
304 while (resol < (ARRAY_SIZE(ds1721_convrates) - 1) &&
305 convrate > ds1721_convrates[resol])
306 resol++;
307
308 mutex_lock(&data->update_lock);
309 data->conf = i2c_smbus_read_byte_data(client, DS1621_REG_CONF);
310 data->conf &= ~DS1621_REG_CONFIG_RESOL;
311 data->conf |= (resol << DS1621_REG_CONFIG_RESOL_SHIFT);
312 i2c_smbus_write_byte_data(client, DS1621_REG_CONF, data->conf);
313 data->update_interval = ds1721_convrates[resol];
314 mutex_unlock(&data->update_lock);
315
316 return count;
317}
318
319static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
320static DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO, show_convrate,
321 set_convrate);
322
323static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
324static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp, set_temp, 1);
325static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp, set_temp, 2);
326static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL,
327 DS1621_ALARM_TEMP_LOW);
328static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL,
329 DS1621_ALARM_TEMP_HIGH);
330
331static struct attribute *ds1621_attributes[] = {
332 &sensor_dev_attr_temp1_input.dev_attr.attr,
333 &sensor_dev_attr_temp1_min.dev_attr.attr,
334 &sensor_dev_attr_temp1_max.dev_attr.attr,
335 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
336 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
337 &dev_attr_alarms.attr,
338 &dev_attr_update_interval.attr,
339 NULL
340};
341
342static umode_t ds1621_attribute_visible(struct kobject *kobj,
343 struct attribute *attr, int index)
344{
345 struct device *dev = container_of(kobj, struct device, kobj);
346 struct i2c_client *client = to_i2c_client(dev);
347 struct ds1621_data *data = i2c_get_clientdata(client);
348
349 if (attr == &dev_attr_update_interval.attr)
350 if (data->kind == ds1621 || data->kind == ds1625)
351
352 return 0;
353 return attr->mode;
354}
355
356static const struct attribute_group ds1621_group = {
357 .attrs = ds1621_attributes,
358 .is_visible = ds1621_attribute_visible
359};
360
361static int ds1621_probe(struct i2c_client *client,
362 const struct i2c_device_id *id)
363{
364 struct ds1621_data *data;
365 int err;
366
367 data = devm_kzalloc(&client->dev, sizeof(struct ds1621_data),
368 GFP_KERNEL);
369 if (!data)
370 return -ENOMEM;
371
372 i2c_set_clientdata(client, data);
373 mutex_init(&data->update_lock);
374
375 data->kind = id->driver_data;
376
377
378 ds1621_init_client(client);
379
380
381 err = sysfs_create_group(&client->dev.kobj, &ds1621_group);
382 if (err)
383 return err;
384
385 data->hwmon_dev = hwmon_device_register(&client->dev);
386 if (IS_ERR(data->hwmon_dev)) {
387 err = PTR_ERR(data->hwmon_dev);
388 goto exit_remove_files;
389 }
390
391 return 0;
392
393 exit_remove_files:
394 sysfs_remove_group(&client->dev.kobj, &ds1621_group);
395 return err;
396}
397
398static int ds1621_remove(struct i2c_client *client)
399{
400 struct ds1621_data *data = i2c_get_clientdata(client);
401
402 hwmon_device_unregister(data->hwmon_dev);
403 sysfs_remove_group(&client->dev.kobj, &ds1621_group);
404
405 return 0;
406}
407
408static const struct i2c_device_id ds1621_id[] = {
409 { "ds1621", ds1621 },
410 { "ds1625", ds1625 },
411 { "ds1631", ds1631 },
412 { "ds1721", ds1721 },
413 { "ds1731", ds1731 },
414 { }
415};
416MODULE_DEVICE_TABLE(i2c, ds1621_id);
417
418
419static struct i2c_driver ds1621_driver = {
420 .class = I2C_CLASS_HWMON,
421 .driver = {
422 .name = "ds1621",
423 },
424 .probe = ds1621_probe,
425 .remove = ds1621_remove,
426 .id_table = ds1621_id,
427};
428
429module_i2c_driver(ds1621_driver);
430
431MODULE_AUTHOR("Christian W. Zuckschwerdt <zany@triq.net>");
432MODULE_DESCRIPTION("DS1621 driver");
433MODULE_LICENSE("GPL");
434