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