SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 <linux/mutex.h>
  48 #include "lm75.h"
  49
  50 /* I2C addresses to scan */
  51 static unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END };
  52
  53 /* Insmod parameters */
  54 I2C_CLIENT_INSMOD_1(asb100);
  55 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: "
  56         "{bus, clientaddr, subclientaddr1, subclientaddr2}");
  57
  58 /* Voltage IN registers 0-6 */
  59 #define ASB100_REG_IN(nr)       (0x20 + (nr))
  60 #define ASB100_REG_IN_MAX(nr)   (0x2b + (nr * 2))
  61 #define ASB100_REG_IN_MIN(nr)   (0x2c + (nr * 2))
  62
  63 /* FAN IN registers 1-3 */
  64 #define ASB100_REG_FAN(nr)      (0x28 + (nr))
  65 #define ASB100_REG_FAN_MIN(nr)  (0x3b + (nr))
  66
  67 /* TEMPERATURE registers 1-4 */
  68 static const u16 asb100_reg_temp[]      = {0, 0x27, 0x150, 0x250, 0x17};
  69 static const u16 asb100_reg_temp_max[]  = {0, 0x39, 0x155, 0x255, 0x18};
  70 static const u16 asb100_reg_temp_hyst[] = {0, 0x3a, 0x153, 0x253, 0x19};
  71
  72 #define ASB100_REG_TEMP(nr) (asb100_reg_temp[nr])
  73 #define ASB100_REG_TEMP_MAX(nr) (asb100_reg_temp_max[nr])
  74 #define ASB100_REG_TEMP_HYST(nr) (asb100_reg_temp_hyst[nr])
  75
  76 #define ASB100_REG_TEMP2_CONFIG 0x0152
  77 #define ASB100_REG_TEMP3_CONFIG 0x0252
  78
  79
  80 #define ASB100_REG_CONFIG       0x40
  81 #define ASB100_REG_ALARM1       0x41
  82 #define ASB100_REG_ALARM2       0x42
  83 #define ASB100_REG_SMIM1        0x43
  84 #define ASB100_REG_SMIM2        0x44
  85 #define ASB100_REG_VID_FANDIV   0x47
  86 #define ASB100_REG_I2C_ADDR     0x48
  87 #define ASB100_REG_CHIPID       0x49
  88 #define ASB100_REG_I2C_SUBADDR  0x4a
  89 #define ASB100_REG_PIN          0x4b
  90 #define ASB100_REG_IRQ          0x4c
  91 #define ASB100_REG_BANK         0x4e
  92 #define ASB100_REG_CHIPMAN      0x4f
  93
  94 #define ASB100_REG_WCHIPID      0x58
  95
  96 /* bit 7 -> enable, bits 0-3 -> duty cycle */
  97 #define ASB100_REG_PWM1         0x59
  98
  99 /* CONVERSIONS
 100    Rounding and limit checking is only done on the TO_REG variants. */
 101
 102 /* These constants are a guess, consistent w/ w83781d */
 103 #define ASB100_IN_MIN (   0)
 104 #define ASB100_IN_MAX (4080)
 105
 106 /* IN: 1/1000 V (0V to 4.08V)
 107    REG: 16mV/bit */
 108 static u8 IN_TO_REG(unsigned val)
 109 {
 110         unsigned nval = SENSORS_LIMIT(val, ASB100_IN_MIN, ASB100_IN_MAX);
 111         return (nval + 8) / 16;
 112 }
 113
 114 static unsigned IN_FROM_REG(u8 reg)
 115 {
 116         return reg * 16;
 117 }
 118
 119 static u8 FAN_TO_REG(long rpm, int div)
 120 {
 121         if (rpm == -1)
 122                 return 0;
 123         if (rpm == 0)
 124                 return 255;
 125         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
 126         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
 127 }
 128
 129 static int FAN_FROM_REG(u8 val, int div)
 130 {
 131         return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
 132 }
 133
 134 /* These constants are a guess, consistent w/ w83781d */
 135 #define ASB100_TEMP_MIN (-128000)
 136 #define ASB100_TEMP_MAX ( 127000)
 137
 138 /* TEMP: 0.001C/bit (-128C to +127C)
 139    REG: 1C/bit, two's complement */
 140 static u8 TEMP_TO_REG(long temp)
 141 {
 142         int ntemp = SENSORS_LIMIT(temp, ASB100_TEMP_MIN, ASB100_TEMP_MAX);
 143         ntemp += (ntemp<0 ? -500 : 500);
 144         return (u8)(ntemp / 1000);
 145 }
 146
 147 static int TEMP_FROM_REG(u8 reg)
 148 {
 149         return (s8)reg * 1000;
 150 }
 151
 152 /* PWM: 0 - 255 per sensors documentation
 153    REG: (6.25% duty cycle per bit) */
 154 static u8 ASB100_PWM_TO_REG(int pwm)
 155 {
 156         pwm = SENSORS_LIMIT(pwm, 0, 255);
 157         return (u8)(pwm / 16);
 158 }
 159
 160 static int ASB100_PWM_FROM_REG(u8 reg)
 161 {
 162         return reg * 16;
 163 }
 164
 165 #define DIV_FROM_REG(val) (1 << (val))
 166
 167 /* FAN DIV: 1, 2, 4, or 8 (defaults to 2)
 168    REG: 0, 1, 2, or 3 (respectively) (defaults to 1) */
 169 static u8 DIV_TO_REG(long val)
 170 {
 171         return val==8 ? 3 : val==4 ? 2 : val==1 ? 0 : 1;
 172 }
 173
 174 /* For each registered client, we need to keep some data in memory. That
 175    data is pointed to by client->data. The structure itself is
 176    dynamically allocated, at the same time the client itself is allocated. */
 177 struct asb100_data {
 178         struct i2c_client client;
 179         struct device *hwmon_dev;
 180         struct mutex lock;
 181         enum chips type;
 182
 183         struct mutex update_lock;
 184         unsigned long last_updated;     /* In jiffies */
 185
 186         /* array of 2 pointers to subclients */
 187         struct i2c_client *lm75[2];
 188
 189         char valid;             /* !=0 if following fields are valid */
 190         u8 in[7];               /* Register value */
 191         u8 in_max[7];           /* Register value */
 192         u8 in_min[7];           /* Register value */
 193         u8 fan[3];              /* Register value */
 194         u8 fan_min[3];          /* Register value */
 195         u16 temp[4];            /* Register value (0 and 3 are u8 only) */
 196         u16 temp_max[4];        /* Register value (0 and 3 are u8 only) */
 197         u16 temp_hyst[4];       /* Register value (0 and 3 are u8 only) */
 198         u8 fan_div[3];          /* Register encoding, right justified */
 199         u8 pwm;                 /* Register encoding */
 200         u8 vid;                 /* Register encoding, combined */
 201         u32 alarms;             /* Register encoding, combined */
 202         u8 vrm;
 203 };
 204
 205 static int asb100_read_value(struct i2c_client *client, u16 reg);
 206 static void asb100_write_value(struct i2c_client *client, u16 reg, u16 val);
 207
 208 static int asb100_attach_adapter(struct i2c_adapter *adapter);
 209 static int asb100_detect(struct i2c_adapter *adapter, int address, int kind);
 210 static int asb100_detach_client(struct i2c_client *client);
 211 static struct asb100_data *asb100_update_device(struct device *dev);
 212 static void asb100_init_client(struct i2c_client *client);
 213
 214 static struct i2c_driver asb100_driver = {
 215         .driver = {
 216                 .name   = "asb100",
 217         },
 218         .attach_adapter = asb100_attach_adapter,
 219         .detach_client  = asb100_detach_client,
 220 };
 221
 222 /* 7 Voltages */
 223 #define show_in_reg(reg) \
 224 static ssize_t show_##reg (struct device *dev, char *buf, int nr) \
 225 { \
 226         struct asb100_data *data = asb100_update_device(dev); \
 227         return sprintf(buf, "%d\n", IN_FROM_REG(data->reg[nr])); \
 228 }
 229
 230 show_in_reg(in)
 231 show_in_reg(in_min)
 232 show_in_reg(in_max)
 233
 234 #define set_in_reg(REG, reg) \
 235 static ssize_t set_in_##reg(struct device *dev, const char *buf, \
 236                 size_t count, int nr) \
 237 { \
 238         struct i2c_client *client = to_i2c_client(dev); \
 239         struct asb100_data *data = i2c_get_clientdata(client); \
 240         unsigned long val = simple_strtoul(buf, NULL, 10); \
 241  \
 242         mutex_lock(&data->update_lock); \
 243         data->in_##reg[nr] = IN_TO_REG(val); \
 244         asb100_write_value(client, ASB100_REG_IN_##REG(nr), \
 245                 data->in_##reg[nr]); \
 246         mutex_unlock(&data->update_lock); \
 247         return count; \
 248 }
 249
 250 set_in_reg(MIN, min)
 251 set_in_reg(MAX, max)
 252
 253 #define sysfs_in(offset) \
 254 static ssize_t \
 255         show_in##offset (struct device *dev, struct device_attribute *attr, char *buf) \
 256 { \
 257         return show_in(dev, buf, offset); \
 258 } \
 259 static DEVICE_ATTR(in##offset##_input, S_IRUGO, \
 260                 show_in##offset, NULL); \
 261 static ssize_t \
 262         show_in##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
 263 { \
 264         return show_in_min(dev, buf, offset); \
 265 } \
 266 static ssize_t \
 267         show_in##offset##_max (struct device *dev, struct device_attribute *attr, char *buf) \
 268 { \
 269         return show_in_max(dev, buf, offset); \
 270 } \
 271 static ssize_t set_in##offset##_min (struct device *dev, struct device_attribute *attr, \
 272                 const char *buf, size_t count) \
 273 { \
 274         return set_in_min(dev, buf, count, offset); \
 275 } \
 276 static ssize_t set_in##offset##_max (struct device *dev, struct device_attribute *attr, \
 277                 const char *buf, size_t count) \
 278 { \
 279         return set_in_max(dev, buf, count, offset); \
 280 } \
 281 static DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
 282                 show_in##offset##_min, set_in##offset##_min); \
 283 static DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
 284                 show_in##offset##_max, set_in##offset##_max);
 285
 286 sysfs_in(0);
 287 sysfs_in(1);
 288 sysfs_in(2);
 289 sysfs_in(3);
 290 sysfs_in(4);
 291 sysfs_in(5);
 292 sysfs_in(6);
 293
 294 /* 3 Fans */
 295 static ssize_t show_fan(struct device *dev, char *buf, int nr)
 296 {
 297         struct asb100_data *data = asb100_update_device(dev);
 298         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 299                 DIV_FROM_REG(data->fan_div[nr])));
 300 }
 301
 302 static ssize_t show_fan_min(struct device *dev, char *buf, int nr)
 303 {
 304         struct asb100_data *data = asb100_update_device(dev);
 305         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
 306                 DIV_FROM_REG(data->fan_div[nr])));
 307 }
 308
 309 static ssize_t show_fan_div(struct device *dev, char *buf, int nr)
 310 {
 311         struct asb100_data *data = asb100_update_device(dev);
 312         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
 313 }
 314
 315 static ssize_t set_fan_min(struct device *dev, const char *buf,
 316                                 size_t count, int nr)
 317 {
 318         struct i2c_client *client = to_i2c_client(dev);
 319         struct asb100_data *data = i2c_get_clientdata(client);
 320         u32 val = simple_strtoul(buf, NULL, 10);
 321
 322         mutex_lock(&data->update_lock);
 323         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 324         asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
 325         mutex_unlock(&data->update_lock);
 326         return count;
 327 }
 328
 329 /* Note: we save and restore the fan minimum here, because its value is
 330    determined in part by the fan divisor.  This follows the principle of
 331    least surprise; the user doesn't expect the fan minimum to change just
 332    because the divisor changed. */
 333 static ssize_t set_fan_div(struct device *dev, const char *buf,
 334                                 size_t count, int nr)
 335 {
 336         struct i2c_client *client = to_i2c_client(dev);
 337         struct asb100_data *data = i2c_get_clientdata(client);
 338         unsigned long min;
 339         unsigned long val = simple_strtoul(buf, NULL, 10);
 340         int reg;
 341
 342         mutex_lock(&data->update_lock);
 343
 344         min = FAN_FROM_REG(data->fan_min[nr],
 345                         DIV_FROM_REG(data->fan_div[nr]));
 346         data->fan_div[nr] = DIV_TO_REG(val);
 347
 348         switch (nr) {
 349         case 0: /* fan 1 */
 350                 reg = asb100_read_value(client, ASB100_REG_VID_FANDIV);
 351                 reg = (reg & 0xcf) | (data->fan_div[0] << 4);
 352                 asb100_write_value(client, ASB100_REG_VID_FANDIV, reg);
 353                 break;
 354
 355         case 1: /* fan 2 */
 356                 reg = asb100_read_value(client, ASB100_REG_VID_FANDIV);
 357                 reg = (reg & 0x3f) | (data->fan_div[1] << 6);
 358                 asb100_write_value(client, ASB100_REG_VID_FANDIV, reg);
 359                 break;
 360
 361         case 2: /* fan 3 */
 362                 reg = asb100_read_value(client, ASB100_REG_PIN);
 363                 reg = (reg & 0x3f) | (data->fan_div[2] << 6);
 364                 asb100_write_value(client, ASB100_REG_PIN, reg);
 365                 break;
 366         }
 367
 368         data->fan_min[nr] =
 369                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 370         asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
 371
 372         mutex_unlock(&data->update_lock);
 373
 374         return count;
 375 }
 376
 377 #define sysfs_fan(offset) \
 378 static ssize_t show_fan##offset(struct device *dev, struct device_attribute *attr, char *buf) \
 379 { \
 380         return show_fan(dev, buf, offset - 1); \
 381 } \
 382 static ssize_t show_fan##offset##_min(struct device *dev, struct device_attribute *attr, char *buf) \
 383 { \
 384         return show_fan_min(dev, buf, offset - 1); \
 385 } \
 386 static ssize_t show_fan##offset##_div(struct device *dev, struct device_attribute *attr, char *buf) \
 387 { \
 388         return show_fan_div(dev, buf, offset - 1); \
 389 } \
 390 static ssize_t set_fan##offset##_min(struct device *dev, struct device_attribute *attr, const char *buf, \
 391                                         size_t count) \
 392 { \
 393         return set_fan_min(dev, buf, count, offset - 1); \
 394 } \
 395 static ssize_t set_fan##offset##_div(struct device *dev, struct device_attribute *attr, const char *buf, \
 396                                         size_t count) \
 397 { \
 398         return set_fan_div(dev, buf, count, offset - 1); \
 399 } \
 400 static DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
 401                 show_fan##offset, NULL); \
 402 static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 403                 show_fan##offset##_min, set_fan##offset##_min); \
 404 static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
 405                 show_fan##offset##_div, set_fan##offset##_div);
 406
 407 sysfs_fan(1);
 408 sysfs_fan(2);
 409 sysfs_fan(3);
 410
 411 /* 4 Temp. Sensors */
 412 static int sprintf_temp_from_reg(u16 reg, char *buf, int nr)
 413 {
 414         int ret = 0;
 415
 416         switch (nr) {
 417         case 1: case 2:
 418                 ret = sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(reg));
 419                 break;
 420         case 0: case 3: default:
 421                 ret = sprintf(buf, "%d\n", TEMP_FROM_REG(reg));
 422                 break;
 423         }
 424         return ret;
 425 }
 426
 427 #define show_temp_reg(reg) \
 428 static ssize_t show_##reg(struct device *dev, char *buf, int nr) \
 429 { \
 430         struct asb100_data *data = asb100_update_device(dev); \
 431         return sprintf_temp_from_reg(data->reg[nr], buf, nr); \
 432 }
 433
 434 show_temp_reg(temp);
 435 show_temp_reg(temp_max);
 436 show_temp_reg(temp_hyst);
 437
 438 #define set_temp_reg(REG, reg) \
 439 static ssize_t set_##reg(struct device *dev, const char *buf, \
 440                         size_t count, int nr) \
 441 { \
 442         struct i2c_client *client = to_i2c_client(dev); \
 443         struct asb100_data *data = i2c_get_clientdata(client); \
 444         long val = simple_strtol(buf, NULL, 10); \
 445  \
 446         mutex_lock(&data->update_lock); \
 447         switch (nr) { \
 448         case 1: case 2: \
 449                 data->reg[nr] = LM75_TEMP_TO_REG(val); \
 450                 break; \
 451         case 0: case 3: default: \
 452                 data->reg[nr] = TEMP_TO_REG(val); \
 453                 break; \
 454         } \
 455         asb100_write_value(client, ASB100_REG_TEMP_##REG(nr+1), \
 456                         data->reg[nr]); \
 457         mutex_unlock(&data->update_lock); \
 458         return count; \
 459 }
 460
 461 set_temp_reg(MAX, temp_max);
 462 set_temp_reg(HYST, temp_hyst);
 463
 464 #define sysfs_temp(num) \
 465 static ssize_t show_temp##num(struct device *dev, struct device_attribute *attr, char *buf) \
 466 { \
 467         return show_temp(dev, buf, num-1); \
 468 } \
 469 static DEVICE_ATTR(temp##num##_input, S_IRUGO, show_temp##num, NULL); \
 470 static ssize_t show_temp_max##num(struct device *dev, struct device_attribute *attr, char *buf) \
 471 { \
 472         return show_temp_max(dev, buf, num-1); \
 473 } \
 474 static ssize_t set_temp_max##num(struct device *dev, struct device_attribute *attr, const char *buf, \
 475                                         size_t count) \
 476 { \
 477         return set_temp_max(dev, buf, count, num-1); \
 478 } \
 479 static DEVICE_ATTR(temp##num##_max, S_IRUGO | S_IWUSR, \
 480                 show_temp_max##num, set_temp_max##num); \
 481 static ssize_t show_temp_hyst##num(struct device *dev, struct device_attribute *attr, char *buf) \
 482 { \
 483         return show_temp_hyst(dev, buf, num-1); \
 484 } \
 485 static ssize_t set_temp_hyst##num(struct device *dev, struct device_attribute *attr, const char *buf, \
 486                                         size_t count) \
 487 { \
 488         return set_temp_hyst(dev, buf, count, num-1); \
 489 } \
 490 static DEVICE_ATTR(temp##num##_max_hyst, S_IRUGO | S_IWUSR, \
 491                 show_temp_hyst##num, set_temp_hyst##num);
 492
 493 sysfs_temp(1);
 494 sysfs_temp(2);
 495 sysfs_temp(3);
 496 sysfs_temp(4);
 497
 498 /* VID */
 499 static ssize_t show_vid(struct device *dev, struct device_attribute *attr,
 500                 char *buf)
 501 {
 502         struct asb100_data *data = asb100_update_device(dev);
 503         return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
 504 }
 505
 506 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 507
 508 /* VRM */
 509 static ssize_t show_vrm(struct device *dev, struct device_attribute *attr,
 510                 char *buf)
 511 {
 512         struct asb100_data *data = dev_get_drvdata(dev);
 513         return sprintf(buf, "%d\n", data->vrm);
 514 }
 515
 516 static ssize_t set_vrm(struct device *dev, struct device_attribute *attr,
 517                 const char *buf, size_t count)
 518 {
 519         struct asb100_data *data = dev_get_drvdata(dev);
 520         data->vrm = simple_strtoul(buf, NULL, 10);
 521         return count;
 522 }
 523
 524 /* Alarms */
 525 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm);
 526
 527 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
 528                 char *buf)
 529 {
 530         struct asb100_data *data = asb100_update_device(dev);
 531         return sprintf(buf, "%u\n", data->alarms);
 532 }
 533
 534 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 535
 536 /* 1 PWM */
 537 static ssize_t show_pwm1(struct device *dev, struct device_attribute *attr,
 538                 char *buf)
 539 {
 540         struct asb100_data *data = asb100_update_device(dev);
 541         return sprintf(buf, "%d\n", ASB100_PWM_FROM_REG(data->pwm & 0x0f));
 542 }
 543
 544 static ssize_t set_pwm1(struct device *dev, struct device_attribute *attr,
 545                 const char *buf, size_t count)
 546 {
 547         struct i2c_client *client = to_i2c_client(dev);
 548         struct asb100_data *data = i2c_get_clientdata(client);
 549         unsigned long val = simple_strtoul(buf, NULL, 10);
 550
 551         mutex_lock(&data->update_lock);
 552         data->pwm &= 0x80; /* keep the enable bit */
 553         data->pwm |= (0x0f & ASB100_PWM_TO_REG(val));
 554         asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
 555         mutex_unlock(&data->update_lock);
 556         return count;
 557 }
 558
 559 static ssize_t show_pwm_enable1(struct device *dev,
 560                 struct device_attribute *attr, char *buf)
 561 {
 562         struct asb100_data *data = asb100_update_device(dev);
 563         return sprintf(buf, "%d\n", (data->pwm & 0x80) ? 1 : 0);
 564 }
 565
 566 static ssize_t set_pwm_enable1(struct device *dev,
 567                 struct device_attribute *attr, const char *buf, size_t count)
 568 {
 569         struct i2c_client *client = to_i2c_client(dev);
 570         struct asb100_data *data = i2c_get_clientdata(client);
 571         unsigned long val = simple_strtoul(buf, NULL, 10);
 572
 573         mutex_lock(&data->update_lock);
 574         data->pwm &= 0x0f; /* keep the duty cycle bits */
 575         data->pwm |= (val ? 0x80 : 0x00);
 576         asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
 577         mutex_unlock(&data->update_lock);
 578         return count;
 579 }
 580
 581 static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm1, set_pwm1);
 582 static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
 583                 show_pwm_enable1, set_pwm_enable1);
 584
 585 static struct attribute *asb100_attributes[] = {
 586         &dev_attr_in0_input.attr,
 587         &dev_attr_in0_min.attr,
 588         &dev_attr_in0_max.attr,
 589         &dev_attr_in1_input.attr,
 590         &dev_attr_in1_min.attr,
 591         &dev_attr_in1_max.attr,
 592         &dev_attr_in2_input.attr,
 593         &dev_attr_in2_min.attr,
 594         &dev_attr_in2_max.attr,
 595         &dev_attr_in3_input.attr,
 596         &dev_attr_in3_min.attr,
 597         &dev_attr_in3_max.attr,
 598         &dev_attr_in4_input.attr,
 599         &dev_attr_in4_min.attr,
 600         &dev_attr_in4_max.attr,
 601         &dev_attr_in5_input.attr,
 602         &dev_attr_in5_min.attr,
 603         &dev_attr_in5_max.attr,
 604         &dev_attr_in6_input.attr,
 605         &dev_attr_in6_min.attr,
 606         &dev_attr_in6_max.attr,
 607
 608         &dev_attr_fan1_input.attr,
 609         &dev_attr_fan1_min.attr,
 610         &dev_attr_fan1_div.attr,
 611         &dev_attr_fan2_input.attr,
 612         &dev_attr_fan2_min.attr,
 613         &dev_attr_fan2_div.attr,
 614         &dev_attr_fan3_input.attr,
 615         &dev_attr_fan3_min.attr,
 616         &dev_attr_fan3_div.attr,
 617
 618         &dev_attr_temp1_input.attr,
 619         &dev_attr_temp1_max.attr,
 620         &dev_attr_temp1_max_hyst.attr,
 621         &dev_attr_temp2_input.attr,
 622         &dev_attr_temp2_max.attr,
 623         &dev_attr_temp2_max_hyst.attr,
 624         &dev_attr_temp3_input.attr,
 625         &dev_attr_temp3_max.attr,
 626         &dev_attr_temp3_max_hyst.attr,
 627         &dev_attr_temp4_input.attr,
 628         &dev_attr_temp4_max.attr,
 629         &dev_attr_temp4_max_hyst.attr,
 630
 631         &dev_attr_cpu0_vid.attr,
 632         &dev_attr_vrm.attr,
 633         &dev_attr_alarms.attr,
 634         &dev_attr_pwm1.attr,
 635         &dev_attr_pwm1_enable.attr,
 636
 637         NULL
 638 };
 639
 640 static const struct attribute_group asb100_group = {
 641         .attrs = asb100_attributes,
 642 };
 643
 644 /* This function is called when:
 645         asb100_driver is inserted (when this module is loaded), for each
 646                 available adapter
 647         when a new adapter is inserted (and asb100_driver is still present)
 648  */
 649 static int asb100_attach_adapter(struct i2c_adapter *adapter)
 650 {
 651         if (!(adapter->class & I2C_CLASS_HWMON))
 652                 return 0;
 653         return i2c_probe(adapter, &addr_data, asb100_detect);
 654 }
 655
 656 static int asb100_detect_subclients(struct i2c_adapter *adapter, int address,
 657                 int kind, struct i2c_client *client)
 658 {
 659         int i, id, err;
 660         struct asb100_data *data = i2c_get_clientdata(client);
 661
 662         data->lm75[0] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 663         if (!(data->lm75[0])) {
 664                 err = -ENOMEM;
 665                 goto ERROR_SC_0;
 666         }
 667
 668         data->lm75[1] = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 669         if (!(data->lm75[1])) {
 670                 err = -ENOMEM;
 671                 goto ERROR_SC_1;
 672         }
 673
 674         id = i2c_adapter_id(adapter);
 675
 676         if (force_subclients[0] == id && force_subclients[1] == address) {
 677                 for (i = 2; i <= 3; i++) {
 678                         if (force_subclients[i] < 0x48 ||
 679                             force_subclients[i] > 0x4f) {
 680                                 dev_err(&client->dev, "invalid subclient "
 681                                         "address %d; must be 0x48-0x4f\n",
 682                                         force_subclients[i]);
 683                                 err = -ENODEV;
 684                                 goto ERROR_SC_2;
 685                         }
 686                 }
 687                 asb100_write_value(client, ASB100_REG_I2C_SUBADDR,
 688                                         (force_subclients[2] & 0x07) |
 689                                         ((force_subclients[3] & 0x07) << 4));
 690                 data->lm75[0]->addr = force_subclients[2];
 691                 data->lm75[1]->addr = force_subclients[3];
 692         } else {
 693                 int val = asb100_read_value(client, ASB100_REG_I2C_SUBADDR);
 694                 data->lm75[0]->addr = 0x48 + (val & 0x07);
 695                 data->lm75[1]->addr = 0x48 + ((val >> 4) & 0x07);
 696         }
 697
 698         if (data->lm75[0]->addr == data->lm75[1]->addr) {
 699                 dev_err(&client->dev, "duplicate addresses 0x%x "
 700                                 "for subclients\n", data->lm75[0]->addr);
 701                 err = -ENODEV;
 702                 goto ERROR_SC_2;
 703         }
 704
 705         for (i = 0; i <= 1; i++) {
 706                 i2c_set_clientdata(data->lm75[i], NULL);
 707                 data->lm75[i]->adapter = adapter;
 708                 data->lm75[i]->driver = &asb100_driver;
 709                 strlcpy(data->lm75[i]->name, "asb100 subclient", I2C_NAME_SIZE);
 710         }
 711
 712         if ((err = i2c_attach_client(data->lm75[0]))) {
 713                 dev_err(&client->dev, "subclient %d registration "
 714                         "at address 0x%x failed.\n", i, data->lm75[0]->addr);
 715                 goto ERROR_SC_2;
 716         }
 717
 718         if ((err = i2c_attach_client(data->lm75[1]))) {
 719                 dev_err(&client->dev, "subclient %d registration "
 720                         "at address 0x%x failed.\n", i, data->lm75[1]->addr);
 721                 goto ERROR_SC_3;
 722         }
 723
 724         return 0;
 725
 726 /* Undo inits in case of errors */
 727 ERROR_SC_3:
 728         i2c_detach_client(data->lm75[0]);
 729 ERROR_SC_2:
 730         kfree(data->lm75[1]);
 731 ERROR_SC_1:
 732         kfree(data->lm75[0]);
 733 ERROR_SC_0:
 734         return err;
 735 }
 736
 737 static int asb100_detect(struct i2c_adapter *adapter, int address, int kind)
 738 {
 739         int err;
 740         struct i2c_client *client;
 741         struct asb100_data *data;
 742
 743         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 744                 pr_debug("asb100.o: detect failed, "
 745                                 "smbus byte data not supported!\n");
 746                 err = -ENODEV;
 747                 goto ERROR0;
 748         }
 749
 750         /* OK. For now, we presume we have a valid client. We now create the
 751            client structure, even though we cannot fill it completely yet.
 752            But it allows us to access asb100_{read,write}_value. */
 753
 754         if (!(data = kzalloc(sizeof(struct asb100_data), GFP_KERNEL))) {
 755                 pr_debug("asb100.o: detect failed, kzalloc failed!\n");
 756                 err = -ENOMEM;
 757                 goto ERROR0;
 758         }
 759
 760         client = &data->client;
 761         mutex_init(&data->lock);
 762         i2c_set_clientdata(client, data);
 763         client->addr = address;
 764         client->adapter = adapter;
 765         client->driver = &asb100_driver;
 766
 767         /* Now, we do the remaining detection. */
 768
 769         /* The chip may be stuck in some other bank than bank 0. This may
 770            make reading other information impossible. Specify a force=... or
 771            force_*=... parameter, and the chip will be reset to the right
 772            bank. */
 773         if (kind < 0) {
 774
 775                 int val1 = asb100_read_value(client, ASB100_REG_BANK);
 776                 int val2 = asb100_read_value(client, ASB100_REG_CHIPMAN);
 777
 778                 /* If we're in bank 0 */
 779                 if ((!(val1 & 0x07)) &&
 780                                 /* Check for ASB100 ID (low byte) */
 781                                 (((!(val1 & 0x80)) && (val2 != 0x94)) ||
 782                                 /* Check for ASB100 ID (high byte ) */
 783                                 ((val1 & 0x80) && (val2 != 0x06)))) {
 784                         pr_debug("asb100.o: detect failed, "
 785                                         "bad chip id 0x%02x!\n", val2);
 786                         err = -ENODEV;
 787                         goto ERROR1;
 788                 }
 789
 790         } /* kind < 0 */
 791
 792         /* We have either had a force parameter, or we have already detected
 793            Winbond. Put it now into bank 0 and Vendor ID High Byte */
 794         asb100_write_value(client, ASB100_REG_BANK,
 795                 (asb100_read_value(client, ASB100_REG_BANK) & 0x78) | 0x80);
 796
 797         /* Determine the chip type. */
 798         if (kind <= 0) {
 799                 int val1 = asb100_read_value(client, ASB100_REG_WCHIPID);
 800                 int val2 = asb100_read_value(client, ASB100_REG_CHIPMAN);
 801
 802                 if ((val1 == 0x31) && (val2 == 0x06))
 803                         kind = asb100;
 804                 else {
 805                         if (kind == 0)
 806                                 dev_warn(&client->dev, "ignoring "
 807                                         "'force' parameter for unknown chip "
 808                                         "at adapter %d, address 0x%02x.\n",
 809                                         i2c_adapter_id(adapter), address);
 810                         err = -ENODEV;
 811                         goto ERROR1;
 812                 }
 813         }
 814
 815         /* Fill in remaining client fields and put it into the global list */
 816         strlcpy(client->name, "asb100", I2C_NAME_SIZE);
 817         data->type = kind;
 818         mutex_init(&data->update_lock);
 819
 820         /* Tell the I2C layer a new client has arrived */
 821         if ((err = i2c_attach_client(client)))
 822                 goto ERROR1;
 823
 824         /* Attach secondary lm75 clients */
 825         if ((err = asb100_detect_subclients(adapter, address, kind,
 826                         client)))
 827                 goto ERROR2;
 828
 829         /* Initialize the chip */
 830         asb100_init_client(client);
 831
 832         /* A few vars need to be filled upon startup */
 833         data->fan_min[0] = asb100_read_value(client, ASB100_REG_FAN_MIN(0));
 834         data->fan_min[1] = asb100_read_value(client, ASB100_REG_FAN_MIN(1));
 835         data->fan_min[2] = asb100_read_value(client, ASB100_REG_FAN_MIN(2));
 836
 837         /* Register sysfs hooks */
 838         if ((err = sysfs_create_group(&client->dev.kobj, &asb100_group)))
 839                 goto ERROR3;
 840
 841         data->hwmon_dev = hwmon_device_register(&client->dev);
 842         if (IS_ERR(data->hwmon_dev)) {
 843                 err = PTR_ERR(data->hwmon_dev);
 844                 goto ERROR4;
 845         }
 846
 847         return 0;
 848
 849 ERROR4:
 850         sysfs_remove_group(&client->dev.kobj, &asb100_group);
 851 ERROR3:
 852         i2c_detach_client(data->lm75[1]);
 853         i2c_detach_client(data->lm75[0]);
 854         kfree(data->lm75[1]);
 855         kfree(data->lm75[0]);
 856 ERROR2:
 857         i2c_detach_client(client);
 858 ERROR1:
 859         kfree(data);
 860 ERROR0:
 861         return err;
 862 }
 863
 864 static int asb100_detach_client(struct i2c_client *client)
 865 {
 866         struct asb100_data *data = i2c_get_clientdata(client);
 867         int err;
 868
 869         /* main client */
 870         if (data) {
 871                 hwmon_device_unregister(data->hwmon_dev);
 872                 sysfs_remove_group(&client->dev.kobj, &asb100_group);
 873         }
 874
 875         if ((err = i2c_detach_client(client)))
 876                 return err;
 877
 878         /* main client */
 879         if (data)
 880                 kfree(data);
 881
 882         /* subclient */
 883         else
 884                 kfree(client);
 885
 886         return 0;
 887 }
 888
 889 /* The SMBus locks itself, usually, but nothing may access the chip between
 890    bank switches. */
 891 static int asb100_read_value(struct i2c_client *client, u16 reg)
 892 {
 893         struct asb100_data *data = i2c_get_clientdata(client);
 894         struct i2c_client *cl;
 895         int res, bank;
 896
 897         mutex_lock(&data->lock);
 898
 899         bank = (reg >> 8) & 0x0f;
 900         if (bank > 2)
 901                 /* switch banks */
 902                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
 903
 904         if (bank == 0 || bank > 2) {
 905                 res = i2c_smbus_read_byte_data(client, reg & 0xff);
 906         } else {
 907                 /* switch to subclient */
 908                 cl = data->lm75[bank - 1];
 909
 910                 /* convert from ISA to LM75 I2C addresses */
 911                 switch (reg & 0xff) {
 912                 case 0x50: /* TEMP */
 913                         res = swab16(i2c_smbus_read_word_data(cl, 0));
 914                         break;
 915                 case 0x52: /* CONFIG */
 916                         res = i2c_smbus_read_byte_data(cl, 1);
 917                         break;
 918                 case 0x53: /* HYST */
 919                         res = swab16(i2c_smbus_read_word_data(cl, 2));
 920                         break;
 921                 case 0x55: /* MAX */
 922                 default:
 923                         res = swab16(i2c_smbus_read_word_data(cl, 3));
 924                         break;
 925                 }
 926         }
 927
 928         if (bank > 2)
 929                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
 930
 931         mutex_unlock(&data->lock);
 932
 933         return res;
 934 }
 935
 936 static void asb100_write_value(struct i2c_client *client, u16 reg, u16 value)
 937 {
 938         struct asb100_data *data = i2c_get_clientdata(client);
 939         struct i2c_client *cl;
 940         int bank;
 941
 942         mutex_lock(&data->lock);
 943
 944         bank = (reg >> 8) & 0x0f;
 945         if (bank > 2)
 946                 /* switch banks */
 947                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, bank);
 948
 949         if (bank == 0 || bank > 2) {
 950                 i2c_smbus_write_byte_data(client, reg & 0xff, value & 0xff);
 951         } else {
 952                 /* switch to subclient */
 953                 cl = data->lm75[bank - 1];
 954
 955                 /* convert from ISA to LM75 I2C addresses */
 956                 switch (reg & 0xff) {
 957                 case 0x52: /* CONFIG */
 958                         i2c_smbus_write_byte_data(cl, 1, value & 0xff);
 959                         break;
 960                 case 0x53: /* HYST */
 961                         i2c_smbus_write_word_data(cl, 2, swab16(value));
 962                         break;
 963                 case 0x55: /* MAX */
 964                         i2c_smbus_write_word_data(cl, 3, swab16(value));
 965                         break;
 966                 }
 967         }
 968
 969         if (bank > 2)
 970                 i2c_smbus_write_byte_data(client, ASB100_REG_BANK, 0);
 971
 972         mutex_unlock(&data->lock);
 973 }
 974
 975 static void asb100_init_client(struct i2c_client *client)
 976 {
 977         struct asb100_data *data = i2c_get_clientdata(client);
 978         int vid = 0;
 979
 980         vid = asb100_read_value(client, ASB100_REG_VID_FANDIV) & 0x0f;
 981         vid |= (asb100_read_value(client, ASB100_REG_CHIPID) & 0x01) << 4;
 982         data->vrm = vid_which_vrm();
 983         vid = vid_from_reg(vid, data->vrm);
 984
 985         /* Start monitoring */
 986         asb100_write_value(client, ASB100_REG_CONFIG,
 987                 (asb100_read_value(client, ASB100_REG_CONFIG) & 0xf7) | 0x01);
 988 }
 989
 990 static struct asb100_data *asb100_update_device(struct device *dev)
 991 {
 992         struct i2c_client *client = to_i2c_client(dev);
 993         struct asb100_data *data = i2c_get_clientdata(client);
 994         int i;
 995
 996         mutex_lock(&data->update_lock);
 997
 998         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 999                 || !data->valid) {
1000
1001                 dev_dbg(&client->dev, "starting device update...\n");
1002
1003                 /* 7 voltage inputs */
1004                 for (i = 0; i < 7; i++) {
1005                         data->in[i] = asb100_read_value(client,
1006                                 ASB100_REG_IN(i));
1007                         data->in_min[i] = asb100_read_value(client,
1008                                 ASB100_REG_IN_MIN(i));
1009                         data->in_max[i] = asb100_read_value(client,
1010                                 ASB100_REG_IN_MAX(i));
1011                 }
1012
1013                 /* 3 fan inputs */
1014                 for (i = 0; i < 3; i++) {
1015                         data->fan[i] = asb100_read_value(client,
1016                                         ASB100_REG_FAN(i));
1017                         data->fan_min[i] = asb100_read_value(client,
1018                                         ASB100_REG_FAN_MIN(i));
1019                 }
1020
1021                 /* 4 temperature inputs */
1022                 for (i = 1; i <= 4; i++) {
1023                         data->temp[i-1] = asb100_read_value(client,
1024                                         ASB100_REG_TEMP(i));
1025                         data->temp_max[i-1] = asb100_read_value(client,
1026                                         ASB100_REG_TEMP_MAX(i));
1027                         data->temp_hyst[i-1] = asb100_read_value(client,
1028                                         ASB100_REG_TEMP_HYST(i));
1029                 }
1030
1031                 /* VID and fan divisors */
1032                 i = asb100_read_value(client, ASB100_REG_VID_FANDIV);
1033                 data->vid = i & 0x0f;
1034                 data->vid |= (asb100_read_value(client,
1035                                 ASB100_REG_CHIPID) & 0x01) << 4;
1036                 data->fan_div[0] = (i >> 4) & 0x03;
1037                 data->fan_div[1] = (i >> 6) & 0x03;
1038                 data->fan_div[2] = (asb100_read_value(client,
1039                                 ASB100_REG_PIN) >> 6) & 0x03;
1040
1041                 /* PWM */
1042                 data->pwm = asb100_read_value(client, ASB100_REG_PWM1);
1043
1044                 /* alarms */
1045                 data->alarms = asb100_read_value(client, ASB100_REG_ALARM1) +
1046                         (asb100_read_value(client, ASB100_REG_ALARM2) << 8);
1047
1048                 data->last_updated = jiffies;
1049                 data->valid = 1;
1050
1051                 dev_dbg(&client->dev, "... device update complete\n");
1052         }
1053
1054         mutex_unlock(&data->update_lock);
1055
1056         return data;
1057 }
1058
1059 static int __init asb100_init(void)
1060 {
1061         return i2c_add_driver(&asb100_driver);
1062 }
1063
1064 static void __exit asb100_exit(void)
1065 {
1066         i2c_del_driver(&asb100_driver);
1067 }
1068
1069 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
1070 MODULE_DESCRIPTION("ASB100 Bach driver");
1071 MODULE_LICENSE("GPL");
1072
1073 module_init(asb100_init);
1074 module_exit(asb100_exit);