2 asb100.c - Part of lm_sensors, Linux kernel modules for hardware
5 Copyright (C) 2004 Mark M. Hoffman <mhoffman@lightlink.com>
7 (derived from w83781d.c)
9 Copyright (C) 1998 - 2003 Frodo Looijaard <frodol@dds.nl>,
10 Philip Edelbrock <phil@netroedge.com>, and
11 Mark Studebaker <mdsxyz123@yahoo.com>
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 This driver supports the hardware sensor chips: Asus ASB100 and
32 ASB100-A supports pwm1, while plain ASB100 does not. There is no known
33 way for the driver to tell which one is there.
35 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
36 asb100 7 3 1 4 0x31 0x0694 yes no
39 #include <linux/module.h>
40 #include <linux/slab.h>
41 #include <linux/i2c.h>
42 #include <linux/hwmon.h>
43 #include <linux/hwmon-vid.h>
44 #include <linux/err.h>
45 #include <linux/init.h>
46 #include <linux/jiffies.h>
51 2003-12-29 1.0.0 Ported from lm_sensors project for kernel 2.6
53 #define ASB100_VERSION "1.0.0"
55 /* I2C addresses to scan */
56 static unsigned short normal_i2c
[] = { 0x2d, I2C_CLIENT_END
};
58 /* Insmod parameters */
59 I2C_CLIENT_INSMOD_1(asb100
);
60 I2C_CLIENT_MODULE_PARM(force_subclients
, "List of subclient addresses: "
61 "{bus, clientaddr, subclientaddr1, subclientaddr2}");
63 /* Voltage IN registers 0-6 */
64 #define ASB100_REG_IN(nr) (0x20 + (nr))
65 #define ASB100_REG_IN_MAX(nr) (0x2b + (nr * 2))
66 #define ASB100_REG_IN_MIN(nr) (0x2c + (nr * 2))
68 /* FAN IN registers 1-3 */
69 #define ASB100_REG_FAN(nr) (0x28 + (nr))
70 #define ASB100_REG_FAN_MIN(nr) (0x3b + (nr))
72 /* TEMPERATURE registers 1-4 */
73 static const u16 asb100_reg_temp
[] = {0, 0x27, 0x150, 0x250, 0x17};
74 static const u16 asb100_reg_temp_max
[] = {0, 0x39, 0x155, 0x255, 0x18};
75 static const u16 asb100_reg_temp_hyst
[] = {0, 0x3a, 0x153, 0x253, 0x19};
77 #define ASB100_REG_TEMP(nr) (asb100_reg_temp[nr])
78 #define ASB100_REG_TEMP_MAX(nr) (asb100_reg_temp_max[nr])
79 #define ASB100_REG_TEMP_HYST(nr) (asb100_reg_temp_hyst[nr])
81 #define ASB100_REG_TEMP2_CONFIG 0x0152
82 #define ASB100_REG_TEMP3_CONFIG 0x0252
85 #define ASB100_REG_CONFIG 0x40
86 #define ASB100_REG_ALARM1 0x41
87 #define ASB100_REG_ALARM2 0x42
88 #define ASB100_REG_SMIM1 0x43
89 #define ASB100_REG_SMIM2 0x44
90 #define ASB100_REG_VID_FANDIV 0x47
91 #define ASB100_REG_I2C_ADDR 0x48
92 #define ASB100_REG_CHIPID 0x49
93 #define ASB100_REG_I2C_SUBADDR 0x4a
94 #define ASB100_REG_PIN 0x4b
95 #define ASB100_REG_IRQ 0x4c
96 #define ASB100_REG_BANK 0x4e
97 #define ASB100_REG_CHIPMAN 0x4f
99 #define ASB100_REG_WCHIPID 0x58
101 /* bit 7 -> enable, bits 0-3 -> duty cycle */
102 #define ASB100_REG_PWM1 0x59
105 Rounding and limit checking is only done on the TO_REG variants. */
107 /* These constants are a guess, consistent w/ w83781d */
108 #define ASB100_IN_MIN ( 0)
109 #define ASB100_IN_MAX (4080)
111 /* IN: 1/1000 V (0V to 4.08V)
113 static u8
IN_TO_REG(unsigned val
)
115 unsigned nval
= SENSORS_LIMIT(val
, ASB100_IN_MIN
, ASB100_IN_MAX
);
116 return (nval
+ 8) / 16;
119 static unsigned IN_FROM_REG(u8 reg
)
124 static u8
FAN_TO_REG(long rpm
, int div
)
130 rpm
= SENSORS_LIMIT(rpm
, 1, 1000000);
131 return SENSORS_LIMIT((1350000 + rpm
* div
/ 2) / (rpm
* div
), 1, 254);
134 static int FAN_FROM_REG(u8 val
, int div
)
136 return val
==0 ? -1 : val
==255 ? 0 : 1350000/(val
*div
);
139 /* These constants are a guess, consistent w/ w83781d */
140 #define ASB100_TEMP_MIN (-128000)
141 #define ASB100_TEMP_MAX ( 127000)
143 /* TEMP: 0.001C/bit (-128C to +127C)
144 REG: 1C/bit, two's complement */
145 static u8
TEMP_TO_REG(int temp
)
147 int ntemp
= SENSORS_LIMIT(temp
, ASB100_TEMP_MIN
, ASB100_TEMP_MAX
);
148 ntemp
+= (ntemp
<0 ? -500 : 500);
149 return (u8
)(ntemp
/ 1000);
152 static int TEMP_FROM_REG(u8 reg
)
154 return (s8
)reg
* 1000;
157 /* PWM: 0 - 255 per sensors documentation
158 REG: (6.25% duty cycle per bit) */
159 static u8
ASB100_PWM_TO_REG(int pwm
)
161 pwm
= SENSORS_LIMIT(pwm
, 0, 255);
162 return (u8
)(pwm
/ 16);
165 static int ASB100_PWM_FROM_REG(u8 reg
)
170 #define DIV_FROM_REG(val) (1 << (val))
172 /* FAN DIV: 1, 2, 4, or 8 (defaults to 2)
173 REG: 0, 1, 2, or 3 (respectively) (defaults to 1) */
174 static u8
DIV_TO_REG(long val
)
176 return val
==8 ? 3 : val
==4 ? 2 : val
==1 ? 0 : 1;
179 /* For each registered client, we need to keep some data in memory. That
180 data is pointed to by client->data. The structure itself is
181 dynamically allocated, at the same time the client itself is allocated. */
183 struct i2c_client client
;
184 struct class_device
*class_dev
;
185 struct semaphore lock
;
188 struct semaphore update_lock
;
189 unsigned long last_updated
; /* In jiffies */
191 /* array of 2 pointers to subclients */
192 struct i2c_client
*lm75
[2];
194 char valid
; /* !=0 if following fields are valid */
195 u8 in
[7]; /* Register value */
196 u8 in_max
[7]; /* Register value */
197 u8 in_min
[7]; /* Register value */
198 u8 fan
[3]; /* Register value */
199 u8 fan_min
[3]; /* Register value */
200 u16 temp
[4]; /* Register value (0 and 3 are u8 only) */
201 u16 temp_max
[4]; /* Register value (0 and 3 are u8 only) */
202 u16 temp_hyst
[4]; /* Register value (0 and 3 are u8 only) */
203 u8 fan_div
[3]; /* Register encoding, right justified */
204 u8 pwm
; /* Register encoding */
205 u8 vid
; /* Register encoding, combined */
206 u32 alarms
; /* Register encoding, combined */
210 static int asb100_read_value(struct i2c_client
*client
, u16 reg
);
211 static void asb100_write_value(struct i2c_client
*client
, u16 reg
, u16 val
);
213 static int asb100_attach_adapter(struct i2c_adapter
*adapter
);
214 static int asb100_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
215 static int asb100_detach_client(struct i2c_client
*client
);
216 static struct asb100_data
*asb100_update_device(struct device
*dev
);
217 static void asb100_init_client(struct i2c_client
*client
);
219 static struct i2c_driver asb100_driver
= {
220 .owner
= THIS_MODULE
,
222 .id
= I2C_DRIVERID_ASB100
,
223 .flags
= I2C_DF_NOTIFY
,
224 .attach_adapter
= asb100_attach_adapter
,
225 .detach_client
= asb100_detach_client
,
229 #define show_in_reg(reg) \
230 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
232 struct asb100_data *data = asb100_update_device(dev); \
233 return sprintf(buf, "%d\n", IN_FROM_REG(data->reg[nr])); \
240 #define set_in_reg(REG, reg) \
241 static ssize_t set_in_##reg(struct device *dev, const char *buf, \
242 size_t count, int nr) \
244 struct i2c_client *client = to_i2c_client(dev); \
245 struct asb100_data *data = i2c_get_clientdata(client); \
246 unsigned long val = simple_strtoul(buf, NULL, 10); \
248 down(&data->update_lock); \
249 data->in_##reg[nr] = IN_TO_REG(val); \
250 asb100_write_value(client, ASB100_REG_IN_##REG(nr), \
251 data->in_##reg[nr]); \
252 up(&data->update_lock); \
259 #define sysfs_in(offset) \
261 show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \
263 return show_in(dev, buf, offset); \
265 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \
266 show_in##offset, NULL); \
268 show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
270 return show_in_min(dev, buf, offset); \
273 show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \
275 return show_in_max(dev, buf, offset); \
277 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
278 const char *buf, size_t count) \
280 return set_in_min(dev, buf, count, offset); \
282 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
283 const char *buf, size_t count) \
285 return set_in_max(dev, buf, count, offset); \
287 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
288 show_in##offset##_min, set_in##offset##_min); \
289 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
290 show_in##offset##_max, set_in##offset##_max);
300 #define device_create_file_in(client, offset) do { \
301 device_create_file(&client->dev, &dev_attr_in##offset##_input); \
302 device_create_file(&client->dev, &dev_attr_in##offset##_min); \
303 device_create_file(&client->dev, &dev_attr_in##offset##_max); \
307 static ssize_t
show_fan(struct device
*dev
, char *buf
, int nr
)
309 struct asb100_data
*data
= asb100_update_device(dev
);
310 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan
[nr
],
311 DIV_FROM_REG(data
->fan_div
[nr
])));
314 static ssize_t
show_fan_min(struct device
*dev
, char *buf
, int nr
)
316 struct asb100_data
*data
= asb100_update_device(dev
);
317 return sprintf(buf
, "%d\n", FAN_FROM_REG(data
->fan_min
[nr
],
318 DIV_FROM_REG(data
->fan_div
[nr
])));
321 static ssize_t
show_fan_div(struct device
*dev
, char *buf
, int nr
)
323 struct asb100_data
*data
= asb100_update_device(dev
);
324 return sprintf(buf
, "%d\n", DIV_FROM_REG(data
->fan_div
[nr
]));
327 static ssize_t
set_fan_min(struct device
*dev
, const char *buf
,
328 size_t count
, int nr
)
330 struct i2c_client
*client
= to_i2c_client(dev
);
331 struct asb100_data
*data
= i2c_get_clientdata(client
);
332 u32 val
= simple_strtoul(buf
, NULL
, 10);
334 down(&data
->update_lock
);
335 data
->fan_min
[nr
] = FAN_TO_REG(val
, DIV_FROM_REG(data
->fan_div
[nr
]));
336 asb100_write_value(client
, ASB100_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
337 up(&data
->update_lock
);
341 /* Note: we save and restore the fan minimum here, because its value is
342 determined in part by the fan divisor. This follows the principle of
343 least suprise; the user doesn't expect the fan minimum to change just
344 because the divisor changed. */
345 static ssize_t
set_fan_div(struct device
*dev
, const char *buf
,
346 size_t count
, int nr
)
348 struct i2c_client
*client
= to_i2c_client(dev
);
349 struct asb100_data
*data
= i2c_get_clientdata(client
);
351 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
354 down(&data
->update_lock
);
356 min
= FAN_FROM_REG(data
->fan_min
[nr
],
357 DIV_FROM_REG(data
->fan_div
[nr
]));
358 data
->fan_div
[nr
] = DIV_TO_REG(val
);
362 reg
= asb100_read_value(client
, ASB100_REG_VID_FANDIV
);
363 reg
= (reg
& 0xcf) | (data
->fan_div
[0] << 4);
364 asb100_write_value(client
, ASB100_REG_VID_FANDIV
, reg
);
368 reg
= asb100_read_value(client
, ASB100_REG_VID_FANDIV
);
369 reg
= (reg
& 0x3f) | (data
->fan_div
[1] << 6);
370 asb100_write_value(client
, ASB100_REG_VID_FANDIV
, reg
);
374 reg
= asb100_read_value(client
, ASB100_REG_PIN
);
375 reg
= (reg
& 0x3f) | (data
->fan_div
[2] << 6);
376 asb100_write_value(client
, ASB100_REG_PIN
, reg
);
381 FAN_TO_REG(min
, DIV_FROM_REG(data
->fan_div
[nr
]));
382 asb100_write_value(client
, ASB100_REG_FAN_MIN(nr
), data
->fan_min
[nr
]);
384 up(&data
->update_lock
);
389 #define sysfs_fan(offset) \
390 static ssize_t show_fan##offset(struct device *dev, struct device_attribute *attr, char *buf) \
392 return show_fan(dev, buf, offset - 1); \
394 static ssize_t show_fan##offset##_min(struct device *dev, struct device_attribute *attr, char *buf) \
396 return show_fan_min(dev, buf, offset - 1); \
398 static ssize_t show_fan##offset##_div(struct device *dev, struct device_attribute *attr, char *buf) \
400 return show_fan_div(dev, buf, offset - 1); \
402 static ssize_t set_fan##offset##_min(struct device *dev, struct device_attribute *attr, const char *buf, \
405 return set_fan_min(dev, buf, count, offset - 1); \
407 static ssize_t set_fan##offset##_div(struct device *dev, struct device_attribute *attr, const char *buf, \
410 return set_fan_div(dev, buf, count, offset - 1); \
412 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
413 show_fan##offset, NULL); \
414 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
415 show_fan##offset##_min, set_fan##offset##_min); \
416 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
417 show_fan##offset##_div, set_fan##offset##_div);
423 #define device_create_file_fan(client, offset) do { \
424 device_create_file(&client->dev, &dev_attr_fan##offset##_input); \
425 device_create_file(&client->dev, &dev_attr_fan##offset##_min); \
426 device_create_file(&client->dev, &dev_attr_fan##offset##_div); \
429 /* 4 Temp. Sensors */
430 static int sprintf_temp_from_reg(u16 reg
, char *buf
, int nr
)
436 ret
= sprintf(buf
, "%d\n", LM75_TEMP_FROM_REG(reg
));
438 case 0: case 3: default:
439 ret
= sprintf(buf
, "%d\n", TEMP_FROM_REG(reg
));
445 #define show_temp_reg(reg) \
446 static ssize_t show_##reg(struct device *dev, char *buf, int nr) \
448 struct asb100_data *data = asb100_update_device(dev); \
449 return sprintf_temp_from_reg(data->reg[nr], buf, nr); \
453 show_temp_reg(temp_max
);
454 show_temp_reg(temp_hyst
);
456 #define set_temp_reg(REG, reg) \
457 static ssize_t set_##reg(struct device *dev, const char *buf, \
458 size_t count, int nr) \
460 struct i2c_client *client = to_i2c_client(dev); \
461 struct asb100_data *data = i2c_get_clientdata(client); \
462 unsigned long val = simple_strtoul(buf, NULL, 10); \
464 down(&data->update_lock); \
467 data->reg[nr] = LM75_TEMP_TO_REG(val); \
469 case 0: case 3: default: \
470 data->reg[nr] = TEMP_TO_REG(val); \
473 asb100_write_value(client, ASB100_REG_TEMP_##REG(nr+1), \
475 up(&data->update_lock); \
479 set_temp_reg(MAX
, temp_max
);
480 set_temp_reg(HYST
, temp_hyst
);
482 #define sysfs_temp(num) \
483 static ssize_t show_temp##num(struct device *dev, struct device_attribute *attr, char *buf) \
485 return show_temp(dev, buf, num-1); \
487 static DEVICE_ATTR(temp##num##_input, S_IRUGO, show_temp##num, NULL); \
488 static ssize_t show_temp_max##num(struct device *dev, struct device_attribute *attr, char *buf) \
490 return show_temp_max(dev, buf, num-1); \
492 static ssize_t set_temp_max##num(struct device *dev, struct device_attribute *attr, const char *buf, \
495 return set_temp_max(dev, buf, count, num-1); \
497 static DEVICE_ATTR(temp##num##_max, S_IRUGO | S_IWUSR, \
498 show_temp_max##num, set_temp_max##num); \
499 static ssize_t show_temp_hyst##num(struct device *dev, struct device_attribute *attr, char *buf) \
501 return show_temp_hyst(dev, buf, num-1); \
503 static ssize_t set_temp_hyst##num(struct device *dev, struct device_attribute *attr, const char *buf, \
506 return set_temp_hyst(dev, buf, count, num-1); \
508 static DEVICE_ATTR(temp##num##_max_hyst, S_IRUGO | S_IWUSR, \
509 show_temp_hyst##num, set_temp_hyst##num);
517 #define device_create_file_temp(client, num) do { \
518 device_create_file(&client->dev, &dev_attr_temp##num##_input); \
519 device_create_file(&client->dev, &dev_attr_temp##num##_max); \
520 device_create_file(&client->dev, &dev_attr_temp##num##_max_hyst); \
523 static ssize_t
show_vid(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
525 struct asb100_data
*data
= asb100_update_device(dev
);
526 return sprintf(buf
, "%d\n", vid_from_reg(data
->vid
, data
->vrm
));
529 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
, show_vid
, NULL
);
530 #define device_create_file_vid(client) \
531 device_create_file(&client->dev, &dev_attr_cpu0_vid)
534 static ssize_t
show_vrm(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
536 struct asb100_data
*data
= asb100_update_device(dev
);
537 return sprintf(buf
, "%d\n", data
->vrm
);
540 static ssize_t
set_vrm(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
542 struct i2c_client
*client
= to_i2c_client(dev
);
543 struct asb100_data
*data
= i2c_get_clientdata(client
);
544 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
550 static DEVICE_ATTR(vrm
, S_IRUGO
| S_IWUSR
, show_vrm
, set_vrm
);
551 #define device_create_file_vrm(client) \
552 device_create_file(&client->dev, &dev_attr_vrm);
554 static ssize_t
show_alarms(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
556 struct asb100_data
*data
= asb100_update_device(dev
);
557 return sprintf(buf
, "%u\n", data
->alarms
);
560 static DEVICE_ATTR(alarms
, S_IRUGO
, show_alarms
, NULL
);
561 #define device_create_file_alarms(client) \
562 device_create_file(&client->dev, &dev_attr_alarms)
565 static ssize_t
show_pwm1(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
567 struct asb100_data
*data
= asb100_update_device(dev
);
568 return sprintf(buf
, "%d\n", ASB100_PWM_FROM_REG(data
->pwm
& 0x0f));
571 static ssize_t
set_pwm1(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
573 struct i2c_client
*client
= to_i2c_client(dev
);
574 struct asb100_data
*data
= i2c_get_clientdata(client
);
575 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
577 down(&data
->update_lock
);
578 data
->pwm
&= 0x80; /* keep the enable bit */
579 data
->pwm
|= (0x0f & ASB100_PWM_TO_REG(val
));
580 asb100_write_value(client
, ASB100_REG_PWM1
, data
->pwm
);
581 up(&data
->update_lock
);
585 static ssize_t
show_pwm_enable1(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
587 struct asb100_data
*data
= asb100_update_device(dev
);
588 return sprintf(buf
, "%d\n", (data
->pwm
& 0x80) ? 1 : 0);
591 static ssize_t
set_pwm_enable1(struct device
*dev
, struct device_attribute
*attr
, const char *buf
,
594 struct i2c_client
*client
= to_i2c_client(dev
);
595 struct asb100_data
*data
= i2c_get_clientdata(client
);
596 unsigned long val
= simple_strtoul(buf
, NULL
, 10);
598 down(&data
->update_lock
);
599 data
->pwm
&= 0x0f; /* keep the duty cycle bits */
600 data
->pwm
|= (val
? 0x80 : 0x00);
601 asb100_write_value(client
, ASB100_REG_PWM1
, data
->pwm
);
602 up(&data
->update_lock
);
606 static DEVICE_ATTR(pwm1
, S_IRUGO
| S_IWUSR
, show_pwm1
, set_pwm1
);
607 static DEVICE_ATTR(pwm1_enable
, S_IRUGO
| S_IWUSR
,
608 show_pwm_enable1
, set_pwm_enable1
);
609 #define device_create_file_pwm1(client) do { \
610 device_create_file(&new_client->dev, &dev_attr_pwm1); \
611 device_create_file(&new_client->dev, &dev_attr_pwm1_enable); \
614 /* This function is called when:
615 asb100_driver is inserted (when this module is loaded), for each
617 when a new adapter is inserted (and asb100_driver is still present)
619 static int asb100_attach_adapter(struct i2c_adapter
*adapter
)
621 if (!(adapter
->class & I2C_CLASS_HWMON
))
623 return i2c_probe(adapter
, &addr_data
, asb100_detect
);
626 static int asb100_detect_subclients(struct i2c_adapter
*adapter
, int address
,
627 int kind
, struct i2c_client
*new_client
)
630 struct asb100_data
*data
= i2c_get_clientdata(new_client
);
632 data
->lm75
[0] = kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
633 if (!(data
->lm75
[0])) {
638 data
->lm75
[1] = kzalloc(sizeof(struct i2c_client
), GFP_KERNEL
);
639 if (!(data
->lm75
[1])) {
644 id
= i2c_adapter_id(adapter
);
646 if (force_subclients
[0] == id
&& force_subclients
[1] == address
) {
647 for (i
= 2; i
<= 3; i
++) {
648 if (force_subclients
[i
] < 0x48 ||
649 force_subclients
[i
] > 0x4f) {
650 dev_err(&new_client
->dev
, "invalid subclient "
651 "address %d; must be 0x48-0x4f\n",
652 force_subclients
[i
]);
657 asb100_write_value(new_client
, ASB100_REG_I2C_SUBADDR
,
658 (force_subclients
[2] & 0x07) |
659 ((force_subclients
[3] & 0x07) <<4));
660 data
->lm75
[0]->addr
= force_subclients
[2];
661 data
->lm75
[1]->addr
= force_subclients
[3];
663 int val
= asb100_read_value(new_client
, ASB100_REG_I2C_SUBADDR
);
664 data
->lm75
[0]->addr
= 0x48 + (val
& 0x07);
665 data
->lm75
[1]->addr
= 0x48 + ((val
>> 4) & 0x07);
668 if(data
->lm75
[0]->addr
== data
->lm75
[1]->addr
) {
669 dev_err(&new_client
->dev
, "duplicate addresses 0x%x "
670 "for subclients\n", data
->lm75
[0]->addr
);
675 for (i
= 0; i
<= 1; i
++) {
676 i2c_set_clientdata(data
->lm75
[i
], NULL
);
677 data
->lm75
[i
]->adapter
= adapter
;
678 data
->lm75
[i
]->driver
= &asb100_driver
;
679 data
->lm75
[i
]->flags
= 0;
680 strlcpy(data
->lm75
[i
]->name
, "asb100 subclient", I2C_NAME_SIZE
);
683 if ((err
= i2c_attach_client(data
->lm75
[0]))) {
684 dev_err(&new_client
->dev
, "subclient %d registration "
685 "at address 0x%x failed.\n", i
, data
->lm75
[0]->addr
);
689 if ((err
= i2c_attach_client(data
->lm75
[1]))) {
690 dev_err(&new_client
->dev
, "subclient %d registration "
691 "at address 0x%x failed.\n", i
, data
->lm75
[1]->addr
);
697 /* Undo inits in case of errors */
699 i2c_detach_client(data
->lm75
[0]);
701 kfree(data
->lm75
[1]);
703 kfree(data
->lm75
[0]);
708 static int asb100_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
711 struct i2c_client
*new_client
;
712 struct asb100_data
*data
;
714 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
)) {
715 pr_debug("asb100.o: detect failed, "
716 "smbus byte data not supported!\n");
721 /* OK. For now, we presume we have a valid client. We now create the
722 client structure, even though we cannot fill it completely yet.
723 But it allows us to access asb100_{read,write}_value. */
725 if (!(data
= kzalloc(sizeof(struct asb100_data
), GFP_KERNEL
))) {
726 pr_debug("asb100.o: detect failed, kzalloc failed!\n");
731 new_client
= &data
->client
;
732 init_MUTEX(&data
->lock
);
733 i2c_set_clientdata(new_client
, data
);
734 new_client
->addr
= address
;
735 new_client
->adapter
= adapter
;
736 new_client
->driver
= &asb100_driver
;
737 new_client
->flags
= 0;
739 /* Now, we do the remaining detection. */
741 /* The chip may be stuck in some other bank than bank 0. This may
742 make reading other information impossible. Specify a force=... or
743 force_*=... parameter, and the chip will be reset to the right
747 int val1
= asb100_read_value(new_client
, ASB100_REG_BANK
);
748 int val2
= asb100_read_value(new_client
, ASB100_REG_CHIPMAN
);
750 /* If we're in bank 0 */
751 if ( (!(val1
& 0x07)) &&
752 /* Check for ASB100 ID (low byte) */
753 ( ((!(val1
& 0x80)) && (val2
!= 0x94)) ||
754 /* Check for ASB100 ID (high byte ) */
755 ((val1
& 0x80) && (val2
!= 0x06)) ) ) {
756 pr_debug("asb100.o: detect failed, "
757 "bad chip id 0x%02x!\n", val2
);
764 /* We have either had a force parameter, or we have already detected
765 Winbond. Put it now into bank 0 and Vendor ID High Byte */
766 asb100_write_value(new_client
, ASB100_REG_BANK
,
767 (asb100_read_value(new_client
, ASB100_REG_BANK
) & 0x78) | 0x80);
769 /* Determine the chip type. */
771 int val1
= asb100_read_value(new_client
, ASB100_REG_WCHIPID
);
772 int val2
= asb100_read_value(new_client
, ASB100_REG_CHIPMAN
);
774 if ((val1
== 0x31) && (val2
== 0x06))
778 dev_warn(&new_client
->dev
, "ignoring "
779 "'force' parameter for unknown chip "
780 "at adapter %d, address 0x%02x.\n",
781 i2c_adapter_id(adapter
), address
);
787 /* Fill in remaining client fields and put it into the global list */
788 strlcpy(new_client
->name
, "asb100", I2C_NAME_SIZE
);
792 init_MUTEX(&data
->update_lock
);
794 /* Tell the I2C layer a new client has arrived */
795 if ((err
= i2c_attach_client(new_client
)))
798 /* Attach secondary lm75 clients */
799 if ((err
= asb100_detect_subclients(adapter
, address
, kind
,
803 /* Initialize the chip */
804 asb100_init_client(new_client
);
806 /* A few vars need to be filled upon startup */
807 data
->fan_min
[0] = asb100_read_value(new_client
, ASB100_REG_FAN_MIN(0));
808 data
->fan_min
[1] = asb100_read_value(new_client
, ASB100_REG_FAN_MIN(1));
809 data
->fan_min
[2] = asb100_read_value(new_client
, ASB100_REG_FAN_MIN(2));
811 /* Register sysfs hooks */
812 data
->class_dev
= hwmon_device_register(&new_client
->dev
);
813 if (IS_ERR(data
->class_dev
)) {
814 err
= PTR_ERR(data
->class_dev
);
818 device_create_file_in(new_client
, 0);
819 device_create_file_in(new_client
, 1);
820 device_create_file_in(new_client
, 2);
821 device_create_file_in(new_client
, 3);
822 device_create_file_in(new_client
, 4);
823 device_create_file_in(new_client
, 5);
824 device_create_file_in(new_client
, 6);
826 device_create_file_fan(new_client
, 1);
827 device_create_file_fan(new_client
, 2);
828 device_create_file_fan(new_client
, 3);
830 device_create_file_temp(new_client
, 1);
831 device_create_file_temp(new_client
, 2);
832 device_create_file_temp(new_client
, 3);
833 device_create_file_temp(new_client
, 4);
835 device_create_file_vid(new_client
);
836 device_create_file_vrm(new_client
);
838 device_create_file_alarms(new_client
);
840 device_create_file_pwm1(new_client
);
845 i2c_detach_client(data
->lm75
[1]);
846 i2c_detach_client(data
->lm75
[0]);
847 kfree(data
->lm75
[1]);
848 kfree(data
->lm75
[0]);
850 i2c_detach_client(new_client
);
857 static int asb100_detach_client(struct i2c_client
*client
)
859 struct asb100_data
*data
= i2c_get_clientdata(client
);
864 hwmon_device_unregister(data
->class_dev
);
866 if ((err
= i2c_detach_client(client
)))
880 /* The SMBus locks itself, usually, but nothing may access the chip between
882 static int asb100_read_value(struct i2c_client
*client
, u16 reg
)
884 struct asb100_data
*data
= i2c_get_clientdata(client
);
885 struct i2c_client
*cl
;
890 bank
= (reg
>> 8) & 0x0f;
893 i2c_smbus_write_byte_data(client
, ASB100_REG_BANK
, bank
);
895 if (bank
== 0 || bank
> 2) {
896 res
= i2c_smbus_read_byte_data(client
, reg
& 0xff);
898 /* switch to subclient */
899 cl
= data
->lm75
[bank
- 1];
901 /* convert from ISA to LM75 I2C addresses */
902 switch (reg
& 0xff) {
903 case 0x50: /* TEMP */
904 res
= swab16(i2c_smbus_read_word_data (cl
, 0));
906 case 0x52: /* CONFIG */
907 res
= i2c_smbus_read_byte_data(cl
, 1);
909 case 0x53: /* HYST */
910 res
= swab16(i2c_smbus_read_word_data (cl
, 2));
914 res
= swab16(i2c_smbus_read_word_data (cl
, 3));
920 i2c_smbus_write_byte_data(client
, ASB100_REG_BANK
, 0);
927 static void asb100_write_value(struct i2c_client
*client
, u16 reg
, u16 value
)
929 struct asb100_data
*data
= i2c_get_clientdata(client
);
930 struct i2c_client
*cl
;
935 bank
= (reg
>> 8) & 0x0f;
938 i2c_smbus_write_byte_data(client
, ASB100_REG_BANK
, bank
);
940 if (bank
== 0 || bank
> 2) {
941 i2c_smbus_write_byte_data(client
, reg
& 0xff, value
& 0xff);
943 /* switch to subclient */
944 cl
= data
->lm75
[bank
- 1];
946 /* convert from ISA to LM75 I2C addresses */
947 switch (reg
& 0xff) {
948 case 0x52: /* CONFIG */
949 i2c_smbus_write_byte_data(cl
, 1, value
& 0xff);
951 case 0x53: /* HYST */
952 i2c_smbus_write_word_data(cl
, 2, swab16(value
));
955 i2c_smbus_write_word_data(cl
, 3, swab16(value
));
961 i2c_smbus_write_byte_data(client
, ASB100_REG_BANK
, 0);
966 static void asb100_init_client(struct i2c_client
*client
)
968 struct asb100_data
*data
= i2c_get_clientdata(client
);
971 vid
= asb100_read_value(client
, ASB100_REG_VID_FANDIV
) & 0x0f;
972 vid
|= (asb100_read_value(client
, ASB100_REG_CHIPID
) & 0x01) << 4;
973 data
->vrm
= vid_which_vrm();
974 vid
= vid_from_reg(vid
, data
->vrm
);
976 /* Start monitoring */
977 asb100_write_value(client
, ASB100_REG_CONFIG
,
978 (asb100_read_value(client
, ASB100_REG_CONFIG
) & 0xf7) | 0x01);
981 static struct asb100_data
*asb100_update_device(struct device
*dev
)
983 struct i2c_client
*client
= to_i2c_client(dev
);
984 struct asb100_data
*data
= i2c_get_clientdata(client
);
987 down(&data
->update_lock
);
989 if (time_after(jiffies
, data
->last_updated
+ HZ
+ HZ
/ 2)
992 dev_dbg(&client
->dev
, "starting device update...\n");
994 /* 7 voltage inputs */
995 for (i
= 0; i
< 7; i
++) {
996 data
->in
[i
] = asb100_read_value(client
,
998 data
->in_min
[i
] = asb100_read_value(client
,
999 ASB100_REG_IN_MIN(i
));
1000 data
->in_max
[i
] = asb100_read_value(client
,
1001 ASB100_REG_IN_MAX(i
));
1005 for (i
= 0; i
< 3; i
++) {
1006 data
->fan
[i
] = asb100_read_value(client
,
1008 data
->fan_min
[i
] = asb100_read_value(client
,
1009 ASB100_REG_FAN_MIN(i
));
1012 /* 4 temperature inputs */
1013 for (i
= 1; i
<= 4; i
++) {
1014 data
->temp
[i
-1] = asb100_read_value(client
,
1015 ASB100_REG_TEMP(i
));
1016 data
->temp_max
[i
-1] = asb100_read_value(client
,
1017 ASB100_REG_TEMP_MAX(i
));
1018 data
->temp_hyst
[i
-1] = asb100_read_value(client
,
1019 ASB100_REG_TEMP_HYST(i
));
1022 /* VID and fan divisors */
1023 i
= asb100_read_value(client
, ASB100_REG_VID_FANDIV
);
1024 data
->vid
= i
& 0x0f;
1025 data
->vid
|= (asb100_read_value(client
,
1026 ASB100_REG_CHIPID
) & 0x01) << 4;
1027 data
->fan_div
[0] = (i
>> 4) & 0x03;
1028 data
->fan_div
[1] = (i
>> 6) & 0x03;
1029 data
->fan_div
[2] = (asb100_read_value(client
,
1030 ASB100_REG_PIN
) >> 6) & 0x03;
1033 data
->pwm
= asb100_read_value(client
, ASB100_REG_PWM1
);
1036 data
->alarms
= asb100_read_value(client
, ASB100_REG_ALARM1
) +
1037 (asb100_read_value(client
, ASB100_REG_ALARM2
) << 8);
1039 data
->last_updated
= jiffies
;
1042 dev_dbg(&client
->dev
, "... device update complete\n");
1045 up(&data
->update_lock
);
1050 static int __init
asb100_init(void)
1052 return i2c_add_driver(&asb100_driver
);
1055 static void __exit
asb100_exit(void)
1057 i2c_del_driver(&asb100_driver
);
1060 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
1061 MODULE_DESCRIPTION("ASB100 Bach driver");
1062 MODULE_LICENSE("GPL");
1064 module_init(asb100_init
);
1065 module_exit(asb100_exit
);