projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
hwmon: (f75375s) Let f75375_update_device treat pwmX as a measured value
[deliverable/linux.git] / drivers / hwmon / f75375s.c
1 /*
2 * f75375s.c - driver for the Fintek F75375/SP, F75373 and
3 * F75387SG/RG hardware monitoring features
4 * Copyright (C) 2006-2007 Riku Voipio
5 *
6 * Datasheets available at:
7 *
8 * f75375:
9 * http://www.fintek.com.tw/files/productfiles/F75375_V026P.pdf
10 *
11 * f75373:
12 * http://www.fintek.com.tw/files/productfiles/F75373_V025P.pdf
13 *
14 * f75387:
15 * http://www.fintek.com.tw/files/productfiles/F75387_V027P.pdf
16 *
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30 *
31 */
32
33 #include <linux/module.h>
34 #include <linux/jiffies.h>
35 #include <linux/hwmon.h>
36 #include <linux/hwmon-sysfs.h>
37 #include <linux/i2c.h>
38 #include <linux/err.h>
39 #include <linux/mutex.h>
40 #include <linux/f75375s.h>
41 #include <linux/slab.h>
42
43 /* Addresses to scan */
44 static const unsigned short normal_i2c[] = { 0x2d, 0x2e, I2C_CLIENT_END };
45
46 enum chips { f75373, f75375, f75387 };
47
48 /* Fintek F75375 registers */
49 #define F75375_REG_CONFIG0 0x0
50 #define F75375_REG_CONFIG1 0x1
51 #define F75375_REG_CONFIG2 0x2
52 #define F75375_REG_CONFIG3 0x3
53 #define F75375_REG_ADDR 0x4
54 #define F75375_REG_INTR 0x31
55 #define F75375_CHIP_ID 0x5A
56 #define F75375_REG_VERSION 0x5C
57 #define F75375_REG_VENDOR 0x5D
58 #define F75375_REG_FAN_TIMER 0x60
59
60 #define F75375_REG_VOLT(nr) (0x10 + (nr))
61 #define F75375_REG_VOLT_HIGH(nr) (0x20 + (nr) * 2)
62 #define F75375_REG_VOLT_LOW(nr) (0x21 + (nr) * 2)
63
64 #define F75375_REG_TEMP(nr) (0x14 + (nr))
65 #define F75387_REG_TEMP11_LSB(nr) (0x1a + (nr))
66 #define F75375_REG_TEMP_HIGH(nr) (0x28 + (nr) * 2)
67 #define F75375_REG_TEMP_HYST(nr) (0x29 + (nr) * 2)
68
69 #define F75375_REG_FAN(nr) (0x16 + (nr) * 2)
70 #define F75375_REG_FAN_MIN(nr) (0x2C + (nr) * 2)
71 #define F75375_REG_FAN_FULL(nr) (0x70 + (nr) * 0x10)
72 #define F75375_REG_FAN_PWM_DUTY(nr) (0x76 + (nr) * 0x10)
73 #define F75375_REG_FAN_PWM_CLOCK(nr) (0x7D + (nr) * 0x10)
74
75 #define F75375_REG_FAN_EXP(nr) (0x74 + (nr) * 0x10)
76 #define F75375_REG_FAN_B_TEMP(nr, step) ((0xA0 + (nr) * 0x10) + (step))
77 #define F75375_REG_FAN_B_SPEED(nr, step) \
78 ((0xA5 + (nr) * 0x10) + (step) * 2)
79
80 #define F75375_REG_PWM1_RAISE_DUTY 0x69
81 #define F75375_REG_PWM2_RAISE_DUTY 0x6A
82 #define F75375_REG_PWM1_DROP_DUTY 0x6B
83 #define F75375_REG_PWM2_DROP_DUTY 0x6C
84
85 #define F75375_FAN_CTRL_LINEAR(nr) (4 + nr)
86 #define F75387_FAN_CTRL_LINEAR(nr) (1 + ((nr) * 4))
87 #define FAN_CTRL_MODE(nr) (4 + ((nr) * 2))
88 #define F75387_FAN_DUTY_MODE(nr) (2 + ((nr) * 4))
89 #define F75387_FAN_MANU_MODE(nr) ((nr) * 4)
90
91 /*
92 * Data structures and manipulation thereof
93 */
94
95 struct f75375_data {
96 unsigned short addr;
97 struct device *hwmon_dev;
98
99 const char *name;
100 int kind;
101 struct mutex update_lock; /* protect register access */
102 char valid;
103 unsigned long last_updated; /* In jiffies */
104 unsigned long last_limits; /* In jiffies */
105
106 /* Register values */
107 u8 in[4];
108 u8 in_max[4];
109 u8 in_min[4];
110 u16 fan[2];
111 u16 fan_min[2];
112 u16 fan_max[2];
113 u16 fan_target[2];
114 u8 fan_timer;
115 u8 pwm[2];
116 u8 pwm_mode[2];
117 u8 pwm_enable[2];
118 /*
119 * f75387: For remote temperature reading, it uses signed 11-bit
120 * values with LSB = 0.125 degree Celsius, left-justified in 16-bit
121 * registers. For original 8-bit temp readings, the LSB just is 0.
122 */
123 s16 temp11[2];
124 s8 temp_high[2];
125 s8 temp_max_hyst[2];
126 };
127
128 static int f75375_detect(struct i2c_client *client,
129 struct i2c_board_info *info);
130 static int f75375_probe(struct i2c_client *client,
131 const struct i2c_device_id *id);
132 static int f75375_remove(struct i2c_client *client);
133
134 static const struct i2c_device_id f75375_id[] = {
135 { "f75373", f75373 },
136 { "f75375", f75375 },
137 { "f75387", f75387 },
138 { }
139 };
140 MODULE_DEVICE_TABLE(i2c, f75375_id);
141
142 static struct i2c_driver f75375_driver = {
143 .class = I2C_CLASS_HWMON,
144 .driver = {
145 .name = "f75375",
146 },
147 .probe = f75375_probe,
148 .remove = f75375_remove,
149 .id_table = f75375_id,
150 .detect = f75375_detect,
151 .address_list = normal_i2c,
152 };
153
154 static inline int f75375_read8(struct i2c_client *client, u8 reg)
155 {
156 return i2c_smbus_read_byte_data(client, reg);
157 }
158
159 /* in most cases, should be called while holding update_lock */
160 static inline u16 f75375_read16(struct i2c_client *client, u8 reg)
161 {
162 return (i2c_smbus_read_byte_data(client, reg) << 8)
163 | i2c_smbus_read_byte_data(client, reg + 1);
164 }
165
166 static inline void f75375_write8(struct i2c_client *client, u8 reg,
167 u8 value)
168 {
169 i2c_smbus_write_byte_data(client, reg, value);
170 }
171
172 static inline void f75375_write16(struct i2c_client *client, u8 reg,
173 u16 value)
174 {
175 int err = i2c_smbus_write_byte_data(client, reg, (value >> 8));
176 if (err)
177 return;
178 i2c_smbus_write_byte_data(client, reg + 1, (value & 0xFF));
179 }
180
181 static struct f75375_data *f75375_update_device(struct device *dev)
182 {
183 struct i2c_client *client = to_i2c_client(dev);
184 struct f75375_data *data = i2c_get_clientdata(client);
185 int nr;
186
187 mutex_lock(&data->update_lock);
188
189 /* Limit registers cache is refreshed after 60 seconds */
190 if (time_after(jiffies, data->last_limits + 60 * HZ)
191 || !data->valid) {
192 for (nr = 0; nr < 2; nr++) {
193 data->temp_high[nr] =
194 f75375_read8(client, F75375_REG_TEMP_HIGH(nr));
195 data->temp_max_hyst[nr] =
196 f75375_read8(client, F75375_REG_TEMP_HYST(nr));
197 data->fan_max[nr] =
198 f75375_read16(client, F75375_REG_FAN_FULL(nr));
199 data->fan_min[nr] =
200 f75375_read16(client, F75375_REG_FAN_MIN(nr));
201 data->fan_target[nr] =
202 f75375_read16(client, F75375_REG_FAN_EXP(nr));
203 }
204 for (nr = 0; nr < 4; nr++) {
205 data->in_max[nr] =
206 f75375_read8(client, F75375_REG_VOLT_HIGH(nr));
207 data->in_min[nr] =
208 f75375_read8(client, F75375_REG_VOLT_LOW(nr));
209 }
210 data->fan_timer = f75375_read8(client, F75375_REG_FAN_TIMER);
211 data->last_limits = jiffies;
212 }
213
214 /* Measurement registers cache is refreshed after 2 second */
215 if (time_after(jiffies, data->last_updated + 2 * HZ)
216 || !data->valid) {
217 for (nr = 0; nr < 2; nr++) {
218 data->pwm[nr] = f75375_read8(client,
219 F75375_REG_FAN_PWM_DUTY(nr));
220 /* assign MSB, therefore shift it by 8 bits */
221 data->temp11[nr] =
222 f75375_read8(client, F75375_REG_TEMP(nr)) << 8;
223 if (data->kind == f75387)
224 /* merge F75387's temperature LSB (11-bit) */
225 data->temp11[nr] |=
226 f75375_read8(client,
227 F75387_REG_TEMP11_LSB(nr));
228 data->fan[nr] =
229 f75375_read16(client, F75375_REG_FAN(nr));
230 }
231 for (nr = 0; nr < 4; nr++)
232 data->in[nr] =
233 f75375_read8(client, F75375_REG_VOLT(nr));
234
235 data->last_updated = jiffies;
236 data->valid = 1;
237 }
238
239 mutex_unlock(&data->update_lock);
240 return data;
241 }
242
243 static inline u16 rpm_from_reg(u16 reg)
244 {
245 if (reg == 0 || reg == 0xffff)
246 return 0;
247 return 1500000 / reg;
248 }
249
250 static inline u16 rpm_to_reg(int rpm)
251 {
252 if (rpm < 367 || rpm > 0xffff)
253 return 0xffff;
254 return 1500000 / rpm;
255 }
256
257 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
258 const char *buf, size_t count)
259 {
260 int nr = to_sensor_dev_attr(attr)->index;
261 struct i2c_client *client = to_i2c_client(dev);
262 struct f75375_data *data = i2c_get_clientdata(client);
263 unsigned long val;
264 int err;
265
266 err = kstrtoul(buf, 10, &val);
267 if (err < 0)
268 return err;
269
270 mutex_lock(&data->update_lock);
271 data->fan_min[nr] = rpm_to_reg(val);
272 f75375_write16(client, F75375_REG_FAN_MIN(nr), data->fan_min[nr]);
273 mutex_unlock(&data->update_lock);
274 return count;
275 }
276
277 static ssize_t set_fan_target(struct device *dev, struct device_attribute *attr,
278 const char *buf, size_t count)
279 {
280 int nr = to_sensor_dev_attr(attr)->index;
281 struct i2c_client *client = to_i2c_client(dev);
282 struct f75375_data *data = i2c_get_clientdata(client);
283 unsigned long val;
284 int err;
285
286 err = kstrtoul(buf, 10, &val);
287 if (err < 0)
288 return err;
289
290 mutex_lock(&data->update_lock);
291 data->fan_target[nr] = rpm_to_reg(val);
292 f75375_write16(client, F75375_REG_FAN_EXP(nr), data->fan_target[nr]);
293 mutex_unlock(&data->update_lock);
294 return count;
295 }
296
297 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
298 const char *buf, size_t count)
299 {
300 int nr = to_sensor_dev_attr(attr)->index;
301 struct i2c_client *client = to_i2c_client(dev);
302 struct f75375_data *data = i2c_get_clientdata(client);
303 unsigned long val;
304 int err;
305
306 err = kstrtoul(buf, 10, &val);
307 if (err < 0)
308 return err;
309
310 mutex_lock(&data->update_lock);
311 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
312 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr), data->pwm[nr]);
313 mutex_unlock(&data->update_lock);
314 return count;
315 }
316
317 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
318 *attr, char *buf)
319 {
320 int nr = to_sensor_dev_attr(attr)->index;
321 struct f75375_data *data = f75375_update_device(dev);
322 return sprintf(buf, "%d\n", data->pwm_enable[nr]);
323 }
324
325 static int set_pwm_enable_direct(struct i2c_client *client, int nr, int val)
326 {
327 struct f75375_data *data = i2c_get_clientdata(client);
328 u8 fanmode;
329
330 if (val < 0 || val > 3)
331 return -EINVAL;
332
333 fanmode = f75375_read8(client, F75375_REG_FAN_TIMER);
334 if (data->kind == f75387) {
335 /* clear each fanX_mode bit before setting them properly */
336 fanmode &= ~(1 << F75387_FAN_DUTY_MODE(nr));
337 fanmode &= ~(1 << F75387_FAN_MANU_MODE(nr));
338 switch (val) {
339 case 0: /* full speed */
340 fanmode |= (1 << F75387_FAN_MANU_MODE(nr));
341 fanmode |= (1 << F75387_FAN_DUTY_MODE(nr));
342 data->pwm[nr] = 255;
343 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr),
344 data->pwm[nr]);
345 break;
346 case 1: /* PWM */
347 fanmode |= (1 << F75387_FAN_MANU_MODE(nr));
348 fanmode |= (1 << F75387_FAN_DUTY_MODE(nr));
349 break;
350 case 2: /* AUTOMATIC*/
351 fanmode |= (1 << F75387_FAN_DUTY_MODE(nr));
352 break;
353 case 3: /* fan speed */
354 fanmode |= (1 << F75387_FAN_MANU_MODE(nr));
355 break;
356 }
357 } else {
358 /* clear each fanX_mode bit before setting them properly */
359 fanmode &= ~(3 << FAN_CTRL_MODE(nr));
360 switch (val) {
361 case 0: /* full speed */
362 fanmode |= (3 << FAN_CTRL_MODE(nr));
363 data->pwm[nr] = 255;
364 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr),
365 data->pwm[nr]);
366 break;
367 case 1: /* PWM */
368 fanmode |= (3 << FAN_CTRL_MODE(nr));
369 break;
370 case 2: /* AUTOMATIC*/
371 fanmode |= (1 << FAN_CTRL_MODE(nr));
372 break;
373 case 3: /* fan speed */
374 break;
375 }
376 }
377
378 f75375_write8(client, F75375_REG_FAN_TIMER, fanmode);
379 data->pwm_enable[nr] = val;
380 return 0;
381 }
382
383 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
384 const char *buf, size_t count)
385 {
386 int nr = to_sensor_dev_attr(attr)->index;
387 struct i2c_client *client = to_i2c_client(dev);
388 struct f75375_data *data = i2c_get_clientdata(client);
389 unsigned long val;
390 int err;
391
392 err = kstrtoul(buf, 10, &val);
393 if (err < 0)
394 return err;
395
396 mutex_lock(&data->update_lock);
397 err = set_pwm_enable_direct(client, nr, val);
398 mutex_unlock(&data->update_lock);
399 return err ? err : count;
400 }
401
402 static ssize_t set_pwm_mode(struct device *dev, struct device_attribute *attr,
403 const char *buf, size_t count)
404 {
405 int nr = to_sensor_dev_attr(attr)->index;
406 struct i2c_client *client = to_i2c_client(dev);
407 struct f75375_data *data = i2c_get_clientdata(client);
408 unsigned long val;
409 int err;
410 u8 conf;
411 char reg, ctrl;
412
413 err = kstrtoul(buf, 10, &val);
414 if (err < 0)
415 return err;
416
417 if (!(val == 0 || val == 1))
418 return -EINVAL;
419
420 /* F75373 does not support DC (linear voltage) fan control mode */
421 if (data->kind == f75373 && val == 0)
422 return -EINVAL;
423
424 /* take care for different registers */
425 if (data->kind == f75387) {
426 reg = F75375_REG_FAN_TIMER;
427 ctrl = F75387_FAN_CTRL_LINEAR(nr);
428 } else {
429 reg = F75375_REG_CONFIG1;
430 ctrl = F75375_FAN_CTRL_LINEAR(nr);
431 }
432
433 mutex_lock(&data->update_lock);
434 conf = f75375_read8(client, reg);
435 conf &= ~(1 << ctrl);
436
437 if (val == 0)
438 conf |= (1 << ctrl);
439
440 f75375_write8(client, reg, conf);
441 data->pwm_mode[nr] = val;
442 mutex_unlock(&data->update_lock);
443 return count;
444 }
445
446 static ssize_t show_pwm(struct device *dev, struct device_attribute
447 *attr, char *buf)
448 {
449 int nr = to_sensor_dev_attr(attr)->index;
450 struct f75375_data *data = f75375_update_device(dev);
451 return sprintf(buf, "%d\n", data->pwm[nr]);
452 }
453
454 static ssize_t show_pwm_mode(struct device *dev, struct device_attribute
455 *attr, char *buf)
456 {
457 int nr = to_sensor_dev_attr(attr)->index;
458 struct f75375_data *data = f75375_update_device(dev);
459 return sprintf(buf, "%d\n", data->pwm_mode[nr]);
460 }
461
462 #define VOLT_FROM_REG(val) ((val) * 8)
463 #define VOLT_TO_REG(val) ((val) / 8)
464
465 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
466 char *buf)
467 {
468 int nr = to_sensor_dev_attr(attr)->index;
469 struct f75375_data *data = f75375_update_device(dev);
470 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in[nr]));
471 }
472
473 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
474 char *buf)
475 {
476 int nr = to_sensor_dev_attr(attr)->index;
477 struct f75375_data *data = f75375_update_device(dev);
478 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_max[nr]));
479 }
480
481 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
482 char *buf)
483 {
484 int nr = to_sensor_dev_attr(attr)->index;
485 struct f75375_data *data = f75375_update_device(dev);
486 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_min[nr]));
487 }
488
489 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
490 const char *buf, size_t count)
491 {
492 int nr = to_sensor_dev_attr(attr)->index;
493 struct i2c_client *client = to_i2c_client(dev);
494 struct f75375_data *data = i2c_get_clientdata(client);
495 unsigned long val;
496 int err;
497
498 err = kstrtoul(buf, 10, &val);
499 if (err < 0)
500 return err;
501
502 val = SENSORS_LIMIT(VOLT_TO_REG(val), 0, 0xff);
503 mutex_lock(&data->update_lock);
504 data->in_max[nr] = val;
505 f75375_write8(client, F75375_REG_VOLT_HIGH(nr), data->in_max[nr]);
506 mutex_unlock(&data->update_lock);
507 return count;
508 }
509
510 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
511 const char *buf, size_t count)
512 {
513 int nr = to_sensor_dev_attr(attr)->index;
514 struct i2c_client *client = to_i2c_client(dev);
515 struct f75375_data *data = i2c_get_clientdata(client);
516 unsigned long val;
517 int err;
518
519 err = kstrtoul(buf, 10, &val);
520 if (err < 0)
521 return err;
522
523 val = SENSORS_LIMIT(VOLT_TO_REG(val), 0, 0xff);
524 mutex_lock(&data->update_lock);
525 data->in_min[nr] = val;
526 f75375_write8(client, F75375_REG_VOLT_LOW(nr), data->in_min[nr]);
527 mutex_unlock(&data->update_lock);
528 return count;
529 }
530 #define TEMP_FROM_REG(val) ((val) * 1000)
531 #define TEMP_TO_REG(val) ((val) / 1000)
532 #define TEMP11_FROM_REG(reg) ((reg) / 32 * 125)
533
534 static ssize_t show_temp11(struct device *dev, struct device_attribute *attr,
535 char *buf)
536 {
537 int nr = to_sensor_dev_attr(attr)->index;
538 struct f75375_data *data = f75375_update_device(dev);
539 return sprintf(buf, "%d\n", TEMP11_FROM_REG(data->temp11[nr]));
540 }
541
542 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
543 char *buf)
544 {
545 int nr = to_sensor_dev_attr(attr)->index;
546 struct f75375_data *data = f75375_update_device(dev);
547 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
548 }
549
550 static ssize_t show_temp_max_hyst(struct device *dev,
551 struct device_attribute *attr, char *buf)
552 {
553 int nr = to_sensor_dev_attr(attr)->index;
554 struct f75375_data *data = f75375_update_device(dev);
555 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[nr]));
556 }
557
558 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
559 const char *buf, size_t count)
560 {
561 int nr = to_sensor_dev_attr(attr)->index;
562 struct i2c_client *client = to_i2c_client(dev);
563 struct f75375_data *data = i2c_get_clientdata(client);
564 unsigned long val;
565 int err;
566
567 err = kstrtoul(buf, 10, &val);
568 if (err < 0)
569 return err;
570
571 val = SENSORS_LIMIT(TEMP_TO_REG(val), 0, 127);
572 mutex_lock(&data->update_lock);
573 data->temp_high[nr] = val;
574 f75375_write8(client, F75375_REG_TEMP_HIGH(nr), data->temp_high[nr]);
575 mutex_unlock(&data->update_lock);
576 return count;
577 }
578
579 static ssize_t set_temp_max_hyst(struct device *dev,
580 struct device_attribute *attr, const char *buf, size_t count)
581 {
582 int nr = to_sensor_dev_attr(attr)->index;
583 struct i2c_client *client = to_i2c_client(dev);
584 struct f75375_data *data = i2c_get_clientdata(client);
585 unsigned long val;
586 int err;
587
588 err = kstrtoul(buf, 10, &val);
589 if (err < 0)
590 return err;
591
592 val = SENSORS_LIMIT(TEMP_TO_REG(val), 0, 127);
593 mutex_lock(&data->update_lock);
594 data->temp_max_hyst[nr] = val;
595 f75375_write8(client, F75375_REG_TEMP_HYST(nr),
596 data->temp_max_hyst[nr]);
597 mutex_unlock(&data->update_lock);
598 return count;
599 }
600
601 #define show_fan(thing) \
602 static ssize_t show_##thing(struct device *dev, struct device_attribute *attr, \
603 char *buf)\
604 {\
605 int nr = to_sensor_dev_attr(attr)->index;\
606 struct f75375_data *data = f75375_update_device(dev); \
607 return sprintf(buf, "%d\n", rpm_from_reg(data->thing[nr])); \
608 }
609
610 show_fan(fan);
611 show_fan(fan_min);
612 show_fan(fan_max);
613 show_fan(fan_target);
614
615 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0);
616 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO|S_IWUSR,
617 show_in_max, set_in_max, 0);
618 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO|S_IWUSR,
619 show_in_min, set_in_min, 0);
620 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
621 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO|S_IWUSR,
622 show_in_max, set_in_max, 1);
623 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO|S_IWUSR,
624 show_in_min, set_in_min, 1);
625 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
626 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO|S_IWUSR,
627 show_in_max, set_in_max, 2);
628 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO|S_IWUSR,
629 show_in_min, set_in_min, 2);
630 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
631 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO|S_IWUSR,
632 show_in_max, set_in_max, 3);
633 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO|S_IWUSR,
634 show_in_min, set_in_min, 3);
635 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 0);
636 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO|S_IWUSR,
637 show_temp_max_hyst, set_temp_max_hyst, 0);
638 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO|S_IWUSR,
639 show_temp_max, set_temp_max, 0);
640 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 1);
641 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO|S_IWUSR,
642 show_temp_max_hyst, set_temp_max_hyst, 1);
643 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO|S_IWUSR,
644 show_temp_max, set_temp_max, 1);
645 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
646 static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO, show_fan_max, NULL, 0);
647 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO|S_IWUSR,
648 show_fan_min, set_fan_min, 0);
649 static SENSOR_DEVICE_ATTR(fan1_target, S_IRUGO|S_IWUSR,
650 show_fan_target, set_fan_target, 0);
651 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
652 static SENSOR_DEVICE_ATTR(fan2_max, S_IRUGO, show_fan_max, NULL, 1);
653 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO|S_IWUSR,
654 show_fan_min, set_fan_min, 1);
655 static SENSOR_DEVICE_ATTR(fan2_target, S_IRUGO|S_IWUSR,
656 show_fan_target, set_fan_target, 1);
657 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR,
658 show_pwm, set_pwm, 0);
659 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR,
660 show_pwm_enable, set_pwm_enable, 0);
661 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO,
662 show_pwm_mode, set_pwm_mode, 0);
663 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR,
664 show_pwm, set_pwm, 1);
665 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR,
666 show_pwm_enable, set_pwm_enable, 1);
667 static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO,
668 show_pwm_mode, set_pwm_mode, 1);
669
670 static struct attribute *f75375_attributes[] = {
671 &sensor_dev_attr_temp1_input.dev_attr.attr,
672 &sensor_dev_attr_temp1_max.dev_attr.attr,
673 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
674 &sensor_dev_attr_temp2_input.dev_attr.attr,
675 &sensor_dev_attr_temp2_max.dev_attr.attr,
676 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
677 &sensor_dev_attr_fan1_input.dev_attr.attr,
678 &sensor_dev_attr_fan1_max.dev_attr.attr,
679 &sensor_dev_attr_fan1_min.dev_attr.attr,
680 &sensor_dev_attr_fan1_target.dev_attr.attr,
681 &sensor_dev_attr_fan2_input.dev_attr.attr,
682 &sensor_dev_attr_fan2_max.dev_attr.attr,
683 &sensor_dev_attr_fan2_min.dev_attr.attr,
684 &sensor_dev_attr_fan2_target.dev_attr.attr,
685 &sensor_dev_attr_pwm1.dev_attr.attr,
686 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
687 &sensor_dev_attr_pwm1_mode.dev_attr.attr,
688 &sensor_dev_attr_pwm2.dev_attr.attr,
689 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
690 &sensor_dev_attr_pwm2_mode.dev_attr.attr,
691 &sensor_dev_attr_in0_input.dev_attr.attr,
692 &sensor_dev_attr_in0_max.dev_attr.attr,
693 &sensor_dev_attr_in0_min.dev_attr.attr,
694 &sensor_dev_attr_in1_input.dev_attr.attr,
695 &sensor_dev_attr_in1_max.dev_attr.attr,
696 &sensor_dev_attr_in1_min.dev_attr.attr,
697 &sensor_dev_attr_in2_input.dev_attr.attr,
698 &sensor_dev_attr_in2_max.dev_attr.attr,
699 &sensor_dev_attr_in2_min.dev_attr.attr,
700 &sensor_dev_attr_in3_input.dev_attr.attr,
701 &sensor_dev_attr_in3_max.dev_attr.attr,
702 &sensor_dev_attr_in3_min.dev_attr.attr,
703 NULL
704 };
705
706 static const struct attribute_group f75375_group = {
707 .attrs = f75375_attributes,
708 };
709
710 static void f75375_init(struct i2c_client *client, struct f75375_data *data,
711 struct f75375s_platform_data *f75375s_pdata)
712 {
713 int nr;
714
715 if (!f75375s_pdata) {
716 u8 conf, mode;
717 int nr;
718
719 conf = f75375_read8(client, F75375_REG_CONFIG1);
720 mode = f75375_read8(client, F75375_REG_FAN_TIMER);
721 for (nr = 0; nr < 2; nr++) {
722 if (data->kind == f75387) {
723 bool manu, duty;
724
725 if (!(mode & (1 << F75387_FAN_CTRL_LINEAR(nr))))
726 data->pwm_mode[nr] = 1;
727
728 manu = ((mode >> F75387_FAN_MANU_MODE(nr)) & 1);
729 duty = ((mode >> F75387_FAN_DUTY_MODE(nr)) & 1);
730 if (manu && duty)
731 /* speed */
732 data->pwm_enable[nr] = 3;
733 else if (!manu && duty)
734 /* automatic */
735 data->pwm_enable[nr] = 2;
736 else
737 /* manual */
738 data->pwm_enable[nr] = 1;
739 } else {
740 if (!(conf & (1 << F75375_FAN_CTRL_LINEAR(nr))))
741 data->pwm_mode[nr] = 1;
742
743 switch ((mode >> FAN_CTRL_MODE(nr)) & 3) {
744 case 0: /* speed */
745 data->pwm_enable[nr] = 3;
746 break;
747 case 1: /* automatic */
748 data->pwm_enable[nr] = 2;
749 break;
750 default: /* manual */
751 data->pwm_enable[nr] = 1;
752 break;
753 }
754 }
755 }
756 return;
757 }
758
759 set_pwm_enable_direct(client, 0, f75375s_pdata->pwm_enable[0]);
760 set_pwm_enable_direct(client, 1, f75375s_pdata->pwm_enable[1]);
761 for (nr = 0; nr < 2; nr++) {
762 data->pwm[nr] = SENSORS_LIMIT(f75375s_pdata->pwm[nr], 0, 255);
763 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr),
764 data->pwm[nr]);
765 }
766
767 }
768
769 static int f75375_probe(struct i2c_client *client,
770 const struct i2c_device_id *id)
771 {
772 struct f75375_data *data;
773 struct f75375s_platform_data *f75375s_pdata = client->dev.platform_data;
774 int err;
775
776 if (!i2c_check_functionality(client->adapter,
777 I2C_FUNC_SMBUS_BYTE_DATA))
778 return -EIO;
779 data = kzalloc(sizeof(struct f75375_data), GFP_KERNEL);
780 if (!data)
781 return -ENOMEM;
782
783 i2c_set_clientdata(client, data);
784 mutex_init(&data->update_lock);
785 data->kind = id->driver_data;
786
787 err = sysfs_create_group(&client->dev.kobj, &f75375_group);
788 if (err)
789 goto exit_free;
790
791 if (data->kind == f75375) {
792 err = sysfs_chmod_file(&client->dev.kobj,
793 &sensor_dev_attr_pwm1_mode.dev_attr.attr,
794 S_IRUGO | S_IWUSR);
795 if (err)
796 goto exit_remove;
797 err = sysfs_chmod_file(&client->dev.kobj,
798 &sensor_dev_attr_pwm2_mode.dev_attr.attr,
799 S_IRUGO | S_IWUSR);
800 if (err)
801 goto exit_remove;
802 }
803
804 data->hwmon_dev = hwmon_device_register(&client->dev);
805 if (IS_ERR(data->hwmon_dev)) {
806 err = PTR_ERR(data->hwmon_dev);
807 goto exit_remove;
808 }
809
810 f75375_init(client, data, f75375s_pdata);
811
812 return 0;
813
814 exit_remove:
815 sysfs_remove_group(&client->dev.kobj, &f75375_group);
816 exit_free:
817 kfree(data);
818 return err;
819 }
820
821 static int f75375_remove(struct i2c_client *client)
822 {
823 struct f75375_data *data = i2c_get_clientdata(client);
824 hwmon_device_unregister(data->hwmon_dev);
825 sysfs_remove_group(&client->dev.kobj, &f75375_group);
826 kfree(data);
827 return 0;
828 }
829
830 /* Return 0 if detection is successful, -ENODEV otherwise */
831 static int f75375_detect(struct i2c_client *client,
832 struct i2c_board_info *info)
833 {
834 struct i2c_adapter *adapter = client->adapter;
835 u16 vendid, chipid;
836 u8 version;
837 const char *name;
838
839 vendid = f75375_read16(client, F75375_REG_VENDOR);
840 chipid = f75375_read16(client, F75375_CHIP_ID);
841 if (vendid != 0x1934)
842 return -ENODEV;
843
844 if (chipid == 0x0306)
845 name = "f75375";
846 else if (chipid == 0x0204)
847 name = "f75373";
848 else if (chipid == 0x0410)
849 name = "f75387";
850 else
851 return -ENODEV;
852
853 version = f75375_read8(client, F75375_REG_VERSION);
854 dev_info(&adapter->dev, "found %s version: %02X\n", name, version);
855 strlcpy(info->type, name, I2C_NAME_SIZE);
856
857 return 0;
858 }
859
860 static int __init sensors_f75375_init(void)
861 {
862 return i2c_add_driver(&f75375_driver);
863 }
864
865 static void __exit sensors_f75375_exit(void)
866 {
867 i2c_del_driver(&f75375_driver);
868 }
869
870 MODULE_AUTHOR("Riku Voipio");
871 MODULE_LICENSE("GPL");
872 MODULE_DESCRIPTION("F75373/F75375/F75387 hardware monitoring driver");
873
874 module_init(sensors_f75375_init);
875 module_exit(sensors_f75375_exit);
Linux kernel - Deliverables
This page took 0.069977 seconds and 5 git commands to generate.