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