blob: cced18626174d75bc2a93153ab5bfc072f2c1108 [file] [log] [blame]
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +02001/*
2 * max6650.c - Part of lm_sensors, Linux kernel modules for hardware
3 * monitoring.
4 *
Hans J. Koch2aa25c22010-11-15 21:38:56 +01005 * (C) 2007 by Hans J. Koch <hjk@hansjkoch.de>
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +02006 *
7 * based on code written by John Morris <john.morris@spirentcom.com>
8 * Copyright (c) 2003 Spirent Communications
9 * and Claus Gindhart <claus.gindhart@kontron.com>
10 *
11 * This module has only been tested with the MAX6650 chip. It should
12 * also work with the MAX6651. It does not distinguish max6650 and max6651
13 * chips.
14 *
Christian Engelmayer52b52262009-06-15 18:39:52 +020015 * The datasheet was last seen at:
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +020016 *
17 * http://pdfserv.maxim-ic.com/en/ds/MAX6650-MAX6651.pdf
18 *
19 * This program is free software; you can redistribute it and/or modify
20 * it under the terms of the GNU General Public License as published by
21 * the Free Software Foundation; either version 2 of the License, or
22 * (at your option) any later version.
23 *
24 * This program is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 * GNU General Public License for more details.
28 *
29 * You should have received a copy of the GNU General Public License
30 * along with this program; if not, write to the Free Software
31 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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/*
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +020044 * Insmod parameters
45 */
46
47/* fan_voltage: 5=5V fan, 12=12V fan, 0=don't change */
48static int fan_voltage;
49/* prescaler: Possible values are 1, 2, 4, 8, 16 or 0 for don't change */
50static int prescaler;
51/* clock: The clock frequency of the chip the driver should assume */
52static int clock = 254000;
53
54module_param(fan_voltage, int, S_IRUGO);
55module_param(prescaler, int, S_IRUGO);
56module_param(clock, int, S_IRUGO);
57
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +020058/*
59 * MAX 6650/6651 registers
60 */
61
62#define MAX6650_REG_SPEED 0x00
63#define MAX6650_REG_CONFIG 0x02
64#define MAX6650_REG_GPIO_DEF 0x04
65#define MAX6650_REG_DAC 0x06
66#define MAX6650_REG_ALARM_EN 0x08
67#define MAX6650_REG_ALARM 0x0A
68#define MAX6650_REG_TACH0 0x0C
69#define MAX6650_REG_TACH1 0x0E
70#define MAX6650_REG_TACH2 0x10
71#define MAX6650_REG_TACH3 0x12
72#define MAX6650_REG_GPIO_STAT 0x14
73#define MAX6650_REG_COUNT 0x16
74
75/*
76 * Config register bits
77 */
78
79#define MAX6650_CFG_V12 0x08
80#define MAX6650_CFG_PRESCALER_MASK 0x07
81#define MAX6650_CFG_PRESCALER_2 0x01
82#define MAX6650_CFG_PRESCALER_4 0x02
83#define MAX6650_CFG_PRESCALER_8 0x03
84#define MAX6650_CFG_PRESCALER_16 0x04
85#define MAX6650_CFG_MODE_MASK 0x30
86#define MAX6650_CFG_MODE_ON 0x00
87#define MAX6650_CFG_MODE_OFF 0x10
88#define MAX6650_CFG_MODE_CLOSED_LOOP 0x20
89#define MAX6650_CFG_MODE_OPEN_LOOP 0x30
90#define MAX6650_COUNT_MASK 0x03
91
Christian Engelmayer52b52262009-06-15 18:39:52 +020092/*
93 * Alarm status register bits
94 */
95
96#define MAX6650_ALRM_MAX 0x01
97#define MAX6650_ALRM_MIN 0x02
98#define MAX6650_ALRM_TACH 0x04
99#define MAX6650_ALRM_GPIO1 0x08
100#define MAX6650_ALRM_GPIO2 0x10
101
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200102/* Minimum and maximum values of the FAN-RPM */
103#define FAN_RPM_MIN 240
104#define FAN_RPM_MAX 30000
105
106#define DIV_FROM_REG(reg) (1 << (reg & 7))
107
Jean Delvare0d57abd2008-07-16 19:30:16 +0200108static int max6650_probe(struct i2c_client *client,
109 const struct i2c_device_id *id);
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200110static int max6650_init_client(struct i2c_client *client);
Jean Delvare0d57abd2008-07-16 19:30:16 +0200111static int max6650_remove(struct i2c_client *client);
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200112static struct max6650_data *max6650_update_device(struct device *dev);
113
114/*
115 * Driver data (common to all clients)
116 */
117
Jean Delvare0d57abd2008-07-16 19:30:16 +0200118static const struct i2c_device_id max6650_id[] = {
Jean Delvare1f86df42009-12-14 21:17:26 +0100119 { "max6650", 0 },
Jean Delvare0d57abd2008-07-16 19:30:16 +0200120 { }
121};
122MODULE_DEVICE_TABLE(i2c, max6650_id);
123
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200124static struct i2c_driver max6650_driver = {
125 .driver = {
126 .name = "max6650",
127 },
Jean Delvare0d57abd2008-07-16 19:30:16 +0200128 .probe = max6650_probe,
129 .remove = max6650_remove,
130 .id_table = max6650_id,
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200131};
132
133/*
134 * Client data (each client gets its own)
135 */
136
137struct max6650_data
138{
Tony Jones1beeffe2007-08-20 13:46:20 -0700139 struct device *hwmon_dev;
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200140 struct mutex update_lock;
141 char valid; /* zero until following fields are valid */
142 unsigned long last_updated; /* in jiffies */
143
144 /* register values */
145 u8 speed;
146 u8 config;
147 u8 tach[4];
148 u8 count;
149 u8 dac;
Christian Engelmayer52b52262009-06-15 18:39:52 +0200150 u8 alarm;
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200151};
152
153static ssize_t get_fan(struct device *dev, struct device_attribute *devattr,
154 char *buf)
155{
156 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
157 struct max6650_data *data = max6650_update_device(dev);
158 int rpm;
159
160 /*
161 * Calculation details:
162 *
163 * Each tachometer counts over an interval given by the "count"
164 * register (0.25, 0.5, 1 or 2 seconds). This module assumes
165 * that the fans produce two pulses per revolution (this seems
166 * to be the most common).
167 */
168
169 rpm = ((data->tach[attr->index] * 120) / DIV_FROM_REG(data->count));
170 return sprintf(buf, "%d\n", rpm);
171}
172
173/*
174 * Set the fan speed to the specified RPM (or read back the RPM setting).
175 * This works in closed loop mode only. Use pwm1 for open loop speed setting.
176 *
177 * The MAX6650/1 will automatically control fan speed when in closed loop
178 * mode.
179 *
180 * Assumptions:
181 *
182 * 1) The MAX6650/1 internal 254kHz clock frequency is set correctly. Use
183 * the clock module parameter if you need to fine tune this.
184 *
185 * 2) The prescaler (low three bits of the config register) has already
186 * been set to an appropriate value. Use the prescaler module parameter
187 * if your BIOS doesn't initialize the chip properly.
188 *
189 * The relevant equations are given on pages 21 and 22 of the datasheet.
190 *
191 * From the datasheet, the relevant equation when in regulation is:
192 *
193 * [fCLK / (128 x (KTACH + 1))] = 2 x FanSpeed / KSCALE
194 *
195 * where:
196 *
197 * fCLK is the oscillator frequency (either the 254kHz internal
198 * oscillator or the externally applied clock)
199 *
200 * KTACH is the value in the speed register
201 *
202 * FanSpeed is the speed of the fan in rps
203 *
204 * KSCALE is the prescaler value (1, 2, 4, 8, or 16)
205 *
206 * When reading, we need to solve for FanSpeed. When writing, we need to
207 * solve for KTACH.
208 *
209 * Note: this tachometer is completely separate from the tachometers
210 * used to measure the fan speeds. Only one fan's speed (fan1) is
211 * controlled.
212 */
213
214static ssize_t get_target(struct device *dev, struct device_attribute *devattr,
215 char *buf)
216{
217 struct max6650_data *data = max6650_update_device(dev);
218 int kscale, ktach, rpm;
219
220 /*
221 * Use the datasheet equation:
222 *
223 * FanSpeed = KSCALE x fCLK / [256 x (KTACH + 1)]
224 *
225 * then multiply by 60 to give rpm.
226 */
227
228 kscale = DIV_FROM_REG(data->config);
229 ktach = data->speed;
230 rpm = 60 * kscale * clock / (256 * (ktach + 1));
231 return sprintf(buf, "%d\n", rpm);
232}
233
234static ssize_t set_target(struct device *dev, struct device_attribute *devattr,
235 const char *buf, size_t count)
236{
237 struct i2c_client *client = to_i2c_client(dev);
238 struct max6650_data *data = i2c_get_clientdata(client);
239 int rpm = simple_strtoul(buf, NULL, 10);
240 int kscale, ktach;
241
242 rpm = SENSORS_LIMIT(rpm, FAN_RPM_MIN, FAN_RPM_MAX);
243
244 /*
245 * Divide the required speed by 60 to get from rpm to rps, then
246 * use the datasheet equation:
247 *
248 * KTACH = [(fCLK x KSCALE) / (256 x FanSpeed)] - 1
249 */
250
251 mutex_lock(&data->update_lock);
252
253 kscale = DIV_FROM_REG(data->config);
254 ktach = ((clock * kscale) / (256 * rpm / 60)) - 1;
255 if (ktach < 0)
256 ktach = 0;
257 if (ktach > 255)
258 ktach = 255;
259 data->speed = ktach;
260
261 i2c_smbus_write_byte_data(client, MAX6650_REG_SPEED, data->speed);
262
263 mutex_unlock(&data->update_lock);
264
265 return count;
266}
267
268/*
269 * Get/set the fan speed in open loop mode using pwm1 sysfs file.
270 * Speed is given as a relative value from 0 to 255, where 255 is maximum
271 * speed. Note that this is done by writing directly to the chip's DAC,
272 * it won't change the closed loop speed set by fan1_target.
273 * Also note that due to rounding errors it is possible that you don't read
274 * back exactly the value you have set.
275 */
276
277static ssize_t get_pwm(struct device *dev, struct device_attribute *devattr,
278 char *buf)
279{
280 int pwm;
281 struct max6650_data *data = max6650_update_device(dev);
282
283 /* Useful range for dac is 0-180 for 12V fans and 0-76 for 5V fans.
284 Lower DAC values mean higher speeds. */
285 if (data->config & MAX6650_CFG_V12)
286 pwm = 255 - (255 * (int)data->dac)/180;
287 else
288 pwm = 255 - (255 * (int)data->dac)/76;
289
290 if (pwm < 0)
291 pwm = 0;
292
293 return sprintf(buf, "%d\n", pwm);
294}
295
296static ssize_t set_pwm(struct device *dev, struct device_attribute *devattr,
297 const char *buf, size_t count)
298{
299 struct i2c_client *client = to_i2c_client(dev);
300 struct max6650_data *data = i2c_get_clientdata(client);
301 int pwm = simple_strtoul(buf, NULL, 10);
302
303 pwm = SENSORS_LIMIT(pwm, 0, 255);
304
305 mutex_lock(&data->update_lock);
306
307 if (data->config & MAX6650_CFG_V12)
308 data->dac = 180 - (180 * pwm)/255;
309 else
310 data->dac = 76 - (76 * pwm)/255;
311
312 i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, data->dac);
313
314 mutex_unlock(&data->update_lock);
315
316 return count;
317}
318
319/*
320 * Get/Set controller mode:
321 * Possible values:
322 * 0 = Fan always on
323 * 1 = Open loop, Voltage is set according to speed, not regulated.
324 * 2 = Closed loop, RPM for all fans regulated by fan1 tachometer
325 */
326
327static ssize_t get_enable(struct device *dev, struct device_attribute *devattr,
328 char *buf)
329{
330 struct max6650_data *data = max6650_update_device(dev);
331 int mode = (data->config & MAX6650_CFG_MODE_MASK) >> 4;
332 int sysfs_modes[4] = {0, 1, 2, 1};
333
334 return sprintf(buf, "%d\n", sysfs_modes[mode]);
335}
336
337static ssize_t set_enable(struct device *dev, struct device_attribute *devattr,
338 const char *buf, size_t count)
339{
340 struct i2c_client *client = to_i2c_client(dev);
341 struct max6650_data *data = i2c_get_clientdata(client);
342 int mode = simple_strtoul(buf, NULL, 10);
343 int max6650_modes[3] = {0, 3, 2};
344
345 if ((mode < 0)||(mode > 2)) {
346 dev_err(&client->dev,
347 "illegal value for pwm1_enable (%d)\n", mode);
348 return -EINVAL;
349 }
350
351 mutex_lock(&data->update_lock);
352
353 data->config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG);
354 data->config = (data->config & ~MAX6650_CFG_MODE_MASK)
355 | (max6650_modes[mode] << 4);
356
357 i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, data->config);
358
359 mutex_unlock(&data->update_lock);
360
361 return count;
362}
363
364/*
365 * Read/write functions for fan1_div sysfs file. The MAX6650 has no such
366 * divider. We handle this by converting between divider and counttime:
367 *
368 * (counttime == k) <==> (divider == 2^k), k = 0, 1, 2, or 3
369 *
370 * Lower values of k allow to connect a faster fan without the risk of
371 * counter overflow. The price is lower resolution. You can also set counttime
372 * using the module parameter. Note that the module parameter "prescaler" also
373 * influences the behaviour. Unfortunately, there's no sysfs attribute
374 * defined for that. See the data sheet for details.
375 */
376
377static ssize_t get_div(struct device *dev, struct device_attribute *devattr,
378 char *buf)
379{
380 struct max6650_data *data = max6650_update_device(dev);
381
382 return sprintf(buf, "%d\n", DIV_FROM_REG(data->count));
383}
384
385static ssize_t set_div(struct device *dev, struct device_attribute *devattr,
386 const char *buf, size_t count)
387{
388 struct i2c_client *client = to_i2c_client(dev);
389 struct max6650_data *data = i2c_get_clientdata(client);
390 int div = simple_strtoul(buf, NULL, 10);
391
392 mutex_lock(&data->update_lock);
393 switch (div) {
394 case 1:
395 data->count = 0;
396 break;
397 case 2:
398 data->count = 1;
399 break;
400 case 4:
401 data->count = 2;
402 break;
403 case 8:
404 data->count = 3;
405 break;
406 default:
Jiri Slaby025dc742009-07-11 13:42:37 +0200407 mutex_unlock(&data->update_lock);
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200408 dev_err(&client->dev,
409 "illegal value for fan divider (%d)\n", div);
410 return -EINVAL;
411 }
412
413 i2c_smbus_write_byte_data(client, MAX6650_REG_COUNT, data->count);
414 mutex_unlock(&data->update_lock);
415
416 return count;
417}
418
Christian Engelmayer52b52262009-06-15 18:39:52 +0200419/*
420 * Get alarm stati:
421 * Possible values:
422 * 0 = no alarm
423 * 1 = alarm
424 */
425
426static ssize_t get_alarm(struct device *dev, struct device_attribute *devattr,
427 char *buf)
428{
429 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
430 struct max6650_data *data = max6650_update_device(dev);
431 struct i2c_client *client = to_i2c_client(dev);
432 int alarm = 0;
433
434 if (data->alarm & attr->index) {
435 mutex_lock(&data->update_lock);
436 alarm = 1;
437 data->alarm &= ~attr->index;
438 data->alarm |= i2c_smbus_read_byte_data(client,
439 MAX6650_REG_ALARM);
440 mutex_unlock(&data->update_lock);
441 }
442
443 return sprintf(buf, "%d\n", alarm);
444}
445
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200446static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, 0);
447static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan, NULL, 1);
448static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, get_fan, NULL, 2);
449static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, get_fan, NULL, 3);
450static DEVICE_ATTR(fan1_target, S_IWUSR | S_IRUGO, get_target, set_target);
451static DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO, get_div, set_div);
452static DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, get_enable, set_enable);
453static DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm, set_pwm);
Christian Engelmayer52b52262009-06-15 18:39:52 +0200454static SENSOR_DEVICE_ATTR(fan1_max_alarm, S_IRUGO, get_alarm, NULL,
455 MAX6650_ALRM_MAX);
456static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, get_alarm, NULL,
457 MAX6650_ALRM_MIN);
458static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_alarm, NULL,
459 MAX6650_ALRM_TACH);
460static SENSOR_DEVICE_ATTR(gpio1_alarm, S_IRUGO, get_alarm, NULL,
461 MAX6650_ALRM_GPIO1);
462static SENSOR_DEVICE_ATTR(gpio2_alarm, S_IRUGO, get_alarm, NULL,
463 MAX6650_ALRM_GPIO2);
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200464
Christian Engelmayer52b52262009-06-15 18:39:52 +0200465static mode_t max6650_attrs_visible(struct kobject *kobj, struct attribute *a,
466 int n)
467{
468 struct device *dev = container_of(kobj, struct device, kobj);
469 struct i2c_client *client = to_i2c_client(dev);
470 u8 alarm_en = i2c_smbus_read_byte_data(client, MAX6650_REG_ALARM_EN);
471 struct device_attribute *devattr;
472
473 /*
474 * Hide the alarms that have not been enabled by the firmware
475 */
476
477 devattr = container_of(a, struct device_attribute, attr);
478 if (devattr == &sensor_dev_attr_fan1_max_alarm.dev_attr
479 || devattr == &sensor_dev_attr_fan1_min_alarm.dev_attr
480 || devattr == &sensor_dev_attr_fan1_fault.dev_attr
481 || devattr == &sensor_dev_attr_gpio1_alarm.dev_attr
482 || devattr == &sensor_dev_attr_gpio2_alarm.dev_attr) {
483 if (!(alarm_en & to_sensor_dev_attr(devattr)->index))
484 return 0;
485 }
486
487 return a->mode;
488}
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200489
490static struct attribute *max6650_attrs[] = {
491 &sensor_dev_attr_fan1_input.dev_attr.attr,
492 &sensor_dev_attr_fan2_input.dev_attr.attr,
493 &sensor_dev_attr_fan3_input.dev_attr.attr,
494 &sensor_dev_attr_fan4_input.dev_attr.attr,
495 &dev_attr_fan1_target.attr,
496 &dev_attr_fan1_div.attr,
497 &dev_attr_pwm1_enable.attr,
498 &dev_attr_pwm1.attr,
Christian Engelmayer52b52262009-06-15 18:39:52 +0200499 &sensor_dev_attr_fan1_max_alarm.dev_attr.attr,
500 &sensor_dev_attr_fan1_min_alarm.dev_attr.attr,
501 &sensor_dev_attr_fan1_fault.dev_attr.attr,
502 &sensor_dev_attr_gpio1_alarm.dev_attr.attr,
503 &sensor_dev_attr_gpio2_alarm.dev_attr.attr,
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200504 NULL
505};
506
507static struct attribute_group max6650_attr_grp = {
508 .attrs = max6650_attrs,
Christian Engelmayer52b52262009-06-15 18:39:52 +0200509 .is_visible = max6650_attrs_visible,
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200510};
511
512/*
513 * Real code
514 */
515
Jean Delvare0d57abd2008-07-16 19:30:16 +0200516static int max6650_probe(struct i2c_client *client,
517 const struct i2c_device_id *id)
518{
519 struct max6650_data *data;
520 int err;
521
522 if (!(data = kzalloc(sizeof(struct max6650_data), GFP_KERNEL))) {
523 dev_err(&client->dev, "out of memory.\n");
524 return -ENOMEM;
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200525 }
526
Jean Delvare0d57abd2008-07-16 19:30:16 +0200527 i2c_set_clientdata(client, data);
528 mutex_init(&data->update_lock);
529
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200530 /*
531 * Initialize the max6650 chip
532 */
Jean Delvare0d57abd2008-07-16 19:30:16 +0200533 err = max6650_init_client(client);
534 if (err)
535 goto err_free;
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200536
537 err = sysfs_create_group(&client->dev.kobj, &max6650_attr_grp);
538 if (err)
Jean Delvare0d57abd2008-07-16 19:30:16 +0200539 goto err_free;
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200540
Tony Jones1beeffe2007-08-20 13:46:20 -0700541 data->hwmon_dev = hwmon_device_register(&client->dev);
542 if (!IS_ERR(data->hwmon_dev))
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200543 return 0;
544
Tony Jones1beeffe2007-08-20 13:46:20 -0700545 err = PTR_ERR(data->hwmon_dev);
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200546 dev_err(&client->dev, "error registering hwmon device.\n");
547 sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp);
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200548err_free:
549 kfree(data);
550 return err;
551}
552
Jean Delvare0d57abd2008-07-16 19:30:16 +0200553static int max6650_remove(struct i2c_client *client)
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200554{
555 struct max6650_data *data = i2c_get_clientdata(client);
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200556
557 sysfs_remove_group(&client->dev.kobj, &max6650_attr_grp);
Tony Jones1beeffe2007-08-20 13:46:20 -0700558 hwmon_device_unregister(data->hwmon_dev);
Jean Delvare0d57abd2008-07-16 19:30:16 +0200559 kfree(data);
560 return 0;
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200561}
562
563static int max6650_init_client(struct i2c_client *client)
564{
565 struct max6650_data *data = i2c_get_clientdata(client);
566 int config;
567 int err = -EIO;
568
569 config = i2c_smbus_read_byte_data(client, MAX6650_REG_CONFIG);
570
571 if (config < 0) {
572 dev_err(&client->dev, "Error reading config, aborting.\n");
573 return err;
574 }
575
576 switch (fan_voltage) {
577 case 0:
578 break;
579 case 5:
580 config &= ~MAX6650_CFG_V12;
581 break;
582 case 12:
583 config |= MAX6650_CFG_V12;
584 break;
585 default:
586 dev_err(&client->dev,
587 "illegal value for fan_voltage (%d)\n",
588 fan_voltage);
589 }
590
591 dev_info(&client->dev, "Fan voltage is set to %dV.\n",
592 (config & MAX6650_CFG_V12) ? 12 : 5);
593
594 switch (prescaler) {
595 case 0:
596 break;
597 case 1:
598 config &= ~MAX6650_CFG_PRESCALER_MASK;
599 break;
600 case 2:
601 config = (config & ~MAX6650_CFG_PRESCALER_MASK)
602 | MAX6650_CFG_PRESCALER_2;
603 break;
604 case 4:
605 config = (config & ~MAX6650_CFG_PRESCALER_MASK)
606 | MAX6650_CFG_PRESCALER_4;
607 break;
608 case 8:
609 config = (config & ~MAX6650_CFG_PRESCALER_MASK)
610 | MAX6650_CFG_PRESCALER_8;
611 break;
612 case 16:
613 config = (config & ~MAX6650_CFG_PRESCALER_MASK)
614 | MAX6650_CFG_PRESCALER_16;
615 break;
616 default:
617 dev_err(&client->dev,
618 "illegal value for prescaler (%d)\n",
619 prescaler);
620 }
621
622 dev_info(&client->dev, "Prescaler is set to %d.\n",
623 1 << (config & MAX6650_CFG_PRESCALER_MASK));
624
625 /* If mode is set to "full off", we change it to "open loop" and
626 * set DAC to 255, which has the same effect. We do this because
627 * there's no "full off" mode defined in hwmon specifcations.
628 */
629
630 if ((config & MAX6650_CFG_MODE_MASK) == MAX6650_CFG_MODE_OFF) {
631 dev_dbg(&client->dev, "Change mode to open loop, full off.\n");
632 config = (config & ~MAX6650_CFG_MODE_MASK)
633 | MAX6650_CFG_MODE_OPEN_LOOP;
634 if (i2c_smbus_write_byte_data(client, MAX6650_REG_DAC, 255)) {
635 dev_err(&client->dev, "DAC write error, aborting.\n");
636 return err;
637 }
638 }
639
640 if (i2c_smbus_write_byte_data(client, MAX6650_REG_CONFIG, config)) {
641 dev_err(&client->dev, "Config write error, aborting.\n");
642 return err;
643 }
644
645 data->config = config;
646 data->count = i2c_smbus_read_byte_data(client, MAX6650_REG_COUNT);
647
648 return 0;
649}
650
651static const u8 tach_reg[] = {
652 MAX6650_REG_TACH0,
653 MAX6650_REG_TACH1,
654 MAX6650_REG_TACH2,
655 MAX6650_REG_TACH3,
656};
657
658static struct max6650_data *max6650_update_device(struct device *dev)
659{
660 int i;
661 struct i2c_client *client = to_i2c_client(dev);
662 struct max6650_data *data = i2c_get_clientdata(client);
663
664 mutex_lock(&data->update_lock);
665
666 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
667 data->speed = i2c_smbus_read_byte_data(client,
668 MAX6650_REG_SPEED);
669 data->config = i2c_smbus_read_byte_data(client,
670 MAX6650_REG_CONFIG);
671 for (i = 0; i < 4; i++) {
672 data->tach[i] = i2c_smbus_read_byte_data(client,
673 tach_reg[i]);
674 }
675 data->count = i2c_smbus_read_byte_data(client,
676 MAX6650_REG_COUNT);
677 data->dac = i2c_smbus_read_byte_data(client, MAX6650_REG_DAC);
678
Christian Engelmayer52b52262009-06-15 18:39:52 +0200679 /* Alarms are cleared on read in case the condition that
680 * caused the alarm is removed. Keep the value latched here
681 * for providing the register through different alarm files. */
682 data->alarm |= i2c_smbus_read_byte_data(client,
683 MAX6650_REG_ALARM);
684
Hans-Juergen Kochd20620d2007-05-08 17:22:00 +0200685 data->last_updated = jiffies;
686 data->valid = 1;
687 }
688
689 mutex_unlock(&data->update_lock);
690
691 return data;
692}
693
694static int __init sensors_max6650_init(void)
695{
696 return i2c_add_driver(&max6650_driver);
697}
698
699static void __exit sensors_max6650_exit(void)
700{
701 i2c_del_driver(&max6650_driver);
702}
703
704MODULE_AUTHOR("Hans J. Koch");
705MODULE_DESCRIPTION("MAX6650 sensor driver");
706MODULE_LICENSE("GPL");
707
708module_init(sensors_max6650_init);
709module_exit(sensors_max6650_exit);