Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-for-linus-2.6
[linux-2.6] / 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] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
633         if (!(data->lm75[0])) {
634                 err = -ENOMEM;
635                 goto ERROR_SC_0;
636         }
637         memset(data->lm75[0], 0x00, sizeof(struct i2c_client));
638
639         data->lm75[1] = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
640         if (!(data->lm75[1])) {
641                 err = -ENOMEM;
642                 goto ERROR_SC_1;
643         }
644         memset(data->lm75[1], 0x00, sizeof(struct i2c_client));
645
646         id = i2c_adapter_id(adapter);
647
648         if (force_subclients[0] == id && force_subclients[1] == address) {
649                 for (i = 2; i <= 3; i++) {
650                         if (force_subclients[i] < 0x48 ||
651                             force_subclients[i] > 0x4f) {
652                                 dev_err(&new_client->dev, "invalid subclient "
653                                         "address %d; must be 0x48-0x4f\n",
654                                         force_subclients[i]);
655                                 err = -ENODEV;
656                                 goto ERROR_SC_2;
657                         }
658                 }
659                 asb100_write_value(new_client, ASB100_REG_I2C_SUBADDR,
660                                         (force_subclients[2] & 0x07) |
661                                         ((force_subclients[3] & 0x07) <<4));
662                 data->lm75[0]->addr = force_subclients[2];
663                 data->lm75[1]->addr = force_subclients[3];
664         } else {
665                 int val = asb100_read_value(new_client, ASB100_REG_I2C_SUBADDR);
666                 data->lm75[0]->addr = 0x48 + (val & 0x07);
667                 data->lm75[1]->addr = 0x48 + ((val >> 4) & 0x07);
668         }
669
670         if(data->lm75[0]->addr == data->lm75[1]->addr) {
671                 dev_err(&new_client->dev, "duplicate addresses 0x%x "
672                                 "for subclients\n", data->lm75[0]->addr);
673                 err = -ENODEV;
674                 goto ERROR_SC_2;
675         }
676
677         for (i = 0; i <= 1; i++) {
678                 i2c_set_clientdata(data->lm75[i], NULL);
679                 data->lm75[i]->adapter = adapter;
680                 data->lm75[i]->driver = &asb100_driver;
681                 data->lm75[i]->flags = 0;
682                 strlcpy(data->lm75[i]->name, "asb100 subclient", I2C_NAME_SIZE);
683         }
684
685         if ((err = i2c_attach_client(data->lm75[0]))) {
686                 dev_err(&new_client->dev, "subclient %d registration "
687                         "at address 0x%x failed.\n", i, data->lm75[0]->addr);
688                 goto ERROR_SC_2;
689         }
690
691         if ((err = i2c_attach_client(data->lm75[1]))) {
692                 dev_err(&new_client->dev, "subclient %d registration "
693                         "at address 0x%x failed.\n", i, data->lm75[1]->addr);
694                 goto ERROR_SC_3;
695         }
696
697         return 0;
698
699 /* Undo inits in case of errors */
700 ERROR_SC_3:
701         i2c_detach_client(data->lm75[0]);
702 ERROR_SC_2:
703         kfree(data->lm75[1]);
704 ERROR_SC_1:
705         kfree(data->lm75[0]);
706 ERROR_SC_0:
707         return err;
708 }
709
710 static int asb100_detect(struct i2c_adapter *adapter, int address, int kind)
711 {
712         int err;
713         struct i2c_client *new_client;
714         struct asb100_data *data;
715
716         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
717                 pr_debug("asb100.o: detect failed, "
718                                 "smbus byte data not supported!\n");
719                 err = -ENODEV;
720                 goto ERROR0;
721         }
722
723         /* OK. For now, we presume we have a valid client. We now create the
724            client structure, even though we cannot fill it completely yet.
725            But it allows us to access asb100_{read,write}_value. */
726
727         if (!(data = kmalloc(sizeof(struct asb100_data), GFP_KERNEL))) {
728                 pr_debug("asb100.o: detect failed, kmalloc failed!\n");
729                 err = -ENOMEM;
730                 goto ERROR0;
731         }
732         memset(data, 0, sizeof(struct asb100_data));
733
734         new_client = &data->client;
735         init_MUTEX(&data->lock);
736         i2c_set_clientdata(new_client, data);
737         new_client->addr = address;
738         new_client->adapter = adapter;
739         new_client->driver = &asb100_driver;
740         new_client->flags = 0;
741
742         /* Now, we do the remaining detection. */
743
744         /* The chip may be stuck in some other bank than bank 0. This may
745            make reading other information impossible. Specify a force=... or
746            force_*=... parameter, and the chip will be reset to the right
747            bank. */
748         if (kind < 0) {
749
750                 int val1 = asb100_read_value(new_client, ASB100_REG_BANK);
751                 int val2 = asb100_read_value(new_client, ASB100_REG_CHIPMAN);
752
753                 /* If we're in bank 0 */
754                 if ( (!(val1 & 0x07)) &&
755                                 /* Check for ASB100 ID (low byte) */
756                                 ( ((!(val1 & 0x80)) && (val2 != 0x94)) ||
757                                 /* Check for ASB100 ID (high byte ) */
758                                 ((val1 & 0x80) && (val2 != 0x06)) ) ) {
759                         pr_debug("asb100.o: detect failed, "
760                                         "bad chip id 0x%02x!\n", val2);
761                         err = -ENODEV;
762                         goto ERROR1;
763                 }
764
765         } /* kind < 0 */
766
767         /* We have either had a force parameter, or we have already detected
768            Winbond. Put it now into bank 0 and Vendor ID High Byte */
769         asb100_write_value(new_client, ASB100_REG_BANK,
770                 (asb100_read_value(new_client, ASB100_REG_BANK) & 0x78) | 0x80);
771
772         /* Determine the chip type. */
773         if (kind <= 0) {
774                 int val1 = asb100_read_value(new_client, ASB100_REG_WCHIPID);
775                 int val2 = asb100_read_value(new_client, ASB100_REG_CHIPMAN);
776
777                 if ((val1 == 0x31) && (val2 == 0x06))
778                         kind = asb100;
779                 else {
780                         if (kind == 0)
781                                 dev_warn(&new_client->dev, "ignoring "
782                                         "'force' parameter for unknown chip "
783                                         "at adapter %d, address 0x%02x.\n",
784                                         i2c_adapter_id(adapter), address);
785                         err = -ENODEV;
786                         goto ERROR1;
787                 }
788         }
789
790         /* Fill in remaining client fields and put it into the global list */
791         strlcpy(new_client->name, "asb100", I2C_NAME_SIZE);
792         data->type = kind;
793
794         data->valid = 0;
795         init_MUTEX(&data->update_lock);
796
797         /* Tell the I2C layer a new client has arrived */
798         if ((err = i2c_attach_client(new_client)))
799                 goto ERROR1;
800
801         /* Attach secondary lm75 clients */
802         if ((err = asb100_detect_subclients(adapter, address, kind,
803                         new_client)))
804                 goto ERROR2;
805
806         /* Initialize the chip */
807         asb100_init_client(new_client);
808
809         /* A few vars need to be filled upon startup */
810         data->fan_min[0] = asb100_read_value(new_client, ASB100_REG_FAN_MIN(0));
811         data->fan_min[1] = asb100_read_value(new_client, ASB100_REG_FAN_MIN(1));
812         data->fan_min[2] = asb100_read_value(new_client, ASB100_REG_FAN_MIN(2));
813
814         /* Register sysfs hooks */
815         data->class_dev = hwmon_device_register(&new_client->dev);
816         if (IS_ERR(data->class_dev)) {
817                 err = PTR_ERR(data->class_dev);
818                 goto ERROR3;
819         }
820
821         device_create_file_in(new_client, 0);
822         device_create_file_in(new_client, 1);
823         device_create_file_in(new_client, 2);
824         device_create_file_in(new_client, 3);
825         device_create_file_in(new_client, 4);
826         device_create_file_in(new_client, 5);
827         device_create_file_in(new_client, 6);
828
829         device_create_file_fan(new_client, 1);
830         device_create_file_fan(new_client, 2);
831         device_create_file_fan(new_client, 3);
832
833         device_create_file_temp(new_client, 1);
834         device_create_file_temp(new_client, 2);
835         device_create_file_temp(new_client, 3);
836         device_create_file_temp(new_client, 4);
837
838         device_create_file_vid(new_client);
839         device_create_file_vrm(new_client);
840
841         device_create_file_alarms(new_client);
842
843         device_create_file_pwm1(new_client);
844
845         return 0;
846
847 ERROR3:
848         i2c_detach_client(data->lm75[1]);
849         i2c_detach_client(data->lm75[0]);
850         kfree(data->lm75[1]);
851         kfree(data->lm75[0]);
852 ERROR2:
853         i2c_detach_client(new_client);
854 ERROR1:
855         kfree(data);
856 ERROR0:
857         return err;
858 }
859
860 static int asb100_detach_client(struct i2c_client *client)
861 {
862         struct asb100_data *data = i2c_get_clientdata(client);
863         int err;
864
865         /* main client */
866         if (data)
867                 hwmon_device_unregister(data->class_dev);
868
869         if ((err = i2c_detach_client(client)))
870                 return err;
871
872         /* main client */
873         if (data)
874                 kfree(data);
875
876         /* subclient */
877         else
878                 kfree(client);
879
880         return 0;
881 }
882
883 /* The SMBus locks itself, usually, but nothing may access the chip between
884    bank switches. */
885 static int asb100_read_value(struct i2c_client *client, u16 reg)
886 {
887         struct asb100_data *data = i2c_get_clientdata(client);
888         struct i2c_client *cl;
889         int res, bank;
890
891         down(&data->lock);
892
893         bank = (reg >> 8) & 0x0f;
894         if (bank > 2)
895                 /* switch banks */
896                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
897
898         if (bank == 0 || bank > 2) {
899                 res = i2c_smbus_read_byte_data(client, reg & 0xff);
900         } else {
901                 /* switch to subclient */
902                 cl = data->lm75[bank - 1];
903
904                 /* convert from ISA to LM75 I2C addresses */
905                 switch (reg & 0xff) {
906                 case 0x50: /* TEMP */
907                         res = swab16(i2c_smbus_read_word_data (cl, 0));
908                         break;
909                 case 0x52: /* CONFIG */
910                         res = i2c_smbus_read_byte_data(cl, 1);
911                         break;
912                 case 0x53: /* HYST */
913                         res = swab16(i2c_smbus_read_word_data (cl, 2));
914                         break;
915                 case 0x55: /* MAX */
916                 default:
917                         res = swab16(i2c_smbus_read_word_data (cl, 3));
918                         break;
919                 }
920         }
921
922         if (bank > 2)
923                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
924
925         up(&data->lock);
926
927         return res;
928 }
929
930 static void asb100_write_value(struct i2c_client *client, u16 reg, u16 value)
931 {
932         struct asb100_data *data = i2c_get_clientdata(client);
933         struct i2c_client *cl;
934         int bank;
935
936         down(&data->lock);
937
938         bank = (reg >> 8) & 0x0f;
939         if (bank > 2)
940                 /* switch banks */
941                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
942
943         if (bank == 0 || bank > 2) {
944                 i2c_smbus_write_byte_data(client, reg & 0xff, value & 0xff);
945         } else {
946                 /* switch to subclient */
947                 cl = data->lm75[bank - 1];
948
949                 /* convert from ISA to LM75 I2C addresses */
950                 switch (reg & 0xff) {
951                 case 0x52: /* CONFIG */
952                         i2c_smbus_write_byte_data(cl, 1, value & 0xff);
953                         break;
954                 case 0x53: /* HYST */
955                         i2c_smbus_write_word_data(cl, 2, swab16(value));
956                         break;
957                 case 0x55: /* MAX */
958                         i2c_smbus_write_word_data(cl, 3, swab16(value));
959                         break;
960                 }
961         }
962
963         if (bank > 2)
964                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
965
966         up(&data->lock);
967 }
968
969 static void asb100_init_client(struct i2c_client *client)
970 {
971         struct asb100_data *data = i2c_get_clientdata(client);
972         int vid = 0;
973
974         vid = asb100_read_value(client, ASB100_REG_VID_FANDIV) & 0x0f;
975         vid |= (asb100_read_value(client, ASB100_REG_CHIPID) & 0x01) << 4;
976         data->vrm = vid_which_vrm();
977         vid = vid_from_reg(vid, data->vrm);
978
979         /* Start monitoring */
980         asb100_write_value(client, ASB100_REG_CONFIG, 
981                 (asb100_read_value(client, ASB100_REG_CONFIG) & 0xf7) | 0x01);
982 }
983
984 static struct asb100_data *asb100_update_device(struct device *dev)
985 {
986         struct i2c_client *client = to_i2c_client(dev);
987         struct asb100_data *data = i2c_get_clientdata(client);
988         int i;
989
990         down(&data->update_lock);
991
992         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
993                 || !data->valid) {
994
995                 dev_dbg(&client->dev, "starting device update...\n");
996
997                 /* 7 voltage inputs */
998                 for (i = 0; i < 7; i++) {
999                         data->in[i] = asb100_read_value(client,
1000                                 ASB100_REG_IN(i));
1001                         data->in_min[i] = asb100_read_value(client,
1002                                 ASB100_REG_IN_MIN(i));
1003                         data->in_max[i] = asb100_read_value(client,
1004                                 ASB100_REG_IN_MAX(i));
1005                 }
1006
1007                 /* 3 fan inputs */
1008                 for (i = 0; i < 3; i++) {
1009                         data->fan[i] = asb100_read_value(client,
1010                                         ASB100_REG_FAN(i));
1011                         data->fan_min[i] = asb100_read_value(client,
1012                                         ASB100_REG_FAN_MIN(i));
1013                 }
1014
1015                 /* 4 temperature inputs */
1016                 for (i = 1; i <= 4; i++) {
1017                         data->temp[i-1] = asb100_read_value(client,
1018                                         ASB100_REG_TEMP(i));
1019                         data->temp_max[i-1] = asb100_read_value(client,
1020                                         ASB100_REG_TEMP_MAX(i));
1021                         data->temp_hyst[i-1] = asb100_read_value(client,
1022                                         ASB100_REG_TEMP_HYST(i));
1023                 }
1024
1025                 /* VID and fan divisors */
1026                 i = asb100_read_value(client, ASB100_REG_VID_FANDIV);
1027                 data->vid = i & 0x0f;
1028                 data->vid |= (asb100_read_value(client,
1029                                 ASB100_REG_CHIPID) & 0x01) << 4;
1030                 data->fan_div[0] = (i >> 4) & 0x03;
1031                 data->fan_div[1] = (i >> 6) & 0x03;
1032                 data->fan_div[2] = (asb100_read_value(client,
1033                                 ASB100_REG_PIN) >> 6) & 0x03;
1034
1035                 /* PWM */
1036                 data->pwm = asb100_read_value(client, ASB100_REG_PWM1);
1037
1038                 /* alarms */
1039                 data->alarms = asb100_read_value(client, ASB100_REG_ALARM1) +
1040                         (asb100_read_value(client, ASB100_REG_ALARM2) << 8);
1041
1042                 data->last_updated = jiffies;
1043                 data->valid = 1;
1044
1045                 dev_dbg(&client->dev, "... device update complete\n");
1046         }
1047
1048         up(&data->update_lock);
1049
1050         return data;
1051 }
1052
1053 static int __init asb100_init(void)
1054 {
1055         return i2c_add_driver(&asb100_driver);
1056 }
1057
1058 static void __exit asb100_exit(void)
1059 {
1060         i2c_del_driver(&asb100_driver);
1061 }
1062
1063 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
1064 MODULE_DESCRIPTION("ASB100 Bach driver");
1065 MODULE_LICENSE("GPL");
1066
1067 module_init(asb100_init);
1068 module_exit(asb100_exit);
1069