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