aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/hwmon/f75375s.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/hwmon/f75375s.c')
-rw-r--r--drivers/hwmon/f75375s.c691
1 files changed, 691 insertions, 0 deletions
diff --git a/drivers/hwmon/f75375s.c b/drivers/hwmon/f75375s.c
new file mode 100644
index 000000000000..6425184d9316
--- /dev/null
+++ b/drivers/hwmon/f75375s.c
@@ -0,0 +1,691 @@
1/*
2 * f75375s.c - driver for the Fintek F75375/SP and F75373
3 * hardware monitoring features
4 * Copyright (C) 2006-2007 Riku Voipio <riku.voipio@movial.fi>
5 *
6 * Datasheets available at:
7 *
8 * f75375:
9 * http://www.fintek.com.tw/files/productfiles/2005111152950.pdf
10 *
11 * f75373:
12 * http://www.fintek.com.tw/files/productfiles/2005111153128.pdf
13 *
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 *
28 */
29
30#include <linux/module.h>
31#include <linux/jiffies.h>
32#include <linux/hwmon.h>
33#include <linux/hwmon-sysfs.h>
34#include <linux/i2c.h>
35#include <linux/err.h>
36#include <linux/mutex.h>
37
38/* Addresses to scan */
39static unsigned short normal_i2c[] = { 0x2d, 0x2e, I2C_CLIENT_END };
40
41/* Insmod parameters */
42I2C_CLIENT_INSMOD_2(f75373, f75375);
43
44/* Fintek F75375 registers */
45#define F75375_REG_CONFIG0 0x0
46#define F75375_REG_CONFIG1 0x1
47#define F75375_REG_CONFIG2 0x2
48#define F75375_REG_CONFIG3 0x3
49#define F75375_REG_ADDR 0x4
50#define F75375_REG_INTR 0x31
51#define F75375_CHIP_ID 0x5A
52#define F75375_REG_VERSION 0x5C
53#define F75375_REG_VENDOR 0x5D
54#define F75375_REG_FAN_TIMER 0x60
55
56#define F75375_REG_VOLT(nr) (0x10 + (nr))
57#define F75375_REG_VOLT_HIGH(nr) (0x20 + (nr) * 2)
58#define F75375_REG_VOLT_LOW(nr) (0x21 + (nr) * 2)
59
60#define F75375_REG_TEMP(nr) (0x14 + (nr))
61#define F75375_REG_TEMP_HIGH(nr) (0x28 + (nr) * 2)
62#define F75375_REG_TEMP_HYST(nr) (0x29 + (nr) * 2)
63
64#define F75375_REG_FAN(nr) (0x16 + (nr) * 2)
65#define F75375_REG_FAN_MIN(nr) (0x2C + (nr) * 2)
66#define F75375_REG_FAN_FULL(nr) (0x70 + (nr) * 0x10)
67#define F75375_REG_FAN_PWM_DUTY(nr) (0x76 + (nr) * 0x10)
68#define F75375_REG_FAN_PWM_CLOCK(nr) (0x7D + (nr) * 0x10)
69
70#define F75375_REG_FAN_EXP(nr) (0x74 + (nr) * 0x10)
71#define F75375_REG_FAN_B_TEMP(nr, step) ((0xA0 + (nr) * 0x10) + (step))
72#define F75375_REG_FAN_B_SPEED(nr, step) \
73 ((0xA5 + (nr) * 0x10) + (step) * 2)
74
75#define F75375_REG_PWM1_RAISE_DUTY 0x69
76#define F75375_REG_PWM2_RAISE_DUTY 0x6A
77#define F75375_REG_PWM1_DROP_DUTY 0x6B
78#define F75375_REG_PWM2_DROP_DUTY 0x6C
79
80#define FAN_CTRL_LINEAR(nr) (4 + nr)
81#define FAN_CTRL_MODE(nr) (5 + ((nr) * 2))
82
83/*
84 * Data structures and manipulation thereof
85 */
86
87struct f75375_data {
88 unsigned short addr;
89 struct i2c_client client;
90 struct class_device *class_dev;
91
92 const char *name;
93 int kind;
94 struct mutex update_lock; /* protect register access */
95 char valid;
96 unsigned long last_updated; /* In jiffies */
97 unsigned long last_limits; /* In jiffies */
98
99 /* Register values */
100 u8 in[4];
101 u8 in_max[4];
102 u8 in_min[4];
103 u16 fan[2];
104 u16 fan_min[2];
105 u16 fan_full[2];
106 u16 fan_exp[2];
107 u8 fan_timer;
108 u8 pwm[2];
109 u8 pwm_mode[2];
110 u8 pwm_enable[2];
111 s8 temp[2];
112 s8 temp_high[2];
113 s8 temp_max_hyst[2];
114};
115
116static int f75375_attach_adapter(struct i2c_adapter *adapter);
117static int f75375_detect(struct i2c_adapter *adapter, int address, int kind);
118static int f75375_detach_client(struct i2c_client *client);
119
120static struct i2c_driver f75375_driver = {
121 .driver = {
122 .name = "f75375",
123 },
124 .attach_adapter = f75375_attach_adapter,
125 .detach_client = f75375_detach_client,
126};
127
128static inline int f75375_read8(struct i2c_client *client, u8 reg)
129{
130 return i2c_smbus_read_byte_data(client, reg);
131}
132
133/* in most cases, should be called while holding update_lock */
134static inline u16 f75375_read16(struct i2c_client *client, u8 reg)
135{
136 return ((i2c_smbus_read_byte_data(client, reg) << 8)
137 | i2c_smbus_read_byte_data(client, reg + 1));
138}
139
140static inline void f75375_write8(struct i2c_client *client, u8 reg,
141 u8 value)
142{
143 i2c_smbus_write_byte_data(client, reg, value);
144}
145
146static inline void f75375_write16(struct i2c_client *client, u8 reg,
147 u16 value)
148{
149 int err = i2c_smbus_write_byte_data(client, reg, (value << 8));
150 if (err)
151 return;
152 i2c_smbus_write_byte_data(client, reg + 1, (value & 0xFF));
153}
154
155static struct f75375_data *f75375_update_device(struct device *dev)
156{
157 struct i2c_client *client = to_i2c_client(dev);
158 struct f75375_data *data = i2c_get_clientdata(client);
159 int nr;
160
161 mutex_lock(&data->update_lock);
162
163 /* Limit registers cache is refreshed after 60 seconds */
164 if (time_after(jiffies, data->last_limits + 60 * HZ)
165 || !data->valid) {
166 for (nr = 0; nr < 2; nr++) {
167 data->temp_high[nr] =
168 f75375_read8(client, F75375_REG_TEMP_HIGH(nr));
169 data->temp_max_hyst[nr] =
170 f75375_read8(client, F75375_REG_TEMP_HYST(nr));
171 data->fan_full[nr] =
172 f75375_read16(client, F75375_REG_FAN_FULL(nr));
173 data->fan_min[nr] =
174 f75375_read16(client, F75375_REG_FAN_MIN(nr));
175 data->fan_exp[nr] =
176 f75375_read16(client, F75375_REG_FAN_EXP(nr));
177 data->pwm[nr] = f75375_read8(client,
178 F75375_REG_FAN_PWM_DUTY(nr));
179
180 }
181 for (nr = 0; nr < 4; nr++) {
182 data->in_max[nr] =
183 f75375_read8(client, F75375_REG_VOLT_HIGH(nr));
184 data->in_min[nr] =
185 f75375_read8(client, F75375_REG_VOLT_LOW(nr));
186 }
187 data->fan_timer = f75375_read8(client, F75375_REG_FAN_TIMER);
188 data->last_limits = jiffies;
189 }
190
191 /* Measurement registers cache is refreshed after 2 second */
192 if (time_after(jiffies, data->last_updated + 2 * HZ)
193 || !data->valid) {
194 for (nr = 0; nr < 2; nr++) {
195 data->temp[nr] =
196 f75375_read8(client, F75375_REG_TEMP(nr));
197 data->fan[nr] =
198 f75375_read16(client, F75375_REG_FAN(nr));
199 }
200 for (nr = 0; nr < 4; nr++)
201 data->in[nr] =
202 f75375_read8(client, F75375_REG_VOLT(nr));
203
204 data->last_updated = jiffies;
205 data->valid = 1;
206 }
207
208 mutex_unlock(&data->update_lock);
209 return data;
210}
211
212static inline u16 rpm_from_reg(u16 reg)
213{
214 if (reg == 0 || reg == 0xffff)
215 return 0;
216 return (1500000 / reg);
217}
218
219static inline u16 rpm_to_reg(int rpm)
220{
221 if (rpm < 367 || rpm > 0xffff)
222 return 0xffff;
223 return (1500000 / rpm);
224}
225
226static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
227 const char *buf, size_t count)
228{
229 int nr = to_sensor_dev_attr(attr)->index;
230 struct i2c_client *client = to_i2c_client(dev);
231 struct f75375_data *data = i2c_get_clientdata(client);
232 int val = simple_strtoul(buf, NULL, 10);
233
234 mutex_lock(&data->update_lock);
235 data->fan_min[nr] = rpm_to_reg(val);
236 f75375_write16(client, F75375_REG_FAN_MIN(nr), data->fan_min[nr]);
237 mutex_unlock(&data->update_lock);
238 return count;
239}
240
241static ssize_t set_fan_exp(struct device *dev, struct device_attribute *attr,
242 const char *buf, size_t count)
243{
244 int nr = to_sensor_dev_attr(attr)->index;
245 struct i2c_client *client = to_i2c_client(dev);
246 struct f75375_data *data = i2c_get_clientdata(client);
247 int val = simple_strtoul(buf, NULL, 10);
248
249 mutex_lock(&data->update_lock);
250 data->fan_exp[nr] = rpm_to_reg(val);
251 f75375_write16(client, F75375_REG_FAN_EXP(nr), data->fan_exp[nr]);
252 mutex_unlock(&data->update_lock);
253 return count;
254}
255
256static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
257 const char *buf, size_t count)
258{
259 int nr = to_sensor_dev_attr(attr)->index;
260 struct i2c_client *client = to_i2c_client(dev);
261 struct f75375_data *data = i2c_get_clientdata(client);
262 int val = simple_strtoul(buf, NULL, 10);
263
264 mutex_lock(&data->update_lock);
265 data->pwm[nr] = SENSORS_LIMIT(val, 0, 255);
266 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr), data->pwm[nr]);
267 mutex_unlock(&data->update_lock);
268 return count;
269}
270
271static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
272 *attr, char *buf)
273{
274 int nr = to_sensor_dev_attr(attr)->index;
275 struct f75375_data *data = f75375_update_device(dev);
276 return sprintf(buf, "%d\n", data->pwm_enable[nr]);
277}
278
279static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
280 const char *buf, size_t count)
281{
282 int nr = to_sensor_dev_attr(attr)->index;
283 struct i2c_client *client = to_i2c_client(dev);
284 struct f75375_data *data = i2c_get_clientdata(client);
285 int val = simple_strtoul(buf, NULL, 10);
286 u8 fanmode;
287
288 if (val < 0 || val > 4)
289 return -EINVAL;
290
291 mutex_lock(&data->update_lock);
292 fanmode = f75375_read8(client, F75375_REG_FAN_TIMER);
293 fanmode = ~(3 << FAN_CTRL_MODE(nr));
294
295 switch (val) {
296 case 0: /* Full speed */
297 fanmode |= (3 << FAN_CTRL_MODE(nr));
298 data->pwm[nr] = 255;
299 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr),
300 data->pwm[nr]);
301 break;
302 case 1: /* PWM */
303 fanmode |= (3 << FAN_CTRL_MODE(nr));
304 break;
305 case 2: /* AUTOMATIC*/
306 fanmode |= (2 << FAN_CTRL_MODE(nr));
307 break;
308 case 3: /* fan speed */
309 break;
310 }
311 f75375_write8(client, F75375_REG_FAN_TIMER, fanmode);
312 data->pwm_enable[nr] = val;
313 mutex_unlock(&data->update_lock);
314 return count;
315}
316
317static ssize_t set_pwm_mode(struct device *dev, struct device_attribute *attr,
318 const char *buf, size_t count)
319{
320 int nr = to_sensor_dev_attr(attr)->index;
321 struct i2c_client *client = to_i2c_client(dev);
322 struct f75375_data *data = i2c_get_clientdata(client);
323 int val = simple_strtoul(buf, NULL, 10);
324 u8 conf = 0;
325
326 if (val != 0 || val != 1 || data->kind == f75373)
327 return -EINVAL;
328
329 mutex_lock(&data->update_lock);
330 conf = f75375_read8(client, F75375_REG_CONFIG1);
331 conf = ~(1 << FAN_CTRL_LINEAR(nr));
332
333 if (val == 0)
334 conf |= (1 << FAN_CTRL_LINEAR(nr)) ;
335
336 f75375_write8(client, F75375_REG_CONFIG1, conf);
337 data->pwm_mode[nr] = val;
338 mutex_unlock(&data->update_lock);
339 return count;
340}
341
342static ssize_t show_pwm(struct device *dev, struct device_attribute
343 *attr, char *buf)
344{
345 int nr = to_sensor_dev_attr(attr)->index;
346 struct f75375_data *data = f75375_update_device(dev);
347 return sprintf(buf, "%d\n", data->pwm[nr]);
348}
349
350static ssize_t show_pwm_mode(struct device *dev, struct device_attribute
351 *attr, char *buf)
352{
353 int nr = to_sensor_dev_attr(attr)->index;
354 struct f75375_data *data = f75375_update_device(dev);
355 return sprintf(buf, "%d\n", data->pwm_mode[nr]);
356}
357
358#define VOLT_FROM_REG(val) ((val) * 8)
359#define VOLT_TO_REG(val) ((val) / 8)
360
361static ssize_t show_in(struct device *dev, struct device_attribute *attr,
362 char *buf)
363{
364 int nr = to_sensor_dev_attr(attr)->index;
365 struct f75375_data *data = f75375_update_device(dev);
366 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in[nr]));
367}
368
369static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
370 char *buf)
371{
372 int nr = to_sensor_dev_attr(attr)->index;
373 struct f75375_data *data = f75375_update_device(dev);
374 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_max[nr]));
375}
376
377static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
378 char *buf)
379{
380 int nr = to_sensor_dev_attr(attr)->index;
381 struct f75375_data *data = f75375_update_device(dev);
382 return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_min[nr]));
383}
384
385static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
386 const char *buf, size_t count)
387{
388 int nr = to_sensor_dev_attr(attr)->index;
389 struct i2c_client *client = to_i2c_client(dev);
390 struct f75375_data *data = i2c_get_clientdata(client);
391 int val = simple_strtoul(buf, NULL, 10);
392 val = SENSORS_LIMIT(VOLT_TO_REG(val), 0, 0xff);
393 mutex_lock(&data->update_lock);
394 data->in_max[nr] = val;
395 f75375_write8(client, F75375_REG_VOLT_HIGH(nr), data->in_max[nr]);
396 mutex_unlock(&data->update_lock);
397 return count;
398}
399
400static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
401 const char *buf, size_t count)
402{
403 int nr = to_sensor_dev_attr(attr)->index;
404 struct i2c_client *client = to_i2c_client(dev);
405 struct f75375_data *data = i2c_get_clientdata(client);
406 int val = simple_strtoul(buf, NULL, 10);
407 val = SENSORS_LIMIT(VOLT_TO_REG(val), 0, 0xff);
408 mutex_lock(&data->update_lock);
409 data->in_min[nr] = val;
410 f75375_write8(client, F75375_REG_VOLT_LOW(nr), data->in_min[nr]);
411 mutex_unlock(&data->update_lock);
412 return count;
413}
414#define TEMP_FROM_REG(val) ((val) * 1000)
415#define TEMP_TO_REG(val) ((val) / 1000)
416
417static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
418 char *buf)
419{
420 int nr = to_sensor_dev_attr(attr)->index;
421 struct f75375_data *data = f75375_update_device(dev);
422 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
423}
424
425static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
426 char *buf)
427{
428 int nr = to_sensor_dev_attr(attr)->index;
429 struct f75375_data *data = f75375_update_device(dev);
430 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
431}
432
433static ssize_t show_temp_max_hyst(struct device *dev,
434 struct device_attribute *attr, char *buf)
435{
436 int nr = to_sensor_dev_attr(attr)->index;
437 struct f75375_data *data = f75375_update_device(dev);
438 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[nr]));
439}
440
441static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
442 const char *buf, size_t count)
443{
444 int nr = to_sensor_dev_attr(attr)->index;
445 struct i2c_client *client = to_i2c_client(dev);
446 struct f75375_data *data = i2c_get_clientdata(client);
447 int val = simple_strtol(buf, NULL, 10);
448 val = SENSORS_LIMIT(TEMP_TO_REG(val), 0, 127);
449 mutex_lock(&data->update_lock);
450 data->temp_high[nr] = val;
451 f75375_write8(client, F75375_REG_TEMP_HIGH(nr), data->temp_high[nr]);
452 mutex_unlock(&data->update_lock);
453 return count;
454}
455
456static ssize_t set_temp_max_hyst(struct device *dev,
457 struct device_attribute *attr, const char *buf, size_t count)
458{
459 int nr = to_sensor_dev_attr(attr)->index;
460 struct i2c_client *client = to_i2c_client(dev);
461 struct f75375_data *data = i2c_get_clientdata(client);
462 int val = simple_strtol(buf, NULL, 10);
463 val = SENSORS_LIMIT(TEMP_TO_REG(val), 0, 127);
464 mutex_lock(&data->update_lock);
465 data->temp_max_hyst[nr] = val;
466 f75375_write8(client, F75375_REG_TEMP_HYST(nr),
467 data->temp_max_hyst[nr]);
468 mutex_unlock(&data->update_lock);
469 return count;
470}
471
472#define show_fan(thing) \
473static ssize_t show_##thing(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", rpm_from_reg(data->thing[nr])); \
479}
480
481show_fan(fan);
482show_fan(fan_min);
483show_fan(fan_full);
484show_fan(fan_exp);
485
486static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0);
487static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO|S_IWUSR,
488 show_in_max, set_in_max, 0);
489static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO|S_IWUSR,
490 show_in_min, set_in_min, 0);
491static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
492static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO|S_IWUSR,
493 show_in_max, set_in_max, 1);
494static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO|S_IWUSR,
495 show_in_min, set_in_min, 1);
496static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
497static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO|S_IWUSR,
498 show_in_max, set_in_max, 2);
499static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO|S_IWUSR,
500 show_in_min, set_in_min, 2);
501static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
502static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO|S_IWUSR,
503 show_in_max, set_in_max, 3);
504static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO|S_IWUSR,
505 show_in_min, set_in_min, 3);
506static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
507static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO|S_IWUSR,
508 show_temp_max_hyst, set_temp_max_hyst, 0);
509static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO|S_IWUSR,
510 show_temp_max, set_temp_max, 0);
511static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
512static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO|S_IWUSR,
513 show_temp_max_hyst, set_temp_max_hyst, 1);
514static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO|S_IWUSR,
515 show_temp_max, set_temp_max, 1);
516static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
517static SENSOR_DEVICE_ATTR(fan1_full, S_IRUGO, show_fan_full, NULL, 0);
518static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO|S_IWUSR,
519 show_fan_min, set_fan_min, 0);
520static SENSOR_DEVICE_ATTR(fan1_exp, S_IRUGO|S_IWUSR,
521 show_fan_exp, set_fan_exp, 0);
522static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
523static SENSOR_DEVICE_ATTR(fan2_full, S_IRUGO, show_fan_full, NULL, 1);
524static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO|S_IWUSR,
525 show_fan_min, set_fan_min, 1);
526static SENSOR_DEVICE_ATTR(fan2_exp, S_IRUGO|S_IWUSR,
527 show_fan_exp, set_fan_exp, 1);
528static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR,
529 show_pwm, set_pwm, 0);
530static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR,
531 show_pwm_enable, set_pwm_enable, 0);
532static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO|S_IWUSR,
533 show_pwm_mode, set_pwm_mode, 0);
534static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR,
535 show_pwm, set_pwm, 1);
536static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR,
537 show_pwm_enable, set_pwm_enable, 1);
538static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO|S_IWUSR,
539 show_pwm_mode, set_pwm_mode, 1);
540
541static struct attribute *f75375_attributes[] = {
542 &sensor_dev_attr_temp1_input.dev_attr.attr,
543 &sensor_dev_attr_temp1_max.dev_attr.attr,
544 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
545 &sensor_dev_attr_temp2_input.dev_attr.attr,
546 &sensor_dev_attr_temp2_max.dev_attr.attr,
547 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
548 &sensor_dev_attr_fan1_input.dev_attr.attr,
549 &sensor_dev_attr_fan1_full.dev_attr.attr,
550 &sensor_dev_attr_fan1_min.dev_attr.attr,
551 &sensor_dev_attr_fan1_exp.dev_attr.attr,
552 &sensor_dev_attr_fan2_input.dev_attr.attr,
553 &sensor_dev_attr_fan2_full.dev_attr.attr,
554 &sensor_dev_attr_fan2_min.dev_attr.attr,
555 &sensor_dev_attr_fan2_exp.dev_attr.attr,
556 &sensor_dev_attr_pwm1.dev_attr.attr,
557 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
558 &sensor_dev_attr_pwm1_mode.dev_attr.attr,
559 &sensor_dev_attr_pwm2.dev_attr.attr,
560 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
561 &sensor_dev_attr_pwm2_mode.dev_attr.attr,
562 &sensor_dev_attr_in0_input.dev_attr.attr,
563 &sensor_dev_attr_in0_max.dev_attr.attr,
564 &sensor_dev_attr_in0_min.dev_attr.attr,
565 &sensor_dev_attr_in1_input.dev_attr.attr,
566 &sensor_dev_attr_in1_max.dev_attr.attr,
567 &sensor_dev_attr_in1_min.dev_attr.attr,
568 &sensor_dev_attr_in2_input.dev_attr.attr,
569 &sensor_dev_attr_in2_max.dev_attr.attr,
570 &sensor_dev_attr_in2_min.dev_attr.attr,
571 &sensor_dev_attr_in3_input.dev_attr.attr,
572 &sensor_dev_attr_in3_max.dev_attr.attr,
573 &sensor_dev_attr_in3_min.dev_attr.attr,
574 NULL
575};
576
577static const struct attribute_group f75375_group = {
578 .attrs = f75375_attributes,
579};
580
581static int f75375_detach_client(struct i2c_client *client)
582{
583 struct f75375_data *data = i2c_get_clientdata(client);
584 int err;
585
586 hwmon_device_unregister(data->class_dev);
587 sysfs_remove_group(&client->dev.kobj, &f75375_group);
588
589 err = i2c_detach_client(client);
590 if (err) {
591 dev_err(&client->dev,
592 "Client deregistration failed, "
593 "client not detached.\n");
594 return err;
595 }
596 kfree(data);
597 return 0;
598}
599
600static int f75375_attach_adapter(struct i2c_adapter *adapter)
601{
602 if (!(adapter->class & I2C_CLASS_HWMON))
603 return 0;
604 return i2c_probe(adapter, &addr_data, f75375_detect);
605}
606
607/* This function is called by i2c_probe */
608static int f75375_detect(struct i2c_adapter *adapter, int address, int kind)
609{
610 struct i2c_client *client;
611 struct f75375_data *data;
612 u8 version = 0;
613 int err = 0;
614 const char *name = "";
615
616 if (!(data = kzalloc(sizeof(struct f75375_data), GFP_KERNEL))) {
617 err = -ENOMEM;
618 goto exit;
619 }
620 client = &data->client;
621 i2c_set_clientdata(client, data);
622 client->addr = address;
623 client->adapter = adapter;
624 client->driver = &f75375_driver;
625
626 if (kind < 0) {
627 u16 vendid = f75375_read16(client, F75375_REG_VENDOR);
628 u16 chipid = f75375_read16(client, F75375_CHIP_ID);
629 version = f75375_read8(client, F75375_REG_VERSION);
630 if (chipid == 0x0306 && vendid == 0x1934) {
631 kind = f75375;
632 } else if (chipid == 0x0204 && vendid == 0x1934) {
633 kind = f75373;
634 } else {
635 dev_err(&adapter->dev,
636 "failed,%02X,%02X,%02X\n",
637 chipid, version, vendid);
638 goto exit_free;
639 }
640 }
641
642 if (kind == f75375) {
643 name = "f75375";
644 } else if (kind == f75373) {
645 name = "f75373";
646 }
647
648 dev_info(&adapter->dev, "found %s version: %02X\n", name, version);
649 strlcpy(client->name, name, I2C_NAME_SIZE);
650 data->kind = kind;
651 mutex_init(&data->update_lock);
652 if ((err = i2c_attach_client(client)))
653 goto exit_free;
654
655 if ((err = sysfs_create_group(&client->dev.kobj, &f75375_group)))
656 goto exit_detach;
657
658 data->class_dev = hwmon_device_register(&client->dev);
659 if (IS_ERR(data->class_dev)) {
660 err = PTR_ERR(data->class_dev);
661 goto exit_remove;
662 }
663
664 return 0;
665
666exit_remove:
667 sysfs_remove_group(&client->dev.kobj, &f75375_group);
668exit_detach:
669 i2c_detach_client(client);
670exit_free:
671 kfree(data);
672exit:
673 return err;
674}
675
676static int __init sensors_f75375_init(void)
677{
678 return i2c_add_driver(&f75375_driver);
679}
680
681static void __exit sensors_f75375_exit(void)
682{
683 i2c_del_driver(&f75375_driver);
684}
685
686MODULE_AUTHOR("Riku Voipio <riku.voipio@movial.fi>");
687MODULE_LICENSE("GPL");
688MODULE_DESCRIPTION("F75373/F75375 hardware monitoring driver");
689
690module_init(sensors_f75375_init);
691module_exit(sensors_f75375_exit);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-23 15:10:53 -0500