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