?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'davinci-next-2' of git://git.kernel.org/pub/scm/linux/kernel/git/khilma...
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / hwmon / w83793.c
blobe3bdedfb534708eabcc006c9933fd54b699af9d7
1 /*
2 w83793.c - Linux kernel driver for hardware monitoring
3 Copyright (C) 2006 Winbond Electronics Corp.
4 Yuan Mu
5 Rudolf Marek <r.marek@assembler.cz>
6 Copyright (C) 2009-2010 Sven Anders <anders@anduras.de>, ANDURAS AG.
7 Watchdog driver part
8 (Based partially on fschmd driver,
9 Copyright 2007-2008 by Hans de Goede)
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation - version 2.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 02110-1301 USA.
24 */
25
26 /*
27 Supports following chips:
28
29 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
30 w83793 10 12 8 6 0x7b 0x5ca3 yes no
31 */
32
33 #include <linux/module.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36 #include <linux/i2c.h>
37 #include <linux/hwmon.h>
38 #include <linux/hwmon-vid.h>
39 #include <linux/hwmon-sysfs.h>
40 #include <linux/err.h>
41 #include <linux/mutex.h>
42 #include <linux/fs.h>
43 #include <linux/watchdog.h>
44 #include <linux/miscdevice.h>
45 #include <linux/uaccess.h>
46 #include <linux/kref.h>
47 #include <linux/notifier.h>
48 #include <linux/reboot.h>
49
50 /* Default values */
51 #define WATCHDOG_TIMEOUT 2 /* 2 minute default timeout */
52
53 /* Addresses to scan */
54 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
55 I2C_CLIENT_END };
56
57 /* Insmod parameters */
58
59 static unsigned short force_subclients[4];
60 module_param_array(force_subclients, short, NULL, 0);
61 MODULE_PARM_DESC(force_subclients, "List of subclient addresses: "
62 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
63
64 static int reset;
65 module_param(reset, bool, 0);
66 MODULE_PARM_DESC(reset, "Set to 1 to reset chip, not recommended");
67
68 static int timeout = WATCHDOG_TIMEOUT; /* default timeout in minutes */
69 module_param(timeout, int, 0);
70 MODULE_PARM_DESC(timeout,
71 "Watchdog timeout in minutes. 2<= timeout <=255 (default="
72 __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
73
74 static int nowayout = WATCHDOG_NOWAYOUT;
75 module_param(nowayout, int, 0);
76 MODULE_PARM_DESC(nowayout,
77 "Watchdog cannot be stopped once started (default="
78 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
79
80 /*
81 Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved
82 as ID, Bank Select registers
83 */
84 #define W83793_REG_BANKSEL 0x00
85 #define W83793_REG_VENDORID 0x0d
86 #define W83793_REG_CHIPID 0x0e
87 #define W83793_REG_DEVICEID 0x0f
88
89 #define W83793_REG_CONFIG 0x40
90 #define W83793_REG_MFC 0x58
91 #define W83793_REG_FANIN_CTRL 0x5c
92 #define W83793_REG_FANIN_SEL 0x5d
93 #define W83793_REG_I2C_ADDR 0x0b
94 #define W83793_REG_I2C_SUBADDR 0x0c
95 #define W83793_REG_VID_INA 0x05
96 #define W83793_REG_VID_INB 0x06
97 #define W83793_REG_VID_LATCHA 0x07
98 #define W83793_REG_VID_LATCHB 0x08
99 #define W83793_REG_VID_CTRL 0x59
100
101 #define W83793_REG_WDT_LOCK 0x01
102 #define W83793_REG_WDT_ENABLE 0x02
103 #define W83793_REG_WDT_STATUS 0x03
104 #define W83793_REG_WDT_TIMEOUT 0x04
105
106 static u16 W83793_REG_TEMP_MODE[2] = { 0x5e, 0x5f };
107
108 #define TEMP_READ 0
109 #define TEMP_CRIT 1
110 #define TEMP_CRIT_HYST 2
111 #define TEMP_WARN 3
112 #define TEMP_WARN_HYST 4
113 /* only crit and crit_hyst affect real-time alarm status
114 current crit crit_hyst warn warn_hyst */
115 static u16 W83793_REG_TEMP[][5] = {
116 {0x1c, 0x78, 0x79, 0x7a, 0x7b},
117 {0x1d, 0x7c, 0x7d, 0x7e, 0x7f},
118 {0x1e, 0x80, 0x81, 0x82, 0x83},
119 {0x1f, 0x84, 0x85, 0x86, 0x87},
120 {0x20, 0x88, 0x89, 0x8a, 0x8b},
121 {0x21, 0x8c, 0x8d, 0x8e, 0x8f},
122 };
123
124 #define W83793_REG_TEMP_LOW_BITS 0x22
125
126 #define W83793_REG_BEEP(index) (0x53 + (index))
127 #define W83793_REG_ALARM(index) (0x4b + (index))
128
129 #define W83793_REG_CLR_CHASSIS 0x4a /* SMI MASK4 */
130 #define W83793_REG_IRQ_CTRL 0x50
131 #define W83793_REG_OVT_CTRL 0x51
132 #define W83793_REG_OVT_BEEP 0x52
133
134 #define IN_READ 0
135 #define IN_MAX 1
136 #define IN_LOW 2
137 static const u16 W83793_REG_IN[][3] = {
138 /* Current, High, Low */
139 {0x10, 0x60, 0x61}, /* Vcore A */
140 {0x11, 0x62, 0x63}, /* Vcore B */
141 {0x12, 0x64, 0x65}, /* Vtt */
142 {0x14, 0x6a, 0x6b}, /* VSEN1 */
143 {0x15, 0x6c, 0x6d}, /* VSEN2 */
144 {0x16, 0x6e, 0x6f}, /* +3VSEN */
145 {0x17, 0x70, 0x71}, /* +12VSEN */
146 {0x18, 0x72, 0x73}, /* 5VDD */
147 {0x19, 0x74, 0x75}, /* 5VSB */
148 {0x1a, 0x76, 0x77}, /* VBAT */
149 };
150
151 /* Low Bits of Vcore A/B Vtt Read/High/Low */
152 static const u16 W83793_REG_IN_LOW_BITS[] = { 0x1b, 0x68, 0x69 };
153 static u8 scale_in[] = { 2, 2, 2, 16, 16, 16, 8, 24, 24, 16 };
154 static u8 scale_in_add[] = { 0, 0, 0, 0, 0, 0, 0, 150, 150, 0 };
155
156 #define W83793_REG_FAN(index) (0x23 + 2 * (index)) /* High byte */
157 #define W83793_REG_FAN_MIN(index) (0x90 + 2 * (index)) /* High byte */
158
159 #define W83793_REG_PWM_DEFAULT 0xb2
160 #define W83793_REG_PWM_ENABLE 0x207
161 #define W83793_REG_PWM_UPTIME 0xc3 /* Unit in 0.1 second */
162 #define W83793_REG_PWM_DOWNTIME 0xc4 /* Unit in 0.1 second */
163 #define W83793_REG_TEMP_CRITICAL 0xc5
164
165 #define PWM_DUTY 0
166 #define PWM_START 1
167 #define PWM_NONSTOP 2
168 #define PWM_STOP_TIME 3
169 #define W83793_REG_PWM(index, nr) (((nr) == 0 ? 0xb3 : \
170 (nr) == 1 ? 0x220 : 0x218) + (index))
171
172 /* bit field, fan1 is bit0, fan2 is bit1 ... */
173 #define W83793_REG_TEMP_FAN_MAP(index) (0x201 + (index))
174 #define W83793_REG_TEMP_TOL(index) (0x208 + (index))
175 #define W83793_REG_TEMP_CRUISE(index) (0x210 + (index))
176 #define W83793_REG_PWM_STOP_TIME(index) (0x228 + (index))
177 #define W83793_REG_SF2_TEMP(index, nr) (0x230 + ((index) << 4) + (nr))
178 #define W83793_REG_SF2_PWM(index, nr) (0x238 + ((index) << 4) + (nr))
179
180 static inline unsigned long FAN_FROM_REG(u16 val)
181 {
182 if ((val >= 0xfff) || (val == 0))
183 return 0;
184 return (1350000UL / val);
185 }
186
187 static inline u16 FAN_TO_REG(long rpm)
188 {
189 if (rpm <= 0)
190 return 0x0fff;
191 return SENSORS_LIMIT((1350000 + (rpm >> 1)) / rpm, 1, 0xffe);
192 }
193
194 static inline unsigned long TIME_FROM_REG(u8 reg)
195 {
196 return (reg * 100);
197 }
198
199 static inline u8 TIME_TO_REG(unsigned long val)
200 {
201 return SENSORS_LIMIT((val + 50) / 100, 0, 0xff);
202 }
203
204 static inline long TEMP_FROM_REG(s8 reg)
205 {
206 return (reg * 1000);
207 }
208
209 static inline s8 TEMP_TO_REG(long val, s8 min, s8 max)
210 {
211 return SENSORS_LIMIT((val + (val < 0 ? -500 : 500)) / 1000, min, max);
212 }
213
214 struct w83793_data {
215 struct i2c_client *lm75[2];
216 struct device *hwmon_dev;
217 struct mutex update_lock;
218 char valid; /* !=0 if following fields are valid */
219 unsigned long last_updated; /* In jiffies */
220 unsigned long last_nonvolatile; /* In jiffies, last time we update the
221 nonvolatile registers */
222
223 u8 bank;
224 u8 vrm;
225 u8 vid[2];
226 u8 in[10][3]; /* Register value, read/high/low */
227 u8 in_low_bits[3]; /* Additional resolution for VCore A/B Vtt */
228
229 u16 has_fan; /* Only fan1- fan5 has own pins */
230 u16 fan[12]; /* Register value combine */
231 u16 fan_min[12]; /* Register value combine */
232
233 s8 temp[6][5]; /* current, crit, crit_hyst,warn, warn_hyst */
234 u8 temp_low_bits; /* Additional resolution TD1-TD4 */
235 u8 temp_mode[2]; /* byte 0: Temp D1-D4 mode each has 2 bits
236 byte 1: Temp R1,R2 mode, each has 1 bit */
237 u8 temp_critical; /* If reached all fan will be at full speed */
238 u8 temp_fan_map[6]; /* Temp controls which pwm fan, bit field */
239
240 u8 has_pwm;
241 u8 has_temp;
242 u8 has_vid;
243 u8 pwm_enable; /* Register value, each Temp has 1 bit */
244 u8 pwm_uptime; /* Register value */
245 u8 pwm_downtime; /* Register value */
246 u8 pwm_default; /* All fan default pwm, next poweron valid */
247 u8 pwm[8][3]; /* Register value */
248 u8 pwm_stop_time[8];
249 u8 temp_cruise[6];
250
251 u8 alarms[5]; /* realtime status registers */
252 u8 beeps[5];
253 u8 beep_enable;
254 u8 tolerance[3]; /* Temp tolerance(Smart Fan I/II) */
255 u8 sf2_pwm[6][7]; /* Smart FanII: Fan duty cycle */
256 u8 sf2_temp[6][7]; /* Smart FanII: Temp level point */
257
258 /* watchdog */
259 struct i2c_client *client;
260 struct mutex watchdog_lock;
261 struct list_head list; /* member of the watchdog_data_list */
262 struct kref kref;
263 struct miscdevice watchdog_miscdev;
264 unsigned long watchdog_is_open;
265 char watchdog_expect_close;
266 char watchdog_name[10]; /* must be unique to avoid sysfs conflict */
267 unsigned int watchdog_caused_reboot;
268 int watchdog_timeout; /* watchdog timeout in minutes */
269 };
270
271 /* Somewhat ugly :( global data pointer list with all devices, so that
272 we can find our device data as when using misc_register. There is no
273 other method to get to one's device data from the open file-op and
274 for usage in the reboot notifier callback. */
275 static LIST_HEAD(watchdog_data_list);
276
277 /* Note this lock not only protect list access, but also data.kref access */
278 static DEFINE_MUTEX(watchdog_data_mutex);
279
280 /* Release our data struct when we're detached from the i2c client *and* all
281 references to our watchdog device are released */
282 static void w83793_release_resources(struct kref *ref)
283 {
284 struct w83793_data *data = container_of(ref, struct w83793_data, kref);
285 kfree(data);
286 }
287
288 static u8 w83793_read_value(struct i2c_client *client, u16 reg);
289 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value);
290 static int w83793_probe(struct i2c_client *client,
291 const struct i2c_device_id *id);
292 static int w83793_detect(struct i2c_client *client,
293 struct i2c_board_info *info);
294 static int w83793_remove(struct i2c_client *client);
295 static void w83793_init_client(struct i2c_client *client);
296 static void w83793_update_nonvolatile(struct device *dev);
297 static struct w83793_data *w83793_update_device(struct device *dev);
298
299 static const struct i2c_device_id w83793_id[] = {
300 { "w83793", 0 },
301 { }
302 };
303 MODULE_DEVICE_TABLE(i2c, w83793_id);
304
305 static struct i2c_driver w83793_driver = {
306 .class = I2C_CLASS_HWMON,
307 .driver = {
308 .name = "w83793",
309 },
310 .probe = w83793_probe,
311 .remove = w83793_remove,
312 .id_table = w83793_id,
313 .detect = w83793_detect,
314 .address_list = normal_i2c,
315 };
316
317 static ssize_t
318 show_vrm(struct device *dev, struct device_attribute *attr, char *buf)
319 {
320 struct w83793_data *data = dev_get_drvdata(dev);
321 return sprintf(buf, "%d\n", data->vrm);
322 }
323
324 static ssize_t
325 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
326 {
327 struct w83793_data *data = w83793_update_device(dev);
328 struct sensor_device_attribute_2 *sensor_attr =
329 to_sensor_dev_attr_2(attr);
330 int index = sensor_attr->index;
331
332 return sprintf(buf, "%d\n", vid_from_reg(data->vid[index], data->vrm));
333 }
334
335 static ssize_t
336 store_vrm(struct device *dev, struct device_attribute *attr,
337 const char *buf, size_t count)
338 {
339 struct w83793_data *data = dev_get_drvdata(dev);
340 data->vrm = simple_strtoul(buf, NULL, 10);
341 return count;
342 }
343
344 #define ALARM_STATUS 0
345 #define BEEP_ENABLE 1
346 static ssize_t
347 show_alarm_beep(struct device *dev, struct device_attribute *attr, char *buf)
348 {
349 struct w83793_data *data = w83793_update_device(dev);
350 struct sensor_device_attribute_2 *sensor_attr =
351 to_sensor_dev_attr_2(attr);
352 int nr = sensor_attr->nr;
353 int index = sensor_attr->index >> 3;
354 int bit = sensor_attr->index & 0x07;
355 u8 val;
356
357 if (ALARM_STATUS == nr) {
358 val = (data->alarms[index] >> (bit)) & 1;
359 } else { /* BEEP_ENABLE */
360 val = (data->beeps[index] >> (bit)) & 1;
361 }
362
363 return sprintf(buf, "%u\n", val);
364 }
365
366 static ssize_t
367 store_beep(struct device *dev, struct device_attribute *attr,
368 const char *buf, size_t count)
369 {
370 struct i2c_client *client = to_i2c_client(dev);
371 struct w83793_data *data = i2c_get_clientdata(client);
372 struct sensor_device_attribute_2 *sensor_attr =
373 to_sensor_dev_attr_2(attr);
374 int index = sensor_attr->index >> 3;
375 int shift = sensor_attr->index & 0x07;
376 u8 beep_bit = 1 << shift;
377 u8 val;
378
379 val = simple_strtoul(buf, NULL, 10);
380 if (val != 0 && val != 1)
381 return -EINVAL;
382
383 mutex_lock(&data->update_lock);
384 data->beeps[index] = w83793_read_value(client, W83793_REG_BEEP(index));
385 data->beeps[index] &= ~beep_bit;
386 data->beeps[index] |= val << shift;
387 w83793_write_value(client, W83793_REG_BEEP(index), data->beeps[index]);
388 mutex_unlock(&data->update_lock);
389
390 return count;
391 }
392
393 static ssize_t
394 show_beep_enable(struct device *dev, struct device_attribute *attr, char *buf)
395 {
396 struct w83793_data *data = w83793_update_device(dev);
397 return sprintf(buf, "%u\n", (data->beep_enable >> 1) & 0x01);
398 }
399
400 static ssize_t
401 store_beep_enable(struct device *dev, struct device_attribute *attr,
402 const char *buf, size_t count)
403 {
404 struct i2c_client *client = to_i2c_client(dev);
405 struct w83793_data *data = i2c_get_clientdata(client);
406 u8 val = simple_strtoul(buf, NULL, 10);
407
408 if (val != 0 && val != 1)
409 return -EINVAL;
410
411 mutex_lock(&data->update_lock);
412 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP)
413 & 0xfd;
414 data->beep_enable |= val << 1;
415 w83793_write_value(client, W83793_REG_OVT_BEEP, data->beep_enable);
416 mutex_unlock(&data->update_lock);
417
418 return count;
419 }
420
421 /* Write any value to clear chassis alarm */
422 static ssize_t
423 store_chassis_clear_legacy(struct device *dev,
424 struct device_attribute *attr, const char *buf,
425 size_t count)
426 {
427 struct i2c_client *client = to_i2c_client(dev);
428 struct w83793_data *data = i2c_get_clientdata(client);
429 u8 val;
430
431 dev_warn(dev, "Attribute chassis is deprecated, "
432 "use intrusion0_alarm instead\n");
433
434 mutex_lock(&data->update_lock);
435 val = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
436 val |= 0x80;
437 w83793_write_value(client, W83793_REG_CLR_CHASSIS, val);
438 mutex_unlock(&data->update_lock);
439 return count;
440 }
441
442 /* Write 0 to clear chassis alarm */
443 static ssize_t
444 store_chassis_clear(struct device *dev,
445 struct device_attribute *attr, const char *buf,
446 size_t count)
447 {
448 struct i2c_client *client = to_i2c_client(dev);
449 struct w83793_data *data = i2c_get_clientdata(client);
450 unsigned long val;
451 u8 reg;
452
453 if (strict_strtoul(buf, 10, &val) || val != 0)
454 return -EINVAL;
455
456 mutex_lock(&data->update_lock);
457 reg = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
458 w83793_write_value(client, W83793_REG_CLR_CHASSIS, reg | 0x80);
459 data->valid = 0; /* Force cache refresh */
460 mutex_unlock(&data->update_lock);
461 return count;
462 }
463
464 #define FAN_INPUT 0
465 #define FAN_MIN 1
466 static ssize_t
467 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
468 {
469 struct sensor_device_attribute_2 *sensor_attr =
470 to_sensor_dev_attr_2(attr);
471 int nr = sensor_attr->nr;
472 int index = sensor_attr->index;
473 struct w83793_data *data = w83793_update_device(dev);
474 u16 val;
475
476 if (FAN_INPUT == nr) {
477 val = data->fan[index] & 0x0fff;
478 } else {
479 val = data->fan_min[index] & 0x0fff;
480 }
481
482 return sprintf(buf, "%lu\n", FAN_FROM_REG(val));
483 }
484
485 static ssize_t
486 store_fan_min(struct device *dev, struct device_attribute *attr,
487 const char *buf, size_t count)
488 {
489 struct sensor_device_attribute_2 *sensor_attr =
490 to_sensor_dev_attr_2(attr);
491 int index = sensor_attr->index;
492 struct i2c_client *client = to_i2c_client(dev);
493 struct w83793_data *data = i2c_get_clientdata(client);
494 u16 val = FAN_TO_REG(simple_strtoul(buf, NULL, 10));
495
496 mutex_lock(&data->update_lock);
497 data->fan_min[index] = val;
498 w83793_write_value(client, W83793_REG_FAN_MIN(index),
499 (val >> 8) & 0xff);
500 w83793_write_value(client, W83793_REG_FAN_MIN(index) + 1, val & 0xff);
501 mutex_unlock(&data->update_lock);
502
503 return count;
504 }
505
506 static ssize_t
507 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
508 {
509 struct sensor_device_attribute_2 *sensor_attr =
510 to_sensor_dev_attr_2(attr);
511 struct w83793_data *data = w83793_update_device(dev);
512 u16 val;
513 int nr = sensor_attr->nr;
514 int index = sensor_attr->index;
515
516 if (PWM_STOP_TIME == nr)
517 val = TIME_FROM_REG(data->pwm_stop_time[index]);
518 else
519 val = (data->pwm[index][nr] & 0x3f) << 2;
520
521 return sprintf(buf, "%d\n", val);
522 }
523
524 static ssize_t
525 store_pwm(struct device *dev, struct device_attribute *attr,
526 const char *buf, size_t count)
527 {
528 struct i2c_client *client = to_i2c_client(dev);
529 struct w83793_data *data = i2c_get_clientdata(client);
530 struct sensor_device_attribute_2 *sensor_attr =
531 to_sensor_dev_attr_2(attr);
532 int nr = sensor_attr->nr;
533 int index = sensor_attr->index;
534 u8 val;
535
536 mutex_lock(&data->update_lock);
537 if (PWM_STOP_TIME == nr) {
538 val = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
539 data->pwm_stop_time[index] = val;
540 w83793_write_value(client, W83793_REG_PWM_STOP_TIME(index),
541 val);
542 } else {
543 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff)
544 >> 2;
545 data->pwm[index][nr] =
546 w83793_read_value(client, W83793_REG_PWM(index, nr)) & 0xc0;
547 data->pwm[index][nr] |= val;
548 w83793_write_value(client, W83793_REG_PWM(index, nr),
549 data->pwm[index][nr]);
550 }
551
552 mutex_unlock(&data->update_lock);
553 return count;
554 }
555
556 static ssize_t
557 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
558 {
559 struct sensor_device_attribute_2 *sensor_attr =
560 to_sensor_dev_attr_2(attr);
561 int nr = sensor_attr->nr;
562 int index = sensor_attr->index;
563 struct w83793_data *data = w83793_update_device(dev);
564 long temp = TEMP_FROM_REG(data->temp[index][nr]);
565
566 if (TEMP_READ == nr && index < 4) { /* Only TD1-TD4 have low bits */
567 int low = ((data->temp_low_bits >> (index * 2)) & 0x03) * 250;
568 temp += temp > 0 ? low : -low;
569 }
570 return sprintf(buf, "%ld\n", temp);
571 }
572
573 static ssize_t
574 store_temp(struct device *dev, struct device_attribute *attr,
575 const char *buf, size_t count)
576 {
577 struct sensor_device_attribute_2 *sensor_attr =
578 to_sensor_dev_attr_2(attr);
579 int nr = sensor_attr->nr;
580 int index = sensor_attr->index;
581 struct i2c_client *client = to_i2c_client(dev);
582 struct w83793_data *data = i2c_get_clientdata(client);
583 long tmp = simple_strtol(buf, NULL, 10);
584
585 mutex_lock(&data->update_lock);
586 data->temp[index][nr] = TEMP_TO_REG(tmp, -128, 127);
587 w83793_write_value(client, W83793_REG_TEMP[index][nr],
588 data->temp[index][nr]);
589 mutex_unlock(&data->update_lock);
590 return count;
591 }
592
593 /*
594 TD1-TD4
595 each has 4 mode:(2 bits)
596 0: Stop monitor
597 1: Use internal temp sensor(default)
598 2: Reserved
599 3: Use sensor in Intel CPU and get result by PECI
600
601 TR1-TR2
602 each has 2 mode:(1 bit)
603 0: Disable temp sensor monitor
604 1: To enable temp sensors monitor
605 */
606
607 /* 0 disable, 6 PECI */
608 static u8 TO_TEMP_MODE[] = { 0, 0, 0, 6 };
609
610 static ssize_t
611 show_temp_mode(struct device *dev, struct device_attribute *attr, char *buf)
612 {
613 struct w83793_data *data = w83793_update_device(dev);
614 struct sensor_device_attribute_2 *sensor_attr =
615 to_sensor_dev_attr_2(attr);
616 int index = sensor_attr->index;
617 u8 mask = (index < 4) ? 0x03 : 0x01;
618 u8 shift = (index < 4) ? (2 * index) : (index - 4);
619 u8 tmp;
620 index = (index < 4) ? 0 : 1;
621
622 tmp = (data->temp_mode[index] >> shift) & mask;
623
624 /* for the internal sensor, found out if diode or thermistor */
625 if (tmp == 1) {
626 tmp = index == 0 ? 3 : 4;
627 } else {
628 tmp = TO_TEMP_MODE[tmp];
629 }
630
631 return sprintf(buf, "%d\n", tmp);
632 }
633
634 static ssize_t
635 store_temp_mode(struct device *dev, struct device_attribute *attr,
636 const char *buf, size_t count)
637 {
638 struct i2c_client *client = to_i2c_client(dev);
639 struct w83793_data *data = i2c_get_clientdata(client);
640 struct sensor_device_attribute_2 *sensor_attr =
641 to_sensor_dev_attr_2(attr);
642 int index = sensor_attr->index;
643 u8 mask = (index < 4) ? 0x03 : 0x01;
644 u8 shift = (index < 4) ? (2 * index) : (index - 4);
645 u8 val = simple_strtoul(buf, NULL, 10);
646
647 /* transform the sysfs interface values into table above */
648 if ((val == 6) && (index < 4)) {
649 val -= 3;
650 } else if ((val == 3 && index < 4)
651 || (val == 4 && index >= 4)) {
652 /* transform diode or thermistor into internal enable */
653 val = !!val;
654 } else {
655 return -EINVAL;
656 }
657
658 index = (index < 4) ? 0 : 1;
659 mutex_lock(&data->update_lock);
660 data->temp_mode[index] =
661 w83793_read_value(client, W83793_REG_TEMP_MODE[index]);
662 data->temp_mode[index] &= ~(mask << shift);
663 data->temp_mode[index] |= val << shift;
664 w83793_write_value(client, W83793_REG_TEMP_MODE[index],
665 data->temp_mode[index]);
666 mutex_unlock(&data->update_lock);
667
668 return count;
669 }
670
671 #define SETUP_PWM_DEFAULT 0
672 #define SETUP_PWM_UPTIME 1 /* Unit in 0.1s */
673 #define SETUP_PWM_DOWNTIME 2 /* Unit in 0.1s */
674 #define SETUP_TEMP_CRITICAL 3
675 static ssize_t
676 show_sf_setup(struct device *dev, struct device_attribute *attr, char *buf)
677 {
678 struct sensor_device_attribute_2 *sensor_attr =
679 to_sensor_dev_attr_2(attr);
680 int nr = sensor_attr->nr;
681 struct w83793_data *data = w83793_update_device(dev);
682 u32 val = 0;
683
684 if (SETUP_PWM_DEFAULT == nr) {
685 val = (data->pwm_default & 0x3f) << 2;
686 } else if (SETUP_PWM_UPTIME == nr) {
687 val = TIME_FROM_REG(data->pwm_uptime);
688 } else if (SETUP_PWM_DOWNTIME == nr) {
689 val = TIME_FROM_REG(data->pwm_downtime);
690 } else if (SETUP_TEMP_CRITICAL == nr) {
691 val = TEMP_FROM_REG(data->temp_critical & 0x7f);
692 }
693
694 return sprintf(buf, "%d\n", val);
695 }
696
697 static ssize_t
698 store_sf_setup(struct device *dev, struct device_attribute *attr,
699 const char *buf, size_t count)
700 {
701 struct sensor_device_attribute_2 *sensor_attr =
702 to_sensor_dev_attr_2(attr);
703 int nr = sensor_attr->nr;
704 struct i2c_client *client = to_i2c_client(dev);
705 struct w83793_data *data = i2c_get_clientdata(client);
706
707 mutex_lock(&data->update_lock);
708 if (SETUP_PWM_DEFAULT == nr) {
709 data->pwm_default =
710 w83793_read_value(client, W83793_REG_PWM_DEFAULT) & 0xc0;
711 data->pwm_default |= SENSORS_LIMIT(simple_strtoul(buf, NULL,
712 10),
713 0, 0xff) >> 2;
714 w83793_write_value(client, W83793_REG_PWM_DEFAULT,
715 data->pwm_default);
716 } else if (SETUP_PWM_UPTIME == nr) {
717 data->pwm_uptime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
718 data->pwm_uptime += data->pwm_uptime == 0 ? 1 : 0;
719 w83793_write_value(client, W83793_REG_PWM_UPTIME,
720 data->pwm_uptime);
721 } else if (SETUP_PWM_DOWNTIME == nr) {
722 data->pwm_downtime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
723 data->pwm_downtime += data->pwm_downtime == 0 ? 1 : 0;
724 w83793_write_value(client, W83793_REG_PWM_DOWNTIME,
725 data->pwm_downtime);
726 } else { /* SETUP_TEMP_CRITICAL */
727 data->temp_critical =
728 w83793_read_value(client, W83793_REG_TEMP_CRITICAL) & 0x80;
729 data->temp_critical |= TEMP_TO_REG(simple_strtol(buf, NULL, 10),
730 0, 0x7f);
731 w83793_write_value(client, W83793_REG_TEMP_CRITICAL,
732 data->temp_critical);
733 }
734
735 mutex_unlock(&data->update_lock);
736 return count;
737 }
738
739 /*
740 Temp SmartFan control
741 TEMP_FAN_MAP
742 Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1...
743 It's possible two or more temp channels control the same fan, w83793
744 always prefers to pick the most critical request and applies it to
745 the related Fan.
746 It's possible one fan is not in any mapping of 6 temp channels, this
747 means the fan is manual mode
748
749 TEMP_PWM_ENABLE
750 Each temp channel has its own SmartFan mode, and temp channel
751 control fans that are set by TEMP_FAN_MAP
752 0: SmartFanII mode
753 1: Thermal Cruise Mode
754
755 TEMP_CRUISE
756 Target temperature in thermal cruise mode, w83793 will try to turn
757 fan speed to keep the temperature of target device around this
758 temperature.
759
760 TEMP_TOLERANCE
761 If Temp higher or lower than target with this tolerance, w83793
762 will take actions to speed up or slow down the fan to keep the
763 temperature within the tolerance range.
764 */
765
766 #define TEMP_FAN_MAP 0
767 #define TEMP_PWM_ENABLE 1
768 #define TEMP_CRUISE 2
769 #define TEMP_TOLERANCE 3
770 static ssize_t
771 show_sf_ctrl(struct device *dev, struct device_attribute *attr, char *buf)
772 {
773 struct sensor_device_attribute_2 *sensor_attr =
774 to_sensor_dev_attr_2(attr);
775 int nr = sensor_attr->nr;
776 int index = sensor_attr->index;
777 struct w83793_data *data = w83793_update_device(dev);
778 u32 val;
779
780 if (TEMP_FAN_MAP == nr) {
781 val = data->temp_fan_map[index];
782 } else if (TEMP_PWM_ENABLE == nr) {
783 /* +2 to transfrom into 2 and 3 to conform with sysfs intf */
784 val = ((data->pwm_enable >> index) & 0x01) + 2;
785 } else if (TEMP_CRUISE == nr) {
786 val = TEMP_FROM_REG(data->temp_cruise[index] & 0x7f);
787 } else { /* TEMP_TOLERANCE */
788 val = data->tolerance[index >> 1] >> ((index & 0x01) ? 4 : 0);
789 val = TEMP_FROM_REG(val & 0x0f);
790 }
791 return sprintf(buf, "%d\n", val);
792 }
793
794 static ssize_t
795 store_sf_ctrl(struct device *dev, struct device_attribute *attr,
796 const char *buf, size_t count)
797 {
798 struct sensor_device_attribute_2 *sensor_attr =
799 to_sensor_dev_attr_2(attr);
800 int nr = sensor_attr->nr;
801 int index = sensor_attr->index;
802 struct i2c_client *client = to_i2c_client(dev);
803 struct w83793_data *data = i2c_get_clientdata(client);
804 u32 val;
805
806 mutex_lock(&data->update_lock);
807 if (TEMP_FAN_MAP == nr) {
808 val = simple_strtoul(buf, NULL, 10) & 0xff;
809 w83793_write_value(client, W83793_REG_TEMP_FAN_MAP(index), val);
810 data->temp_fan_map[index] = val;
811 } else if (TEMP_PWM_ENABLE == nr) {
812 val = simple_strtoul(buf, NULL, 10);
813 if (2 == val || 3 == val) {
814 data->pwm_enable =
815 w83793_read_value(client, W83793_REG_PWM_ENABLE);
816 if (val - 2)
817 data->pwm_enable |= 1 << index;
818 else
819 data->pwm_enable &= ~(1 << index);
820 w83793_write_value(client, W83793_REG_PWM_ENABLE,
821 data->pwm_enable);
822 } else {
823 mutex_unlock(&data->update_lock);
824 return -EINVAL;
825 }
826 } else if (TEMP_CRUISE == nr) {
827 data->temp_cruise[index] =
828 w83793_read_value(client, W83793_REG_TEMP_CRUISE(index));
829 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
830 data->temp_cruise[index] &= 0x80;
831 data->temp_cruise[index] |= val;
832
833 w83793_write_value(client, W83793_REG_TEMP_CRUISE(index),
834 data->temp_cruise[index]);
835 } else { /* TEMP_TOLERANCE */
836 int i = index >> 1;
837 u8 shift = (index & 0x01) ? 4 : 0;
838 data->tolerance[i] =
839 w83793_read_value(client, W83793_REG_TEMP_TOL(i));
840
841 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x0f);
842 data->tolerance[i] &= ~(0x0f << shift);
843 data->tolerance[i] |= val << shift;
844 w83793_write_value(client, W83793_REG_TEMP_TOL(i),
845 data->tolerance[i]);
846 }
847
848 mutex_unlock(&data->update_lock);
849 return count;
850 }
851
852 static ssize_t
853 show_sf2_pwm(struct device *dev, struct device_attribute *attr, char *buf)
854 {
855 struct sensor_device_attribute_2 *sensor_attr =
856 to_sensor_dev_attr_2(attr);
857 int nr = sensor_attr->nr;
858 int index = sensor_attr->index;
859 struct w83793_data *data = w83793_update_device(dev);
860
861 return sprintf(buf, "%d\n", (data->sf2_pwm[index][nr] & 0x3f) << 2);
862 }
863
864 static ssize_t
865 store_sf2_pwm(struct device *dev, struct device_attribute *attr,
866 const char *buf, size_t count)
867 {
868 struct i2c_client *client = to_i2c_client(dev);
869 struct w83793_data *data = i2c_get_clientdata(client);
870 struct sensor_device_attribute_2 *sensor_attr =
871 to_sensor_dev_attr_2(attr);
872 int nr = sensor_attr->nr;
873 int index = sensor_attr->index;
874 u8 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff) >> 2;
875
876 mutex_lock(&data->update_lock);
877 data->sf2_pwm[index][nr] =
878 w83793_read_value(client, W83793_REG_SF2_PWM(index, nr)) & 0xc0;
879 data->sf2_pwm[index][nr] |= val;
880 w83793_write_value(client, W83793_REG_SF2_PWM(index, nr),
881 data->sf2_pwm[index][nr]);
882 mutex_unlock(&data->update_lock);
883 return count;
884 }
885
886 static ssize_t
887 show_sf2_temp(struct device *dev, struct device_attribute *attr, char *buf)
888 {
889 struct sensor_device_attribute_2 *sensor_attr =
890 to_sensor_dev_attr_2(attr);
891 int nr = sensor_attr->nr;
892 int index = sensor_attr->index;
893 struct w83793_data *data = w83793_update_device(dev);
894
895 return sprintf(buf, "%ld\n",
896 TEMP_FROM_REG(data->sf2_temp[index][nr] & 0x7f));
897 }
898
899 static ssize_t
900 store_sf2_temp(struct device *dev, struct device_attribute *attr,
901 const char *buf, size_t count)
902 {
903 struct i2c_client *client = to_i2c_client(dev);
904 struct w83793_data *data = i2c_get_clientdata(client);
905 struct sensor_device_attribute_2 *sensor_attr =
906 to_sensor_dev_attr_2(attr);
907 int nr = sensor_attr->nr;
908 int index = sensor_attr->index;
909 u8 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
910
911 mutex_lock(&data->update_lock);
912 data->sf2_temp[index][nr] =
913 w83793_read_value(client, W83793_REG_SF2_TEMP(index, nr)) & 0x80;
914 data->sf2_temp[index][nr] |= val;
915 w83793_write_value(client, W83793_REG_SF2_TEMP(index, nr),
916 data->sf2_temp[index][nr]);
917 mutex_unlock(&data->update_lock);
918 return count;
919 }
920
921 /* only Vcore A/B and Vtt have additional 2 bits precision */
922 static ssize_t
923 show_in(struct device *dev, struct device_attribute *attr, char *buf)
924 {
925 struct sensor_device_attribute_2 *sensor_attr =
926 to_sensor_dev_attr_2(attr);
927 int nr = sensor_attr->nr;
928 int index = sensor_attr->index;
929 struct w83793_data *data = w83793_update_device(dev);
930 u16 val = data->in[index][nr];
931
932 if (index < 3) {
933 val <<= 2;
934 val += (data->in_low_bits[nr] >> (index * 2)) & 0x3;
935 }
936 /* voltage inputs 5VDD and 5VSB needs 150mV offset */
937 val = val * scale_in[index] + scale_in_add[index];
938 return sprintf(buf, "%d\n", val);
939 }
940
941 static ssize_t
942 store_in(struct device *dev, struct device_attribute *attr,
943 const char *buf, size_t count)
944 {
945 struct sensor_device_attribute_2 *sensor_attr =
946 to_sensor_dev_attr_2(attr);
947 int nr = sensor_attr->nr;
948 int index = sensor_attr->index;
949 struct i2c_client *client = to_i2c_client(dev);
950 struct w83793_data *data = i2c_get_clientdata(client);
951 u32 val;
952
953 val =
954 (simple_strtoul(buf, NULL, 10) +
955 scale_in[index] / 2) / scale_in[index];
956 mutex_lock(&data->update_lock);
957 if (index > 2) {
958 /* fix the limit values of 5VDD and 5VSB to ALARM mechanism */
959 if (1 == nr || 2 == nr) {
960 val -= scale_in_add[index] / scale_in[index];
961 }
962 val = SENSORS_LIMIT(val, 0, 255);
963 } else {
964 val = SENSORS_LIMIT(val, 0, 0x3FF);
965 data->in_low_bits[nr] =
966 w83793_read_value(client, W83793_REG_IN_LOW_BITS[nr]);
967 data->in_low_bits[nr] &= ~(0x03 << (2 * index));
968 data->in_low_bits[nr] |= (val & 0x03) << (2 * index);
969 w83793_write_value(client, W83793_REG_IN_LOW_BITS[nr],
970 data->in_low_bits[nr]);
971 val >>= 2;
972 }
973 data->in[index][nr] = val;
974 w83793_write_value(client, W83793_REG_IN[index][nr],
975 data->in[index][nr]);
976 mutex_unlock(&data->update_lock);
977 return count;
978 }
979
980 #define NOT_USED -1
981
982 #define SENSOR_ATTR_IN(index) \
983 SENSOR_ATTR_2(in##index##_input, S_IRUGO, show_in, NULL, \
984 IN_READ, index), \
985 SENSOR_ATTR_2(in##index##_max, S_IRUGO | S_IWUSR, show_in, \
986 store_in, IN_MAX, index), \
987 SENSOR_ATTR_2(in##index##_min, S_IRUGO | S_IWUSR, show_in, \
988 store_in, IN_LOW, index), \
989 SENSOR_ATTR_2(in##index##_alarm, S_IRUGO, show_alarm_beep, \
990 NULL, ALARM_STATUS, index + ((index > 2) ? 1 : 0)), \
991 SENSOR_ATTR_2(in##index##_beep, S_IWUSR | S_IRUGO, \
992 show_alarm_beep, store_beep, BEEP_ENABLE, \
993 index + ((index > 2) ? 1 : 0))
994
995 #define SENSOR_ATTR_FAN(index) \
996 SENSOR_ATTR_2(fan##index##_alarm, S_IRUGO, show_alarm_beep, \
997 NULL, ALARM_STATUS, index + 17), \
998 SENSOR_ATTR_2(fan##index##_beep, S_IWUSR | S_IRUGO, \
999 show_alarm_beep, store_beep, BEEP_ENABLE, index + 17), \
1000 SENSOR_ATTR_2(fan##index##_input, S_IRUGO, show_fan, \
1001 NULL, FAN_INPUT, index - 1), \
1002 SENSOR_ATTR_2(fan##index##_min, S_IWUSR | S_IRUGO, \
1003 show_fan, store_fan_min, FAN_MIN, index - 1)
1004
1005 #define SENSOR_ATTR_PWM(index) \
1006 SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm, \
1007 store_pwm, PWM_DUTY, index - 1), \
1008 SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO, \
1009 show_pwm, store_pwm, PWM_NONSTOP, index - 1), \
1010 SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO, \
1011 show_pwm, store_pwm, PWM_START, index - 1), \
1012 SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO, \
1013 show_pwm, store_pwm, PWM_STOP_TIME, index - 1)
1014
1015 #define SENSOR_ATTR_TEMP(index) \
1016 SENSOR_ATTR_2(temp##index##_type, S_IRUGO | S_IWUSR, \
1017 show_temp_mode, store_temp_mode, NOT_USED, index - 1), \
1018 SENSOR_ATTR_2(temp##index##_input, S_IRUGO, show_temp, \
1019 NULL, TEMP_READ, index - 1), \
1020 SENSOR_ATTR_2(temp##index##_max, S_IRUGO | S_IWUSR, show_temp, \
1021 store_temp, TEMP_CRIT, index - 1), \
1022 SENSOR_ATTR_2(temp##index##_max_hyst, S_IRUGO | S_IWUSR, \
1023 show_temp, store_temp, TEMP_CRIT_HYST, index - 1), \
1024 SENSOR_ATTR_2(temp##index##_warn, S_IRUGO | S_IWUSR, show_temp, \
1025 store_temp, TEMP_WARN, index - 1), \
1026 SENSOR_ATTR_2(temp##index##_warn_hyst, S_IRUGO | S_IWUSR, \
1027 show_temp, store_temp, TEMP_WARN_HYST, index - 1), \
1028 SENSOR_ATTR_2(temp##index##_alarm, S_IRUGO, \
1029 show_alarm_beep, NULL, ALARM_STATUS, index + 11), \
1030 SENSOR_ATTR_2(temp##index##_beep, S_IWUSR | S_IRUGO, \
1031 show_alarm_beep, store_beep, BEEP_ENABLE, index + 11), \
1032 SENSOR_ATTR_2(temp##index##_auto_channels_pwm, \
1033 S_IRUGO | S_IWUSR, show_sf_ctrl, store_sf_ctrl, \
1034 TEMP_FAN_MAP, index - 1), \
1035 SENSOR_ATTR_2(temp##index##_pwm_enable, S_IWUSR | S_IRUGO, \
1036 show_sf_ctrl, store_sf_ctrl, TEMP_PWM_ENABLE, \
1037 index - 1), \
1038 SENSOR_ATTR_2(thermal_cruise##index, S_IRUGO | S_IWUSR, \
1039 show_sf_ctrl, store_sf_ctrl, TEMP_CRUISE, index - 1), \
1040 SENSOR_ATTR_2(tolerance##index, S_IRUGO | S_IWUSR, show_sf_ctrl,\
1041 store_sf_ctrl, TEMP_TOLERANCE, index - 1), \
1042 SENSOR_ATTR_2(temp##index##_auto_point1_pwm, S_IRUGO | S_IWUSR, \
1043 show_sf2_pwm, store_sf2_pwm, 0, index - 1), \
1044 SENSOR_ATTR_2(temp##index##_auto_point2_pwm, S_IRUGO | S_IWUSR, \
1045 show_sf2_pwm, store_sf2_pwm, 1, index - 1), \
1046 SENSOR_ATTR_2(temp##index##_auto_point3_pwm, S_IRUGO | S_IWUSR, \
1047 show_sf2_pwm, store_sf2_pwm, 2, index - 1), \
1048 SENSOR_ATTR_2(temp##index##_auto_point4_pwm, S_IRUGO | S_IWUSR, \
1049 show_sf2_pwm, store_sf2_pwm, 3, index - 1), \
1050 SENSOR_ATTR_2(temp##index##_auto_point5_pwm, S_IRUGO | S_IWUSR, \
1051 show_sf2_pwm, store_sf2_pwm, 4, index - 1), \
1052 SENSOR_ATTR_2(temp##index##_auto_point6_pwm, S_IRUGO | S_IWUSR, \
1053 show_sf2_pwm, store_sf2_pwm, 5, index - 1), \
1054 SENSOR_ATTR_2(temp##index##_auto_point7_pwm, S_IRUGO | S_IWUSR, \
1055 show_sf2_pwm, store_sf2_pwm, 6, index - 1), \
1056 SENSOR_ATTR_2(temp##index##_auto_point1_temp, S_IRUGO | S_IWUSR,\
1057 show_sf2_temp, store_sf2_temp, 0, index - 1), \
1058 SENSOR_ATTR_2(temp##index##_auto_point2_temp, S_IRUGO | S_IWUSR,\
1059 show_sf2_temp, store_sf2_temp, 1, index - 1), \
1060 SENSOR_ATTR_2(temp##index##_auto_point3_temp, S_IRUGO | S_IWUSR,\
1061 show_sf2_temp, store_sf2_temp, 2, index - 1), \
1062 SENSOR_ATTR_2(temp##index##_auto_point4_temp, S_IRUGO | S_IWUSR,\
1063 show_sf2_temp, store_sf2_temp, 3, index - 1), \
1064 SENSOR_ATTR_2(temp##index##_auto_point5_temp, S_IRUGO | S_IWUSR,\
1065 show_sf2_temp, store_sf2_temp, 4, index - 1), \
1066 SENSOR_ATTR_2(temp##index##_auto_point6_temp, S_IRUGO | S_IWUSR,\
1067 show_sf2_temp, store_sf2_temp, 5, index - 1), \
1068 SENSOR_ATTR_2(temp##index##_auto_point7_temp, S_IRUGO | S_IWUSR,\
1069 show_sf2_temp, store_sf2_temp, 6, index - 1)
1070
1071 static struct sensor_device_attribute_2 w83793_sensor_attr_2[] = {
1072 SENSOR_ATTR_IN(0),
1073 SENSOR_ATTR_IN(1),
1074 SENSOR_ATTR_IN(2),
1075 SENSOR_ATTR_IN(3),
1076 SENSOR_ATTR_IN(4),
1077 SENSOR_ATTR_IN(5),
1078 SENSOR_ATTR_IN(6),
1079 SENSOR_ATTR_IN(7),
1080 SENSOR_ATTR_IN(8),
1081 SENSOR_ATTR_IN(9),
1082 SENSOR_ATTR_FAN(1),
1083 SENSOR_ATTR_FAN(2),
1084 SENSOR_ATTR_FAN(3),
1085 SENSOR_ATTR_FAN(4),
1086 SENSOR_ATTR_FAN(5),
1087 SENSOR_ATTR_PWM(1),
1088 SENSOR_ATTR_PWM(2),
1089 SENSOR_ATTR_PWM(3),
1090 };
1091
1092 static struct sensor_device_attribute_2 w83793_temp[] = {
1093 SENSOR_ATTR_TEMP(1),
1094 SENSOR_ATTR_TEMP(2),
1095 SENSOR_ATTR_TEMP(3),
1096 SENSOR_ATTR_TEMP(4),
1097 SENSOR_ATTR_TEMP(5),
1098 SENSOR_ATTR_TEMP(6),
1099 };
1100
1101 /* Fan6-Fan12 */
1102 static struct sensor_device_attribute_2 w83793_left_fan[] = {
1103 SENSOR_ATTR_FAN(6),
1104 SENSOR_ATTR_FAN(7),
1105 SENSOR_ATTR_FAN(8),
1106 SENSOR_ATTR_FAN(9),
1107 SENSOR_ATTR_FAN(10),
1108 SENSOR_ATTR_FAN(11),
1109 SENSOR_ATTR_FAN(12),
1110 };
1111
1112 /* Pwm4-Pwm8 */
1113 static struct sensor_device_attribute_2 w83793_left_pwm[] = {
1114 SENSOR_ATTR_PWM(4),
1115 SENSOR_ATTR_PWM(5),
1116 SENSOR_ATTR_PWM(6),
1117 SENSOR_ATTR_PWM(7),
1118 SENSOR_ATTR_PWM(8),
1119 };
1120
1121 static struct sensor_device_attribute_2 w83793_vid[] = {
1122 SENSOR_ATTR_2(cpu0_vid, S_IRUGO, show_vid, NULL, NOT_USED, 0),
1123 SENSOR_ATTR_2(cpu1_vid, S_IRUGO, show_vid, NULL, NOT_USED, 1),
1124 };
1125 static DEVICE_ATTR(vrm, S_IWUSR | S_IRUGO, show_vrm, store_vrm);
1126
1127 static struct sensor_device_attribute_2 sda_single_files[] = {
1128 SENSOR_ATTR_2(chassis, S_IWUSR | S_IRUGO, show_alarm_beep,
1129 store_chassis_clear_legacy, ALARM_STATUS, 30),
1130 SENSOR_ATTR_2(intrusion0_alarm, S_IWUSR | S_IRUGO, show_alarm_beep,
1131 store_chassis_clear, ALARM_STATUS, 30),
1132 SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable,
1133 store_beep_enable, NOT_USED, NOT_USED),
1134 SENSOR_ATTR_2(pwm_default, S_IWUSR | S_IRUGO, show_sf_setup,
1135 store_sf_setup, SETUP_PWM_DEFAULT, NOT_USED),
1136 SENSOR_ATTR_2(pwm_uptime, S_IWUSR | S_IRUGO, show_sf_setup,
1137 store_sf_setup, SETUP_PWM_UPTIME, NOT_USED),
1138 SENSOR_ATTR_2(pwm_downtime, S_IWUSR | S_IRUGO, show_sf_setup,
1139 store_sf_setup, SETUP_PWM_DOWNTIME, NOT_USED),
1140 SENSOR_ATTR_2(temp_critical, S_IWUSR | S_IRUGO, show_sf_setup,
1141 store_sf_setup, SETUP_TEMP_CRITICAL, NOT_USED),
1142 };
1143
1144 static void w83793_init_client(struct i2c_client *client)
1145 {
1146 if (reset) {
1147 w83793_write_value(client, W83793_REG_CONFIG, 0x80);
1148 }
1149
1150 /* Start monitoring */
1151 w83793_write_value(client, W83793_REG_CONFIG,
1152 w83793_read_value(client, W83793_REG_CONFIG) | 0x01);
1153 }
1154
1155 /*
1156 * Watchdog routines
1157 */
1158
1159 static int watchdog_set_timeout(struct w83793_data *data, int timeout)
1160 {
1161 int ret, mtimeout;
1162
1163 mtimeout = DIV_ROUND_UP(timeout, 60);
1164
1165 if (mtimeout > 255)
1166 return -EINVAL;
1167
1168 mutex_lock(&data->watchdog_lock);
1169 if (!data->client) {
1170 ret = -ENODEV;
1171 goto leave;
1172 }
1173
1174 data->watchdog_timeout = mtimeout;
1175
1176 /* Set Timeout value (in Minutes) */
1177 w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1178 data->watchdog_timeout);
1179
1180 ret = mtimeout * 60;
1181
1182 leave:
1183 mutex_unlock(&data->watchdog_lock);
1184 return ret;
1185 }
1186
1187 static int watchdog_get_timeout(struct w83793_data *data)
1188 {
1189 int timeout;
1190
1191 mutex_lock(&data->watchdog_lock);
1192 timeout = data->watchdog_timeout * 60;
1193 mutex_unlock(&data->watchdog_lock);
1194
1195 return timeout;
1196 }
1197
1198 static int watchdog_trigger(struct w83793_data *data)
1199 {
1200 int ret = 0;
1201
1202 mutex_lock(&data->watchdog_lock);
1203 if (!data->client) {
1204 ret = -ENODEV;
1205 goto leave;
1206 }
1207
1208 /* Set Timeout value (in Minutes) */
1209 w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1210 data->watchdog_timeout);
1211
1212 leave:
1213 mutex_unlock(&data->watchdog_lock);
1214 return ret;
1215 }
1216
1217 static int watchdog_enable(struct w83793_data *data)
1218 {
1219 int ret = 0;
1220
1221 mutex_lock(&data->watchdog_lock);
1222 if (!data->client) {
1223 ret = -ENODEV;
1224 goto leave;
1225 }
1226
1227 /* Set initial timeout */
1228 w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1229 data->watchdog_timeout);
1230
1231 /* Enable Soft Watchdog */
1232 w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0x55);
1233
1234 leave:
1235 mutex_unlock(&data->watchdog_lock);
1236 return ret;
1237 }
1238
1239 static int watchdog_disable(struct w83793_data *data)
1240 {
1241 int ret = 0;
1242
1243 mutex_lock(&data->watchdog_lock);
1244 if (!data->client) {
1245 ret = -ENODEV;
1246 goto leave;
1247 }
1248
1249 /* Disable Soft Watchdog */
1250 w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0xAA);
1251
1252 leave:
1253 mutex_unlock(&data->watchdog_lock);
1254 return ret;
1255 }
1256
1257 static int watchdog_open(struct inode *inode, struct file *filp)
1258 {
1259 struct w83793_data *pos, *data = NULL;
1260 int watchdog_is_open;
1261
1262 /* We get called from drivers/char/misc.c with misc_mtx hold, and we
1263 call misc_register() from w83793_probe() with watchdog_data_mutex
1264 hold, as misc_register() takes the misc_mtx lock, this is a possible
1265 deadlock, so we use mutex_trylock here. */
1266 if (!mutex_trylock(&watchdog_data_mutex))
1267 return -ERESTARTSYS;
1268 list_for_each_entry(pos, &watchdog_data_list, list) {
1269 if (pos->watchdog_miscdev.minor == iminor(inode)) {
1270 data = pos;
1271 break;
1272 }
1273 }
1274
1275 /* Check, if device is already open */
1276 watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
1277
1278 /* Increase data reference counter (if not already done).
1279 Note we can never not have found data, so we don't check for this */
1280 if (!watchdog_is_open)
1281 kref_get(&data->kref);
1282
1283 mutex_unlock(&watchdog_data_mutex);
1284
1285 /* Check, if device is already open and possibly issue error */
1286 if (watchdog_is_open)
1287 return -EBUSY;
1288
1289 /* Enable Soft Watchdog */
1290 watchdog_enable(data);
1291
1292 /* Store pointer to data into filp's private data */
1293 filp->private_data = data;
1294
1295 return nonseekable_open(inode, filp);
1296 }
1297
1298 static int watchdog_close(struct inode *inode, struct file *filp)
1299 {
1300 struct w83793_data *data = filp->private_data;
1301
1302 if (data->watchdog_expect_close) {
1303 watchdog_disable(data);
1304 data->watchdog_expect_close = 0;
1305 } else {
1306 watchdog_trigger(data);
1307 dev_crit(&data->client->dev,
1308 "unexpected close, not stopping watchdog!\n");
1309 }
1310
1311 clear_bit(0, &data->watchdog_is_open);
1312
1313 /* Decrease data reference counter */
1314 mutex_lock(&watchdog_data_mutex);
1315 kref_put(&data->kref, w83793_release_resources);
1316 mutex_unlock(&watchdog_data_mutex);
1317
1318 return 0;
1319 }
1320
1321 static ssize_t watchdog_write(struct file *filp, const char __user *buf,
1322 size_t count, loff_t *offset)
1323 {
1324 ssize_t ret;
1325 struct w83793_data *data = filp->private_data;
1326
1327 if (count) {
1328 if (!nowayout) {
1329 size_t i;
1330
1331 /* Clear it in case it was set with a previous write */
1332 data->watchdog_expect_close = 0;
1333
1334 for (i = 0; i != count; i++) {
1335 char c;
1336 if (get_user(c, buf + i))
1337 return -EFAULT;
1338 if (c == 'V')
1339 data->watchdog_expect_close = 1;
1340 }
1341 }
1342 ret = watchdog_trigger(data);
1343 if (ret < 0)
1344 return ret;
1345 }
1346 return count;
1347 }
1348
1349 static long watchdog_ioctl(struct file *filp, unsigned int cmd,
1350 unsigned long arg)
1351 {
1352 struct watchdog_info ident = {
1353 .options = WDIOF_KEEPALIVEPING |
1354 WDIOF_SETTIMEOUT |
1355 WDIOF_CARDRESET,
1356 .identity = "w83793 watchdog"
1357 };
1358
1359 int val, ret = 0;
1360 struct w83793_data *data = filp->private_data;
1361
1362 switch (cmd) {
1363 case WDIOC_GETSUPPORT:
1364 if (!nowayout)
1365 ident.options |= WDIOF_MAGICCLOSE;
1366 if (copy_to_user((void __user *)arg, &ident, sizeof(ident)))
1367 ret = -EFAULT;
1368 break;
1369
1370 case WDIOC_GETSTATUS:
1371 val = data->watchdog_caused_reboot ? WDIOF_CARDRESET : 0;
1372 ret = put_user(val, (int __user *)arg);
1373 break;
1374
1375 case WDIOC_GETBOOTSTATUS:
1376 ret = put_user(0, (int __user *)arg);
1377 break;
1378
1379 case WDIOC_KEEPALIVE:
1380 ret = watchdog_trigger(data);
1381 break;
1382
1383 case WDIOC_GETTIMEOUT:
1384 val = watchdog_get_timeout(data);
1385 ret = put_user(val, (int __user *)arg);
1386 break;
1387
1388 case WDIOC_SETTIMEOUT:
1389 if (get_user(val, (int __user *)arg)) {
1390 ret = -EFAULT;
1391 break;
1392 }
1393 ret = watchdog_set_timeout(data, val);
1394 if (ret > 0)
1395 ret = put_user(ret, (int __user *)arg);
1396 break;
1397
1398 case WDIOC_SETOPTIONS:
1399 if (get_user(val, (int __user *)arg)) {
1400 ret = -EFAULT;
1401 break;
1402 }
1403
1404 if (val & WDIOS_DISABLECARD)
1405 ret = watchdog_disable(data);
1406 else if (val & WDIOS_ENABLECARD)
1407 ret = watchdog_enable(data);
1408 else
1409 ret = -EINVAL;
1410
1411 break;
1412 default:
1413 ret = -ENOTTY;
1414 }
1415 return ret;
1416 }
1417
1418 static const struct file_operations watchdog_fops = {
1419 .owner = THIS_MODULE,
1420 .llseek = no_llseek,
1421 .open = watchdog_open,
1422 .release = watchdog_close,
1423 .write = watchdog_write,
1424 .unlocked_ioctl = watchdog_ioctl,
1425 };
1426
1427 /*
1428 * Notifier for system down
1429 */
1430
1431 static int watchdog_notify_sys(struct notifier_block *this, unsigned long code,
1432 void *unused)
1433 {
1434 struct w83793_data *data = NULL;
1435
1436 if (code == SYS_DOWN || code == SYS_HALT) {
1437
1438 /* Disable each registered watchdog */
1439 mutex_lock(&watchdog_data_mutex);
1440 list_for_each_entry(data, &watchdog_data_list, list) {
1441 if (data->watchdog_miscdev.minor)
1442 watchdog_disable(data);
1443 }
1444 mutex_unlock(&watchdog_data_mutex);
1445 }
1446
1447 return NOTIFY_DONE;
1448 }
1449
1450 /*
1451 * The WDT needs to learn about soft shutdowns in order to
1452 * turn the timebomb registers off.
1453 */
1454
1455 static struct notifier_block watchdog_notifier = {
1456 .notifier_call = watchdog_notify_sys,
1457 };
1458
1459 /*
1460 * Init / remove routines
1461 */
1462
1463 static int w83793_remove(struct i2c_client *client)
1464 {
1465 struct w83793_data *data = i2c_get_clientdata(client);
1466 struct device *dev = &client->dev;
1467 int i, tmp;
1468
1469 /* Unregister the watchdog (if registered) */
1470 if (data->watchdog_miscdev.minor) {
1471 misc_deregister(&data->watchdog_miscdev);
1472
1473 if (data->watchdog_is_open) {
1474 dev_warn(&client->dev,
1475 "i2c client detached with watchdog open! "
1476 "Stopping watchdog.\n");
1477 watchdog_disable(data);
1478 }
1479
1480 mutex_lock(&watchdog_data_mutex);
1481 list_del(&data->list);
1482 mutex_unlock(&watchdog_data_mutex);
1483
1484 /* Tell the watchdog code the client is gone */
1485 mutex_lock(&data->watchdog_lock);
1486 data->client = NULL;
1487 mutex_unlock(&data->watchdog_lock);
1488 }
1489
1490 /* Reset Configuration Register to Disable Watch Dog Registers */
1491 tmp = w83793_read_value(client, W83793_REG_CONFIG);
1492 w83793_write_value(client, W83793_REG_CONFIG, tmp & ~0x04);
1493
1494 unregister_reboot_notifier(&watchdog_notifier);
1495
1496 hwmon_device_unregister(data->hwmon_dev);
1497
1498 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1499 device_remove_file(dev,
1500 &w83793_sensor_attr_2[i].dev_attr);
1501
1502 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1503 device_remove_file(dev, &sda_single_files[i].dev_attr);
1504
1505 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1506 device_remove_file(dev, &w83793_vid[i].dev_attr);
1507 device_remove_file(dev, &dev_attr_vrm);
1508
1509 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1510 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1511
1512 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1513 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1514
1515 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1516 device_remove_file(dev, &w83793_temp[i].dev_attr);
1517
1518 if (data->lm75[0] != NULL)
1519 i2c_unregister_device(data->lm75[0]);
1520 if (data->lm75[1] != NULL)
1521 i2c_unregister_device(data->lm75[1]);
1522
1523 /* Decrease data reference counter */
1524 mutex_lock(&watchdog_data_mutex);
1525 kref_put(&data->kref, w83793_release_resources);
1526 mutex_unlock(&watchdog_data_mutex);
1527
1528 return 0;
1529 }
1530
1531 static int
1532 w83793_detect_subclients(struct i2c_client *client)
1533 {
1534 int i, id, err;
1535 int address = client->addr;
1536 u8 tmp;
1537 struct i2c_adapter *adapter = client->adapter;
1538 struct w83793_data *data = i2c_get_clientdata(client);
1539
1540 id = i2c_adapter_id(adapter);
1541 if (force_subclients[0] == id && force_subclients[1] == address) {
1542 for (i = 2; i <= 3; i++) {
1543 if (force_subclients[i] < 0x48
1544 || force_subclients[i] > 0x4f) {
1545 dev_err(&client->dev,
1546 "invalid subclient "
1547 "address %d; must be 0x48-0x4f\n",
1548 force_subclients[i]);
1549 err = -EINVAL;
1550 goto ERROR_SC_0;
1551 }
1552 }
1553 w83793_write_value(client, W83793_REG_I2C_SUBADDR,
1554 (force_subclients[2] & 0x07) |
1555 ((force_subclients[3] & 0x07) << 4));
1556 }
1557
1558 tmp = w83793_read_value(client, W83793_REG_I2C_SUBADDR);
1559 if (!(tmp & 0x08)) {
1560 data->lm75[0] = i2c_new_dummy(adapter, 0x48 + (tmp & 0x7));
1561 }
1562 if (!(tmp & 0x80)) {
1563 if ((data->lm75[0] != NULL)
1564 && ((tmp & 0x7) == ((tmp >> 4) & 0x7))) {
1565 dev_err(&client->dev,
1566 "duplicate addresses 0x%x, "
1567 "use force_subclients\n", data->lm75[0]->addr);
1568 err = -ENODEV;
1569 goto ERROR_SC_1;
1570 }
1571 data->lm75[1] = i2c_new_dummy(adapter,
1572 0x48 + ((tmp >> 4) & 0x7));
1573 }
1574
1575 return 0;
1576
1577 /* Undo inits in case of errors */
1578
1579 ERROR_SC_1:
1580 if (data->lm75[0] != NULL)
1581 i2c_unregister_device(data->lm75[0]);
1582 ERROR_SC_0:
1583 return err;
1584 }
1585
1586 /* Return 0 if detection is successful, -ENODEV otherwise */
1587 static int w83793_detect(struct i2c_client *client,
1588 struct i2c_board_info *info)
1589 {
1590 u8 tmp, bank, chip_id;
1591 struct i2c_adapter *adapter = client->adapter;
1592 unsigned short address = client->addr;
1593
1594 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1595 return -ENODEV;
1596 }
1597
1598 bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1599
1600 tmp = bank & 0x80 ? 0x5c : 0xa3;
1601 /* Check Winbond vendor ID */
1602 if (tmp != i2c_smbus_read_byte_data(client, W83793_REG_VENDORID)) {
1603 pr_debug("w83793: Detection failed at check vendor id\n");
1604 return -ENODEV;
1605 }
1606
1607 /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR
1608 should match */
1609 if ((bank & 0x07) == 0
1610 && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
1611 (address << 1)) {
1612 pr_debug("w83793: Detection failed at check i2c addr\n");
1613 return -ENODEV;
1614 }
1615
1616 /* Determine the chip type now */
1617 chip_id = i2c_smbus_read_byte_data(client, W83793_REG_CHIPID);
1618 if (chip_id != 0x7b)
1619 return -ENODEV;
1620
1621 strlcpy(info->type, "w83793", I2C_NAME_SIZE);
1622
1623 return 0;
1624 }
1625
1626 static int w83793_probe(struct i2c_client *client,
1627 const struct i2c_device_id *id)
1628 {
1629 struct device *dev = &client->dev;
1630 const int watchdog_minors[] = { WATCHDOG_MINOR, 212, 213, 214, 215 };
1631 struct w83793_data *data;
1632 int i, tmp, val, err;
1633 int files_fan = ARRAY_SIZE(w83793_left_fan) / 7;
1634 int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5;
1635 int files_temp = ARRAY_SIZE(w83793_temp) / 6;
1636
1637 data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL);
1638 if (!data) {
1639 err = -ENOMEM;
1640 goto exit;
1641 }
1642
1643 i2c_set_clientdata(client, data);
1644 data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1645 mutex_init(&data->update_lock);
1646 mutex_init(&data->watchdog_lock);
1647 INIT_LIST_HEAD(&data->list);
1648 kref_init(&data->kref);
1649
1650 /* Store client pointer in our data struct for watchdog usage
1651 (where the client is found through a data ptr instead of the
1652 otherway around) */
1653 data->client = client;
1654
1655 err = w83793_detect_subclients(client);
1656 if (err)
1657 goto free_mem;
1658
1659 /* Initialize the chip */
1660 w83793_init_client(client);
1661
1662 /*
1663 Only fan 1-5 has their own input pins,
1664 Pwm 1-3 has their own pins
1665 */
1666 data->has_fan = 0x1f;
1667 data->has_pwm = 0x07;
1668 tmp = w83793_read_value(client, W83793_REG_MFC);
1669 val = w83793_read_value(client, W83793_REG_FANIN_CTRL);
1670
1671 /* check the function of pins 49-56 */
1672 if (tmp & 0x80) {
1673 data->has_vid |= 0x2; /* has VIDB */
1674 } else {
1675 data->has_pwm |= 0x18; /* pwm 4,5 */
1676 if (val & 0x01) { /* fan 6 */
1677 data->has_fan |= 0x20;
1678 data->has_pwm |= 0x20;
1679 }
1680 if (val & 0x02) { /* fan 7 */
1681 data->has_fan |= 0x40;
1682 data->has_pwm |= 0x40;
1683 }
1684 if (!(tmp & 0x40) && (val & 0x04)) { /* fan 8 */
1685 data->has_fan |= 0x80;
1686 data->has_pwm |= 0x80;
1687 }
1688 }
1689
1690 /* check the function of pins 37-40 */
1691 if (!(tmp & 0x29))
1692 data->has_vid |= 0x1; /* has VIDA */
1693 if (0x08 == (tmp & 0x0c)) {
1694 if (val & 0x08) /* fan 9 */
1695 data->has_fan |= 0x100;
1696 if (val & 0x10) /* fan 10 */
1697 data->has_fan |= 0x200;
1698 }
1699 if (0x20 == (tmp & 0x30)) {
1700 if (val & 0x20) /* fan 11 */
1701 data->has_fan |= 0x400;
1702 if (val & 0x40) /* fan 12 */
1703 data->has_fan |= 0x800;
1704 }
1705
1706 if ((tmp & 0x01) && (val & 0x04)) { /* fan 8, second location */
1707 data->has_fan |= 0x80;
1708 data->has_pwm |= 0x80;
1709 }
1710
1711 tmp = w83793_read_value(client, W83793_REG_FANIN_SEL);
1712 if ((tmp & 0x01) && (val & 0x08)) { /* fan 9, second location */
1713 data->has_fan |= 0x100;
1714 }
1715 if ((tmp & 0x02) && (val & 0x10)) { /* fan 10, second location */
1716 data->has_fan |= 0x200;
1717 }
1718 if ((tmp & 0x04) && (val & 0x20)) { /* fan 11, second location */
1719 data->has_fan |= 0x400;
1720 }
1721 if ((tmp & 0x08) && (val & 0x40)) { /* fan 12, second location */
1722 data->has_fan |= 0x800;
1723 }
1724
1725 /* check the temp1-6 mode, ignore former AMDSI selected inputs */
1726 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[0]);
1727 if (tmp & 0x01)
1728 data->has_temp |= 0x01;
1729 if (tmp & 0x04)
1730 data->has_temp |= 0x02;
1731 if (tmp & 0x10)
1732 data->has_temp |= 0x04;
1733 if (tmp & 0x40)
1734 data->has_temp |= 0x08;
1735
1736 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[1]);
1737 if (tmp & 0x01)
1738 data->has_temp |= 0x10;
1739 if (tmp & 0x02)
1740 data->has_temp |= 0x20;
1741
1742 /* Register sysfs hooks */
1743 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) {
1744 err = device_create_file(dev,
1745 &w83793_sensor_attr_2[i].dev_attr);
1746 if (err)
1747 goto exit_remove;
1748 }
1749
1750 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) {
1751 if (!(data->has_vid & (1 << i)))
1752 continue;
1753 err = device_create_file(dev, &w83793_vid[i].dev_attr);
1754 if (err)
1755 goto exit_remove;
1756 }
1757 if (data->has_vid) {
1758 data->vrm = vid_which_vrm();
1759 err = device_create_file(dev, &dev_attr_vrm);
1760 if (err)
1761 goto exit_remove;
1762 }
1763
1764 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) {
1765 err = device_create_file(dev, &sda_single_files[i].dev_attr);
1766 if (err)
1767 goto exit_remove;
1768
1769 }
1770
1771 for (i = 0; i < 6; i++) {
1772 int j;
1773 if (!(data->has_temp & (1 << i)))
1774 continue;
1775 for (j = 0; j < files_temp; j++) {
1776 err = device_create_file(dev,
1777 &w83793_temp[(i) * files_temp
1778 + j].dev_attr);
1779 if (err)
1780 goto exit_remove;
1781 }
1782 }
1783
1784 for (i = 5; i < 12; i++) {
1785 int j;
1786 if (!(data->has_fan & (1 << i)))
1787 continue;
1788 for (j = 0; j < files_fan; j++) {
1789 err = device_create_file(dev,
1790 &w83793_left_fan[(i - 5) * files_fan
1791 + j].dev_attr);
1792 if (err)
1793 goto exit_remove;
1794 }
1795 }
1796
1797 for (i = 3; i < 8; i++) {
1798 int j;
1799 if (!(data->has_pwm & (1 << i)))
1800 continue;
1801 for (j = 0; j < files_pwm; j++) {
1802 err = device_create_file(dev,
1803 &w83793_left_pwm[(i - 3) * files_pwm
1804 + j].dev_attr);
1805 if (err)
1806 goto exit_remove;
1807 }
1808 }
1809
1810 data->hwmon_dev = hwmon_device_register(dev);
1811 if (IS_ERR(data->hwmon_dev)) {
1812 err = PTR_ERR(data->hwmon_dev);
1813 goto exit_remove;
1814 }
1815
1816 /* Watchdog initialization */
1817
1818 /* Register boot notifier */
1819 err = register_reboot_notifier(&watchdog_notifier);
1820 if (err != 0) {
1821 dev_err(&client->dev,
1822 "cannot register reboot notifier (err=%d)\n", err);
1823 goto exit_devunreg;
1824 }
1825
1826 /* Enable Watchdog registers.
1827 Set Configuration Register to Enable Watch Dog Registers
1828 (Bit 2) = XXXX, X1XX. */
1829 tmp = w83793_read_value(client, W83793_REG_CONFIG);
1830 w83793_write_value(client, W83793_REG_CONFIG, tmp | 0x04);
1831
1832 /* Set the default watchdog timeout */
1833 data->watchdog_timeout = timeout;
1834
1835 /* Check, if last reboot was caused by watchdog */
1836 data->watchdog_caused_reboot =
1837 w83793_read_value(data->client, W83793_REG_WDT_STATUS) & 0x01;
1838
1839 /* Disable Soft Watchdog during initialiation */
1840 watchdog_disable(data);
1841
1842 /* We take the data_mutex lock early so that watchdog_open() cannot
1843 run when misc_register() has completed, but we've not yet added
1844 our data to the watchdog_data_list (and set the default timeout) */
1845 mutex_lock(&watchdog_data_mutex);
1846 for (i = 0; i < ARRAY_SIZE(watchdog_minors); i++) {
1847 /* Register our watchdog part */
1848 snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1849 "watchdog%c", (i == 0) ? '\0' : ('0' + i));
1850 data->watchdog_miscdev.name = data->watchdog_name;
1851 data->watchdog_miscdev.fops = &watchdog_fops;
1852 data->watchdog_miscdev.minor = watchdog_minors[i];
1853
1854 err = misc_register(&data->watchdog_miscdev);
1855 if (err == -EBUSY)
1856 continue;
1857 if (err) {
1858 data->watchdog_miscdev.minor = 0;
1859 dev_err(&client->dev,
1860 "Registering watchdog chardev: %d\n", err);
1861 break;
1862 }
1863
1864 list_add(&data->list, &watchdog_data_list);
1865
1866 dev_info(&client->dev,
1867 "Registered watchdog chardev major 10, minor: %d\n",
1868 watchdog_minors[i]);
1869 break;
1870 }
1871 if (i == ARRAY_SIZE(watchdog_minors)) {
1872 data->watchdog_miscdev.minor = 0;
1873 dev_warn(&client->dev, "Couldn't register watchdog chardev "
1874 "(due to no free minor)\n");
1875 }
1876
1877 mutex_unlock(&watchdog_data_mutex);
1878
1879 return 0;
1880
1881 /* Unregister hwmon device */
1882
1883 exit_devunreg:
1884
1885 hwmon_device_unregister(data->hwmon_dev);
1886
1887 /* Unregister sysfs hooks */
1888
1889 exit_remove:
1890 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1891 device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr);
1892
1893 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1894 device_remove_file(dev, &sda_single_files[i].dev_attr);
1895
1896 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1897 device_remove_file(dev, &w83793_vid[i].dev_attr);
1898
1899 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1900 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1901
1902 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1903 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1904
1905 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1906 device_remove_file(dev, &w83793_temp[i].dev_attr);
1907
1908 if (data->lm75[0] != NULL)
1909 i2c_unregister_device(data->lm75[0]);
1910 if (data->lm75[1] != NULL)
1911 i2c_unregister_device(data->lm75[1]);
1912 free_mem:
1913 kfree(data);
1914 exit:
1915 return err;
1916 }
1917
1918 static void w83793_update_nonvolatile(struct device *dev)
1919 {
1920 struct i2c_client *client = to_i2c_client(dev);
1921 struct w83793_data *data = i2c_get_clientdata(client);
1922 int i, j;
1923 /*
1924 They are somewhat "stable" registers, and to update them everytime
1925 takes so much time, it's just not worthy. Update them in a long
1926 interval to avoid exception.
1927 */
1928 if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1929 || !data->valid))
1930 return;
1931 /* update voltage limits */
1932 for (i = 1; i < 3; i++) {
1933 for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1934 data->in[j][i] =
1935 w83793_read_value(client, W83793_REG_IN[j][i]);
1936 }
1937 data->in_low_bits[i] =
1938 w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]);
1939 }
1940
1941 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1942 /* Update the Fan measured value and limits */
1943 if (!(data->has_fan & (1 << i))) {
1944 continue;
1945 }
1946 data->fan_min[i] =
1947 w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8;
1948 data->fan_min[i] |=
1949 w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1);
1950 }
1951
1952 for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1953 if (!(data->has_temp & (1 << i)))
1954 continue;
1955 data->temp_fan_map[i] =
1956 w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i));
1957 for (j = 1; j < 5; j++) {
1958 data->temp[i][j] =
1959 w83793_read_value(client, W83793_REG_TEMP[i][j]);
1960 }
1961 data->temp_cruise[i] =
1962 w83793_read_value(client, W83793_REG_TEMP_CRUISE(i));
1963 for (j = 0; j < 7; j++) {
1964 data->sf2_pwm[i][j] =
1965 w83793_read_value(client, W83793_REG_SF2_PWM(i, j));
1966 data->sf2_temp[i][j] =
1967 w83793_read_value(client,
1968 W83793_REG_SF2_TEMP(i, j));
1969 }
1970 }
1971
1972 for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1973 data->temp_mode[i] =
1974 w83793_read_value(client, W83793_REG_TEMP_MODE[i]);
1975
1976 for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1977 data->tolerance[i] =
1978 w83793_read_value(client, W83793_REG_TEMP_TOL(i));
1979 }
1980
1981 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1982 if (!(data->has_pwm & (1 << i)))
1983 continue;
1984 data->pwm[i][PWM_NONSTOP] =
1985 w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP));
1986 data->pwm[i][PWM_START] =
1987 w83793_read_value(client, W83793_REG_PWM(i, PWM_START));
1988 data->pwm_stop_time[i] =
1989 w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i));
1990 }
1991
1992 data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
1993 data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
1994 data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
1995 data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
1996 data->temp_critical =
1997 w83793_read_value(client, W83793_REG_TEMP_CRITICAL);
1998 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
1999
2000 for (i = 0; i < ARRAY_SIZE(data->beeps); i++) {
2001 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
2002 }
2003
2004 data->last_nonvolatile = jiffies;
2005 }
2006
2007 static struct w83793_data *w83793_update_device(struct device *dev)
2008 {
2009 struct i2c_client *client = to_i2c_client(dev);
2010 struct w83793_data *data = i2c_get_clientdata(client);
2011 int i;
2012
2013 mutex_lock(&data->update_lock);
2014
2015 if (!(time_after(jiffies, data->last_updated + HZ * 2)
2016 || !data->valid))
2017 goto END;
2018
2019 /* Update the voltages measured value and limits */
2020 for (i = 0; i < ARRAY_SIZE(data->in); i++)
2021 data->in[i][IN_READ] =
2022 w83793_read_value(client, W83793_REG_IN[i][IN_READ]);
2023
2024 data->in_low_bits[IN_READ] =
2025 w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]);
2026
2027 for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
2028 if (!(data->has_fan & (1 << i))) {
2029 continue;
2030 }
2031 data->fan[i] =
2032 w83793_read_value(client, W83793_REG_FAN(i)) << 8;
2033 data->fan[i] |=
2034 w83793_read_value(client, W83793_REG_FAN(i) + 1);
2035 }
2036
2037 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
2038 if (!(data->has_temp & (1 << i)))
2039 continue;
2040 data->temp[i][TEMP_READ] =
2041 w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]);
2042 }
2043
2044 data->temp_low_bits =
2045 w83793_read_value(client, W83793_REG_TEMP_LOW_BITS);
2046
2047 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
2048 if (data->has_pwm & (1 << i))
2049 data->pwm[i][PWM_DUTY] =
2050 w83793_read_value(client,
2051 W83793_REG_PWM(i, PWM_DUTY));
2052 }
2053
2054 for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
2055 data->alarms[i] =
2056 w83793_read_value(client, W83793_REG_ALARM(i));
2057 if (data->has_vid & 0x01)
2058 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
2059 if (data->has_vid & 0x02)
2060 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
2061 w83793_update_nonvolatile(dev);
2062 data->last_updated = jiffies;
2063 data->valid = 1;
2064
2065 END:
2066 mutex_unlock(&data->update_lock);
2067 return data;
2068 }
2069
2070 /* Ignore the possibility that somebody change bank outside the driver
2071 Must be called with data->update_lock held, except during initialization */
2072 static u8 w83793_read_value(struct i2c_client *client, u16 reg)
2073 {
2074 struct w83793_data *data = i2c_get_clientdata(client);
2075 u8 res = 0xff;
2076 u8 new_bank = reg >> 8;
2077
2078 new_bank |= data->bank & 0xfc;
2079 if (data->bank != new_bank) {
2080 if (i2c_smbus_write_byte_data
2081 (client, W83793_REG_BANKSEL, new_bank) >= 0)
2082 data->bank = new_bank;
2083 else {
2084 dev_err(&client->dev,
2085 "set bank to %d failed, fall back "
2086 "to bank %d, read reg 0x%x error\n",
2087 new_bank, data->bank, reg);
2088 res = 0x0; /* read 0x0 from the chip */
2089 goto END;
2090 }
2091 }
2092 res = i2c_smbus_read_byte_data(client, reg & 0xff);
2093 END:
2094 return res;
2095 }
2096
2097 /* Must be called with data->update_lock held, except during initialization */
2098 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value)
2099 {
2100 struct w83793_data *data = i2c_get_clientdata(client);
2101 int res;
2102 u8 new_bank = reg >> 8;
2103
2104 new_bank |= data->bank & 0xfc;
2105 if (data->bank != new_bank) {
2106 if ((res = i2c_smbus_write_byte_data
2107 (client, W83793_REG_BANKSEL, new_bank)) >= 0)
2108 data->bank = new_bank;
2109 else {
2110 dev_err(&client->dev,
2111 "set bank to %d failed, fall back "
2112 "to bank %d, write reg 0x%x error\n",
2113 new_bank, data->bank, reg);
2114 goto END;
2115 }
2116 }
2117
2118 res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
2119 END:
2120 return res;
2121 }
2122
2123 static int __init sensors_w83793_init(void)
2124 {
2125 return i2c_add_driver(&w83793_driver);
2126 }
2127
2128 static void __exit sensors_w83793_exit(void)
2129 {
2130 i2c_del_driver(&w83793_driver);
2131 }
2132
2133 MODULE_AUTHOR("Yuan Mu, Sven Anders");
2134 MODULE_DESCRIPTION("w83793 driver");
2135 MODULE_LICENSE("GPL");
2136
2137 module_init(sensors_w83793_init);
2138 module_exit(sensors_w83793_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree