tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * smsc47m192.c - Support for hardware monitoring block of
3 * SMSC LPC47M192 and compatible Super I/O chips
4 *
5 * Copyright (C) 2006 Hartmut Rick <linux@rick.claranet.de>
6 *
7 * Derived from lm78.c and other chip drivers.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24#include <linux/module.h>
25#include <linux/init.h>
26#include <linux/slab.h>
27#include <linux/jiffies.h>
28#include <linux/i2c.h>
29#include <linux/hwmon.h>
30#include <linux/hwmon-sysfs.h>
31#include <linux/hwmon-vid.h>
32#include <linux/err.h>
33#include <linux/sysfs.h>
34#include <linux/mutex.h>
35
36/* Addresses to scan */
37static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
38
39/* SMSC47M192 registers */
40#define SMSC47M192_REG_IN(nr) ((nr) < 6 ? (0x20 + (nr)) : \
41 (0x50 + (nr) - 6))
42#define SMSC47M192_REG_IN_MAX(nr) ((nr) < 6 ? (0x2b + (nr) * 2) : \
43 (0x54 + (((nr) - 6) * 2)))
44#define SMSC47M192_REG_IN_MIN(nr) ((nr) < 6 ? (0x2c + (nr) * 2) : \
45 (0x55 + (((nr) - 6) * 2)))
46static u8 SMSC47M192_REG_TEMP[3] = { 0x27, 0x26, 0x52 };
47static u8 SMSC47M192_REG_TEMP_MAX[3] = { 0x39, 0x37, 0x58 };
48static u8 SMSC47M192_REG_TEMP_MIN[3] = { 0x3A, 0x38, 0x59 };
49#define SMSC47M192_REG_TEMP_OFFSET(nr) ((nr) == 2 ? 0x1e : 0x1f)
50#define SMSC47M192_REG_ALARM1 0x41
51#define SMSC47M192_REG_ALARM2 0x42
52#define SMSC47M192_REG_VID 0x47
53#define SMSC47M192_REG_VID4 0x49
54#define SMSC47M192_REG_CONFIG 0x40
55#define SMSC47M192_REG_SFR 0x4f
56#define SMSC47M192_REG_COMPANY_ID 0x3e
57#define SMSC47M192_REG_VERSION 0x3f
58
59/* generalised scaling with integer rounding */
60static inline int SCALE(long val, int mul, int div)
61{
62 if (val < 0)
63 return (val * mul - div / 2) / div;
64 else
65 return (val * mul + div / 2) / div;
66}
67
68/* Conversions */
69
70/* smsc47m192 internally scales voltage measurements */
71static const u16 nom_mv[] = { 2500, 2250, 3300, 5000, 12000, 3300, 1500, 1800 };
72
73static inline unsigned int IN_FROM_REG(u8 reg, int n)
74{
75 return SCALE(reg, nom_mv[n], 192);
76}
77
78static inline u8 IN_TO_REG(unsigned long val, int n)
79{
80 val = clamp_val(val, 0, nom_mv[n] * 255 / 192);
81 return SCALE(val, 192, nom_mv[n]);
82}
83
84/*
85 * TEMP: 0.001 degC units (-128C to +127C)
86 * REG: 1C/bit, two's complement
87 */
88static inline s8 TEMP_TO_REG(long val)
89{
90 return SCALE(clamp_val(val, -128000, 127000), 1, 1000);
91}
92
93static inline int TEMP_FROM_REG(s8 val)
94{
95 return val * 1000;
96}
97
98struct smsc47m192_data {
99 struct i2c_client *client;
100 const struct attribute_group *groups[3];
101 struct mutex update_lock;
102 char valid; /* !=0 if following fields are valid */
103 unsigned long last_updated; /* In jiffies */
104
105 u8 in[8]; /* Register value */
106 u8 in_max[8]; /* Register value */
107 u8 in_min[8]; /* Register value */
108 s8 temp[3]; /* Register value */
109 s8 temp_max[3]; /* Register value */
110 s8 temp_min[3]; /* Register value */
111 s8 temp_offset[3]; /* Register value */
112 u16 alarms; /* Register encoding, combined */
113 u8 vid; /* Register encoding, combined */
114 u8 vrm;
115};
116
117static struct smsc47m192_data *smsc47m192_update_device(struct device *dev)
118{
119 struct smsc47m192_data *data = dev_get_drvdata(dev);
120 struct i2c_client *client = data->client;
121 int i, config;
122
123 mutex_lock(&data->update_lock);
124
125 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
126 || !data->valid) {
127 u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
128
129 dev_dbg(&client->dev, "Starting smsc47m192 update\n");
130
131 for (i = 0; i <= 7; i++) {
132 data->in[i] = i2c_smbus_read_byte_data(client,
133 SMSC47M192_REG_IN(i));
134 data->in_min[i] = i2c_smbus_read_byte_data(client,
135 SMSC47M192_REG_IN_MIN(i));
136 data->in_max[i] = i2c_smbus_read_byte_data(client,
137 SMSC47M192_REG_IN_MAX(i));
138 }
139 for (i = 0; i < 3; i++) {
140 data->temp[i] = i2c_smbus_read_byte_data(client,
141 SMSC47M192_REG_TEMP[i]);
142 data->temp_max[i] = i2c_smbus_read_byte_data(client,
143 SMSC47M192_REG_TEMP_MAX[i]);
144 data->temp_min[i] = i2c_smbus_read_byte_data(client,
145 SMSC47M192_REG_TEMP_MIN[i]);
146 }
147 for (i = 1; i < 3; i++)
148 data->temp_offset[i] = i2c_smbus_read_byte_data(client,
149 SMSC47M192_REG_TEMP_OFFSET(i));
150 /*
151 * first offset is temp_offset[0] if SFR bit 4 is set,
152 * temp_offset[1] otherwise
153 */
154 if (sfr & 0x10) {
155 data->temp_offset[0] = data->temp_offset[1];
156 data->temp_offset[1] = 0;
157 } else
158 data->temp_offset[0] = 0;
159
160 data->vid = i2c_smbus_read_byte_data(client, SMSC47M192_REG_VID)
161 & 0x0f;
162 config = i2c_smbus_read_byte_data(client,
163 SMSC47M192_REG_CONFIG);
164 if (config & 0x20)
165 data->vid |= (i2c_smbus_read_byte_data(client,
166 SMSC47M192_REG_VID4) & 0x01) << 4;
167 data->alarms = i2c_smbus_read_byte_data(client,
168 SMSC47M192_REG_ALARM1) |
169 (i2c_smbus_read_byte_data(client,
170 SMSC47M192_REG_ALARM2) << 8);
171
172 data->last_updated = jiffies;
173 data->valid = 1;
174 }
175
176 mutex_unlock(&data->update_lock);
177
178 return data;
179}
180
181/* Voltages */
182static ssize_t in_show(struct device *dev, struct device_attribute *attr,
183 char *buf)
184{
185 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
186 int nr = sensor_attr->index;
187 struct smsc47m192_data *data = smsc47m192_update_device(dev);
188 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr], nr));
189}
190
191static ssize_t in_min_show(struct device *dev, struct device_attribute *attr,
192 char *buf)
193{
194 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
195 int nr = sensor_attr->index;
196 struct smsc47m192_data *data = smsc47m192_update_device(dev);
197 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr], nr));
198}
199
200static ssize_t in_max_show(struct device *dev, struct device_attribute *attr,
201 char *buf)
202{
203 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
204 int nr = sensor_attr->index;
205 struct smsc47m192_data *data = smsc47m192_update_device(dev);
206 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr], nr));
207}
208
209static ssize_t in_min_store(struct device *dev, struct device_attribute *attr,
210 const char *buf, size_t count)
211{
212 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
213 int nr = sensor_attr->index;
214 struct smsc47m192_data *data = dev_get_drvdata(dev);
215 struct i2c_client *client = data->client;
216 unsigned long val;
217 int err;
218
219 err = kstrtoul(buf, 10, &val);
220 if (err)
221 return err;
222
223 mutex_lock(&data->update_lock);
224 data->in_min[nr] = IN_TO_REG(val, nr);
225 i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MIN(nr),
226 data->in_min[nr]);
227 mutex_unlock(&data->update_lock);
228 return count;
229}
230
231static ssize_t in_max_store(struct device *dev, struct device_attribute *attr,
232 const char *buf, size_t count)
233{
234 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
235 int nr = sensor_attr->index;
236 struct smsc47m192_data *data = dev_get_drvdata(dev);
237 struct i2c_client *client = data->client;
238 unsigned long val;
239 int err;
240
241 err = kstrtoul(buf, 10, &val);
242 if (err)
243 return err;
244
245 mutex_lock(&data->update_lock);
246 data->in_max[nr] = IN_TO_REG(val, nr);
247 i2c_smbus_write_byte_data(client, SMSC47M192_REG_IN_MAX(nr),
248 data->in_max[nr]);
249 mutex_unlock(&data->update_lock);
250 return count;
251}
252
253static SENSOR_DEVICE_ATTR_RO(in0_input, in, 0);
254static SENSOR_DEVICE_ATTR_RW(in0_min, in_min, 0);
255static SENSOR_DEVICE_ATTR_RW(in0_max, in_max, 0);
256static SENSOR_DEVICE_ATTR_RO(in1_input, in, 1);
257static SENSOR_DEVICE_ATTR_RW(in1_min, in_min, 1);
258static SENSOR_DEVICE_ATTR_RW(in1_max, in_max, 1);
259static SENSOR_DEVICE_ATTR_RO(in2_input, in, 2);
260static SENSOR_DEVICE_ATTR_RW(in2_min, in_min, 2);
261static SENSOR_DEVICE_ATTR_RW(in2_max, in_max, 2);
262static SENSOR_DEVICE_ATTR_RO(in3_input, in, 3);
263static SENSOR_DEVICE_ATTR_RW(in3_min, in_min, 3);
264static SENSOR_DEVICE_ATTR_RW(in3_max, in_max, 3);
265static SENSOR_DEVICE_ATTR_RO(in4_input, in, 4);
266static SENSOR_DEVICE_ATTR_RW(in4_min, in_min, 4);
267static SENSOR_DEVICE_ATTR_RW(in4_max, in_max, 4);
268static SENSOR_DEVICE_ATTR_RO(in5_input, in, 5);
269static SENSOR_DEVICE_ATTR_RW(in5_min, in_min, 5);
270static SENSOR_DEVICE_ATTR_RW(in5_max, in_max, 5);
271static SENSOR_DEVICE_ATTR_RO(in6_input, in, 6);
272static SENSOR_DEVICE_ATTR_RW(in6_min, in_min, 6);
273static SENSOR_DEVICE_ATTR_RW(in6_max, in_max, 6);
274static SENSOR_DEVICE_ATTR_RO(in7_input, in, 7);
275static SENSOR_DEVICE_ATTR_RW(in7_min, in_min, 7);
276static SENSOR_DEVICE_ATTR_RW(in7_max, in_max, 7);
277
278/* Temperatures */
279static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
280 char *buf)
281{
282 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
283 int nr = sensor_attr->index;
284 struct smsc47m192_data *data = smsc47m192_update_device(dev);
285 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
286}
287
288static ssize_t temp_min_show(struct device *dev,
289 struct device_attribute *attr, char *buf)
290{
291 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
292 int nr = sensor_attr->index;
293 struct smsc47m192_data *data = smsc47m192_update_device(dev);
294 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
295}
296
297static ssize_t temp_max_show(struct device *dev,
298 struct device_attribute *attr, char *buf)
299{
300 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
301 int nr = sensor_attr->index;
302 struct smsc47m192_data *data = smsc47m192_update_device(dev);
303 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
304}
305
306static ssize_t temp_min_store(struct device *dev,
307 struct device_attribute *attr, const char *buf,
308 size_t count)
309{
310 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
311 int nr = sensor_attr->index;
312 struct smsc47m192_data *data = dev_get_drvdata(dev);
313 struct i2c_client *client = data->client;
314 long val;
315 int err;
316
317 err = kstrtol(buf, 10, &val);
318 if (err)
319 return err;
320
321 mutex_lock(&data->update_lock);
322 data->temp_min[nr] = TEMP_TO_REG(val);
323 i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MIN[nr],
324 data->temp_min[nr]);
325 mutex_unlock(&data->update_lock);
326 return count;
327}
328
329static ssize_t temp_max_store(struct device *dev,
330 struct device_attribute *attr, const char *buf,
331 size_t count)
332{
333 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
334 int nr = sensor_attr->index;
335 struct smsc47m192_data *data = dev_get_drvdata(dev);
336 struct i2c_client *client = data->client;
337 long val;
338 int err;
339
340 err = kstrtol(buf, 10, &val);
341 if (err)
342 return err;
343
344 mutex_lock(&data->update_lock);
345 data->temp_max[nr] = TEMP_TO_REG(val);
346 i2c_smbus_write_byte_data(client, SMSC47M192_REG_TEMP_MAX[nr],
347 data->temp_max[nr]);
348 mutex_unlock(&data->update_lock);
349 return count;
350}
351
352static ssize_t temp_offset_show(struct device *dev,
353 struct device_attribute *attr, char *buf)
354{
355 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
356 int nr = sensor_attr->index;
357 struct smsc47m192_data *data = smsc47m192_update_device(dev);
358 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_offset[nr]));
359}
360
361static ssize_t temp_offset_store(struct device *dev,
362 struct device_attribute *attr,
363 const char *buf, size_t count)
364{
365 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
366 int nr = sensor_attr->index;
367 struct smsc47m192_data *data = dev_get_drvdata(dev);
368 struct i2c_client *client = data->client;
369 u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
370 long val;
371 int err;
372
373 err = kstrtol(buf, 10, &val);
374 if (err)
375 return err;
376
377 mutex_lock(&data->update_lock);
378 data->temp_offset[nr] = TEMP_TO_REG(val);
379 if (nr > 1)
380 i2c_smbus_write_byte_data(client,
381 SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
382 else if (data->temp_offset[nr] != 0) {
383 /*
384 * offset[0] and offset[1] share the same register,
385 * SFR bit 4 activates offset[0]
386 */
387 i2c_smbus_write_byte_data(client, SMSC47M192_REG_SFR,
388 (sfr & 0xef) | (nr == 0 ? 0x10 : 0));
389 data->temp_offset[1-nr] = 0;
390 i2c_smbus_write_byte_data(client,
391 SMSC47M192_REG_TEMP_OFFSET(nr), data->temp_offset[nr]);
392 } else if ((sfr & 0x10) == (nr == 0 ? 0x10 : 0))
393 i2c_smbus_write_byte_data(client,
394 SMSC47M192_REG_TEMP_OFFSET(nr), 0);
395 mutex_unlock(&data->update_lock);
396 return count;
397}
398
399static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
400static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
401static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
402static SENSOR_DEVICE_ATTR_RW(temp1_offset, temp_offset, 0);
403static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
404static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
405static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
406static SENSOR_DEVICE_ATTR_RW(temp2_offset, temp_offset, 1);
407static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
408static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
409static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
410static SENSOR_DEVICE_ATTR_RW(temp3_offset, temp_offset, 2);
411
412/* VID */
413static ssize_t cpu0_vid_show(struct device *dev,
414 struct device_attribute *attr, char *buf)
415{
416 struct smsc47m192_data *data = smsc47m192_update_device(dev);
417 return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
418}
419static DEVICE_ATTR_RO(cpu0_vid);
420
421static ssize_t vrm_show(struct device *dev, struct device_attribute *attr,
422 char *buf)
423{
424 struct smsc47m192_data *data = dev_get_drvdata(dev);
425 return sprintf(buf, "%d\n", data->vrm);
426}
427
428static ssize_t vrm_store(struct device *dev, struct device_attribute *attr,
429 const char *buf, size_t count)
430{
431 struct smsc47m192_data *data = dev_get_drvdata(dev);
432 unsigned long val;
433 int err;
434
435 err = kstrtoul(buf, 10, &val);
436 if (err)
437 return err;
438 if (val > 255)
439 return -EINVAL;
440
441 data->vrm = val;
442 return count;
443}
444static DEVICE_ATTR_RW(vrm);
445
446/* Alarms */
447static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
448 char *buf)
449{
450 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr);
451 int nr = sensor_attr->index;
452 struct smsc47m192_data *data = smsc47m192_update_device(dev);
453 return sprintf(buf, "%u\n", (data->alarms & nr) ? 1 : 0);
454}
455
456static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 0x0010);
457static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 0x0020);
458static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 0x0040);
459static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 0x4000);
460static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 0x8000);
461static SENSOR_DEVICE_ATTR_RO(in0_alarm, alarm, 0x0001);
462static SENSOR_DEVICE_ATTR_RO(in1_alarm, alarm, 0x0002);
463static SENSOR_DEVICE_ATTR_RO(in2_alarm, alarm, 0x0004);
464static SENSOR_DEVICE_ATTR_RO(in3_alarm, alarm, 0x0008);
465static SENSOR_DEVICE_ATTR_RO(in4_alarm, alarm, 0x0100);
466static SENSOR_DEVICE_ATTR_RO(in5_alarm, alarm, 0x0200);
467static SENSOR_DEVICE_ATTR_RO(in6_alarm, alarm, 0x0400);
468static SENSOR_DEVICE_ATTR_RO(in7_alarm, alarm, 0x0800);
469
470static struct attribute *smsc47m192_attributes[] = {
471 &sensor_dev_attr_in0_input.dev_attr.attr,
472 &sensor_dev_attr_in0_min.dev_attr.attr,
473 &sensor_dev_attr_in0_max.dev_attr.attr,
474 &sensor_dev_attr_in0_alarm.dev_attr.attr,
475 &sensor_dev_attr_in1_input.dev_attr.attr,
476 &sensor_dev_attr_in1_min.dev_attr.attr,
477 &sensor_dev_attr_in1_max.dev_attr.attr,
478 &sensor_dev_attr_in1_alarm.dev_attr.attr,
479 &sensor_dev_attr_in2_input.dev_attr.attr,
480 &sensor_dev_attr_in2_min.dev_attr.attr,
481 &sensor_dev_attr_in2_max.dev_attr.attr,
482 &sensor_dev_attr_in2_alarm.dev_attr.attr,
483 &sensor_dev_attr_in3_input.dev_attr.attr,
484 &sensor_dev_attr_in3_min.dev_attr.attr,
485 &sensor_dev_attr_in3_max.dev_attr.attr,
486 &sensor_dev_attr_in3_alarm.dev_attr.attr,
487 &sensor_dev_attr_in5_input.dev_attr.attr,
488 &sensor_dev_attr_in5_min.dev_attr.attr,
489 &sensor_dev_attr_in5_max.dev_attr.attr,
490 &sensor_dev_attr_in5_alarm.dev_attr.attr,
491 &sensor_dev_attr_in6_input.dev_attr.attr,
492 &sensor_dev_attr_in6_min.dev_attr.attr,
493 &sensor_dev_attr_in6_max.dev_attr.attr,
494 &sensor_dev_attr_in6_alarm.dev_attr.attr,
495 &sensor_dev_attr_in7_input.dev_attr.attr,
496 &sensor_dev_attr_in7_min.dev_attr.attr,
497 &sensor_dev_attr_in7_max.dev_attr.attr,
498 &sensor_dev_attr_in7_alarm.dev_attr.attr,
499
500 &sensor_dev_attr_temp1_input.dev_attr.attr,
501 &sensor_dev_attr_temp1_max.dev_attr.attr,
502 &sensor_dev_attr_temp1_min.dev_attr.attr,
503 &sensor_dev_attr_temp1_offset.dev_attr.attr,
504 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
505 &sensor_dev_attr_temp2_input.dev_attr.attr,
506 &sensor_dev_attr_temp2_max.dev_attr.attr,
507 &sensor_dev_attr_temp2_min.dev_attr.attr,
508 &sensor_dev_attr_temp2_offset.dev_attr.attr,
509 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
510 &sensor_dev_attr_temp2_fault.dev_attr.attr,
511 &sensor_dev_attr_temp3_input.dev_attr.attr,
512 &sensor_dev_attr_temp3_max.dev_attr.attr,
513 &sensor_dev_attr_temp3_min.dev_attr.attr,
514 &sensor_dev_attr_temp3_offset.dev_attr.attr,
515 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
516 &sensor_dev_attr_temp3_fault.dev_attr.attr,
517
518 &dev_attr_cpu0_vid.attr,
519 &dev_attr_vrm.attr,
520 NULL
521};
522
523static const struct attribute_group smsc47m192_group = {
524 .attrs = smsc47m192_attributes,
525};
526
527static struct attribute *smsc47m192_attributes_in4[] = {
528 &sensor_dev_attr_in4_input.dev_attr.attr,
529 &sensor_dev_attr_in4_min.dev_attr.attr,
530 &sensor_dev_attr_in4_max.dev_attr.attr,
531 &sensor_dev_attr_in4_alarm.dev_attr.attr,
532 NULL
533};
534
535static const struct attribute_group smsc47m192_group_in4 = {
536 .attrs = smsc47m192_attributes_in4,
537};
538
539static void smsc47m192_init_client(struct i2c_client *client)
540{
541 int i;
542 u8 config = i2c_smbus_read_byte_data(client, SMSC47M192_REG_CONFIG);
543 u8 sfr = i2c_smbus_read_byte_data(client, SMSC47M192_REG_SFR);
544
545 /* select cycle mode (pause 1 sec between updates) */
546 i2c_smbus_write_byte_data(client, SMSC47M192_REG_SFR,
547 (sfr & 0xfd) | 0x02);
548 if (!(config & 0x01)) {
549 /* initialize alarm limits */
550 for (i = 0; i < 8; i++) {
551 i2c_smbus_write_byte_data(client,
552 SMSC47M192_REG_IN_MIN(i), 0);
553 i2c_smbus_write_byte_data(client,
554 SMSC47M192_REG_IN_MAX(i), 0xff);
555 }
556 for (i = 0; i < 3; i++) {
557 i2c_smbus_write_byte_data(client,
558 SMSC47M192_REG_TEMP_MIN[i], 0x80);
559 i2c_smbus_write_byte_data(client,
560 SMSC47M192_REG_TEMP_MAX[i], 0x7f);
561 }
562
563 /* start monitoring */
564 i2c_smbus_write_byte_data(client, SMSC47M192_REG_CONFIG,
565 (config & 0xf7) | 0x01);
566 }
567}
568
569/* Return 0 if detection is successful, -ENODEV otherwise */
570static int smsc47m192_detect(struct i2c_client *client,
571 struct i2c_board_info *info)
572{
573 struct i2c_adapter *adapter = client->adapter;
574 int version;
575
576 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
577 return -ENODEV;
578
579 /* Detection criteria from sensors_detect script */
580 version = i2c_smbus_read_byte_data(client, SMSC47M192_REG_VERSION);
581 if (i2c_smbus_read_byte_data(client,
582 SMSC47M192_REG_COMPANY_ID) == 0x55
583 && (version & 0xf0) == 0x20
584 && (i2c_smbus_read_byte_data(client,
585 SMSC47M192_REG_VID) & 0x70) == 0x00
586 && (i2c_smbus_read_byte_data(client,
587 SMSC47M192_REG_VID4) & 0xfe) == 0x80) {
588 dev_info(&adapter->dev,
589 "found SMSC47M192 or compatible, "
590 "version 2, stepping A%d\n", version & 0x0f);
591 } else {
592 dev_dbg(&adapter->dev,
593 "SMSC47M192 detection failed at 0x%02x\n",
594 client->addr);
595 return -ENODEV;
596 }
597
598 strlcpy(info->type, "smsc47m192", I2C_NAME_SIZE);
599
600 return 0;
601}
602
603static int smsc47m192_probe(struct i2c_client *client,
604 const struct i2c_device_id *id)
605{
606 struct device *dev = &client->dev;
607 struct device *hwmon_dev;
608 struct smsc47m192_data *data;
609 int config;
610
611 data = devm_kzalloc(dev, sizeof(struct smsc47m192_data), GFP_KERNEL);
612 if (!data)
613 return -ENOMEM;
614
615 data->client = client;
616 data->vrm = vid_which_vrm();
617 mutex_init(&data->update_lock);
618
619 /* Initialize the SMSC47M192 chip */
620 smsc47m192_init_client(client);
621
622 /* sysfs hooks */
623 data->groups[0] = &smsc47m192_group;
624 /* Pin 110 is either in4 (+12V) or VID4 */
625 config = i2c_smbus_read_byte_data(client, SMSC47M192_REG_CONFIG);
626 if (!(config & 0x20))
627 data->groups[1] = &smsc47m192_group_in4;
628
629 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
630 data, data->groups);
631 return PTR_ERR_OR_ZERO(hwmon_dev);
632}
633
634static const struct i2c_device_id smsc47m192_id[] = {
635 { "smsc47m192", 0 },
636 { }
637};
638MODULE_DEVICE_TABLE(i2c, smsc47m192_id);
639
640static struct i2c_driver smsc47m192_driver = {
641 .class = I2C_CLASS_HWMON,
642 .driver = {
643 .name = "smsc47m192",
644 },
645 .probe = smsc47m192_probe,
646 .id_table = smsc47m192_id,
647 .detect = smsc47m192_detect,
648 .address_list = normal_i2c,
649};
650
651module_i2c_driver(smsc47m192_driver);
652
653MODULE_AUTHOR("Hartmut Rick <linux@rick.claranet.de>");
654MODULE_DESCRIPTION("SMSC47M192 driver");
655MODULE_LICENSE("GPL");