?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kfifo: fix Error/broken kernel-doc notation
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / adt7473.c
blob434576f61c84b7572575ceb26f698b23f1fece40
1 /*
2 * A hwmon driver for the Analog Devices ADT7473
3 * Copyright (C) 2007 IBM
4 *
5 * Author: Darrick J. Wong <djwong@us.ibm.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include <linux/module.h>
23 #include <linux/jiffies.h>
24 #include <linux/i2c.h>
25 #include <linux/hwmon.h>
26 #include <linux/hwmon-sysfs.h>
27 #include <linux/err.h>
28 #include <linux/mutex.h>
29 #include <linux/delay.h>
30 #include <linux/log2.h>
31
32 /* Addresses to scan */
33 static const unsigned short normal_i2c[] = { 0x2C, 0x2D, 0x2E, I2C_CLIENT_END };
34
35 /* ADT7473 registers */
36 #define ADT7473_REG_BASE_ADDR 0x20
37
38 #define ADT7473_REG_VOLT_BASE_ADDR 0x21
39 #define ADT7473_REG_VOLT_MIN_BASE_ADDR 0x46
40
41 #define ADT7473_REG_TEMP_BASE_ADDR 0x25
42 #define ADT7473_REG_TEMP_LIMITS_BASE_ADDR 0x4E
43 #define ADT7473_REG_TEMP_TMIN_BASE_ADDR 0x67
44 #define ADT7473_REG_TEMP_TMAX_BASE_ADDR 0x6A
45
46 #define ADT7473_REG_FAN_BASE_ADDR 0x28
47 #define ADT7473_REG_FAN_MIN_BASE_ADDR 0x54
48
49 #define ADT7473_REG_PWM_BASE_ADDR 0x30
50 #define ADT7473_REG_PWM_MIN_BASE_ADDR 0x64
51 #define ADT7473_REG_PWM_MAX_BASE_ADDR 0x38
52 #define ADT7473_REG_PWM_BHVR_BASE_ADDR 0x5C
53 #define ADT7473_PWM_BHVR_MASK 0xE0
54 #define ADT7473_PWM_BHVR_SHIFT 5
55
56 #define ADT7473_REG_CFG1 0x40
57 #define ADT7473_CFG1_START 0x01
58 #define ADT7473_CFG1_READY 0x04
59 #define ADT7473_REG_CFG2 0x73
60 #define ADT7473_REG_CFG3 0x78
61 #define ADT7473_REG_CFG4 0x7D
62 #define ADT7473_CFG4_MAX_DUTY_AT_OVT 0x08
63 #define ADT7473_REG_CFG5 0x7C
64 #define ADT7473_CFG5_TEMP_TWOS 0x01
65 #define ADT7473_CFG5_TEMP_OFFSET 0x02
66
67 #define ADT7473_REG_DEVICE 0x3D
68 #define ADT7473_VENDOR 0x41
69 #define ADT7473_REG_VENDOR 0x3E
70 #define ADT7473_DEVICE 0x73
71 #define ADT7473_REG_REVISION 0x3F
72 #define ADT7473_REV_68 0x68
73 #define ADT7473_REV_69 0x69
74
75 #define ADT7473_REG_ALARM1 0x41
76 #define ADT7473_VCCP_ALARM 0x02
77 #define ADT7473_VCC_ALARM 0x04
78 #define ADT7473_R1T_ALARM 0x10
79 #define ADT7473_LT_ALARM 0x20
80 #define ADT7473_R2T_ALARM 0x40
81 #define ADT7473_OOL 0x80
82 #define ADT7473_REG_ALARM2 0x42
83 #define ADT7473_OVT_ALARM 0x02
84 #define ADT7473_FAN1_ALARM 0x04
85 #define ADT7473_FAN2_ALARM 0x08
86 #define ADT7473_FAN3_ALARM 0x10
87 #define ADT7473_FAN4_ALARM 0x20
88 #define ADT7473_R1T_SHORT 0x40
89 #define ADT7473_R2T_SHORT 0x80
90
91 #define ALARM2(x) ((x) << 8)
92
93 #define ADT7473_VOLT_COUNT 2
94 #define ADT7473_REG_VOLT(x) (ADT7473_REG_VOLT_BASE_ADDR + (x))
95 #define ADT7473_REG_VOLT_MIN(x) (ADT7473_REG_VOLT_MIN_BASE_ADDR + ((x) * 2))
96 #define ADT7473_REG_VOLT_MAX(x) (ADT7473_REG_VOLT_MIN_BASE_ADDR + \
97 ((x) * 2) + 1)
98
99 #define ADT7473_TEMP_COUNT 3
100 #define ADT7473_REG_TEMP(x) (ADT7473_REG_TEMP_BASE_ADDR + (x))
101 #define ADT7473_REG_TEMP_MIN(x) (ADT7473_REG_TEMP_LIMITS_BASE_ADDR + ((x) * 2))
102 #define ADT7473_REG_TEMP_MAX(x) (ADT7473_REG_TEMP_LIMITS_BASE_ADDR + \
103 ((x) * 2) + 1)
104 #define ADT7473_REG_TEMP_TMIN(x) (ADT7473_REG_TEMP_TMIN_BASE_ADDR + (x))
105 #define ADT7473_REG_TEMP_TMAX(x) (ADT7473_REG_TEMP_TMAX_BASE_ADDR + (x))
106
107 #define ADT7473_FAN_COUNT 4
108 #define ADT7473_REG_FAN(x) (ADT7473_REG_FAN_BASE_ADDR + ((x) * 2))
109 #define ADT7473_REG_FAN_MIN(x) (ADT7473_REG_FAN_MIN_BASE_ADDR + ((x) * 2))
110
111 #define ADT7473_PWM_COUNT 3
112 #define ADT7473_REG_PWM(x) (ADT7473_REG_PWM_BASE_ADDR + (x))
113 #define ADT7473_REG_PWM_MAX(x) (ADT7473_REG_PWM_MAX_BASE_ADDR + (x))
114 #define ADT7473_REG_PWM_MIN(x) (ADT7473_REG_PWM_MIN_BASE_ADDR + (x))
115 #define ADT7473_REG_PWM_BHVR(x) (ADT7473_REG_PWM_BHVR_BASE_ADDR + (x))
116
117 /* How often do we reread sensors values? (In jiffies) */
118 #define SENSOR_REFRESH_INTERVAL (2 * HZ)
119
120 /* How often do we reread sensor limit values? (In jiffies) */
121 #define LIMIT_REFRESH_INTERVAL (60 * HZ)
122
123 /* datasheet says to divide this number by the fan reading to get fan rpm */
124 #define FAN_PERIOD_TO_RPM(x) ((90000 * 60) / (x))
125 #define FAN_RPM_TO_PERIOD FAN_PERIOD_TO_RPM
126 #define FAN_PERIOD_INVALID 65535
127 #define FAN_DATA_VALID(x) ((x) && (x) != FAN_PERIOD_INVALID)
128
129 struct adt7473_data {
130 struct device *hwmon_dev;
131 struct attribute_group attrs;
132 struct mutex lock;
133 char sensors_valid;
134 char limits_valid;
135 unsigned long sensors_last_updated; /* In jiffies */
136 unsigned long limits_last_updated; /* In jiffies */
137
138 u8 volt[ADT7473_VOLT_COUNT];
139 s8 volt_min[ADT7473_VOLT_COUNT];
140 s8 volt_max[ADT7473_VOLT_COUNT];
141
142 s8 temp[ADT7473_TEMP_COUNT];
143 s8 temp_min[ADT7473_TEMP_COUNT];
144 s8 temp_max[ADT7473_TEMP_COUNT];
145 s8 temp_tmin[ADT7473_TEMP_COUNT];
146 /* This is called the !THERM limit in the datasheet */
147 s8 temp_tmax[ADT7473_TEMP_COUNT];
148
149 u16 fan[ADT7473_FAN_COUNT];
150 u16 fan_min[ADT7473_FAN_COUNT];
151
152 u8 pwm[ADT7473_PWM_COUNT];
153 u8 pwm_max[ADT7473_PWM_COUNT];
154 u8 pwm_min[ADT7473_PWM_COUNT];
155 u8 pwm_behavior[ADT7473_PWM_COUNT];
156
157 u8 temp_twos_complement;
158 u8 temp_offset;
159
160 u16 alarm;
161 u8 max_duty_at_overheat;
162 };
163
164 static int adt7473_probe(struct i2c_client *client,
165 const struct i2c_device_id *id);
166 static int adt7473_detect(struct i2c_client *client,
167 struct i2c_board_info *info);
168 static int adt7473_remove(struct i2c_client *client);
169
170 static const struct i2c_device_id adt7473_id[] = {
171 { "adt7473", 0 },
172 { }
173 };
174
175 static struct i2c_driver adt7473_driver = {
176 .class = I2C_CLASS_HWMON,
177 .driver = {
178 .name = "adt7473",
179 },
180 .probe = adt7473_probe,
181 .remove = adt7473_remove,
182 .id_table = adt7473_id,
183 .detect = adt7473_detect,
184 .address_list = normal_i2c,
185 };
186
187 /*
188 * 16-bit registers on the ADT7473 are low-byte first. The data sheet says
189 * that the low byte must be read before the high byte.
190 */
191 static inline int adt7473_read_word_data(struct i2c_client *client, u8 reg)
192 {
193 u16 foo;
194 foo = i2c_smbus_read_byte_data(client, reg);
195 foo |= ((u16)i2c_smbus_read_byte_data(client, reg + 1) << 8);
196 return foo;
197 }
198
199 static inline int adt7473_write_word_data(struct i2c_client *client, u8 reg,
200 u16 value)
201 {
202 return i2c_smbus_write_byte_data(client, reg, value & 0xFF)
203 && i2c_smbus_write_byte_data(client, reg + 1, value >> 8);
204 }
205
206 static void adt7473_init_client(struct i2c_client *client)
207 {
208 int reg = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG1);
209
210 if (!(reg & ADT7473_CFG1_READY)) {
211 dev_err(&client->dev, "Chip not ready.\n");
212 } else {
213 /* start monitoring */
214 i2c_smbus_write_byte_data(client, ADT7473_REG_CFG1,
215 reg | ADT7473_CFG1_START);
216 }
217 }
218
219 static struct adt7473_data *adt7473_update_device(struct device *dev)
220 {
221 struct i2c_client *client = to_i2c_client(dev);
222 struct adt7473_data *data = i2c_get_clientdata(client);
223 unsigned long local_jiffies = jiffies;
224 u8 cfg;
225 int i;
226
227 mutex_lock(&data->lock);
228 if (time_before(local_jiffies, data->sensors_last_updated +
229 SENSOR_REFRESH_INTERVAL)
230 && data->sensors_valid)
231 goto no_sensor_update;
232
233 for (i = 0; i < ADT7473_VOLT_COUNT; i++)
234 data->volt[i] = i2c_smbus_read_byte_data(client,
235 ADT7473_REG_VOLT(i));
236
237 /* Determine temperature encoding */
238 cfg = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG5);
239 data->temp_twos_complement = (cfg & ADT7473_CFG5_TEMP_TWOS);
240
241 /*
242 * What does this do? it implies a variable temperature sensor
243 * offset, but the datasheet doesn't say anything about this bit
244 * and other parts of the datasheet imply that "offset64" mode
245 * means that you shift temp values by -64 if the above bit was set.
246 */
247 data->temp_offset = (cfg & ADT7473_CFG5_TEMP_OFFSET);
248
249 for (i = 0; i < ADT7473_TEMP_COUNT; i++)
250 data->temp[i] = i2c_smbus_read_byte_data(client,
251 ADT7473_REG_TEMP(i));
252
253 for (i = 0; i < ADT7473_FAN_COUNT; i++)
254 data->fan[i] = adt7473_read_word_data(client,
255 ADT7473_REG_FAN(i));
256
257 for (i = 0; i < ADT7473_PWM_COUNT; i++)
258 data->pwm[i] = i2c_smbus_read_byte_data(client,
259 ADT7473_REG_PWM(i));
260
261 data->alarm = i2c_smbus_read_byte_data(client, ADT7473_REG_ALARM1);
262 if (data->alarm & ADT7473_OOL)
263 data->alarm |= ALARM2(i2c_smbus_read_byte_data(client,
264 ADT7473_REG_ALARM2));
265
266 data->sensors_last_updated = local_jiffies;
267 data->sensors_valid = 1;
268
269 no_sensor_update:
270 if (time_before(local_jiffies, data->limits_last_updated +
271 LIMIT_REFRESH_INTERVAL)
272 && data->limits_valid)
273 goto out;
274
275 for (i = 0; i < ADT7473_VOLT_COUNT; i++) {
276 data->volt_min[i] = i2c_smbus_read_byte_data(client,
277 ADT7473_REG_VOLT_MIN(i));
278 data->volt_max[i] = i2c_smbus_read_byte_data(client,
279 ADT7473_REG_VOLT_MAX(i));
280 }
281
282 for (i = 0; i < ADT7473_TEMP_COUNT; i++) {
283 data->temp_min[i] = i2c_smbus_read_byte_data(client,
284 ADT7473_REG_TEMP_MIN(i));
285 data->temp_max[i] = i2c_smbus_read_byte_data(client,
286 ADT7473_REG_TEMP_MAX(i));
287 data->temp_tmin[i] = i2c_smbus_read_byte_data(client,
288 ADT7473_REG_TEMP_TMIN(i));
289 data->temp_tmax[i] = i2c_smbus_read_byte_data(client,
290 ADT7473_REG_TEMP_TMAX(i));
291 }
292
293 for (i = 0; i < ADT7473_FAN_COUNT; i++)
294 data->fan_min[i] = adt7473_read_word_data(client,
295 ADT7473_REG_FAN_MIN(i));
296
297 for (i = 0; i < ADT7473_PWM_COUNT; i++) {
298 data->pwm_max[i] = i2c_smbus_read_byte_data(client,
299 ADT7473_REG_PWM_MAX(i));
300 data->pwm_min[i] = i2c_smbus_read_byte_data(client,
301 ADT7473_REG_PWM_MIN(i));
302 data->pwm_behavior[i] = i2c_smbus_read_byte_data(client,
303 ADT7473_REG_PWM_BHVR(i));
304 }
305
306 i = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG4);
307 data->max_duty_at_overheat = !!(i & ADT7473_CFG4_MAX_DUTY_AT_OVT);
308
309 data->limits_last_updated = local_jiffies;
310 data->limits_valid = 1;
311
312 out:
313 mutex_unlock(&data->lock);
314 return data;
315 }
316
317 /*
318 * Conversions
319 */
320
321 /* IN are scaled acording to built-in resistors */
322 static const int adt7473_scaling[] = { /* .001 Volts */
323 2250, 3300
324 };
325 #define SCALE(val, from, to) (((val) * (to) + ((from) / 2)) / (from))
326
327 static int decode_volt(int volt_index, u8 raw)
328 {
329 return SCALE(raw, 192, adt7473_scaling[volt_index]);
330 }
331
332 static u8 encode_volt(int volt_index, int cooked)
333 {
334 int raw = SCALE(cooked, adt7473_scaling[volt_index], 192);
335 return SENSORS_LIMIT(raw, 0, 255);
336 }
337
338 static ssize_t show_volt_min(struct device *dev,
339 struct device_attribute *devattr,
340 char *buf)
341 {
342 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
343 struct adt7473_data *data = adt7473_update_device(dev);
344 return sprintf(buf, "%d\n",
345 decode_volt(attr->index, data->volt_min[attr->index]));
346 }
347
348 static ssize_t set_volt_min(struct device *dev,
349 struct device_attribute *devattr,
350 const char *buf,
351 size_t count)
352 {
353 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
354 struct i2c_client *client = to_i2c_client(dev);
355 struct adt7473_data *data = i2c_get_clientdata(client);
356 long volt;
357
358 if (strict_strtol(buf, 10, &volt))
359 return -EINVAL;
360
361 volt = encode_volt(attr->index, volt);
362
363 mutex_lock(&data->lock);
364 data->volt_min[attr->index] = volt;
365 i2c_smbus_write_byte_data(client, ADT7473_REG_VOLT_MIN(attr->index),
366 volt);
367 mutex_unlock(&data->lock);
368
369 return count;
370 }
371
372 static ssize_t show_volt_max(struct device *dev,
373 struct device_attribute *devattr,
374 char *buf)
375 {
376 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
377 struct adt7473_data *data = adt7473_update_device(dev);
378 return sprintf(buf, "%d\n",
379 decode_volt(attr->index, data->volt_max[attr->index]));
380 }
381
382 static ssize_t set_volt_max(struct device *dev,
383 struct device_attribute *devattr,
384 const char *buf,
385 size_t count)
386 {
387 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
388 struct i2c_client *client = to_i2c_client(dev);
389 struct adt7473_data *data = i2c_get_clientdata(client);
390 long volt;
391
392 if (strict_strtol(buf, 10, &volt))
393 return -EINVAL;
394
395 volt = encode_volt(attr->index, volt);
396
397 mutex_lock(&data->lock);
398 data->volt_max[attr->index] = volt;
399 i2c_smbus_write_byte_data(client, ADT7473_REG_VOLT_MAX(attr->index),
400 volt);
401 mutex_unlock(&data->lock);
402
403 return count;
404 }
405
406 static ssize_t show_volt(struct device *dev, struct device_attribute *devattr,
407 char *buf)
408 {
409 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
410 struct adt7473_data *data = adt7473_update_device(dev);
411
412 return sprintf(buf, "%d\n",
413 decode_volt(attr->index, data->volt[attr->index]));
414 }
415
416 /*
417 * This chip can report temperature data either as a two's complement
418 * number in the range -128 to 127, or as an unsigned number that must
419 * be offset by 64.
420 */
421 static int decode_temp(u8 twos_complement, u8 raw)
422 {
423 return twos_complement ? (s8)raw : raw - 64;
424 }
425
426 static u8 encode_temp(u8 twos_complement, int cooked)
427 {
428 u8 ret = twos_complement ? cooked & 0xFF : cooked + 64;
429 return SENSORS_LIMIT(ret, 0, 255);
430 }
431
432 static ssize_t show_temp_min(struct device *dev,
433 struct device_attribute *devattr,
434 char *buf)
435 {
436 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
437 struct adt7473_data *data = adt7473_update_device(dev);
438 return sprintf(buf, "%d\n", 1000 * decode_temp(
439 data->temp_twos_complement,
440 data->temp_min[attr->index]));
441 }
442
443 static ssize_t set_temp_min(struct device *dev,
444 struct device_attribute *devattr,
445 const char *buf,
446 size_t count)
447 {
448 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
449 struct i2c_client *client = to_i2c_client(dev);
450 struct adt7473_data *data = i2c_get_clientdata(client);
451 long temp;
452
453 if (strict_strtol(buf, 10, &temp))
454 return -EINVAL;
455
456 temp = DIV_ROUND_CLOSEST(temp, 1000);
457 temp = encode_temp(data->temp_twos_complement, temp);
458
459 mutex_lock(&data->lock);
460 data->temp_min[attr->index] = temp;
461 i2c_smbus_write_byte_data(client, ADT7473_REG_TEMP_MIN(attr->index),
462 temp);
463 mutex_unlock(&data->lock);
464
465 return count;
466 }
467
468 static ssize_t show_temp_max(struct device *dev,
469 struct device_attribute *devattr,
470 char *buf)
471 {
472 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
473 struct adt7473_data *data = adt7473_update_device(dev);
474 return sprintf(buf, "%d\n", 1000 * decode_temp(
475 data->temp_twos_complement,
476 data->temp_max[attr->index]));
477 }
478
479 static ssize_t set_temp_max(struct device *dev,
480 struct device_attribute *devattr,
481 const char *buf,
482 size_t count)
483 {
484 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
485 struct i2c_client *client = to_i2c_client(dev);
486 struct adt7473_data *data = i2c_get_clientdata(client);
487 long temp;
488
489 if (strict_strtol(buf, 10, &temp))
490 return -EINVAL;
491
492 temp = DIV_ROUND_CLOSEST(temp, 1000);
493 temp = encode_temp(data->temp_twos_complement, temp);
494
495 mutex_lock(&data->lock);
496 data->temp_max[attr->index] = temp;
497 i2c_smbus_write_byte_data(client, ADT7473_REG_TEMP_MAX(attr->index),
498 temp);
499 mutex_unlock(&data->lock);
500
501 return count;
502 }
503
504 static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
505 char *buf)
506 {
507 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
508 struct adt7473_data *data = adt7473_update_device(dev);
509 return sprintf(buf, "%d\n", 1000 * decode_temp(
510 data->temp_twos_complement,
511 data->temp[attr->index]));
512 }
513
514 static ssize_t show_fan_min(struct device *dev,
515 struct device_attribute *devattr,
516 char *buf)
517 {
518 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
519 struct adt7473_data *data = adt7473_update_device(dev);
520
521 if (FAN_DATA_VALID(data->fan_min[attr->index]))
522 return sprintf(buf, "%d\n",
523 FAN_PERIOD_TO_RPM(data->fan_min[attr->index]));
524 else
525 return sprintf(buf, "0\n");
526 }
527
528 static ssize_t set_fan_min(struct device *dev,
529 struct device_attribute *devattr,
530 const char *buf, size_t count)
531 {
532 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
533 struct i2c_client *client = to_i2c_client(dev);
534 struct adt7473_data *data = i2c_get_clientdata(client);
535 long temp;
536
537 if (strict_strtol(buf, 10, &temp) || !temp)
538 return -EINVAL;
539
540 temp = FAN_RPM_TO_PERIOD(temp);
541 temp = SENSORS_LIMIT(temp, 1, 65534);
542
543 mutex_lock(&data->lock);
544 data->fan_min[attr->index] = temp;
545 adt7473_write_word_data(client, ADT7473_REG_FAN_MIN(attr->index), temp);
546 mutex_unlock(&data->lock);
547
548 return count;
549 }
550
551 static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
552 char *buf)
553 {
554 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
555 struct adt7473_data *data = adt7473_update_device(dev);
556
557 if (FAN_DATA_VALID(data->fan[attr->index]))
558 return sprintf(buf, "%d\n",
559 FAN_PERIOD_TO_RPM(data->fan[attr->index]));
560 else
561 return sprintf(buf, "0\n");
562 }
563
564 static ssize_t show_max_duty_at_crit(struct device *dev,
565 struct device_attribute *devattr,
566 char *buf)
567 {
568 struct adt7473_data *data = adt7473_update_device(dev);
569 return sprintf(buf, "%d\n", data->max_duty_at_overheat);
570 }
571
572 static ssize_t set_max_duty_at_crit(struct device *dev,
573 struct device_attribute *devattr,
574 const char *buf,
575 size_t count)
576 {
577 u8 reg;
578 struct i2c_client *client = to_i2c_client(dev);
579 struct adt7473_data *data = i2c_get_clientdata(client);
580 long temp;
581
582 if (strict_strtol(buf, 10, &temp))
583 return -EINVAL;
584
585 mutex_lock(&data->lock);
586 data->max_duty_at_overheat = !!temp;
587 reg = i2c_smbus_read_byte_data(client, ADT7473_REG_CFG4);
588 if (temp)
589 reg |= ADT7473_CFG4_MAX_DUTY_AT_OVT;
590 else
591 reg &= ~ADT7473_CFG4_MAX_DUTY_AT_OVT;
592 i2c_smbus_write_byte_data(client, ADT7473_REG_CFG4, reg);
593 mutex_unlock(&data->lock);
594
595 return count;
596 }
597
598 static ssize_t show_pwm(struct device *dev, struct device_attribute *devattr,
599 char *buf)
600 {
601 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
602 struct adt7473_data *data = adt7473_update_device(dev);
603 return sprintf(buf, "%d\n", data->pwm[attr->index]);
604 }
605
606 static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
607 const char *buf, size_t count)
608 {
609 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
610 struct i2c_client *client = to_i2c_client(dev);
611 struct adt7473_data *data = i2c_get_clientdata(client);
612 long temp;
613
614 if (strict_strtol(buf, 10, &temp))
615 return -EINVAL;
616
617 temp = SENSORS_LIMIT(temp, 0, 255);
618
619 mutex_lock(&data->lock);
620 data->pwm[attr->index] = temp;
621 i2c_smbus_write_byte_data(client, ADT7473_REG_PWM(attr->index), temp);
622 mutex_unlock(&data->lock);
623
624 return count;
625 }
626
627 static ssize_t show_pwm_max(struct device *dev,
628 struct device_attribute *devattr,
629 char *buf)
630 {
631 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
632 struct adt7473_data *data = adt7473_update_device(dev);
633 return sprintf(buf, "%d\n", data->pwm_max[attr->index]);
634 }
635
636 static ssize_t set_pwm_max(struct device *dev,
637 struct device_attribute *devattr,
638 const char *buf,
639 size_t count)
640 {
641 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
642 struct i2c_client *client = to_i2c_client(dev);
643 struct adt7473_data *data = i2c_get_clientdata(client);
644 long temp;
645
646 if (strict_strtol(buf, 10, &temp))
647 return -EINVAL;
648
649 temp = SENSORS_LIMIT(temp, 0, 255);
650
651 mutex_lock(&data->lock);
652 data->pwm_max[attr->index] = temp;
653 i2c_smbus_write_byte_data(client, ADT7473_REG_PWM_MAX(attr->index),
654 temp);
655 mutex_unlock(&data->lock);
656
657 return count;
658 }
659
660 static ssize_t show_pwm_min(struct device *dev,
661 struct device_attribute *devattr,
662 char *buf)
663 {
664 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
665 struct adt7473_data *data = adt7473_update_device(dev);
666 return sprintf(buf, "%d\n", data->pwm_min[attr->index]);
667 }
668
669 static ssize_t set_pwm_min(struct device *dev,
670 struct device_attribute *devattr,
671 const char *buf,
672 size_t count)
673 {
674 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
675 struct i2c_client *client = to_i2c_client(dev);
676 struct adt7473_data *data = i2c_get_clientdata(client);
677 long temp;
678
679 if (strict_strtol(buf, 10, &temp))
680 return -EINVAL;
681
682 temp = SENSORS_LIMIT(temp, 0, 255);
683
684 mutex_lock(&data->lock);
685 data->pwm_min[attr->index] = temp;
686 i2c_smbus_write_byte_data(client, ADT7473_REG_PWM_MIN(attr->index),
687 temp);
688 mutex_unlock(&data->lock);
689
690 return count;
691 }
692
693 static ssize_t show_temp_tmax(struct device *dev,
694 struct device_attribute *devattr,
695 char *buf)
696 {
697 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
698 struct adt7473_data *data = adt7473_update_device(dev);
699 return sprintf(buf, "%d\n", 1000 * decode_temp(
700 data->temp_twos_complement,
701 data->temp_tmax[attr->index]));
702 }
703
704 static ssize_t set_temp_tmax(struct device *dev,
705 struct device_attribute *devattr,
706 const char *buf,
707 size_t count)
708 {
709 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
710 struct i2c_client *client = to_i2c_client(dev);
711 struct adt7473_data *data = i2c_get_clientdata(client);
712 long temp;
713
714 if (strict_strtol(buf, 10, &temp))
715 return -EINVAL;
716
717 temp = DIV_ROUND_CLOSEST(temp, 1000);
718 temp = encode_temp(data->temp_twos_complement, temp);
719
720 mutex_lock(&data->lock);
721 data->temp_tmax[attr->index] = temp;
722 i2c_smbus_write_byte_data(client, ADT7473_REG_TEMP_TMAX(attr->index),
723 temp);
724 mutex_unlock(&data->lock);
725
726 return count;
727 }
728
729 static ssize_t show_temp_tmin(struct device *dev,
730 struct device_attribute *devattr,
731 char *buf)
732 {
733 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
734 struct adt7473_data *data = adt7473_update_device(dev);
735 return sprintf(buf, "%d\n", 1000 * decode_temp(
736 data->temp_twos_complement,
737 data->temp_tmin[attr->index]));
738 }
739
740 static ssize_t set_temp_tmin(struct device *dev,
741 struct device_attribute *devattr,
742 const char *buf,
743 size_t count)
744 {
745 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
746 struct i2c_client *client = to_i2c_client(dev);
747 struct adt7473_data *data = i2c_get_clientdata(client);
748 long temp;
749
750 if (strict_strtol(buf, 10, &temp))
751 return -EINVAL;
752
753 temp = DIV_ROUND_CLOSEST(temp, 1000);
754 temp = encode_temp(data->temp_twos_complement, temp);
755
756 mutex_lock(&data->lock);
757 data->temp_tmin[attr->index] = temp;
758 i2c_smbus_write_byte_data(client, ADT7473_REG_TEMP_TMIN(attr->index),
759 temp);
760 mutex_unlock(&data->lock);
761
762 return count;
763 }
764
765 static ssize_t show_pwm_enable(struct device *dev,
766 struct device_attribute *devattr,
767 char *buf)
768 {
769 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
770 struct adt7473_data *data = adt7473_update_device(dev);
771
772 switch (data->pwm_behavior[attr->index] >> ADT7473_PWM_BHVR_SHIFT) {
773 case 3:
774 return sprintf(buf, "0\n");
775 case 7:
776 return sprintf(buf, "1\n");
777 default:
778 return sprintf(buf, "2\n");
779 }
780 }
781
782 static ssize_t set_pwm_enable(struct device *dev,
783 struct device_attribute *devattr,
784 const char *buf,
785 size_t count)
786 {
787 u8 reg;
788 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
789 struct i2c_client *client = to_i2c_client(dev);
790 struct adt7473_data *data = i2c_get_clientdata(client);
791 long temp;
792
793 if (strict_strtol(buf, 10, &temp))
794 return -EINVAL;
795
796 switch (temp) {
797 case 0:
798 temp = 3;
799 break;
800 case 1:
801 temp = 7;
802 break;
803 case 2:
804 /* Enter automatic mode with fans off */
805 temp = 4;
806 break;
807 default:
808 return -EINVAL;
809 }
810
811 mutex_lock(&data->lock);
812 reg = i2c_smbus_read_byte_data(client,
813 ADT7473_REG_PWM_BHVR(attr->index));
814 reg = (temp << ADT7473_PWM_BHVR_SHIFT) |
815 (reg & ~ADT7473_PWM_BHVR_MASK);
816 i2c_smbus_write_byte_data(client, ADT7473_REG_PWM_BHVR(attr->index),
817 reg);
818 data->pwm_behavior[attr->index] = reg;
819 mutex_unlock(&data->lock);
820
821 return count;
822 }
823
824 static ssize_t show_pwm_auto_temp(struct device *dev,
825 struct device_attribute *devattr,
826 char *buf)
827 {
828 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
829 struct adt7473_data *data = adt7473_update_device(dev);
830 int bhvr = data->pwm_behavior[attr->index] >> ADT7473_PWM_BHVR_SHIFT;
831
832 switch (bhvr) {
833 case 3:
834 case 4:
835 case 7:
836 return sprintf(buf, "0\n");
837 case 0:
838 case 1:
839 case 5:
840 case 6:
841 return sprintf(buf, "%d\n", bhvr + 1);
842 case 2:
843 return sprintf(buf, "4\n");
844 }
845 /* shouldn't ever get here */
846 BUG();
847 }
848
849 static ssize_t set_pwm_auto_temp(struct device *dev,
850 struct device_attribute *devattr,
851 const char *buf,
852 size_t count)
853 {
854 u8 reg;
855 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
856 struct i2c_client *client = to_i2c_client(dev);
857 struct adt7473_data *data = i2c_get_clientdata(client);
858 long temp;
859
860 if (strict_strtol(buf, 10, &temp))
861 return -EINVAL;
862
863 switch (temp) {
864 case 1:
865 case 2:
866 case 6:
867 case 7:
868 temp--;
869 break;
870 case 0:
871 temp = 4;
872 break;
873 default:
874 return -EINVAL;
875 }
876
877 mutex_lock(&data->lock);
878 reg = i2c_smbus_read_byte_data(client,
879 ADT7473_REG_PWM_BHVR(attr->index));
880 reg = (temp << ADT7473_PWM_BHVR_SHIFT) |
881 (reg & ~ADT7473_PWM_BHVR_MASK);
882 i2c_smbus_write_byte_data(client, ADT7473_REG_PWM_BHVR(attr->index),
883 reg);
884 data->pwm_behavior[attr->index] = reg;
885 mutex_unlock(&data->lock);
886
887 return count;
888 }
889
890 static ssize_t show_alarm(struct device *dev,
891 struct device_attribute *devattr,
892 char *buf)
893 {
894 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
895 struct adt7473_data *data = adt7473_update_device(dev);
896
897 if (data->alarm & attr->index)
898 return sprintf(buf, "1\n");
899 else
900 return sprintf(buf, "0\n");
901 }
902
903
904 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO, show_volt_max,
905 set_volt_max, 0);
906 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO, show_volt_max,
907 set_volt_max, 1);
908
909 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO, show_volt_min,
910 set_volt_min, 0);
911 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO, show_volt_min,
912 set_volt_min, 1);
913
914 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_volt, NULL, 0);
915 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_volt, NULL, 1);
916
917 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL,
918 ADT7473_VCCP_ALARM);
919 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL,
920 ADT7473_VCC_ALARM);
921
922 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
923 set_temp_max, 0);
924 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
925 set_temp_max, 1);
926 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO, show_temp_max,
927 set_temp_max, 2);
928
929 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
930 set_temp_min, 0);
931 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
932 set_temp_min, 1);
933 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO, show_temp_min,
934 set_temp_min, 2);
935
936 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
937 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
938 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
939
940 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL,
941 ADT7473_R1T_ALARM | ALARM2(ADT7473_R1T_SHORT));
942 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL,
943 ADT7473_LT_ALARM);
944 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL,
945 ADT7473_R2T_ALARM | ALARM2(ADT7473_R2T_SHORT));
946
947 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
948 set_fan_min, 0);
949 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
950 set_fan_min, 1);
951 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO, show_fan_min,
952 set_fan_min, 2);
953 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO, show_fan_min,
954 set_fan_min, 3);
955
956 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
957 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
958 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan, NULL, 2);
959 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan, NULL, 3);
960
961 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL,
962 ALARM2(ADT7473_FAN1_ALARM));
963 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL,
964 ALARM2(ADT7473_FAN2_ALARM));
965 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL,
966 ALARM2(ADT7473_FAN3_ALARM));
967 static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL,
968 ALARM2(ADT7473_FAN4_ALARM));
969
970 static SENSOR_DEVICE_ATTR(pwm_use_point2_pwm_at_crit, S_IWUSR | S_IRUGO,
971 show_max_duty_at_crit, set_max_duty_at_crit, 0);
972
973 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
974 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
975 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 2);
976
977 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
978 show_pwm_min, set_pwm_min, 0);
979 static SENSOR_DEVICE_ATTR(pwm2_auto_point1_pwm, S_IWUSR | S_IRUGO,
980 show_pwm_min, set_pwm_min, 1);
981 static SENSOR_DEVICE_ATTR(pwm3_auto_point1_pwm, S_IWUSR | S_IRUGO,
982 show_pwm_min, set_pwm_min, 2);
983
984 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
985 show_pwm_max, set_pwm_max, 0);
986 static SENSOR_DEVICE_ATTR(pwm2_auto_point2_pwm, S_IWUSR | S_IRUGO,
987 show_pwm_max, set_pwm_max, 1);
988 static SENSOR_DEVICE_ATTR(pwm3_auto_point2_pwm, S_IWUSR | S_IRUGO,
989 show_pwm_max, set_pwm_max, 2);
990
991 static SENSOR_DEVICE_ATTR(temp1_auto_point1_temp, S_IWUSR | S_IRUGO,
992 show_temp_tmin, set_temp_tmin, 0);
993 static SENSOR_DEVICE_ATTR(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
994 show_temp_tmin, set_temp_tmin, 1);
995 static SENSOR_DEVICE_ATTR(temp3_auto_point1_temp, S_IWUSR | S_IRUGO,
996 show_temp_tmin, set_temp_tmin, 2);
997
998 static SENSOR_DEVICE_ATTR(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
999 show_temp_tmax, set_temp_tmax, 0);
1000 static SENSOR_DEVICE_ATTR(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
1001 show_temp_tmax, set_temp_tmax, 1);
1002 static SENSOR_DEVICE_ATTR(temp3_auto_point2_temp, S_IWUSR | S_IRUGO,
1003 show_temp_tmax, set_temp_tmax, 2);
1004
1005 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1006 set_pwm_enable, 0);
1007 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1008 set_pwm_enable, 1);
1009 static SENSOR_DEVICE_ATTR(pwm3_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
1010 set_pwm_enable, 2);
1011
1012 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IWUSR | S_IRUGO,
1013 show_pwm_auto_temp, set_pwm_auto_temp, 0);
1014 static SENSOR_DEVICE_ATTR(pwm2_auto_channels_temp, S_IWUSR | S_IRUGO,
1015 show_pwm_auto_temp, set_pwm_auto_temp, 1);
1016 static SENSOR_DEVICE_ATTR(pwm3_auto_channels_temp, S_IWUSR | S_IRUGO,
1017 show_pwm_auto_temp, set_pwm_auto_temp, 2);
1018
1019 static struct attribute *adt7473_attr[] =
1020 {
1021 &sensor_dev_attr_in1_max.dev_attr.attr,
1022 &sensor_dev_attr_in2_max.dev_attr.attr,
1023 &sensor_dev_attr_in1_min.dev_attr.attr,
1024 &sensor_dev_attr_in2_min.dev_attr.attr,
1025 &sensor_dev_attr_in1_input.dev_attr.attr,
1026 &sensor_dev_attr_in2_input.dev_attr.attr,
1027 &sensor_dev_attr_in1_alarm.dev_attr.attr,
1028 &sensor_dev_attr_in2_alarm.dev_attr.attr,
1029
1030 &sensor_dev_attr_temp1_max.dev_attr.attr,
1031 &sensor_dev_attr_temp2_max.dev_attr.attr,
1032 &sensor_dev_attr_temp3_max.dev_attr.attr,
1033 &sensor_dev_attr_temp1_min.dev_attr.attr,
1034 &sensor_dev_attr_temp2_min.dev_attr.attr,
1035 &sensor_dev_attr_temp3_min.dev_attr.attr,
1036 &sensor_dev_attr_temp1_input.dev_attr.attr,
1037 &sensor_dev_attr_temp2_input.dev_attr.attr,
1038 &sensor_dev_attr_temp3_input.dev_attr.attr,
1039 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
1040 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
1041 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
1042 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
1043 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
1044 &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
1045 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
1046 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
1047 &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
1048
1049 &sensor_dev_attr_fan1_min.dev_attr.attr,
1050 &sensor_dev_attr_fan2_min.dev_attr.attr,
1051 &sensor_dev_attr_fan3_min.dev_attr.attr,
1052 &sensor_dev_attr_fan4_min.dev_attr.attr,
1053 &sensor_dev_attr_fan1_input.dev_attr.attr,
1054 &sensor_dev_attr_fan2_input.dev_attr.attr,
1055 &sensor_dev_attr_fan3_input.dev_attr.attr,
1056 &sensor_dev_attr_fan4_input.dev_attr.attr,
1057 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
1058 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
1059 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
1060 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
1061
1062 &sensor_dev_attr_pwm_use_point2_pwm_at_crit.dev_attr.attr,
1063
1064 &sensor_dev_attr_pwm1.dev_attr.attr,
1065 &sensor_dev_attr_pwm2.dev_attr.attr,
1066 &sensor_dev_attr_pwm3.dev_attr.attr,
1067 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
1068 &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1069 &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1070 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
1071 &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1072 &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1073
1074 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1075 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
1076 &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1077 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
1078 &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
1079 &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1080
1081 NULL
1082 };
1083
1084 /* Return 0 if detection is successful, -ENODEV otherwise */
1085 static int adt7473_detect(struct i2c_client *client,
1086 struct i2c_board_info *info)
1087 {
1088 struct i2c_adapter *adapter = client->adapter;
1089 int vendor, device, revision;
1090
1091 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1092 return -ENODEV;
1093
1094 vendor = i2c_smbus_read_byte_data(client, ADT7473_REG_VENDOR);
1095 if (vendor != ADT7473_VENDOR)
1096 return -ENODEV;
1097
1098 device = i2c_smbus_read_byte_data(client, ADT7473_REG_DEVICE);
1099 if (device != ADT7473_DEVICE)
1100 return -ENODEV;
1101
1102 revision = i2c_smbus_read_byte_data(client, ADT7473_REG_REVISION);
1103 if (revision != ADT7473_REV_68 && revision != ADT7473_REV_69)
1104 return -ENODEV;
1105
1106 strlcpy(info->type, "adt7473", I2C_NAME_SIZE);
1107
1108 return 0;
1109 }
1110
1111 static int adt7473_probe(struct i2c_client *client,
1112 const struct i2c_device_id *id)
1113 {
1114 struct adt7473_data *data;
1115 int err;
1116
1117 data = kzalloc(sizeof(struct adt7473_data), GFP_KERNEL);
1118 if (!data) {
1119 err = -ENOMEM;
1120 goto exit;
1121 }
1122
1123 i2c_set_clientdata(client, data);
1124 mutex_init(&data->lock);
1125
1126 dev_info(&client->dev, "%s chip found\n", client->name);
1127
1128 /* Initialize the ADT7473 chip */
1129 adt7473_init_client(client);
1130
1131 /* Register sysfs hooks */
1132 data->attrs.attrs = adt7473_attr;
1133 err = sysfs_create_group(&client->dev.kobj, &data->attrs);
1134 if (err)
1135 goto exit_free;
1136
1137 data->hwmon_dev = hwmon_device_register(&client->dev);
1138 if (IS_ERR(data->hwmon_dev)) {
1139 err = PTR_ERR(data->hwmon_dev);
1140 goto exit_remove;
1141 }
1142
1143 return 0;
1144
1145 exit_remove:
1146 sysfs_remove_group(&client->dev.kobj, &data->attrs);
1147 exit_free:
1148 kfree(data);
1149 exit:
1150 return err;
1151 }
1152
1153 static int adt7473_remove(struct i2c_client *client)
1154 {
1155 struct adt7473_data *data = i2c_get_clientdata(client);
1156
1157 hwmon_device_unregister(data->hwmon_dev);
1158 sysfs_remove_group(&client->dev.kobj, &data->attrs);
1159 kfree(data);
1160 return 0;
1161 }
1162
1163 static int __init adt7473_init(void)
1164 {
1165 pr_notice("The adt7473 driver is deprecated, please use the adt7475 "
1166 "driver instead\n");
1167 return i2c_add_driver(&adt7473_driver);
1168 }
1169
1170 static void __exit adt7473_exit(void)
1171 {
1172 i2c_del_driver(&adt7473_driver);
1173 }
1174
1175 MODULE_AUTHOR("Darrick J. Wong <djwong@us.ibm.com>");
1176 MODULE_DESCRIPTION("ADT7473 driver");
1177 MODULE_LICENSE("GPL");
1178
1179 module_init(adt7473_init);
1180 module_exit(adt7473_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree