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