?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial commit
[wrt350n-kernel.git] / drivers / hwmon / w83793.c
blob3ba1d6b334730e06a5ac30c7fddd54f4e97f7a78
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
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation - version 2.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301 USA.
20 */
21
22 /*
23 Supports following chips:
24
25 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
26 w83793 10 12 8 6 0x7b 0x5ca3 yes no
27 */
28
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/i2c.h>
33 #include <linux/hwmon.h>
34 #include <linux/hwmon-vid.h>
35 #include <linux/hwmon-sysfs.h>
36 #include <linux/err.h>
37 #include <linux/mutex.h>
38
39 /* Addresses to scan */
40 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END };
41
42 /* Insmod parameters */
43 I2C_CLIENT_INSMOD_1(w83793);
44 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
45 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
46
47 static int reset;
48 module_param(reset, bool, 0);
49 MODULE_PARM_DESC(reset, "Set to 1 to reset chip, not recommended");
50
51 /*
52 Address 0x00, 0x0d, 0x0e, 0x0f in all three banks are reserved
53 as ID, Bank Select registers
54 */
55 #define W83793_REG_BANKSEL 0x00
56 #define W83793_REG_VENDORID 0x0d
57 #define W83793_REG_CHIPID 0x0e
58 #define W83793_REG_DEVICEID 0x0f
59
60 #define W83793_REG_CONFIG 0x40
61 #define W83793_REG_MFC 0x58
62 #define W83793_REG_FANIN_CTRL 0x5c
63 #define W83793_REG_FANIN_SEL 0x5d
64 #define W83793_REG_I2C_ADDR 0x0b
65 #define W83793_REG_I2C_SUBADDR 0x0c
66 #define W83793_REG_VID_INA 0x05
67 #define W83793_REG_VID_INB 0x06
68 #define W83793_REG_VID_LATCHA 0x07
69 #define W83793_REG_VID_LATCHB 0x08
70 #define W83793_REG_VID_CTRL 0x59
71
72 static u16 W83793_REG_TEMP_MODE[2] = { 0x5e, 0x5f };
73
74 #define TEMP_READ 0
75 #define TEMP_CRIT 1
76 #define TEMP_CRIT_HYST 2
77 #define TEMP_WARN 3
78 #define TEMP_WARN_HYST 4
79 /* only crit and crit_hyst affect real-time alarm status
80 current crit crit_hyst warn warn_hyst */
81 static u16 W83793_REG_TEMP[][5] = {
82 {0x1c, 0x78, 0x79, 0x7a, 0x7b},
83 {0x1d, 0x7c, 0x7d, 0x7e, 0x7f},
84 {0x1e, 0x80, 0x81, 0x82, 0x83},
85 {0x1f, 0x84, 0x85, 0x86, 0x87},
86 {0x20, 0x88, 0x89, 0x8a, 0x8b},
87 {0x21, 0x8c, 0x8d, 0x8e, 0x8f},
88 };
89
90 #define W83793_REG_TEMP_LOW_BITS 0x22
91
92 #define W83793_REG_BEEP(index) (0x53 + (index))
93 #define W83793_REG_ALARM(index) (0x4b + (index))
94
95 #define W83793_REG_CLR_CHASSIS 0x4a /* SMI MASK4 */
96 #define W83793_REG_IRQ_CTRL 0x50
97 #define W83793_REG_OVT_CTRL 0x51
98 #define W83793_REG_OVT_BEEP 0x52
99
100 #define IN_READ 0
101 #define IN_MAX 1
102 #define IN_LOW 2
103 static const u16 W83793_REG_IN[][3] = {
104 /* Current, High, Low */
105 {0x10, 0x60, 0x61}, /* Vcore A */
106 {0x11, 0x62, 0x63}, /* Vcore B */
107 {0x12, 0x64, 0x65}, /* Vtt */
108 {0x14, 0x6a, 0x6b}, /* VSEN1 */
109 {0x15, 0x6c, 0x6d}, /* VSEN2 */
110 {0x16, 0x6e, 0x6f}, /* +3VSEN */
111 {0x17, 0x70, 0x71}, /* +12VSEN */
112 {0x18, 0x72, 0x73}, /* 5VDD */
113 {0x19, 0x74, 0x75}, /* 5VSB */
114 {0x1a, 0x76, 0x77}, /* VBAT */
115 };
116
117 /* Low Bits of Vcore A/B Vtt Read/High/Low */
118 static const u16 W83793_REG_IN_LOW_BITS[] = { 0x1b, 0x68, 0x69 };
119 static u8 scale_in[] = { 2, 2, 2, 16, 16, 16, 8, 24, 24, 16 };
120 static u8 scale_in_add[] = { 0, 0, 0, 0, 0, 0, 0, 150, 150, 0 };
121
122 #define W83793_REG_FAN(index) (0x23 + 2 * (index)) /* High byte */
123 #define W83793_REG_FAN_MIN(index) (0x90 + 2 * (index)) /* High byte */
124
125 #define W83793_REG_PWM_DEFAULT 0xb2
126 #define W83793_REG_PWM_ENABLE 0x207
127 #define W83793_REG_PWM_UPTIME 0xc3 /* Unit in 0.1 second */
128 #define W83793_REG_PWM_DOWNTIME 0xc4 /* Unit in 0.1 second */
129 #define W83793_REG_TEMP_CRITICAL 0xc5
130
131 #define PWM_DUTY 0
132 #define PWM_START 1
133 #define PWM_NONSTOP 2
134 #define PWM_STOP_TIME 3
135 #define W83793_REG_PWM(index, nr) (((nr) == 0 ? 0xb3 : \
136 (nr) == 1 ? 0x220 : 0x218) + (index))
137
138 /* bit field, fan1 is bit0, fan2 is bit1 ... */
139 #define W83793_REG_TEMP_FAN_MAP(index) (0x201 + (index))
140 #define W83793_REG_TEMP_TOL(index) (0x208 + (index))
141 #define W83793_REG_TEMP_CRUISE(index) (0x210 + (index))
142 #define W83793_REG_PWM_STOP_TIME(index) (0x228 + (index))
143 #define W83793_REG_SF2_TEMP(index, nr) (0x230 + ((index) << 4) + (nr))
144 #define W83793_REG_SF2_PWM(index, nr) (0x238 + ((index) << 4) + (nr))
145
146 static inline unsigned long FAN_FROM_REG(u16 val)
147 {
148 if ((val >= 0xfff) || (val == 0))
149 return 0;
150 return (1350000UL / val);
151 }
152
153 static inline u16 FAN_TO_REG(long rpm)
154 {
155 if (rpm <= 0)
156 return 0x0fff;
157 return SENSORS_LIMIT((1350000 + (rpm >> 1)) / rpm, 1, 0xffe);
158 }
159
160 static inline unsigned long TIME_FROM_REG(u8 reg)
161 {
162 return (reg * 100);
163 }
164
165 static inline u8 TIME_TO_REG(unsigned long val)
166 {
167 return SENSORS_LIMIT((val + 50) / 100, 0, 0xff);
168 }
169
170 static inline long TEMP_FROM_REG(s8 reg)
171 {
172 return (reg * 1000);
173 }
174
175 static inline s8 TEMP_TO_REG(long val, s8 min, s8 max)
176 {
177 return SENSORS_LIMIT((val + (val < 0 ? -500 : 500)) / 1000, min, max);
178 }
179
180 struct w83793_data {
181 struct i2c_client client;
182 struct i2c_client *lm75[2];
183 struct device *hwmon_dev;
184 struct mutex update_lock;
185 char valid; /* !=0 if following fields are valid */
186 unsigned long last_updated; /* In jiffies */
187 unsigned long last_nonvolatile; /* In jiffies, last time we update the
188 nonvolatile registers */
189
190 u8 bank;
191 u8 vrm;
192 u8 vid[2];
193 u8 in[10][3]; /* Register value, read/high/low */
194 u8 in_low_bits[3]; /* Additional resolution for VCore A/B Vtt */
195
196 u16 has_fan; /* Only fan1- fan5 has own pins */
197 u16 fan[12]; /* Register value combine */
198 u16 fan_min[12]; /* Register value combine */
199
200 s8 temp[6][5]; /* current, crit, crit_hyst,warn, warn_hyst */
201 u8 temp_low_bits; /* Additional resolution TD1-TD4 */
202 u8 temp_mode[2]; /* byte 0: Temp D1-D4 mode each has 2 bits
203 byte 1: Temp R1,R2 mode, each has 1 bit */
204 u8 temp_critical; /* If reached all fan will be at full speed */
205 u8 temp_fan_map[6]; /* Temp controls which pwm fan, bit field */
206
207 u8 has_pwm;
208 u8 has_temp;
209 u8 has_vid;
210 u8 pwm_enable; /* Register value, each Temp has 1 bit */
211 u8 pwm_uptime; /* Register value */
212 u8 pwm_downtime; /* Register value */
213 u8 pwm_default; /* All fan default pwm, next poweron valid */
214 u8 pwm[8][3]; /* Register value */
215 u8 pwm_stop_time[8];
216 u8 temp_cruise[6];
217
218 u8 alarms[5]; /* realtime status registers */
219 u8 beeps[5];
220 u8 beep_enable;
221 u8 tolerance[3]; /* Temp tolerance(Smart Fan I/II) */
222 u8 sf2_pwm[6][7]; /* Smart FanII: Fan duty cycle */
223 u8 sf2_temp[6][7]; /* Smart FanII: Temp level point */
224 };
225
226 static u8 w83793_read_value(struct i2c_client *client, u16 reg);
227 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value);
228 static int w83793_attach_adapter(struct i2c_adapter *adapter);
229 static int w83793_detect(struct i2c_adapter *adapter, int address, int kind);
230 static int w83793_detach_client(struct i2c_client *client);
231 static void w83793_init_client(struct i2c_client *client);
232 static void w83793_update_nonvolatile(struct device *dev);
233 static struct w83793_data *w83793_update_device(struct device *dev);
234
235 static struct i2c_driver w83793_driver = {
236 .driver = {
237 .name = "w83793",
238 },
239 .attach_adapter = w83793_attach_adapter,
240 .detach_client = w83793_detach_client,
241 };
242
243 static ssize_t
244 show_vrm(struct device *dev, struct device_attribute *attr, char *buf)
245 {
246 struct w83793_data *data = dev_get_drvdata(dev);
247 return sprintf(buf, "%d\n", data->vrm);
248 }
249
250 static ssize_t
251 show_vid(struct device *dev, struct device_attribute *attr, char *buf)
252 {
253 struct w83793_data *data = w83793_update_device(dev);
254 struct sensor_device_attribute_2 *sensor_attr =
255 to_sensor_dev_attr_2(attr);
256 int index = sensor_attr->index;
257
258 return sprintf(buf, "%d\n", vid_from_reg(data->vid[index], data->vrm));
259 }
260
261 static ssize_t
262 store_vrm(struct device *dev, struct device_attribute *attr,
263 const char *buf, size_t count)
264 {
265 struct w83793_data *data = dev_get_drvdata(dev);
266 data->vrm = simple_strtoul(buf, NULL, 10);
267 return count;
268 }
269
270 #define ALARM_STATUS 0
271 #define BEEP_ENABLE 1
272 static ssize_t
273 show_alarm_beep(struct device *dev, struct device_attribute *attr, char *buf)
274 {
275 struct w83793_data *data = w83793_update_device(dev);
276 struct sensor_device_attribute_2 *sensor_attr =
277 to_sensor_dev_attr_2(attr);
278 int nr = sensor_attr->nr;
279 int index = sensor_attr->index >> 3;
280 int bit = sensor_attr->index & 0x07;
281 u8 val;
282
283 if (ALARM_STATUS == nr) {
284 val = (data->alarms[index] >> (bit)) & 1;
285 } else { /* BEEP_ENABLE */
286 val = (data->beeps[index] >> (bit)) & 1;
287 }
288
289 return sprintf(buf, "%u\n", val);
290 }
291
292 static ssize_t
293 store_beep(struct device *dev, struct device_attribute *attr,
294 const char *buf, size_t count)
295 {
296 struct i2c_client *client = to_i2c_client(dev);
297 struct w83793_data *data = i2c_get_clientdata(client);
298 struct sensor_device_attribute_2 *sensor_attr =
299 to_sensor_dev_attr_2(attr);
300 int index = sensor_attr->index >> 3;
301 int shift = sensor_attr->index & 0x07;
302 u8 beep_bit = 1 << shift;
303 u8 val;
304
305 val = simple_strtoul(buf, NULL, 10);
306 if (val != 0 && val != 1)
307 return -EINVAL;
308
309 mutex_lock(&data->update_lock);
310 data->beeps[index] = w83793_read_value(client, W83793_REG_BEEP(index));
311 data->beeps[index] &= ~beep_bit;
312 data->beeps[index] |= val << shift;
313 w83793_write_value(client, W83793_REG_BEEP(index), data->beeps[index]);
314 mutex_unlock(&data->update_lock);
315
316 return count;
317 }
318
319 static ssize_t
320 show_beep_enable(struct device *dev, struct device_attribute *attr, char *buf)
321 {
322 struct w83793_data *data = w83793_update_device(dev);
323 return sprintf(buf, "%u\n", (data->beep_enable >> 1) & 0x01);
324 }
325
326 static ssize_t
327 store_beep_enable(struct device *dev, struct device_attribute *attr,
328 const char *buf, size_t count)
329 {
330 struct i2c_client *client = to_i2c_client(dev);
331 struct w83793_data *data = i2c_get_clientdata(client);
332 u8 val = simple_strtoul(buf, NULL, 10);
333
334 if (val != 0 && val != 1)
335 return -EINVAL;
336
337 mutex_lock(&data->update_lock);
338 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP)
339 & 0xfd;
340 data->beep_enable |= val << 1;
341 w83793_write_value(client, W83793_REG_OVT_BEEP, data->beep_enable);
342 mutex_unlock(&data->update_lock);
343
344 return count;
345 }
346
347 /* Write any value to clear chassis alarm */
348 static ssize_t
349 store_chassis_clear(struct device *dev,
350 struct device_attribute *attr, const char *buf,
351 size_t count)
352 {
353 struct i2c_client *client = to_i2c_client(dev);
354 struct w83793_data *data = i2c_get_clientdata(client);
355 u8 val;
356
357 mutex_lock(&data->update_lock);
358 val = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
359 val |= 0x80;
360 w83793_write_value(client, W83793_REG_CLR_CHASSIS, val);
361 mutex_unlock(&data->update_lock);
362 return count;
363 }
364
365 #define FAN_INPUT 0
366 #define FAN_MIN 1
367 static ssize_t
368 show_fan(struct device *dev, struct device_attribute *attr, char *buf)
369 {
370 struct sensor_device_attribute_2 *sensor_attr =
371 to_sensor_dev_attr_2(attr);
372 int nr = sensor_attr->nr;
373 int index = sensor_attr->index;
374 struct w83793_data *data = w83793_update_device(dev);
375 u16 val;
376
377 if (FAN_INPUT == nr) {
378 val = data->fan[index] & 0x0fff;
379 } else {
380 val = data->fan_min[index] & 0x0fff;
381 }
382
383 return sprintf(buf, "%lu\n", FAN_FROM_REG(val));
384 }
385
386 static ssize_t
387 store_fan_min(struct device *dev, struct device_attribute *attr,
388 const char *buf, size_t count)
389 {
390 struct sensor_device_attribute_2 *sensor_attr =
391 to_sensor_dev_attr_2(attr);
392 int index = sensor_attr->index;
393 struct i2c_client *client = to_i2c_client(dev);
394 struct w83793_data *data = i2c_get_clientdata(client);
395 u16 val = FAN_TO_REG(simple_strtoul(buf, NULL, 10));
396
397 mutex_lock(&data->update_lock);
398 data->fan_min[index] = val;
399 w83793_write_value(client, W83793_REG_FAN_MIN(index),
400 (val >> 8) & 0xff);
401 w83793_write_value(client, W83793_REG_FAN_MIN(index) + 1, val & 0xff);
402 mutex_unlock(&data->update_lock);
403
404 return count;
405 }
406
407 static ssize_t
408 show_pwm(struct device *dev, struct device_attribute *attr, char *buf)
409 {
410 struct sensor_device_attribute_2 *sensor_attr =
411 to_sensor_dev_attr_2(attr);
412 struct w83793_data *data = w83793_update_device(dev);
413 u16 val;
414 int nr = sensor_attr->nr;
415 int index = sensor_attr->index;
416
417 if (PWM_STOP_TIME == nr)
418 val = TIME_FROM_REG(data->pwm_stop_time[index]);
419 else
420 val = (data->pwm[index][nr] & 0x3f) << 2;
421
422 return sprintf(buf, "%d\n", val);
423 }
424
425 static ssize_t
426 store_pwm(struct device *dev, struct device_attribute *attr,
427 const char *buf, size_t count)
428 {
429 struct i2c_client *client = to_i2c_client(dev);
430 struct w83793_data *data = i2c_get_clientdata(client);
431 struct sensor_device_attribute_2 *sensor_attr =
432 to_sensor_dev_attr_2(attr);
433 int nr = sensor_attr->nr;
434 int index = sensor_attr->index;
435 u8 val;
436
437 mutex_lock(&data->update_lock);
438 if (PWM_STOP_TIME == nr) {
439 val = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
440 data->pwm_stop_time[index] = val;
441 w83793_write_value(client, W83793_REG_PWM_STOP_TIME(index),
442 val);
443 } else {
444 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff)
445 >> 2;
446 data->pwm[index][nr] =
447 w83793_read_value(client, W83793_REG_PWM(index, nr)) & 0xc0;
448 data->pwm[index][nr] |= val;
449 w83793_write_value(client, W83793_REG_PWM(index, nr),
450 data->pwm[index][nr]);
451 }
452
453 mutex_unlock(&data->update_lock);
454 return count;
455 }
456
457 static ssize_t
458 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
459 {
460 struct sensor_device_attribute_2 *sensor_attr =
461 to_sensor_dev_attr_2(attr);
462 int nr = sensor_attr->nr;
463 int index = sensor_attr->index;
464 struct w83793_data *data = w83793_update_device(dev);
465 long temp = TEMP_FROM_REG(data->temp[index][nr]);
466
467 if (TEMP_READ == nr && index < 4) { /* Only TD1-TD4 have low bits */
468 int low = ((data->temp_low_bits >> (index * 2)) & 0x03) * 250;
469 temp += temp > 0 ? low : -low;
470 }
471 return sprintf(buf, "%ld\n", temp);
472 }
473
474 static ssize_t
475 store_temp(struct device *dev, struct device_attribute *attr,
476 const char *buf, size_t count)
477 {
478 struct sensor_device_attribute_2 *sensor_attr =
479 to_sensor_dev_attr_2(attr);
480 int nr = sensor_attr->nr;
481 int index = sensor_attr->index;
482 struct i2c_client *client = to_i2c_client(dev);
483 struct w83793_data *data = i2c_get_clientdata(client);
484 long tmp = simple_strtol(buf, NULL, 10);
485
486 mutex_lock(&data->update_lock);
487 data->temp[index][nr] = TEMP_TO_REG(tmp, -128, 127);
488 w83793_write_value(client, W83793_REG_TEMP[index][nr],
489 data->temp[index][nr]);
490 mutex_unlock(&data->update_lock);
491 return count;
492 }
493
494 /*
495 TD1-TD4
496 each has 4 mode:(2 bits)
497 0: Stop monitor
498 1: Use internal temp sensor(default)
499 2: Reserved
500 3: Use sensor in Intel CPU and get result by PECI
501
502 TR1-TR2
503 each has 2 mode:(1 bit)
504 0: Disable temp sensor monitor
505 1: To enable temp sensors monitor
506 */
507
508 /* 0 disable, 6 PECI */
509 static u8 TO_TEMP_MODE[] = { 0, 0, 0, 6 };
510
511 static ssize_t
512 show_temp_mode(struct device *dev, struct device_attribute *attr, char *buf)
513 {
514 struct w83793_data *data = w83793_update_device(dev);
515 struct sensor_device_attribute_2 *sensor_attr =
516 to_sensor_dev_attr_2(attr);
517 int index = sensor_attr->index;
518 u8 mask = (index < 4) ? 0x03 : 0x01;
519 u8 shift = (index < 4) ? (2 * index) : (index - 4);
520 u8 tmp;
521 index = (index < 4) ? 0 : 1;
522
523 tmp = (data->temp_mode[index] >> shift) & mask;
524
525 /* for the internal sensor, found out if diode or thermistor */
526 if (tmp == 1) {
527 tmp = index == 0 ? 3 : 4;
528 } else {
529 tmp = TO_TEMP_MODE[tmp];
530 }
531
532 return sprintf(buf, "%d\n", tmp);
533 }
534
535 static ssize_t
536 store_temp_mode(struct device *dev, struct device_attribute *attr,
537 const char *buf, size_t count)
538 {
539 struct i2c_client *client = to_i2c_client(dev);
540 struct w83793_data *data = i2c_get_clientdata(client);
541 struct sensor_device_attribute_2 *sensor_attr =
542 to_sensor_dev_attr_2(attr);
543 int index = sensor_attr->index;
544 u8 mask = (index < 4) ? 0x03 : 0x01;
545 u8 shift = (index < 4) ? (2 * index) : (index - 4);
546 u8 val = simple_strtoul(buf, NULL, 10);
547
548 /* transform the sysfs interface values into table above */
549 if ((val == 6) && (index < 4)) {
550 val -= 3;
551 } else if ((val == 3 && index < 4)
552 || (val == 4 && index >= 4)) {
553 /* transform diode or thermistor into internal enable */
554 val = !!val;
555 } else {
556 return -EINVAL;
557 }
558
559 index = (index < 4) ? 0 : 1;
560 mutex_lock(&data->update_lock);
561 data->temp_mode[index] =
562 w83793_read_value(client, W83793_REG_TEMP_MODE[index]);
563 data->temp_mode[index] &= ~(mask << shift);
564 data->temp_mode[index] |= val << shift;
565 w83793_write_value(client, W83793_REG_TEMP_MODE[index],
566 data->temp_mode[index]);
567 mutex_unlock(&data->update_lock);
568
569 return count;
570 }
571
572 #define SETUP_PWM_DEFAULT 0
573 #define SETUP_PWM_UPTIME 1 /* Unit in 0.1s */
574 #define SETUP_PWM_DOWNTIME 2 /* Unit in 0.1s */
575 #define SETUP_TEMP_CRITICAL 3
576 static ssize_t
577 show_sf_setup(struct device *dev, struct device_attribute *attr, char *buf)
578 {
579 struct sensor_device_attribute_2 *sensor_attr =
580 to_sensor_dev_attr_2(attr);
581 int nr = sensor_attr->nr;
582 struct w83793_data *data = w83793_update_device(dev);
583 u32 val = 0;
584
585 if (SETUP_PWM_DEFAULT == nr) {
586 val = (data->pwm_default & 0x3f) << 2;
587 } else if (SETUP_PWM_UPTIME == nr) {
588 val = TIME_FROM_REG(data->pwm_uptime);
589 } else if (SETUP_PWM_DOWNTIME == nr) {
590 val = TIME_FROM_REG(data->pwm_downtime);
591 } else if (SETUP_TEMP_CRITICAL == nr) {
592 val = TEMP_FROM_REG(data->temp_critical & 0x7f);
593 }
594
595 return sprintf(buf, "%d\n", val);
596 }
597
598 static ssize_t
599 store_sf_setup(struct device *dev, struct device_attribute *attr,
600 const char *buf, size_t count)
601 {
602 struct sensor_device_attribute_2 *sensor_attr =
603 to_sensor_dev_attr_2(attr);
604 int nr = sensor_attr->nr;
605 struct i2c_client *client = to_i2c_client(dev);
606 struct w83793_data *data = i2c_get_clientdata(client);
607
608 mutex_lock(&data->update_lock);
609 if (SETUP_PWM_DEFAULT == nr) {
610 data->pwm_default =
611 w83793_read_value(client, W83793_REG_PWM_DEFAULT) & 0xc0;
612 data->pwm_default |= SENSORS_LIMIT(simple_strtoul(buf, NULL,
613 10),
614 0, 0xff) >> 2;
615 w83793_write_value(client, W83793_REG_PWM_DEFAULT,
616 data->pwm_default);
617 } else if (SETUP_PWM_UPTIME == nr) {
618 data->pwm_uptime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
619 data->pwm_uptime += data->pwm_uptime == 0 ? 1 : 0;
620 w83793_write_value(client, W83793_REG_PWM_UPTIME,
621 data->pwm_uptime);
622 } else if (SETUP_PWM_DOWNTIME == nr) {
623 data->pwm_downtime = TIME_TO_REG(simple_strtoul(buf, NULL, 10));
624 data->pwm_downtime += data->pwm_downtime == 0 ? 1 : 0;
625 w83793_write_value(client, W83793_REG_PWM_DOWNTIME,
626 data->pwm_downtime);
627 } else { /* SETUP_TEMP_CRITICAL */
628 data->temp_critical =
629 w83793_read_value(client, W83793_REG_TEMP_CRITICAL) & 0x80;
630 data->temp_critical |= TEMP_TO_REG(simple_strtol(buf, NULL, 10),
631 0, 0x7f);
632 w83793_write_value(client, W83793_REG_TEMP_CRITICAL,
633 data->temp_critical);
634 }
635
636 mutex_unlock(&data->update_lock);
637 return count;
638 }
639
640 /*
641 Temp SmartFan control
642 TEMP_FAN_MAP
643 Temp channel control which pwm fan, bitfield, bit 0 indicate pwm1...
644 It's possible two or more temp channels control the same fan, w83793
645 always prefers to pick the most critical request and applies it to
646 the related Fan.
647 It's possible one fan is not in any mapping of 6 temp channels, this
648 means the fan is manual mode
649
650 TEMP_PWM_ENABLE
651 Each temp channel has its own SmartFan mode, and temp channel
652 control fans that are set by TEMP_FAN_MAP
653 0: SmartFanII mode
654 1: Thermal Cruise Mode
655
656 TEMP_CRUISE
657 Target temperature in thermal cruise mode, w83793 will try to turn
658 fan speed to keep the temperature of target device around this
659 temperature.
660
661 TEMP_TOLERANCE
662 If Temp higher or lower than target with this tolerance, w83793
663 will take actions to speed up or slow down the fan to keep the
664 temperature within the tolerance range.
665 */
666
667 #define TEMP_FAN_MAP 0
668 #define TEMP_PWM_ENABLE 1
669 #define TEMP_CRUISE 2
670 #define TEMP_TOLERANCE 3
671 static ssize_t
672 show_sf_ctrl(struct device *dev, struct device_attribute *attr, char *buf)
673 {
674 struct sensor_device_attribute_2 *sensor_attr =
675 to_sensor_dev_attr_2(attr);
676 int nr = sensor_attr->nr;
677 int index = sensor_attr->index;
678 struct w83793_data *data = w83793_update_device(dev);
679 u32 val;
680
681 if (TEMP_FAN_MAP == nr) {
682 val = data->temp_fan_map[index];
683 } else if (TEMP_PWM_ENABLE == nr) {
684 /* +2 to transfrom into 2 and 3 to conform with sysfs intf */
685 val = ((data->pwm_enable >> index) & 0x01) + 2;
686 } else if (TEMP_CRUISE == nr) {
687 val = TEMP_FROM_REG(data->temp_cruise[index] & 0x7f);
688 } else { /* TEMP_TOLERANCE */
689 val = data->tolerance[index >> 1] >> ((index & 0x01) ? 4 : 0);
690 val = TEMP_FROM_REG(val & 0x0f);
691 }
692 return sprintf(buf, "%d\n", val);
693 }
694
695 static ssize_t
696 store_sf_ctrl(struct device *dev, struct device_attribute *attr,
697 const char *buf, size_t count)
698 {
699 struct sensor_device_attribute_2 *sensor_attr =
700 to_sensor_dev_attr_2(attr);
701 int nr = sensor_attr->nr;
702 int index = sensor_attr->index;
703 struct i2c_client *client = to_i2c_client(dev);
704 struct w83793_data *data = i2c_get_clientdata(client);
705 u32 val;
706
707 mutex_lock(&data->update_lock);
708 if (TEMP_FAN_MAP == nr) {
709 val = simple_strtoul(buf, NULL, 10) & 0xff;
710 w83793_write_value(client, W83793_REG_TEMP_FAN_MAP(index), val);
711 data->temp_fan_map[index] = val;
712 } else if (TEMP_PWM_ENABLE == nr) {
713 val = simple_strtoul(buf, NULL, 10);
714 if (2 == val || 3 == val) {
715 data->pwm_enable =
716 w83793_read_value(client, W83793_REG_PWM_ENABLE);
717 if (val - 2)
718 data->pwm_enable |= 1 << index;
719 else
720 data->pwm_enable &= ~(1 << index);
721 w83793_write_value(client, W83793_REG_PWM_ENABLE,
722 data->pwm_enable);
723 } else {
724 mutex_unlock(&data->update_lock);
725 return -EINVAL;
726 }
727 } else if (TEMP_CRUISE == nr) {
728 data->temp_cruise[index] =
729 w83793_read_value(client, W83793_REG_TEMP_CRUISE(index));
730 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
731 data->temp_cruise[index] &= 0x80;
732 data->temp_cruise[index] |= val;
733
734 w83793_write_value(client, W83793_REG_TEMP_CRUISE(index),
735 data->temp_cruise[index]);
736 } else { /* TEMP_TOLERANCE */
737 int i = index >> 1;
738 u8 shift = (index & 0x01) ? 4 : 0;
739 data->tolerance[i] =
740 w83793_read_value(client, W83793_REG_TEMP_TOL(i));
741
742 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x0f);
743 data->tolerance[i] &= ~(0x0f << shift);
744 data->tolerance[i] |= val << shift;
745 w83793_write_value(client, W83793_REG_TEMP_TOL(i),
746 data->tolerance[i]);
747 }
748
749 mutex_unlock(&data->update_lock);
750 return count;
751 }
752
753 static ssize_t
754 show_sf2_pwm(struct device *dev, struct device_attribute *attr, char *buf)
755 {
756 struct sensor_device_attribute_2 *sensor_attr =
757 to_sensor_dev_attr_2(attr);
758 int nr = sensor_attr->nr;
759 int index = sensor_attr->index;
760 struct w83793_data *data = w83793_update_device(dev);
761
762 return sprintf(buf, "%d\n", (data->sf2_pwm[index][nr] & 0x3f) << 2);
763 }
764
765 static ssize_t
766 store_sf2_pwm(struct device *dev, struct device_attribute *attr,
767 const char *buf, size_t count)
768 {
769 struct i2c_client *client = to_i2c_client(dev);
770 struct w83793_data *data = i2c_get_clientdata(client);
771 struct sensor_device_attribute_2 *sensor_attr =
772 to_sensor_dev_attr_2(attr);
773 int nr = sensor_attr->nr;
774 int index = sensor_attr->index;
775 u8 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 0xff) >> 2;
776
777 mutex_lock(&data->update_lock);
778 data->sf2_pwm[index][nr] =
779 w83793_read_value(client, W83793_REG_SF2_PWM(index, nr)) & 0xc0;
780 data->sf2_pwm[index][nr] |= val;
781 w83793_write_value(client, W83793_REG_SF2_PWM(index, nr),
782 data->sf2_pwm[index][nr]);
783 mutex_unlock(&data->update_lock);
784 return count;
785 }
786
787 static ssize_t
788 show_sf2_temp(struct device *dev, struct device_attribute *attr, char *buf)
789 {
790 struct sensor_device_attribute_2 *sensor_attr =
791 to_sensor_dev_attr_2(attr);
792 int nr = sensor_attr->nr;
793 int index = sensor_attr->index;
794 struct w83793_data *data = w83793_update_device(dev);
795
796 return sprintf(buf, "%ld\n",
797 TEMP_FROM_REG(data->sf2_temp[index][nr] & 0x7f));
798 }
799
800 static ssize_t
801 store_sf2_temp(struct device *dev, struct device_attribute *attr,
802 const char *buf, size_t count)
803 {
804 struct i2c_client *client = to_i2c_client(dev);
805 struct w83793_data *data = i2c_get_clientdata(client);
806 struct sensor_device_attribute_2 *sensor_attr =
807 to_sensor_dev_attr_2(attr);
808 int nr = sensor_attr->nr;
809 int index = sensor_attr->index;
810 u8 val = TEMP_TO_REG(simple_strtol(buf, NULL, 10), 0, 0x7f);
811
812 mutex_lock(&data->update_lock);
813 data->sf2_temp[index][nr] =
814 w83793_read_value(client, W83793_REG_SF2_TEMP(index, nr)) & 0x80;
815 data->sf2_temp[index][nr] |= val;
816 w83793_write_value(client, W83793_REG_SF2_TEMP(index, nr),
817 data->sf2_temp[index][nr]);
818 mutex_unlock(&data->update_lock);
819 return count;
820 }
821
822 /* only Vcore A/B and Vtt have additional 2 bits precision */
823 static ssize_t
824 show_in(struct device *dev, struct device_attribute *attr, char *buf)
825 {
826 struct sensor_device_attribute_2 *sensor_attr =
827 to_sensor_dev_attr_2(attr);
828 int nr = sensor_attr->nr;
829 int index = sensor_attr->index;
830 struct w83793_data *data = w83793_update_device(dev);
831 u16 val = data->in[index][nr];
832
833 if (index < 3) {
834 val <<= 2;
835 val += (data->in_low_bits[nr] >> (index * 2)) & 0x3;
836 }
837 /* voltage inputs 5VDD and 5VSB needs 150mV offset */
838 val = val * scale_in[index] + scale_in_add[index];
839 return sprintf(buf, "%d\n", val);
840 }
841
842 static ssize_t
843 store_in(struct device *dev, struct device_attribute *attr,
844 const char *buf, size_t count)
845 {
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 struct i2c_client *client = to_i2c_client(dev);
851 struct w83793_data *data = i2c_get_clientdata(client);
852 u32 val;
853
854 val =
855 (simple_strtoul(buf, NULL, 10) +
856 scale_in[index] / 2) / scale_in[index];
857 mutex_lock(&data->update_lock);
858 if (index > 2) {
859 /* fix the limit values of 5VDD and 5VSB to ALARM mechanism */
860 if (1 == nr || 2 == nr) {
861 val -= scale_in_add[index] / scale_in[index];
862 }
863 val = SENSORS_LIMIT(val, 0, 255);
864 } else {
865 val = SENSORS_LIMIT(val, 0, 0x3FF);
866 data->in_low_bits[nr] =
867 w83793_read_value(client, W83793_REG_IN_LOW_BITS[nr]);
868 data->in_low_bits[nr] &= ~(0x03 << (2 * index));
869 data->in_low_bits[nr] |= (val & 0x03) << (2 * index);
870 w83793_write_value(client, W83793_REG_IN_LOW_BITS[nr],
871 data->in_low_bits[nr]);
872 val >>= 2;
873 }
874 data->in[index][nr] = val;
875 w83793_write_value(client, W83793_REG_IN[index][nr],
876 data->in[index][nr]);
877 mutex_unlock(&data->update_lock);
878 return count;
879 }
880
881 #define NOT_USED -1
882
883 #define SENSOR_ATTR_IN(index) \
884 SENSOR_ATTR_2(in##index##_input, S_IRUGO, show_in, NULL, \
885 IN_READ, index), \
886 SENSOR_ATTR_2(in##index##_max, S_IRUGO | S_IWUSR, show_in, \
887 store_in, IN_MAX, index), \
888 SENSOR_ATTR_2(in##index##_min, S_IRUGO | S_IWUSR, show_in, \
889 store_in, IN_LOW, index), \
890 SENSOR_ATTR_2(in##index##_alarm, S_IRUGO, show_alarm_beep, \
891 NULL, ALARM_STATUS, index + ((index > 2) ? 1 : 0)), \
892 SENSOR_ATTR_2(in##index##_beep, S_IWUSR | S_IRUGO, \
893 show_alarm_beep, store_beep, BEEP_ENABLE, \
894 index + ((index > 2) ? 1 : 0))
895
896 #define SENSOR_ATTR_FAN(index) \
897 SENSOR_ATTR_2(fan##index##_alarm, S_IRUGO, show_alarm_beep, \
898 NULL, ALARM_STATUS, index + 17), \
899 SENSOR_ATTR_2(fan##index##_beep, S_IWUSR | S_IRUGO, \
900 show_alarm_beep, store_beep, BEEP_ENABLE, index + 17), \
901 SENSOR_ATTR_2(fan##index##_input, S_IRUGO, show_fan, \
902 NULL, FAN_INPUT, index - 1), \
903 SENSOR_ATTR_2(fan##index##_min, S_IWUSR | S_IRUGO, \
904 show_fan, store_fan_min, FAN_MIN, index - 1)
905
906 #define SENSOR_ATTR_PWM(index) \
907 SENSOR_ATTR_2(pwm##index, S_IWUSR | S_IRUGO, show_pwm, \
908 store_pwm, PWM_DUTY, index - 1), \
909 SENSOR_ATTR_2(pwm##index##_nonstop, S_IWUSR | S_IRUGO, \
910 show_pwm, store_pwm, PWM_NONSTOP, index - 1), \
911 SENSOR_ATTR_2(pwm##index##_start, S_IWUSR | S_IRUGO, \
912 show_pwm, store_pwm, PWM_START, index - 1), \
913 SENSOR_ATTR_2(pwm##index##_stop_time, S_IWUSR | S_IRUGO, \
914 show_pwm, store_pwm, PWM_STOP_TIME, index - 1)
915
916 #define SENSOR_ATTR_TEMP(index) \
917 SENSOR_ATTR_2(temp##index##_type, S_IRUGO | S_IWUSR, \
918 show_temp_mode, store_temp_mode, NOT_USED, index - 1), \
919 SENSOR_ATTR_2(temp##index##_input, S_IRUGO, show_temp, \
920 NULL, TEMP_READ, index - 1), \
921 SENSOR_ATTR_2(temp##index##_max, S_IRUGO | S_IWUSR, show_temp, \
922 store_temp, TEMP_CRIT, index - 1), \
923 SENSOR_ATTR_2(temp##index##_max_hyst, S_IRUGO | S_IWUSR, \
924 show_temp, store_temp, TEMP_CRIT_HYST, index - 1), \
925 SENSOR_ATTR_2(temp##index##_warn, S_IRUGO | S_IWUSR, show_temp, \
926 store_temp, TEMP_WARN, index - 1), \
927 SENSOR_ATTR_2(temp##index##_warn_hyst, S_IRUGO | S_IWUSR, \
928 show_temp, store_temp, TEMP_WARN_HYST, index - 1), \
929 SENSOR_ATTR_2(temp##index##_alarm, S_IRUGO, \
930 show_alarm_beep, NULL, ALARM_STATUS, index + 11), \
931 SENSOR_ATTR_2(temp##index##_beep, S_IWUSR | S_IRUGO, \
932 show_alarm_beep, store_beep, BEEP_ENABLE, index + 11), \
933 SENSOR_ATTR_2(temp##index##_auto_channels_pwm, \
934 S_IRUGO | S_IWUSR, show_sf_ctrl, store_sf_ctrl, \
935 TEMP_FAN_MAP, index - 1), \
936 SENSOR_ATTR_2(temp##index##_pwm_enable, S_IWUSR | S_IRUGO, \
937 show_sf_ctrl, store_sf_ctrl, TEMP_PWM_ENABLE, \
938 index - 1), \
939 SENSOR_ATTR_2(thermal_cruise##index, S_IRUGO | S_IWUSR, \
940 show_sf_ctrl, store_sf_ctrl, TEMP_CRUISE, index - 1), \
941 SENSOR_ATTR_2(tolerance##index, S_IRUGO | S_IWUSR, show_sf_ctrl,\
942 store_sf_ctrl, TEMP_TOLERANCE, index - 1), \
943 SENSOR_ATTR_2(temp##index##_auto_point1_pwm, S_IRUGO | S_IWUSR, \
944 show_sf2_pwm, store_sf2_pwm, 0, index - 1), \
945 SENSOR_ATTR_2(temp##index##_auto_point2_pwm, S_IRUGO | S_IWUSR, \
946 show_sf2_pwm, store_sf2_pwm, 1, index - 1), \
947 SENSOR_ATTR_2(temp##index##_auto_point3_pwm, S_IRUGO | S_IWUSR, \
948 show_sf2_pwm, store_sf2_pwm, 2, index - 1), \
949 SENSOR_ATTR_2(temp##index##_auto_point4_pwm, S_IRUGO | S_IWUSR, \
950 show_sf2_pwm, store_sf2_pwm, 3, index - 1), \
951 SENSOR_ATTR_2(temp##index##_auto_point5_pwm, S_IRUGO | S_IWUSR, \
952 show_sf2_pwm, store_sf2_pwm, 4, index - 1), \
953 SENSOR_ATTR_2(temp##index##_auto_point6_pwm, S_IRUGO | S_IWUSR, \
954 show_sf2_pwm, store_sf2_pwm, 5, index - 1), \
955 SENSOR_ATTR_2(temp##index##_auto_point7_pwm, S_IRUGO | S_IWUSR, \
956 show_sf2_pwm, store_sf2_pwm, 6, index - 1), \
957 SENSOR_ATTR_2(temp##index##_auto_point1_temp, S_IRUGO | S_IWUSR,\
958 show_sf2_temp, store_sf2_temp, 0, index - 1), \
959 SENSOR_ATTR_2(temp##index##_auto_point2_temp, S_IRUGO | S_IWUSR,\
960 show_sf2_temp, store_sf2_temp, 1, index - 1), \
961 SENSOR_ATTR_2(temp##index##_auto_point3_temp, S_IRUGO | S_IWUSR,\
962 show_sf2_temp, store_sf2_temp, 2, index - 1), \
963 SENSOR_ATTR_2(temp##index##_auto_point4_temp, S_IRUGO | S_IWUSR,\
964 show_sf2_temp, store_sf2_temp, 3, index - 1), \
965 SENSOR_ATTR_2(temp##index##_auto_point5_temp, S_IRUGO | S_IWUSR,\
966 show_sf2_temp, store_sf2_temp, 4, index - 1), \
967 SENSOR_ATTR_2(temp##index##_auto_point6_temp, S_IRUGO | S_IWUSR,\
968 show_sf2_temp, store_sf2_temp, 5, index - 1), \
969 SENSOR_ATTR_2(temp##index##_auto_point7_temp, S_IRUGO | S_IWUSR,\
970 show_sf2_temp, store_sf2_temp, 6, index - 1)
971
972 static struct sensor_device_attribute_2 w83793_sensor_attr_2[] = {
973 SENSOR_ATTR_IN(0),
974 SENSOR_ATTR_IN(1),
975 SENSOR_ATTR_IN(2),
976 SENSOR_ATTR_IN(3),
977 SENSOR_ATTR_IN(4),
978 SENSOR_ATTR_IN(5),
979 SENSOR_ATTR_IN(6),
980 SENSOR_ATTR_IN(7),
981 SENSOR_ATTR_IN(8),
982 SENSOR_ATTR_IN(9),
983 SENSOR_ATTR_FAN(1),
984 SENSOR_ATTR_FAN(2),
985 SENSOR_ATTR_FAN(3),
986 SENSOR_ATTR_FAN(4),
987 SENSOR_ATTR_FAN(5),
988 SENSOR_ATTR_PWM(1),
989 SENSOR_ATTR_PWM(2),
990 SENSOR_ATTR_PWM(3),
991 };
992
993 static struct sensor_device_attribute_2 w83793_temp[] = {
994 SENSOR_ATTR_TEMP(1),
995 SENSOR_ATTR_TEMP(2),
996 SENSOR_ATTR_TEMP(3),
997 SENSOR_ATTR_TEMP(4),
998 SENSOR_ATTR_TEMP(5),
999 SENSOR_ATTR_TEMP(6),
1000 };
1001
1002 /* Fan6-Fan12 */
1003 static struct sensor_device_attribute_2 w83793_left_fan[] = {
1004 SENSOR_ATTR_FAN(6),
1005 SENSOR_ATTR_FAN(7),
1006 SENSOR_ATTR_FAN(8),
1007 SENSOR_ATTR_FAN(9),
1008 SENSOR_ATTR_FAN(10),
1009 SENSOR_ATTR_FAN(11),
1010 SENSOR_ATTR_FAN(12),
1011 };
1012
1013 /* Pwm4-Pwm8 */
1014 static struct sensor_device_attribute_2 w83793_left_pwm[] = {
1015 SENSOR_ATTR_PWM(4),
1016 SENSOR_ATTR_PWM(5),
1017 SENSOR_ATTR_PWM(6),
1018 SENSOR_ATTR_PWM(7),
1019 SENSOR_ATTR_PWM(8),
1020 };
1021
1022 static struct sensor_device_attribute_2 w83793_vid[] = {
1023 SENSOR_ATTR_2(cpu0_vid, S_IRUGO, show_vid, NULL, NOT_USED, 0),
1024 SENSOR_ATTR_2(cpu1_vid, S_IRUGO, show_vid, NULL, NOT_USED, 1),
1025 };
1026
1027 static struct sensor_device_attribute_2 sda_single_files[] = {
1028 SENSOR_ATTR_2(vrm, S_IWUSR | S_IRUGO, show_vrm, store_vrm,
1029 NOT_USED, NOT_USED),
1030 SENSOR_ATTR_2(chassis, S_IWUSR | S_IRUGO, show_alarm_beep,
1031 store_chassis_clear, ALARM_STATUS, 30),
1032 SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable,
1033 store_beep_enable, NOT_USED, NOT_USED),
1034 SENSOR_ATTR_2(pwm_default, S_IWUSR | S_IRUGO, show_sf_setup,
1035 store_sf_setup, SETUP_PWM_DEFAULT, NOT_USED),
1036 SENSOR_ATTR_2(pwm_uptime, S_IWUSR | S_IRUGO, show_sf_setup,
1037 store_sf_setup, SETUP_PWM_UPTIME, NOT_USED),
1038 SENSOR_ATTR_2(pwm_downtime, S_IWUSR | S_IRUGO, show_sf_setup,
1039 store_sf_setup, SETUP_PWM_DOWNTIME, NOT_USED),
1040 SENSOR_ATTR_2(temp_critical, S_IWUSR | S_IRUGO, show_sf_setup,
1041 store_sf_setup, SETUP_TEMP_CRITICAL, NOT_USED),
1042 };
1043
1044 static void w83793_init_client(struct i2c_client *client)
1045 {
1046 if (reset) {
1047 w83793_write_value(client, W83793_REG_CONFIG, 0x80);
1048 }
1049
1050 /* Start monitoring */
1051 w83793_write_value(client, W83793_REG_CONFIG,
1052 w83793_read_value(client, W83793_REG_CONFIG) | 0x01);
1053
1054 }
1055
1056 static int w83793_attach_adapter(struct i2c_adapter *adapter)
1057 {
1058 if (!(adapter->class & I2C_CLASS_HWMON))
1059 return 0;
1060 return i2c_probe(adapter, &addr_data, w83793_detect);
1061 }
1062
1063 static int w83793_detach_client(struct i2c_client *client)
1064 {
1065 struct w83793_data *data = i2c_get_clientdata(client);
1066 struct device *dev = &client->dev;
1067 int err, i;
1068
1069 /* main client */
1070 if (data) {
1071 hwmon_device_unregister(data->hwmon_dev);
1072
1073 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1074 device_remove_file(dev,
1075 &w83793_sensor_attr_2[i].dev_attr);
1076
1077 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1078 device_remove_file(dev, &sda_single_files[i].dev_attr);
1079
1080 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1081 device_remove_file(dev, &w83793_vid[i].dev_attr);
1082
1083 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1084 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1085
1086 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1087 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1088
1089 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1090 device_remove_file(dev, &w83793_temp[i].dev_attr);
1091 }
1092
1093 if ((err = i2c_detach_client(client)))
1094 return err;
1095
1096 /* main client */
1097 if (data)
1098 kfree(data);
1099 /* subclient */
1100 else
1101 kfree(client);
1102
1103 return 0;
1104 }
1105
1106 static int
1107 w83793_create_subclient(struct i2c_adapter *adapter,
1108 struct i2c_client *client, int addr,
1109 struct i2c_client **sub_cli)
1110 {
1111 int err = 0;
1112 struct i2c_client *sub_client;
1113
1114 (*sub_cli) = sub_client =
1115 kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1116 if (!(sub_client)) {
1117 return -ENOMEM;
1118 }
1119 sub_client->addr = 0x48 + addr;
1120 i2c_set_clientdata(sub_client, NULL);
1121 sub_client->adapter = adapter;
1122 sub_client->driver = &w83793_driver;
1123 strlcpy(sub_client->name, "w83793 subclient", I2C_NAME_SIZE);
1124 if ((err = i2c_attach_client(sub_client))) {
1125 dev_err(&client->dev, "subclient registration "
1126 "at address 0x%x failed\n", sub_client->addr);
1127 kfree(sub_client);
1128 }
1129 return err;
1130 }
1131
1132 static int
1133 w83793_detect_subclients(struct i2c_adapter *adapter, int address,
1134 int kind, struct i2c_client *client)
1135 {
1136 int i, id, err;
1137 u8 tmp;
1138 struct w83793_data *data = i2c_get_clientdata(client);
1139
1140 id = i2c_adapter_id(adapter);
1141 if (force_subclients[0] == id && force_subclients[1] == address) {
1142 for (i = 2; i <= 3; i++) {
1143 if (force_subclients[i] < 0x48
1144 || force_subclients[i] > 0x4f) {
1145 dev_err(&client->dev,
1146 "invalid subclient "
1147 "address %d; must be 0x48-0x4f\n",
1148 force_subclients[i]);
1149 err = -EINVAL;
1150 goto ERROR_SC_0;
1151 }
1152 }
1153 w83793_write_value(client, W83793_REG_I2C_SUBADDR,
1154 (force_subclients[2] & 0x07) |
1155 ((force_subclients[3] & 0x07) << 4));
1156 }
1157
1158 tmp = w83793_read_value(client, W83793_REG_I2C_SUBADDR);
1159 if (!(tmp & 0x08)) {
1160 err =
1161 w83793_create_subclient(adapter, client, tmp & 0x7,
1162 &data->lm75[0]);
1163 if (err < 0)
1164 goto ERROR_SC_0;
1165 }
1166 if (!(tmp & 0x80)) {
1167 if ((data->lm75[0] != NULL)
1168 && ((tmp & 0x7) == ((tmp >> 4) & 0x7))) {
1169 dev_err(&client->dev,
1170 "duplicate addresses 0x%x, "
1171 "use force_subclients\n", data->lm75[0]->addr);
1172 err = -ENODEV;
1173 goto ERROR_SC_1;
1174 }
1175 err = w83793_create_subclient(adapter, client,
1176 (tmp >> 4) & 0x7, &data->lm75[1]);
1177 if (err < 0)
1178 goto ERROR_SC_1;
1179 }
1180
1181 return 0;
1182
1183 /* Undo inits in case of errors */
1184
1185 ERROR_SC_1:
1186 if (data->lm75[0] != NULL) {
1187 i2c_detach_client(data->lm75[0]);
1188 kfree(data->lm75[0]);
1189 }
1190 ERROR_SC_0:
1191 return err;
1192 }
1193
1194 static int w83793_detect(struct i2c_adapter *adapter, int address, int kind)
1195 {
1196 int i;
1197 u8 tmp, val;
1198 struct i2c_client *client;
1199 struct device *dev;
1200 struct w83793_data *data;
1201 int files_fan = ARRAY_SIZE(w83793_left_fan) / 7;
1202 int files_pwm = ARRAY_SIZE(w83793_left_pwm) / 5;
1203 int files_temp = ARRAY_SIZE(w83793_temp) / 6;
1204 int err = 0;
1205
1206 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1207 goto exit;
1208 }
1209
1210 /* OK. For now, we presume we have a valid client. We now create the
1211 client structure, even though we cannot fill it completely yet.
1212 But it allows us to access w83793_{read,write}_value. */
1213
1214 if (!(data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL))) {
1215 err = -ENOMEM;
1216 goto exit;
1217 }
1218
1219 client = &data->client;
1220 dev = &client->dev;
1221 i2c_set_clientdata(client, data);
1222 client->addr = address;
1223 client->adapter = adapter;
1224 client->driver = &w83793_driver;
1225
1226 data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1227
1228 /* Now, we do the remaining detection. */
1229 if (kind < 0) {
1230 tmp = data->bank & 0x80 ? 0x5c : 0xa3;
1231 /* Check Winbond vendor ID */
1232 if (tmp != i2c_smbus_read_byte_data(client,
1233 W83793_REG_VENDORID)) {
1234 pr_debug("w83793: Detection failed at check "
1235 "vendor id\n");
1236 err = -ENODEV;
1237 goto free_mem;
1238 }
1239
1240 /* If Winbond chip, address of chip and W83793_REG_I2C_ADDR
1241 should match */
1242 if ((data->bank & 0x07) == 0
1243 && i2c_smbus_read_byte_data(client, W83793_REG_I2C_ADDR) !=
1244 (address << 1)) {
1245 pr_debug("w83793: Detection failed at check "
1246 "i2c addr\n");
1247 err = -ENODEV;
1248 goto free_mem;
1249 }
1250
1251 }
1252
1253 /* We have either had a force parameter, or we have already detected the
1254 Winbond. Determine the chip type now */
1255
1256 if (kind <= 0) {
1257 if (0x7b == w83793_read_value(client, W83793_REG_CHIPID)) {
1258 kind = w83793;
1259 } else {
1260 if (kind == 0)
1261 dev_warn(&adapter->dev, "w83793: Ignoring "
1262 "'force' parameter for unknown chip "
1263 "at address 0x%02x\n", address);
1264 err = -ENODEV;
1265 goto free_mem;
1266 }
1267 }
1268
1269 /* Fill in the remaining client fields and put into the global list */
1270 strlcpy(client->name, "w83793", I2C_NAME_SIZE);
1271
1272 mutex_init(&data->update_lock);
1273
1274 /* Tell the I2C layer a new client has arrived */
1275 if ((err = i2c_attach_client(client)))
1276 goto free_mem;
1277
1278 if ((err = w83793_detect_subclients(adapter, address, kind, client)))
1279 goto detach_client;
1280
1281 /* Initialize the chip */
1282 w83793_init_client(client);
1283
1284 data->vrm = vid_which_vrm();
1285 /*
1286 Only fan 1-5 has their own input pins,
1287 Pwm 1-3 has their own pins
1288 */
1289 data->has_fan = 0x1f;
1290 data->has_pwm = 0x07;
1291 tmp = w83793_read_value(client, W83793_REG_MFC);
1292 val = w83793_read_value(client, W83793_REG_FANIN_CTRL);
1293
1294 /* check the function of pins 49-56 */
1295 if (!(tmp & 0x80)) {
1296 data->has_pwm |= 0x18; /* pwm 4,5 */
1297 if (val & 0x01) { /* fan 6 */
1298 data->has_fan |= 0x20;
1299 data->has_pwm |= 0x20;
1300 }
1301 if (val & 0x02) { /* fan 7 */
1302 data->has_fan |= 0x40;
1303 data->has_pwm |= 0x40;
1304 }
1305 if (!(tmp & 0x40) && (val & 0x04)) { /* fan 8 */
1306 data->has_fan |= 0x80;
1307 data->has_pwm |= 0x80;
1308 }
1309 }
1310
1311 if (0x08 == (tmp & 0x0c)) {
1312 if (val & 0x08) /* fan 9 */
1313 data->has_fan |= 0x100;
1314 if (val & 0x10) /* fan 10 */
1315 data->has_fan |= 0x200;
1316 }
1317
1318 if (0x20 == (tmp & 0x30)) {
1319 if (val & 0x20) /* fan 11 */
1320 data->has_fan |= 0x400;
1321 if (val & 0x40) /* fan 12 */
1322 data->has_fan |= 0x800;
1323 }
1324
1325 if ((tmp & 0x01) && (val & 0x04)) { /* fan 8, second location */
1326 data->has_fan |= 0x80;
1327 data->has_pwm |= 0x80;
1328 }
1329
1330 tmp = w83793_read_value(client, W83793_REG_FANIN_SEL);
1331 if ((tmp & 0x01) && (val & 0x08)) { /* fan 9, second location */
1332 data->has_fan |= 0x100;
1333 }
1334 if ((tmp & 0x02) && (val & 0x10)) { /* fan 10, second location */
1335 data->has_fan |= 0x200;
1336 }
1337 if ((tmp & 0x04) && (val & 0x20)) { /* fan 11, second location */
1338 data->has_fan |= 0x400;
1339 }
1340 if ((tmp & 0x08) && (val & 0x40)) { /* fan 12, second location */
1341 data->has_fan |= 0x800;
1342 }
1343
1344 /* check the temp1-6 mode, ignore former AMDSI selected inputs */
1345 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[0]);
1346 if (tmp & 0x01)
1347 data->has_temp |= 0x01;
1348 if (tmp & 0x04)
1349 data->has_temp |= 0x02;
1350 if (tmp & 0x10)
1351 data->has_temp |= 0x04;
1352 if (tmp & 0x40)
1353 data->has_temp |= 0x08;
1354
1355 tmp = w83793_read_value(client,W83793_REG_TEMP_MODE[1]);
1356 if (tmp & 0x01)
1357 data->has_temp |= 0x10;
1358 if (tmp & 0x02)
1359 data->has_temp |= 0x20;
1360
1361 /* Detect the VID usage and ignore unused input */
1362 tmp = w83793_read_value(client, W83793_REG_MFC);
1363 if (!(tmp & 0x29))
1364 data->has_vid |= 0x1; /* has VIDA */
1365 if (tmp & 0x80)
1366 data->has_vid |= 0x2; /* has VIDB */
1367
1368 /* Register sysfs hooks */
1369 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++) {
1370 err = device_create_file(dev,
1371 &w83793_sensor_attr_2[i].dev_attr);
1372 if (err)
1373 goto exit_remove;
1374 }
1375
1376 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++) {
1377 if (!(data->has_vid & (1 << i)))
1378 continue;
1379 err = device_create_file(dev, &w83793_vid[i].dev_attr);
1380 if (err)
1381 goto exit_remove;
1382 }
1383
1384 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++) {
1385 err = device_create_file(dev, &sda_single_files[i].dev_attr);
1386 if (err)
1387 goto exit_remove;
1388
1389 }
1390
1391 for (i = 0; i < 6; i++) {
1392 int j;
1393 if (!(data->has_temp & (1 << i)))
1394 continue;
1395 for (j = 0; j < files_temp; j++) {
1396 err = device_create_file(dev,
1397 &w83793_temp[(i) * files_temp
1398 + j].dev_attr);
1399 if (err)
1400 goto exit_remove;
1401 }
1402 }
1403
1404 for (i = 5; i < 12; i++) {
1405 int j;
1406 if (!(data->has_fan & (1 << i)))
1407 continue;
1408 for (j = 0; j < files_fan; j++) {
1409 err = device_create_file(dev,
1410 &w83793_left_fan[(i - 5) * files_fan
1411 + j].dev_attr);
1412 if (err)
1413 goto exit_remove;
1414 }
1415 }
1416
1417 for (i = 3; i < 8; i++) {
1418 int j;
1419 if (!(data->has_pwm & (1 << i)))
1420 continue;
1421 for (j = 0; j < files_pwm; j++) {
1422 err = device_create_file(dev,
1423 &w83793_left_pwm[(i - 3) * files_pwm
1424 + j].dev_attr);
1425 if (err)
1426 goto exit_remove;
1427 }
1428 }
1429
1430 data->hwmon_dev = hwmon_device_register(dev);
1431 if (IS_ERR(data->hwmon_dev)) {
1432 err = PTR_ERR(data->hwmon_dev);
1433 goto exit_remove;
1434 }
1435
1436 return 0;
1437
1438 /* Unregister sysfs hooks */
1439
1440 exit_remove:
1441 for (i = 0; i < ARRAY_SIZE(w83793_sensor_attr_2); i++)
1442 device_remove_file(dev, &w83793_sensor_attr_2[i].dev_attr);
1443
1444 for (i = 0; i < ARRAY_SIZE(sda_single_files); i++)
1445 device_remove_file(dev, &sda_single_files[i].dev_attr);
1446
1447 for (i = 0; i < ARRAY_SIZE(w83793_vid); i++)
1448 device_remove_file(dev, &w83793_vid[i].dev_attr);
1449
1450 for (i = 0; i < ARRAY_SIZE(w83793_left_fan); i++)
1451 device_remove_file(dev, &w83793_left_fan[i].dev_attr);
1452
1453 for (i = 0; i < ARRAY_SIZE(w83793_left_pwm); i++)
1454 device_remove_file(dev, &w83793_left_pwm[i].dev_attr);
1455
1456 for (i = 0; i < ARRAY_SIZE(w83793_temp); i++)
1457 device_remove_file(dev, &w83793_temp[i].dev_attr);
1458
1459 if (data->lm75[0] != NULL) {
1460 i2c_detach_client(data->lm75[0]);
1461 kfree(data->lm75[0]);
1462 }
1463 if (data->lm75[1] != NULL) {
1464 i2c_detach_client(data->lm75[1]);
1465 kfree(data->lm75[1]);
1466 }
1467 detach_client:
1468 i2c_detach_client(client);
1469 free_mem:
1470 kfree(data);
1471 exit:
1472 return err;
1473 }
1474
1475 static void w83793_update_nonvolatile(struct device *dev)
1476 {
1477 struct i2c_client *client = to_i2c_client(dev);
1478 struct w83793_data *data = i2c_get_clientdata(client);
1479 int i, j;
1480 /*
1481 They are somewhat "stable" registers, and to update them everytime
1482 takes so much time, it's just not worthy. Update them in a long
1483 interval to avoid exception.
1484 */
1485 if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1486 || !data->valid))
1487 return;
1488 /* update voltage limits */
1489 for (i = 1; i < 3; i++) {
1490 for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1491 data->in[j][i] =
1492 w83793_read_value(client, W83793_REG_IN[j][i]);
1493 }
1494 data->in_low_bits[i] =
1495 w83793_read_value(client, W83793_REG_IN_LOW_BITS[i]);
1496 }
1497
1498 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1499 /* Update the Fan measured value and limits */
1500 if (!(data->has_fan & (1 << i))) {
1501 continue;
1502 }
1503 data->fan_min[i] =
1504 w83793_read_value(client, W83793_REG_FAN_MIN(i)) << 8;
1505 data->fan_min[i] |=
1506 w83793_read_value(client, W83793_REG_FAN_MIN(i) + 1);
1507 }
1508
1509 for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1510 if (!(data->has_temp & (1 << i)))
1511 continue;
1512 data->temp_fan_map[i] =
1513 w83793_read_value(client, W83793_REG_TEMP_FAN_MAP(i));
1514 for (j = 1; j < 5; j++) {
1515 data->temp[i][j] =
1516 w83793_read_value(client, W83793_REG_TEMP[i][j]);
1517 }
1518 data->temp_cruise[i] =
1519 w83793_read_value(client, W83793_REG_TEMP_CRUISE(i));
1520 for (j = 0; j < 7; j++) {
1521 data->sf2_pwm[i][j] =
1522 w83793_read_value(client, W83793_REG_SF2_PWM(i, j));
1523 data->sf2_temp[i][j] =
1524 w83793_read_value(client,
1525 W83793_REG_SF2_TEMP(i, j));
1526 }
1527 }
1528
1529 for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1530 data->temp_mode[i] =
1531 w83793_read_value(client, W83793_REG_TEMP_MODE[i]);
1532
1533 for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1534 data->tolerance[i] =
1535 w83793_read_value(client, W83793_REG_TEMP_TOL(i));
1536 }
1537
1538 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1539 if (!(data->has_pwm & (1 << i)))
1540 continue;
1541 data->pwm[i][PWM_NONSTOP] =
1542 w83793_read_value(client, W83793_REG_PWM(i, PWM_NONSTOP));
1543 data->pwm[i][PWM_START] =
1544 w83793_read_value(client, W83793_REG_PWM(i, PWM_START));
1545 data->pwm_stop_time[i] =
1546 w83793_read_value(client, W83793_REG_PWM_STOP_TIME(i));
1547 }
1548
1549 data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
1550 data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
1551 data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
1552 data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
1553 data->temp_critical =
1554 w83793_read_value(client, W83793_REG_TEMP_CRITICAL);
1555 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
1556
1557 for (i = 0; i < ARRAY_SIZE(data->beeps); i++) {
1558 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
1559 }
1560
1561 data->last_nonvolatile = jiffies;
1562 }
1563
1564 static struct w83793_data *w83793_update_device(struct device *dev)
1565 {
1566 struct i2c_client *client = to_i2c_client(dev);
1567 struct w83793_data *data = i2c_get_clientdata(client);
1568 int i;
1569
1570 mutex_lock(&data->update_lock);
1571
1572 if (!(time_after(jiffies, data->last_updated + HZ * 2)
1573 || !data->valid))
1574 goto END;
1575
1576 /* Update the voltages measured value and limits */
1577 for (i = 0; i < ARRAY_SIZE(data->in); i++)
1578 data->in[i][IN_READ] =
1579 w83793_read_value(client, W83793_REG_IN[i][IN_READ]);
1580
1581 data->in_low_bits[IN_READ] =
1582 w83793_read_value(client, W83793_REG_IN_LOW_BITS[IN_READ]);
1583
1584 for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
1585 if (!(data->has_fan & (1 << i))) {
1586 continue;
1587 }
1588 data->fan[i] =
1589 w83793_read_value(client, W83793_REG_FAN(i)) << 8;
1590 data->fan[i] |=
1591 w83793_read_value(client, W83793_REG_FAN(i) + 1);
1592 }
1593
1594 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
1595 if (!(data->has_temp & (1 << i)))
1596 continue;
1597 data->temp[i][TEMP_READ] =
1598 w83793_read_value(client, W83793_REG_TEMP[i][TEMP_READ]);
1599 }
1600
1601 data->temp_low_bits =
1602 w83793_read_value(client, W83793_REG_TEMP_LOW_BITS);
1603
1604 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1605 if (data->has_pwm & (1 << i))
1606 data->pwm[i][PWM_DUTY] =
1607 w83793_read_value(client,
1608 W83793_REG_PWM(i, PWM_DUTY));
1609 }
1610
1611 for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
1612 data->alarms[i] =
1613 w83793_read_value(client, W83793_REG_ALARM(i));
1614 if (data->has_vid & 0x01)
1615 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
1616 if (data->has_vid & 0x02)
1617 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
1618 w83793_update_nonvolatile(dev);
1619 data->last_updated = jiffies;
1620 data->valid = 1;
1621
1622 END:
1623 mutex_unlock(&data->update_lock);
1624 return data;
1625 }
1626
1627 /* Ignore the possibility that somebody change bank outside the driver
1628 Must be called with data->update_lock held, except during initialization */
1629 static u8 w83793_read_value(struct i2c_client *client, u16 reg)
1630 {
1631 struct w83793_data *data = i2c_get_clientdata(client);
1632 u8 res = 0xff;
1633 u8 new_bank = reg >> 8;
1634
1635 new_bank |= data->bank & 0xfc;
1636 if (data->bank != new_bank) {
1637 if (i2c_smbus_write_byte_data
1638 (client, W83793_REG_BANKSEL, new_bank) >= 0)
1639 data->bank = new_bank;
1640 else {
1641 dev_err(&client->dev,
1642 "set bank to %d failed, fall back "
1643 "to bank %d, read reg 0x%x error\n",
1644 new_bank, data->bank, reg);
1645 res = 0x0; /* read 0x0 from the chip */
1646 goto END;
1647 }
1648 }
1649 res = i2c_smbus_read_byte_data(client, reg & 0xff);
1650 END:
1651 return res;
1652 }
1653
1654 /* Must be called with data->update_lock held, except during initialization */
1655 static int w83793_write_value(struct i2c_client *client, u16 reg, u8 value)
1656 {
1657 struct w83793_data *data = i2c_get_clientdata(client);
1658 int res;
1659 u8 new_bank = reg >> 8;
1660
1661 new_bank |= data->bank & 0xfc;
1662 if (data->bank != new_bank) {
1663 if ((res = i2c_smbus_write_byte_data
1664 (client, W83793_REG_BANKSEL, new_bank)) >= 0)
1665 data->bank = new_bank;
1666 else {
1667 dev_err(&client->dev,
1668 "set bank to %d failed, fall back "
1669 "to bank %d, write reg 0x%x error\n",
1670 new_bank, data->bank, reg);
1671 goto END;
1672 }
1673 }
1674
1675 res = i2c_smbus_write_byte_data(client, reg & 0xff, value);
1676 END:
1677 return res;
1678 }
1679
1680 static int __init sensors_w83793_init(void)
1681 {
1682 return i2c_add_driver(&w83793_driver);
1683 }
1684
1685 static void __exit sensors_w83793_exit(void)
1686 {
1687 i2c_del_driver(&w83793_driver);
1688 }
1689
1690 MODULE_AUTHOR("Yuan Mu");
1691 MODULE_DESCRIPTION("w83793 driver");
1692 MODULE_LICENSE("GPL");
1693
1694 module_init(sensors_w83793_init);
1695 module_exit(sensors_w83793_exit);
WRT350N Kernel Patches