52c469722a6584ea622618dbd99c6c53ff43b329
[linux-2.6.git] / drivers / hwmon / asb100.c
1 /*
2     asb100.c - Part of lm_sensors, Linux kernel modules for hardware
3                 monitoring
4
5     Copyright (C) 2004 Mark M. Hoffman <mhoffman@lightlink.com>
6
7         (derived from w83781d.c)
8
9     Copyright (C) 1998 - 2003  Frodo Looijaard <frodol@dds.nl>,
10     Philip Edelbrock <phil@netroedge.com>, and
11     Mark Studebaker <mdsxyz123@yahoo.com>
12
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.
17
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.
22
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.
26 */
27
28 /*
29     This driver supports the hardware sensor chips: Asus ASB100 and
30     ASB100-A "BACH".
31
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.
34
35     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
36     asb100      7       3       1       4       0x31    0x0694  yes     no
37 */
38
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>
47 #include "lm75.h"
48
49 /*
50         HISTORY:
51         2003-12-29      1.0.0   Ported from lm_sensors project for kernel 2.6
52 */
53 #define ASB100_VERSION "1.0.0"
54
55 /* I2C addresses to scan */
56 static unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END };
57
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}");
62
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))
67
68 /* FAN IN registers 1-3 */
69 #define ASB100_REG_FAN(nr)      (0x28 + (nr))
70 #define ASB100_REG_FAN_MIN(nr)  (0x3b + (nr))
71
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};
76
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])
80
81 #define ASB100_REG_TEMP2_CONFIG 0x0152
82 #define ASB100_REG_TEMP3_CONFIG 0x0252
83
84
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
98
99 #define ASB100_REG_WCHIPID      0x58
100
101 /* bit 7 -> enable, bits 0-3 -> duty cycle */
102 #define ASB100_REG_PWM1         0x59
103
104 /* CONVERSIONS
105    Rounding and limit checking is only done on the TO_REG variants. */
106
107 /* These constants are a guess, consistent w/ w83781d */
108 #define ASB100_IN_MIN (   0)
109 #define ASB100_IN_MAX (4080)
110
111 /* IN: 1/1000 V (0V to 4.08V)
112    REG: 16mV/bit */
113 static u8 IN_TO_REG(unsigned val)
114 {
115         unsigned nval = SENSORS_LIMIT(val, ASB100_IN_MIN, ASB100_IN_MAX);
116         return (nval + 8) / 16;
117 }
118
119 static unsigned IN_FROM_REG(u8 reg)
120 {
121         return reg * 16;
122 }
123
124 static u8 FAN_TO_REG(long rpm, int div)
125 {
126         if (rpm == -1)
127                 return 0;
128         if (rpm == 0)
129                 return 255;
130         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
131         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
132 }
133
134 static int FAN_FROM_REG(u8 val, int div)
135 {
136         return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
137 }
138
139 /* These constants are a guess, consistent w/ w83781d */
140 #define ASB100_TEMP_MIN (-128000)
141 #define ASB100_TEMP_MAX ( 127000)
142
143 /* TEMP: 0.001C/bit (-128C to +127C)
144    REG: 1C/bit, two's complement */
145 static u8 TEMP_TO_REG(int temp)
146 {
147         int ntemp = SENSORS_LIMIT(temp, ASB100_TEMP_MIN, ASB100_TEMP_MAX);
148         ntemp += (ntemp<0 ? -500 : 500);
149         return (u8)(ntemp / 1000);
150 }
151
152 static int TEMP_FROM_REG(u8 reg)
153 {
154         return (s8)reg * 1000;
155 }
156
157 /* PWM: 0 - 255 per sensors documentation
158    REG: (6.25% duty cycle per bit) */
159 static u8 ASB100_PWM_TO_REG(int pwm)
160 {
161         pwm = SENSORS_LIMIT(pwm, 0, 255);
162         return (u8)(pwm / 16);
163 }
164
165 static int ASB100_PWM_FROM_REG(u8 reg)
166 {
167         return reg * 16;
168 }
169
170 #define DIV_FROM_REG(val) (1 << (val))
171
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)
175 {
176         return val==8 ? 3 : val==4 ? 2 : val==1 ? 0 : 1;
177 }
178
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. */
182 struct asb100_data {
183         struct i2c_client client;
184         struct class_device *class_dev;
185         struct semaphore lock;
186         enum chips type;
187
188         struct semaphore update_lock;
189         unsigned long last_updated;     /* In jiffies */
190
191         /* array of 2 pointers to subclients */
192         struct i2c_client *lm75[2];
193
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 */
207         u8 vrm;
208 };
209
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);
212
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);
218
219 static struct i2c_driver asb100_driver = {
220         .owner          = THIS_MODULE,
221         .name           = "asb100",
222         .id             = I2C_DRIVERID_ASB100,
223         .flags          = I2C_DF_NOTIFY,
224         .attach_adapter = asb100_attach_adapter,
225         .detach_client  = asb100_detach_client,
226 };
227
228 /* 7 Voltages */
229 #define show_in_reg(reg) \
230 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
231 { \
232         struct asb100_data *data = asb100_update_device(dev); \
233         return sprintf(buf, "%d\n", IN_FROM_REG(data->reg[nr])); \
234 }
235
236 show_in_reg(in)
237 show_in_reg(in_min)
238 show_in_reg(in_max)
239
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) \
243 { \
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); \
247  \
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); \
253         return count; \
254 }
255
256 set_in_reg(MIN, min)
257 set_in_reg(MAX, max)
258
259 #define sysfs_in(offset) \
260 static ssize_t \
261         show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \
262 { \
263         return show_in(dev, buf, offset); \
264 } \
265 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \
266                 show_in##offset, NULL); \
267 static ssize_t \
268         show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
269 { \
270         return show_in_min(dev, buf, offset); \
271 } \
272 static ssize_t \
273         show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \
274 { \
275         return show_in_max(dev, buf, offset); \
276 } \
277 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
278                 const char *buf, size_t count) \
279 { \
280         return set_in_min(dev, buf, count, offset); \
281 } \
282 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
283                 const char *buf, size_t count) \
284 { \
285         return set_in_max(dev, buf, count, offset); \
286 } \
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);
291
292 sysfs_in(0);
293 sysfs_in(1);
294 sysfs_in(2);
295 sysfs_in(3);
296 sysfs_in(4);
297 sysfs_in(5);
298 sysfs_in(6);
299
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); \
304 } while (0)
305
306 /* 3 Fans */
307 static ssize_t show_fan(struct device *dev, char *buf, int nr)
308 {
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])));
312 }
313
314 static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
315 {
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])));
319 }
320
321 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
322 {
323         struct asb100_data *data = asb100_update_device(dev);
324         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
325 }
326
327 static ssize_t set_fan_min(struct device *dev, const char *buf,
328                                 size_t count, int nr)
329 {
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);
333
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);
338         return count;
339 }
340
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)
347 {
348         struct i2c_client *client = to_i2c_client(dev);
349         struct asb100_data *data = i2c_get_clientdata(client);
350         unsigned long min;
351         unsigned long val = simple_strtoul(buf, NULL, 10);
352         int reg;
353         
354         down(&data->update_lock);
355
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);
359
360         switch(nr) {
361         case 0: /* fan 1 */
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);
365                 break;
366
367         case 1: /* fan 2 */
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);
371                 break;
372
373         case 2: /* fan 3 */
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);
377                 break;
378         }
379
380         data->fan_min[nr] =
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]);
383
384         up(&data->update_lock);
385
386         return count;
387 }
388
389 #define sysfs_fan(offset) \
390 static ssize_t show_fan##offset(struct device *dev, struct device_attribute *attr, char *buf) \
391 { \
392         return show_fan(dev, buf, offset - 1); \
393 } \
394 static ssize_t show_fan##offset##_min(struct device *dev, struct device_attribute *attr, char *buf) \
395 { \
396         return show_fan_min(dev, buf, offset - 1); \
397 } \
398 static ssize_t show_fan##offset##_div(struct device *dev, struct device_attribute *attr, char *buf) \
399 { \
400         return show_fan_div(dev, buf, offset - 1); \
401 } \
402 static ssize_t set_fan##offset##_min(struct device *dev, struct device_attribute *attr, const char *buf, \
403                                         size_t count) \
404 { \
405         return set_fan_min(dev, buf, count, offset - 1); \
406 } \
407 static ssize_t set_fan##offset##_div(struct device *dev, struct device_attribute *attr, const char *buf, \
408                                         size_t count) \
409 { \
410         return set_fan_div(dev, buf, count, offset - 1); \
411 } \
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);
418
419 sysfs_fan(1);
420 sysfs_fan(2);
421 sysfs_fan(3);
422
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); \
427 } while (0)
428
429 /* 4 Temp. Sensors */
430 static int sprintf_temp_from_reg(u16 reg, char *buf, int nr)
431 {
432         int ret = 0;
433
434         switch (nr) {
435         case 1: case 2:
436                 ret = sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(reg));
437                 break;
438         case 0: case 3: default:
439                 ret = sprintf(buf, "%d\n", TEMP_FROM_REG(reg));
440                 break;
441         }
442         return ret;
443 }
444                         
445 #define show_temp_reg(reg) \
446 static ssize_t show_##reg(struct device *dev, char *buf, int nr) \
447 { \
448         struct asb100_data *data = asb100_update_device(dev); \
449         return sprintf_temp_from_reg(data->reg[nr], buf, nr); \
450 }
451
452 show_temp_reg(temp);
453 show_temp_reg(temp_max);
454 show_temp_reg(temp_hyst);
455
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) \
459 { \
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); \
463  \
464         down(&data->update_lock); \
465         switch (nr) { \
466         case 1: case 2: \
467                 data->reg[nr] = LM75_TEMP_TO_REG(val); \
468                 break; \
469         case 0: case 3: default: \
470                 data->reg[nr] = TEMP_TO_REG(val); \
471                 break; \
472         } \
473         asb100_write_value(client, ASB100_REG_TEMP_##REG(nr+1), \
474                         data->reg[nr]); \
475         up(&data->update_lock); \
476         return count; \
477 }
478
479 set_temp_reg(MAX, temp_max);
480 set_temp_reg(HYST, temp_hyst);
481
482 #define sysfs_temp(num) \
483 static ssize_t show_temp##num(struct device *dev, struct device_attribute *attr, char *buf) \
484 { \
485         return show_temp(dev, buf, num-1); \
486 } \
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) \
489 { \
490         return show_temp_max(dev, buf, num-1); \
491 } \
492 static ssize_t set_temp_max##num(struct device *dev, struct device_attribute *attr, const char *buf, \
493                                         size_t count) \
494 { \
495         return set_temp_max(dev, buf, count, num-1); \
496 } \
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) \
500 { \
501         return show_temp_hyst(dev, buf, num-1); \
502 } \
503 static ssize_t set_temp_hyst##num(struct device *dev, struct device_attribute *attr, const char *buf, \
504                                         size_t count) \
505 { \
506         return set_temp_hyst(dev, buf, count, num-1); \
507 } \
508 static DEVICE_ATTR(temp##num##_max_hyst, S_IRUGO | S_IWUSR, \
509                 show_temp_hyst##num, set_temp_hyst##num);
510
511 sysfs_temp(1);
512 sysfs_temp(2);
513 sysfs_temp(3);
514 sysfs_temp(4);
515
516 /* VID */
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); \
521 } while (0)
522
523 static ssize_t show_vid(struct device *dev, struct device_attribute *attr, char *buf)
524 {
525         struct asb100_data *data = asb100_update_device(dev);
526         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
527 }
528
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)
532
533 /* VRM */
534 static ssize_t show_vrm(struct device *dev, struct device_attribute *attr, char *buf)
535 {
536         struct asb100_data *data = asb100_update_device(dev);
537         return sprintf(buf, "%d\n", data->vrm);
538 }
539
540 static ssize_t set_vrm(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
541 {
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);
545         data->vrm = val;
546         return count;
547 }
548
549 /* Alarms */
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);
553
554 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf)
555 {
556         struct asb100_data *data = asb100_update_device(dev);
557         return sprintf(buf, "%u\n", data->alarms);
558 }
559
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)
563
564 /* 1 PWM */
565 static ssize_t show_pwm1(struct device *dev, struct device_attribute *attr, char *buf)
566 {
567         struct asb100_data *data = asb100_update_device(dev);
568         return sprintf(buf, "%d\n", ASB100_PWM_FROM_REG(data->pwm & 0x0f));
569 }
570
571 static ssize_t set_pwm1(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
572 {
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);
576
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);
582         return count;
583 }
584
585 static ssize_t show_pwm_enable1(struct device *dev, struct device_attribute *attr, char *buf)
586 {
587         struct asb100_data *data = asb100_update_device(dev);
588         return sprintf(buf, "%d\n", (data->pwm & 0x80) ? 1 : 0);
589 }
590
591 static ssize_t set_pwm_enable1(struct device *dev, struct device_attribute *attr, const char *buf,
592                                 size_t count)
593 {
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);
597
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);
603         return count;
604 }
605
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); \
612 } while (0)
613
614 /* This function is called when:
615         asb100_driver is inserted (when this module is loaded), for each
616                 available adapter
617         when a new adapter is inserted (and asb100_driver is still present)
618  */
619 static int asb100_attach_adapter(struct i2c_adapter *adapter)
620 {
621         if (!(adapter->class & I2C_CLASS_HWMON))
622                 return 0;
623         return i2c_probe(adapter, &addr_data, asb100_detect);
624 }
625
626 static int asb100_detect_subclients(struct i2c_adapter *adapter, int address,
627                 int kind, struct i2c_client *new_client)
628 {
629         int i, id, err;
630         struct asb100_data *data = i2c_get_clientdata(new_client);
631
632         data->lm75[0] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
633         if (!(data->lm75[0])) {
634                 err = -ENOMEM;
635                 goto ERROR_SC_0;
636         }
637
638         data->lm75[1] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
639         if (!(data->lm75[1])) {
640                 err = -ENOMEM;
641                 goto ERROR_SC_1;
642         }
643
644         id = i2c_adapter_id(adapter);
645
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]);
653                                 err = -ENODEV;
654                                 goto ERROR_SC_2;
655                         }
656                 }
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];
662         } else {
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);
666         }
667
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);
671                 err = -ENODEV;
672                 goto ERROR_SC_2;
673         }
674
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);
681         }
682
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);
686                 goto ERROR_SC_2;
687         }
688
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);
692                 goto ERROR_SC_3;
693         }
694
695         return 0;
696
697 /* Undo inits in case of errors */
698 ERROR_SC_3:
699         i2c_detach_client(data->lm75[0]);
700 ERROR_SC_2:
701         kfree(data->lm75[1]);
702 ERROR_SC_1:
703         kfree(data->lm75[0]);
704 ERROR_SC_0:
705         return err;
706 }
707
708 static int asb100_detect(struct i2c_adapter *adapter, int address, int kind)
709 {
710         int err;
711         struct i2c_client *new_client;
712         struct asb100_data *data;
713
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");
717                 err = -ENODEV;
718                 goto ERROR0;
719         }
720
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. */
724
725         if (!(data = kzalloc(sizeof(struct asb100_data), GFP_KERNEL))) {
726                 pr_debug("asb100.o: detect failed, kzalloc failed!\n");
727                 err = -ENOMEM;
728                 goto ERROR0;
729         }
730
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;
738
739         /* Now, we do the remaining detection. */
740
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
744            bank. */
745         if (kind < 0) {
746
747                 int val1 = asb100_read_value(new_client, ASB100_REG_BANK);
748                 int val2 = asb100_read_value(new_client, ASB100_REG_CHIPMAN);
749
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);
758                         err = -ENODEV;
759                         goto ERROR1;
760                 }
761
762         } /* kind < 0 */
763
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);
768
769         /* Determine the chip type. */
770         if (kind <= 0) {
771                 int val1 = asb100_read_value(new_client, ASB100_REG_WCHIPID);
772                 int val2 = asb100_read_value(new_client, ASB100_REG_CHIPMAN);
773
774                 if ((val1 == 0x31) && (val2 == 0x06))
775                         kind = asb100;
776                 else {
777                         if (kind == 0)
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);
782                         err = -ENODEV;
783                         goto ERROR1;
784                 }
785         }
786
787         /* Fill in remaining client fields and put it into the global list */
788         strlcpy(new_client->name, "asb100", I2C_NAME_SIZE);
789         data->type = kind;
790
791         data->valid = 0;
792         init_MUTEX(&data->update_lock);
793
794         /* Tell the I2C layer a new client has arrived */
795         if ((err = i2c_attach_client(new_client)))
796                 goto ERROR1;
797
798         /* Attach secondary lm75 clients */
799         if ((err = asb100_detect_subclients(adapter, address, kind,
800                         new_client)))
801                 goto ERROR2;
802
803         /* Initialize the chip */
804         asb100_init_client(new_client);
805
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));
810
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);
815                 goto ERROR3;
816         }
817
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);
825
826         device_create_file_fan(new_client, 1);
827         device_create_file_fan(new_client, 2);
828         device_create_file_fan(new_client, 3);
829
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);
834
835         device_create_file_vid(new_client);
836         device_create_file_vrm(new_client);
837
838         device_create_file_alarms(new_client);
839
840         device_create_file_pwm1(new_client);
841
842         return 0;
843
844 ERROR3:
845         i2c_detach_client(data->lm75[1]);
846         i2c_detach_client(data->lm75[0]);
847         kfree(data->lm75[1]);
848         kfree(data->lm75[0]);
849 ERROR2:
850         i2c_detach_client(new_client);
851 ERROR1:
852         kfree(data);
853 ERROR0:
854         return err;
855 }
856
857 static int asb100_detach_client(struct i2c_client *client)
858 {
859         struct asb100_data *data = i2c_get_clientdata(client);
860         int err;
861
862         /* main client */
863         if (data)
864                 hwmon_device_unregister(data->class_dev);
865
866         if ((err = i2c_detach_client(client)))
867                 return err;
868
869         /* main client */
870         if (data)
871                 kfree(data);
872
873         /* subclient */
874         else
875                 kfree(client);
876
877         return 0;
878 }
879
880 /* The SMBus locks itself, usually, but nothing may access the chip between
881    bank switches. */
882 static int asb100_read_value(struct i2c_client *client, u16 reg)
883 {
884         struct asb100_data *data = i2c_get_clientdata(client);
885         struct i2c_client *cl;
886         int res, bank;
887
888         down(&data->lock);
889
890         bank = (reg >> 8) & 0x0f;
891         if (bank > 2)
892                 /* switch banks */
893                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
894
895         if (bank == 0 || bank > 2) {
896                 res = i2c_smbus_read_byte_data(client, reg & 0xff);
897         } else {
898                 /* switch to subclient */
899                 cl = data->lm75[bank - 1];
900
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));
905                         break;
906                 case 0x52: /* CONFIG */
907                         res = i2c_smbus_read_byte_data(cl, 1);
908                         break;
909                 case 0x53: /* HYST */
910                         res = swab16(i2c_smbus_read_word_data (cl, 2));
911                         break;
912                 case 0x55: /* MAX */
913                 default:
914                         res = swab16(i2c_smbus_read_word_data (cl, 3));
915                         break;
916                 }
917         }
918
919         if (bank > 2)
920                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
921
922         up(&data->lock);
923
924         return res;
925 }
926
927 static void asb100_write_value(struct i2c_client *client, u16 reg, u16 value)
928 {
929         struct asb100_data *data = i2c_get_clientdata(client);
930         struct i2c_client *cl;
931         int bank;
932
933         down(&data->lock);
934
935         bank = (reg >> 8) & 0x0f;
936         if (bank > 2)
937                 /* switch banks */
938                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
939
940         if (bank == 0 || bank > 2) {
941                 i2c_smbus_write_byte_data(client, reg & 0xff, value & 0xff);
942         } else {
943                 /* switch to subclient */
944                 cl = data->lm75[bank - 1];
945
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);
950                         break;
951                 case 0x53: /* HYST */
952                         i2c_smbus_write_word_data(cl, 2, swab16(value));
953                         break;
954                 case 0x55: /* MAX */
955                         i2c_smbus_write_word_data(cl, 3, swab16(value));
956                         break;
957                 }
958         }
959
960         if (bank > 2)
961                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
962
963         up(&data->lock);
964 }
965
966 static void asb100_init_client(struct i2c_client *client)
967 {
968         struct asb100_data *data = i2c_get_clientdata(client);
969         int vid = 0;
970
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);
975
976         /* Start monitoring */
977         asb100_write_value(client, ASB100_REG_CONFIG, 
978                 (asb100_read_value(client, ASB100_REG_CONFIG) & 0xf7) | 0x01);
979 }
980
981 static struct asb100_data *asb100_update_device(struct device *dev)
982 {
983         struct i2c_client *client = to_i2c_client(dev);
984         struct asb100_data *data = i2c_get_clientdata(client);
985         int i;
986
987         down(&data->update_lock);
988
989         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
990                 || !data->valid) {
991
992                 dev_dbg(&client->dev, "starting device update...\n");
993
994                 /* 7 voltage inputs */
995                 for (i = 0; i < 7; i++) {
996                         data->in[i] = asb100_read_value(client,
997                                 ASB100_REG_IN(i));
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));
1002                 }
1003
1004                 /* 3 fan inputs */
1005                 for (i = 0; i < 3; i++) {
1006                         data->fan[i] = asb100_read_value(client,
1007                                         ASB100_REG_FAN(i));
1008                         data->fan_min[i] = asb100_read_value(client,
1009                                         ASB100_REG_FAN_MIN(i));
1010                 }
1011
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));
1020                 }
1021
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;
1031
1032                 /* PWM */
1033                 data->pwm = asb100_read_value(client, ASB100_REG_PWM1);
1034
1035                 /* alarms */
1036                 data->alarms = asb100_read_value(client, ASB100_REG_ALARM1) +
1037                         (asb100_read_value(client, ASB100_REG_ALARM2) << 8);
1038
1039                 data->last_updated = jiffies;
1040                 data->valid = 1;
1041
1042                 dev_dbg(&client->dev, "... device update complete\n");
1043         }
1044
1045         up(&data->update_lock);
1046
1047         return data;
1048 }
1049
1050 static int __init asb100_init(void)
1051 {
1052         return i2c_add_driver(&asb100_driver);
1053 }
1054
1055 static void __exit asb100_exit(void)
1056 {
1057         i2c_del_driver(&asb100_driver);
1058 }
1059
1060 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
1061 MODULE_DESCRIPTION("ASB100 Bach driver");
1062 MODULE_LICENSE("GPL");
1063
1064 module_init(asb100_init);
1065 module_exit(asb100_exit);
1066