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
30
31
32
33
34#include <linux/module.h>
35#include <linux/init.h>
36#include <linux/slab.h>
37#include <linux/jiffies.h>
38#include <linux/i2c.h>
39#include <linux/hwmon.h>
40#include <linux/hwmon-sysfs.h>
41#include <linux/err.h>
42
43
44
45
46
47static const unsigned short normal_i2c[] = {0x1b, 0x1f, 0x48, 0x4b,
48 I2C_CLIENT_END};
49
50
51
52
53
54
55static int fan_voltage;
56
57static int prescaler;
58
59static int clock = 254000;
60
61module_param(fan_voltage, int, S_IRUGO);
62module_param(prescaler, int, S_IRUGO);
63module_param(clock, int, S_IRUGO);
64
65
66
67
68
69#define MAX6650_REG_SPEED 0x00
70#define MAX6650_REG_CONFIG 0x02
71#define MAX6650_REG_GPIO_DEF 0x04
72#define MAX6650_REG_DAC 0x06
73#define MAX6650_REG_ALARM_EN 0x08
74#define MAX6650_REG_ALARM 0x0A
75#define MAX6650_REG_TACH0 0x0C
76#define MAX6650_REG_TACH1 0x0E
77#define MAX6650_REG_TACH2 0x10
78#define MAX6650_REG_TACH3 0x12
79#define MAX6650_REG_GPIO_STAT 0x14
80#define MAX6650_REG_COUNT 0x16
81
82
83
84
85
86#define MAX6650_CFG_V12 0x08
87#define MAX6650_CFG_PRESCALER_MASK 0x07
88#define MAX6650_CFG_PRESCALER_2 0x01
89#define MAX6650_CFG_PRESCALER_4 0x02
90#define MAX6650_CFG_PRESCALER_8 0x03
91#define MAX6650_CFG_PRESCALER_16 0x04
92#define MAX6650_CFG_MODE_MASK 0x30
93#define MAX6650_CFG_MODE_ON 0x00
94#define MAX6650_CFG_MODE_OFF 0x10
95#define MAX6650_CFG_MODE_CLOSED_LOOP 0x20
96#define MAX6650_CFG_MODE_OPEN_LOOP 0x30
97#define MAX6650_COUNT_MASK 0x03
98
99
100
101
102
103#define MAX6650_ALRM_MAX 0x01
104#define MAX6650_ALRM_MIN 0x02
105#define MAX6650_ALRM_TACH 0x04
106#define MAX6650_ALRM_GPIO1 0x08
107#define MAX6650_ALRM_GPIO2 0x10
108
109
110#define FAN_RPM_MIN 240
111#define FAN_RPM_MAX 30000
112
113#define DIV_FROM_REG(reg) (1 << (reg & 7))
114
115static int max6650_probe(struct i2c_client *client,
116 const struct i2c_device_id *id);
117static int max6650_detect(struct i2c_client *client,
118 struct i2c_board_info *info);
119static int max6650_init_client(struct i2c_client *client);
120static int max6650_remove(struct i2c_client *client);
121static struct max6650_data *max6650_update_device(struct device *dev);
122
123
124
125
126
127static const struct i2c_device_id max6650_id[] = {
128 { "max6650", 0 },
129 { }
130};
131MODULE_DEVICE_TABLE(i2c, max6650_id);
132
133static struct i2c_driver max6650_driver = {
134 .class = I2C_CLASS_HWMON,
135 .driver = {
136 .name = "max6650",
137 },
138 .probe = max6650_probe,
139 .remove = max6650_remove,
140 .id_table = max6650_id,
141 .detect = max6650_detect,
142 .address_list = normal_i2c,
143};
144
145
146
147
148
149struct max6650_data
150{
151 struct device *hwmon_dev;
152 struct mutex update_lock;
153 char valid;
154 unsigned long last_updated;
155
156
157 u8 speed;
158 u8 config;
159 u8 tach[4];
160 u8 count;
161 u8 dac;
162 u8 alarm;
163};
164
165static ssize_t get_fan(struct device *dev, struct device_attribute *devattr,
166 char *buf)
167{
168 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
169 struct max6650_data *data = max6650_update_device(dev);
170 int rpm;
171
172
173
174
175
176
177
178
179
180
181 rpm = ((data->tach[attr->index] * 120) / DIV_FROM_REG(data->count));
182 return sprintf(buf, "%d\n", rpm);
183}
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226static ssize_t get_target(struct device *dev, struct device_attribute *devattr,
227 char *buf)
228{
229 struct max6650_data *data = max6650_update_device(dev);
230 int kscale, ktach, rpm;
231
232
233
234
235
236
237
238
239
240 kscale = DIV_FROM_REG(data->config);
241 ktach = data->speed;
242 rpm = 60 * kscale * clock / (256 * (ktach + 1));
243 return sprintf(buf, "%d\n", rpm);
244}
245
246static ssize_t set_target(struct device *dev, struct device_attribute *devattr,
247 const char *buf, size_t count)
248{
249 struct i2c_client *client = to_i2c_client(dev);
250 struct max6650_data *data = i2c_get_clientdata(client);
251 int rpm = simple_strtoul(buf, NULL, 10);
252 int kscale, ktach;
253
254 rpm = SENSORS_LIMIT(rpm, FAN_RPM_MIN, FAN_RPM_MAX);
255
256
257
258
259
260
261
262
263 mutex_lock(&data->update_lock);
264
265 kscale = DIV_FROM_REG(data->config);
266 ktach = ((clock * kscale) / (256 * rpm / 60)) - 1;
267 if (ktach < 0)
268 ktach = 0;
269 if (ktach > 255)
270 ktach = 255;
271 data->speed = ktach;
272
273 i2c_smbus_write_byte_data(client, MAX6650_REG_SPEED, data->speed);
274
275 mutex_unlock(&data->update_lock);
276
277 return count;
278}
279
280
281
282
283
284
285
286
287
288
289static ssize_t get_pwm(struct device *dev, struct device_attribute *devattr,
290 char *buf)
291{
292 int pwm;
293 struct max6650_data *data = max6650_update_device(dev);
294
295
296
297 if (data->config & MAX6650_CFG_V12)
298 pwm = 255 - (255 * (int)data->dac)/180;
299 else
300 pwm = 255 - (255 * (int)data->dac)/76;
301
302 if (pwm < 0)
303 pwm = 0;
304
305 return sprintf(buf, "%d\n", pwm);
306}
307
308static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
309 const char *buf, size_t count)
310{
311 struct i2c_client *client = to_i2c_client(dev);
312 struct max6650_data *data = i2c_get_clientdata(client);
313 int pwm = simple_strtoul(buf, NULL, 10);
314
315 pwm = SENSORS_LIMIT(pwm, 0, 255);
316
317 mutex_lock(&data->update_lock);
318
319 if (data->config & MAX6650_CFG_V12)
320 data->dac = 180 - (180 * pwm)/255;
321 else
322 data->dac = 76 - (76 * pwm)/255;
323
324 i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, data->dac);
325
326 mutex_unlock(&data->update_lock);
327
328 return count;
329}
330
331
332
333
334
335
336
337
338
339static ssize_t get_enable(struct device *dev, struct device_attribute *devattr,
340 char *buf)
341{
342 struct max6650_data *data = max6650_update_device(dev);
343 int mode = (data->config & MAX6650_CFG_MODE_MASK) >> 4;
344 int sysfs_modes[4] = {0, 1, 2, 1};
345
346 return sprintf(buf, "%d\n", sysfs_modes[mode]);
347}
348
349static ssize_t set_enable(struct device *dev, struct device_attribute *devattr,
350 const char *buf, size_t count)
351{
352 struct i2c_client *client = to_i2c_client(dev);
353 struct max6650_data *data = i2c_get_clientdata(client);
354 int mode = simple_strtoul(buf, NULL, 10);
355 int max6650_modes[3] = {0, 3, 2};
356
357 if ((mode < 0)||(mode > 2)) {
358 dev_err(&client->dev,
359 "illegal value for pwm1_enable (%d)\n", mode);
360 return -EINVAL;
361 }
362
363 mutex_lock(&data->update_lock);
364
365 data->config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG);
366 data->config = (data->config & ~MAX6650_CFG_MODE_MASK)
367 | (max6650_modes[mode] << 4);
368
369 i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, data->config);
370
371 mutex_unlock(&data->update_lock);
372
373 return count;
374}
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389static ssize_t get_div(struct device *dev, struct device_attribute *devattr,
390 char *buf)
391{
392 struct max6650_data *data = max6650_update_device(dev);
393
394 return sprintf(buf, "%d\n", DIV_FROM_REG(data->count));
395}
396
397static ssize_t set_div(struct device *dev, struct device_attribute *devattr,
398 const char *buf, size_t count)
399{
400 struct i2c_client *client = to_i2c_client(dev);
401 struct max6650_data *data = i2c_get_clientdata(client);
402 int div = simple_strtoul(buf, NULL, 10);
403
404 mutex_lock(&data->update_lock);
405 switch (div) {
406 case 1:
407 data->count = 0;
408 break;
409 case 2:
410 data->count = 1;
411 break;
412 case 4:
413 data->count = 2;
414 break;
415 case 8:
416 data->count = 3;
417 break;
418 default:
419 mutex_unlock(&data->update_lock);
420 dev_err(&client->dev,
421 "illegal value for fan divider (%d)\n", div);
422 return -EINVAL;
423 }
424
425 i2c_smbus_write_byte_data(client, MAX6650_REG_COUNT, data->count);
426 mutex_unlock(&data->update_lock);
427
428 return count;
429}
430
431
432
433
434
435
436
437
438static ssize_t get_alarm(struct device *dev, struct device_attribute *devattr,
439 char *buf)
440{
441 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
442 struct max6650_data *data = max6650_update_device(dev);
443 struct i2c_client *client = to_i2c_client(dev);
444 int alarm = 0;
445
446 if (data->alarm & attr->index) {
447 mutex_lock(&data->update_lock);
448 alarm = 1;
449 data->alarm &= ~attr->index;
450 data->alarm |= i2c_smbus_read_byte_data(client,
451 MAX6650_REG_ALARM);
452 mutex_unlock(&data->update_lock);
453 }
454
455 return sprintf(buf, "%d\n", alarm);
456}
457
458static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, 0);
459static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan, NULL, 1);
460static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, get_fan, NULL, 2);
461static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, get_fan, NULL, 3);
462static DEVICE_ATTR(fan1_target, S_IWUSR | S_IRUGO, get_target, set_target);
463static DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO, get_div, set_div);
464static DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, get_enable, set_enable);
465static DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm, set_pwm);
466static SENSOR_DEVICE_ATTR(fan1_max_alarm, S_IRUGO, get_alarm, NULL,
467 MAX6650_ALRM_MAX);
468static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, get_alarm, NULL,
469 MAX6650_ALRM_MIN);
470static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_alarm, NULL,
471 MAX6650_ALRM_TACH);
472static SENSOR_DEVICE_ATTR(gpio1_alarm, S_IRUGO, get_alarm, NULL,
473 MAX6650_ALRM_GPIO1);
474static SENSOR_DEVICE_ATTR(gpio2_alarm, S_IRUGO, get_alarm, NULL,
475 MAX6650_ALRM_GPIO2);
476
477static mode_t max6650_attrs_visible(struct kobject *kobj, struct attribute *a,
478 int n)
479{
480 struct device *dev = container_of(kobj, struct device, kobj);
481 struct i2c_client *client = to_i2c_client(dev);
482 u8 alarm_en = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN);
483 struct device_attribute *devattr;
484
485
486
487
488
489 devattr = container_of(a, struct device_attribute, attr);
490 if (devattr == &sensor_dev_attr_fan1_max_alarm.dev_attr
491 || devattr == &sensor_dev_attr_fan1_min_alarm.dev_attr
492 || devattr == &sensor_dev_attr_fan1_fault.dev_attr
493 || devattr == &sensor_dev_attr_gpio1_alarm.dev_attr
494 || devattr == &sensor_dev_attr_gpio2_alarm.dev_attr) {
495 if (!(alarm_en & to_sensor_dev_attr(devattr)->index))
496 return 0;
497 }
498
499 return a->mode;
500}
501
502static struct attribute *max6650_attrs[] = {
503 &sensor_dev_attr_fan1_input.dev_attr.attr,
504 &sensor_dev_attr_fan2_input.dev_attr.attr,
505 &sensor_dev_attr_fan3_input.dev_attr.attr,
506 &sensor_dev_attr_fan4_input.dev_attr.attr,
507 &dev_attr_fan1_target.attr,
508 &dev_attr_fan1_div.attr,
509 &dev_attr_pwm1_enable.attr,
510 &dev_attr_pwm1.attr,
511 &sensor_dev_attr_fan1_max_alarm.dev_attr.attr,
512 &sensor_dev_attr_fan1_min_alarm.dev_attr.attr,
513 &sensor_dev_attr_fan1_fault.dev_attr.attr,
514 &sensor_dev_attr_gpio1_alarm.dev_attr.attr,
515 &sensor_dev_attr_gpio2_alarm.dev_attr.attr,
516 NULL
517};
518
519static struct attribute_group max6650_attr_grp = {
520 .attrs = max6650_attrs,
521 .is_visible = max6650_attrs_visible,
522};
523
524
525
526
527
528
529static int max6650_detect(struct i2c_client *client,
530 struct i2c_board_info *info)
531{
532 struct i2c_adapter *adapter = client->adapter;
533 int address = client->addr;
534
535 dev_dbg(&adapter->dev, "max6650_detect called\n");
536
537 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
538 dev_dbg(&adapter->dev, "max6650: I2C bus doesn't support "
539 "byte read mode, skipping.\n");
540 return -ENODEV;
541 }
542
543 if (((i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG) & 0xC0)
544 ||(i2c_smbus_read_byte_data(client, MAX6650_REG_GPIO_STAT) & 0xE0)
545 ||(i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN) & 0xE0)
546 ||(i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM) & 0xE0)
547 ||(i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT) & 0xFC))) {
548 dev_dbg(&adapter->dev,
549 "max6650: detection failed at 0x%02x.\n", address);
550 return -ENODEV;
551 }
552
553 dev_info(&adapter->dev, "max6650: chip found at 0x%02x.\n", address);
554
555 strlcpy(info->type, "max6650", I2C_NAME_SIZE);
556
557 return 0;
558}
559
560static int max6650_probe(struct i2c_client *client,
561 const struct i2c_device_id *id)
562{
563 struct max6650_data *data;
564 int err;
565
566 if (!(data = kzalloc(sizeof(struct max6650_data), GFP_KERNEL))) {
567 dev_err(&client->dev, "out of memory.\n");
568 return -ENOMEM;
569 }
570
571 i2c_set_clientdata(client, data);
572 mutex_init(&data->update_lock);
573
574
575
576
577 err = max6650_init_client(client);
578 if (err)
579 goto err_free;
580
581 err = sysfs_create_group(&client->dev.kobj, &max6650_attr_grp);
582 if (err)
583 goto err_free;
584
585 data->hwmon_dev = hwmon_device_register(&client->dev);
586 if (!IS_ERR(data->hwmon_dev))
587 return 0;
588
589 err = PTR_ERR(data->hwmon_dev);
590 dev_err(&client->dev, "error registering hwmon device.\n");
591 sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp);
592err_free:
593 kfree(data);
594 return err;
595}
596
597static int max6650_remove(struct i2c_client *client)
598{
599 struct max6650_data *data = i2c_get_clientdata(client);
600
601 sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp);
602 hwmon_device_unregister(data->hwmon_dev);
603 kfree(data);
604 return 0;
605}
606
607static int max6650_init_client(struct i2c_client *client)
608{
609 struct max6650_data *data = i2c_get_clientdata(client);
610 int config;
611 int err = -EIO;
612
613 config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG);
614
615 if (config < 0) {
616 dev_err(&client->dev, "Error reading config, aborting.\n");
617 return err;
618 }
619
620 switch (fan_voltage) {
621 case 0:
622 break;
623 case 5:
624 config &= ~MAX6650_CFG_V12;
625 break;
626 case 12:
627 config |= MAX6650_CFG_V12;
628 break;
629 default:
630 dev_err(&client->dev,
631 "illegal value for fan_voltage (%d)\n",
632 fan_voltage);
633 }
634
635 dev_info(&client->dev, "Fan voltage is set to %dV.\n",
636 (config & MAX6650_CFG_V12) ? 12 : 5);
637
638 switch (prescaler) {
639 case 0:
640 break;
641 case 1:
642 config &= ~MAX6650_CFG_PRESCALER_MASK;
643 break;
644 case 2:
645 config = (config & ~MAX6650_CFG_PRESCALER_MASK)
646 | MAX6650_CFG_PRESCALER_2;
647 break;
648 case 4:
649 config = (config & ~MAX6650_CFG_PRESCALER_MASK)
650 | MAX6650_CFG_PRESCALER_4;
651 break;
652 case 8:
653 config = (config & ~MAX6650_CFG_PRESCALER_MASK)
654 | MAX6650_CFG_PRESCALER_8;
655 break;
656 case 16:
657 config = (config & ~MAX6650_CFG_PRESCALER_MASK)
658 | MAX6650_CFG_PRESCALER_16;
659 break;
660 default:
661 dev_err(&client->dev,
662 "illegal value for prescaler (%d)\n",
663 prescaler);
664 }
665
666 dev_info(&client->dev, "Prescaler is set to %d.\n",
667 1 << (config & MAX6650_CFG_PRESCALER_MASK));
668
669
670
671
672
673
674 if ((config & MAX6650_CFG_MODE_MASK) == MAX6650_CFG_MODE_OFF) {
675 dev_dbg(&client->dev, "Change mode to open loop, full off.\n");
676 config = (config & ~MAX6650_CFG_MODE_MASK)
677 | MAX6650_CFG_MODE_OPEN_LOOP;
678 if (i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, 255)) {
679 dev_err(&client->dev, "DAC write error, aborting.\n");
680 return err;
681 }
682 }
683
684 if (i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, config)) {
685 dev_err(&client->dev, "Config write error, aborting.\n");
686 return err;
687 }
688
689 data->config = config;
690 data->count = i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT);
691
692 return 0;
693}
694
695static const u8 tach_reg[] = {
696 MAX6650_REG_TACH0,
697 MAX6650_REG_TACH1,
698 MAX6650_REG_TACH2,
699 MAX6650_REG_TACH3,
700};
701
702static struct max6650_data *max6650_update_device(struct device *dev)
703{
704 int i;
705 struct i2c_client *client = to_i2c_client(dev);
706 struct max6650_data *data = i2c_get_clientdata(client);
707
708 mutex_lock(&data->update_lock);
709
710 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
711 data->speed = i2c_smbus_read_byte_data(client,
712 MAX6650_REG_SPEED);
713 data->config = i2c_smbus_read_byte_data(client,
714 MAX6650_REG_CONFIG);
715 for (i = 0; i < 4; i++) {
716 data->tach[i] = i2c_smbus_read_byte_data(client,
717 tach_reg[i]);
718 }
719 data->count = i2c_smbus_read_byte_data(client,
720 MAX6650_REG_COUNT);
721 data->dac = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC);
722
723
724
725
726 data->alarm |= i2c_smbus_read_byte_data(client,
727 MAX6650_REG_ALARM);
728
729 data->last_updated = jiffies;
730 data->valid = 1;
731 }
732
733 mutex_unlock(&data->update_lock);
734
735 return data;
736}
737
738static int __init sensors_max6650_init(void)
739{
740 return i2c_add_driver(&max6650_driver);
741}
742
743static void __exit sensors_max6650_exit(void)
744{
745 i2c_del_driver(&max6650_driver);
746}
747
748MODULE_AUTHOR("Hans J. Koch");
749MODULE_DESCRIPTION("MAX6650 sensor driver");
750MODULE_LICENSE("GPL");
751
752module_init(sensors_max6650_init);
753module_exit(sensors_max6650_exit);
754