drivers/hwmon/w83l786ng.c

   1 /*
   2     w83l786ng.c - Linux kernel driver for hardware monitoring
   3     Copyright (c) 2007 Kevin Lo <kevlo@kevlo.org>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation - version 2.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17     02110-1301 USA.
  18 */
  19
  20 /*
  21     Supports following chips:
  22
  23     Chip        #vin    #fanin  #pwm    #temp   wchipid vendid  i2c     ISA
  24     w83l786ng   3       2       2       2       0x7b    0x5ca3  yes     no
  25 */
  26
  27 #include <linux/module.h>
  28 #include <linux/init.h>
  29 #include <linux/slab.h>
  30 #include <linux/i2c.h>
  31 #include <linux/hwmon.h>
  32 #include <linux/hwmon-vid.h>
  33 #include <linux/hwmon-sysfs.h>
  34 #include <linux/err.h>
  35 #include <linux/mutex.h>
  36
  37 /* Addresses to scan */
  38 static const unsigned short normal_i2c[] = { 0x2e, 0x2f, I2C_CLIENT_END };
  39
  40 /* Insmod parameters */
  41 I2C_CLIENT_INSMOD_1(w83l786ng);
  42
  43 static int reset;
  44 module_param(reset, bool, 0);
  45 MODULE_PARM_DESC(reset, "Set to 1 to reset chip, not recommended");
  46
  47 #define W83L786NG_REG_IN_MIN(nr)        (0x2C + (nr) * 2)
  48 #define W83L786NG_REG_IN_MAX(nr)        (0x2B + (nr) * 2)
  49 #define W83L786NG_REG_IN(nr)            ((nr) + 0x20)
  50
  51 #define W83L786NG_REG_FAN(nr)           ((nr) + 0x28)
  52 #define W83L786NG_REG_FAN_MIN(nr)       ((nr) + 0x3B)
  53
  54 #define W83L786NG_REG_CONFIG            0x40
  55 #define W83L786NG_REG_ALARM1            0x41
  56 #define W83L786NG_REG_ALARM2            0x42
  57 #define W83L786NG_REG_GPIO_EN           0x47
  58 #define W83L786NG_REG_MAN_ID2           0x4C
  59 #define W83L786NG_REG_MAN_ID1           0x4D
  60 #define W83L786NG_REG_CHIP_ID           0x4E
  61
  62 #define W83L786NG_REG_DIODE             0x53
  63 #define W83L786NG_REG_FAN_DIV           0x54
  64 #define W83L786NG_REG_FAN_CFG           0x80
  65
  66 #define W83L786NG_REG_TOLERANCE         0x8D
  67
  68 static const u8 W83L786NG_REG_TEMP[2][3] = {
  69         { 0x25,         /* TEMP 0 in DataSheet */
  70           0x35,         /* TEMP 0 Over in DataSheet */
  71           0x36 },       /* TEMP 0 Hyst in DataSheet */
  72         { 0x26,         /* TEMP 1 in DataSheet */
  73           0x37,         /* TEMP 1 Over in DataSheet */
  74           0x38 }        /* TEMP 1 Hyst in DataSheet */
  75 };
  76
  77 static const u8 W83L786NG_PWM_MODE_SHIFT[] = {6, 7};
  78 static const u8 W83L786NG_PWM_ENABLE_SHIFT[] = {2, 4};
  79
  80 /* FAN Duty Cycle, be used to control */
  81 static const u8 W83L786NG_REG_PWM[] = {0x81, 0x87};
  82
  83
  84 static inline u8
  85 FAN_TO_REG(long rpm, int div)
  86 {
  87         if (rpm == 0)
  88                 return 255;
  89         rpm = SENSORS_LIMIT(rpm, 1, 1000000);
  90         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
  91 }
  92
  93 #define FAN_FROM_REG(val,div)   ((val) == 0   ? -1 : \
  94                                 ((val) == 255 ? 0 : \
  95                                 1350000 / ((val) * (div))))
  96
  97 /* for temp */
  98 #define TEMP_TO_REG(val)        (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \
  99                                     : (val)) / 1000, 0, 0xff))
 100 #define TEMP_FROM_REG(val)      (((val) & 0x80 ? (val)-0x100 : (val)) * 1000)
 101
 102 /* The analog voltage inputs have 8mV LSB. Since the sysfs output is
 103    in mV as would be measured on the chip input pin, need to just
 104    multiply/divide by 8 to translate from/to register values. */
 105 #define IN_TO_REG(val)          (SENSORS_LIMIT((((val) + 4) / 8), 0, 255))
 106 #define IN_FROM_REG(val)        ((val) * 8)
 107
 108 #define DIV_FROM_REG(val)       (1 << (val))
 109
 110 static inline u8
 111 DIV_TO_REG(long val)
 112 {
 113         int i;
 114         val = SENSORS_LIMIT(val, 1, 128) >> 1;
 115         for (i = 0; i < 7; i++) {
 116                 if (val == 0)
 117                         break;
 118                 val >>= 1;
 119         }
 120         return ((u8) i);
 121 }
 122
 123 struct w83l786ng_data {
 124         struct i2c_client client;
 125         struct device *hwmon_dev;
 126         struct mutex update_lock;
 127         char valid;                     /* !=0 if following fields are valid */
 128         unsigned long last_updated;     /* In jiffies */
 129         unsigned long last_nonvolatile; /* In jiffies, last time we update the
 130                                            nonvolatile registers */
 131
 132         u8 in[3];
 133         u8 in_max[3];
 134         u8 in_min[3];
 135         u8 fan[2];
 136         u8 fan_div[2];
 137         u8 fan_min[2];
 138         u8 temp_type[2];
 139         u8 temp[2][3];
 140         u8 pwm[2];
 141         u8 pwm_mode[2]; /* 0->DC variable voltage
 142                            1->PWM variable duty cycle */
 143
 144         u8 pwm_enable[2]; /* 1->manual
 145                              2->thermal cruise (also called SmartFan I) */
 146         u8 tolerance[2];
 147 };
 148
 149 static int w83l786ng_attach_adapter(struct i2c_adapter *adapter);
 150 static int w83l786ng_detect(struct i2c_adapter *adapter, int address, int kind);
 151 static int w83l786ng_detach_client(struct i2c_client *client);
 152 static void w83l786ng_init_client(struct i2c_client *client);
 153 static struct w83l786ng_data *w83l786ng_update_device(struct device *dev);
 154
 155 static struct i2c_driver w83l786ng_driver = {
 156         .driver = {
 157                    .name = "w83l786ng",
 158         },
 159         .attach_adapter = w83l786ng_attach_adapter,
 160         .detach_client = w83l786ng_detach_client,
 161 };
 162
 163 static u8
 164 w83l786ng_read_value(struct i2c_client *client, u8 reg)
 165 {
 166         return i2c_smbus_read_byte_data(client, reg);
 167 }
 168
 169 static int
 170 w83l786ng_write_value(struct i2c_client *client, u8 reg, u8 value)
 171 {
 172         return i2c_smbus_write_byte_data(client, reg, value);
 173 }
 174
 175 /* following are the sysfs callback functions */
 176 #define show_in_reg(reg) \
 177 static ssize_t \
 178 show_##reg(struct device *dev, struct device_attribute *attr, \
 179            char *buf) \
 180 { \
 181         int nr = to_sensor_dev_attr(attr)->index; \
 182         struct w83l786ng_data *data = w83l786ng_update_device(dev); \
 183         return sprintf(buf,"%d\n", IN_FROM_REG(data->reg[nr])); \
 184 }
 185
 186 show_in_reg(in)
 187 show_in_reg(in_min)
 188 show_in_reg(in_max)
 189
 190 #define store_in_reg(REG, reg) \
 191 static ssize_t \
 192 store_in_##reg (struct device *dev, struct device_attribute *attr, \
 193                 const char *buf, size_t count) \
 194 { \
 195         int nr = to_sensor_dev_attr(attr)->index; \
 196         struct i2c_client *client = to_i2c_client(dev); \
 197         struct w83l786ng_data *data = i2c_get_clientdata(client); \
 198         unsigned long val = simple_strtoul(buf, NULL, 10); \
 199         mutex_lock(&data->update_lock); \
 200         data->in_##reg[nr] = IN_TO_REG(val); \
 201         w83l786ng_write_value(client, W83L786NG_REG_IN_##REG(nr), \
 202                               data->in_##reg[nr]); \
 203         mutex_unlock(&data->update_lock); \
 204         return count; \
 205 }
 206
 207 store_in_reg(MIN, min)
 208 store_in_reg(MAX, max)
 209
 210 static struct sensor_device_attribute sda_in_input[] = {
 211         SENSOR_ATTR(in0_input, S_IRUGO, show_in, NULL, 0),
 212         SENSOR_ATTR(in1_input, S_IRUGO, show_in, NULL, 1),
 213         SENSOR_ATTR(in2_input, S_IRUGO, show_in, NULL, 2),
 214 };
 215
 216 static struct sensor_device_attribute sda_in_min[] = {
 217         SENSOR_ATTR(in0_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 0),
 218         SENSOR_ATTR(in1_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 1),
 219         SENSOR_ATTR(in2_min, S_IWUSR | S_IRUGO, show_in_min, store_in_min, 2),
 220 };
 221
 222 static struct sensor_device_attribute sda_in_max[] = {
 223         SENSOR_ATTR(in0_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 0),
 224         SENSOR_ATTR(in1_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 1),
 225         SENSOR_ATTR(in2_max, S_IWUSR | S_IRUGO, show_in_max, store_in_max, 2),
 226 };
 227
 228 #define show_fan_reg(reg) \
 229 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
 230                           char *buf) \
 231 { \
 232         int nr = to_sensor_dev_attr(attr)->index; \
 233         struct w83l786ng_data *data = w83l786ng_update_device(dev); \
 234         return sprintf(buf,"%d\n", \
 235                 FAN_FROM_REG(data->fan[nr], DIV_FROM_REG(data->fan_div[nr]))); \
 236 }
 237
 238 show_fan_reg(fan);
 239 show_fan_reg(fan_min);
 240
 241 static ssize_t
 242 store_fan_min(struct device *dev, struct device_attribute *attr,
 243               const char *buf, size_t count)
 244 {
 245         int nr = to_sensor_dev_attr(attr)->index;
 246         struct i2c_client *client = to_i2c_client(dev);
 247         struct w83l786ng_data *data = i2c_get_clientdata(client);
 248         u32 val;
 249
 250         val = simple_strtoul(buf, NULL, 10);
 251         mutex_lock(&data->update_lock);
 252         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 253         w83l786ng_write_value(client, W83L786NG_REG_FAN_MIN(nr),
 254                               data->fan_min[nr]);
 255         mutex_unlock(&data->update_lock);
 256
 257         return count;
 258 }
 259
 260 static ssize_t
 261 show_fan_div(struct device *dev, struct device_attribute *attr,
 262              char *buf)
 263 {
 264         int nr = to_sensor_dev_attr(attr)->index;
 265         struct w83l786ng_data *data = w83l786ng_update_device(dev);
 266         return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr]));
 267 }
 268
 269 /* Note: we save and restore the fan minimum here, because its value is
 270    determined in part by the fan divisor.  This follows the principle of
 271    least surprise; the user doesn't expect the fan minimum to change just
 272    because the divisor changed. */
 273 static ssize_t
 274 store_fan_div(struct device *dev, struct device_attribute *attr,
 275               const char *buf, size_t count)
 276 {
 277         int nr = to_sensor_dev_attr(attr)->index;
 278         struct i2c_client *client = to_i2c_client(dev);
 279         struct w83l786ng_data *data = i2c_get_clientdata(client);
 280
 281         unsigned long min;
 282         u8 tmp_fan_div;
 283         u8 fan_div_reg;
 284         u8 keep_mask = 0;
 285         u8 new_shift = 0;
 286
 287         /* Save fan_min */
 288         mutex_lock(&data->update_lock);
 289         min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr]));
 290
 291         data->fan_div[nr] = DIV_TO_REG(simple_strtoul(buf, NULL, 10));
 292
 293         switch (nr) {
 294         case 0:
 295                 keep_mask = 0xf8;
 296                 new_shift = 0;
 297                 break;
 298         case 1:
 299                 keep_mask = 0x8f;
 300                 new_shift = 4;
 301                 break;
 302         }
 303
 304         fan_div_reg = w83l786ng_read_value(client, W83L786NG_REG_FAN_DIV)
 305                                            & keep_mask;
 306
 307         tmp_fan_div = (data->fan_div[nr] << new_shift) & ~keep_mask;
 308
 309         w83l786ng_write_value(client, W83L786NG_REG_FAN_DIV,
 310                               fan_div_reg | tmp_fan_div);
 311
 312         /* Restore fan_min */
 313         data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 314         w83l786ng_write_value(client, W83L786NG_REG_FAN_MIN(nr),
 315                               data->fan_min[nr]);
 316         mutex_unlock(&data->update_lock);
 317
 318         return count;
 319 }
 320
 321 static struct sensor_device_attribute sda_fan_input[] = {
 322         SENSOR_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0),
 323         SENSOR_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1),
 324 };
 325
 326 static struct sensor_device_attribute sda_fan_min[] = {
 327         SENSOR_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan_min,
 328                     store_fan_min, 0),
 329         SENSOR_ATTR(fan2_min, S_IWUSR | S_IRUGO, show_fan_min,
 330                     store_fan_min, 1),
 331 };
 332
 333 static struct sensor_device_attribute sda_fan_div[] = {
 334         SENSOR_ATTR(fan1_div, S_IWUSR | S_IRUGO, show_fan_div,
 335                     store_fan_div, 0),
 336         SENSOR_ATTR(fan2_div, S_IWUSR | S_IRUGO, show_fan_div,
 337                     store_fan_div, 1),
 338 };
 339
 340
 341 /* read/write the temperature, includes measured value and limits */
 342
 343 static ssize_t
 344 show_temp(struct device *dev, struct device_attribute *attr, char *buf)
 345 {
 346         struct sensor_device_attribute_2 *sensor_attr =
 347             to_sensor_dev_attr_2(attr);
 348         int nr = sensor_attr->nr;
 349         int index = sensor_attr->index;
 350         struct w83l786ng_data *data = w83l786ng_update_device(dev);
 351         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr][index]));
 352 }
 353
 354 static ssize_t
 355 store_temp(struct device *dev, struct device_attribute *attr,
 356            const char *buf, size_t count)
 357 {
 358         struct sensor_device_attribute_2 *sensor_attr =
 359             to_sensor_dev_attr_2(attr);
 360         int nr = sensor_attr->nr;
 361         int index = sensor_attr->index;
 362         struct i2c_client *client = to_i2c_client(dev);
 363         struct w83l786ng_data *data = i2c_get_clientdata(client);
 364         s32 val;
 365
 366         val = simple_strtol(buf, NULL, 10);
 367         mutex_lock(&data->update_lock);
 368         data->temp[nr][index] = TEMP_TO_REG(val);
 369         w83l786ng_write_value(client, W83L786NG_REG_TEMP[nr][index],
 370                               data->temp[nr][index]);
 371         mutex_unlock(&data->update_lock);
 372
 373         return count;
 374 }
 375
 376 static struct sensor_device_attribute_2 sda_temp_input[] = {
 377         SENSOR_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0, 0),
 378         SENSOR_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 1, 0),
 379 };
 380
 381 static struct sensor_device_attribute_2 sda_temp_max[] = {
 382         SENSOR_ATTR_2(temp1_max, S_IRUGO | S_IWUSR,
 383                       show_temp, store_temp, 0, 1),
 384         SENSOR_ATTR_2(temp2_max, S_IRUGO | S_IWUSR,
 385                       show_temp, store_temp, 1, 1),
 386 };
 387
 388 static struct sensor_device_attribute_2 sda_temp_max_hyst[] = {
 389         SENSOR_ATTR_2(temp1_max_hyst, S_IRUGO | S_IWUSR,
 390                       show_temp, store_temp, 0, 2),
 391         SENSOR_ATTR_2(temp2_max_hyst, S_IRUGO | S_IWUSR,
 392                       show_temp, store_temp, 1, 2),
 393 };
 394
 395 #define show_pwm_reg(reg) \
 396 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \
 397                            char *buf) \
 398 { \
 399         struct w83l786ng_data *data = w83l786ng_update_device(dev); \
 400         int nr = to_sensor_dev_attr(attr)->index; \
 401         return sprintf(buf, "%d\n", data->reg[nr]); \
 402 }
 403
 404 show_pwm_reg(pwm_mode)
 405 show_pwm_reg(pwm_enable)
 406 show_pwm_reg(pwm)
 407
 408 static ssize_t
 409 store_pwm_mode(struct device *dev, struct device_attribute *attr,
 410                const char *buf, size_t count)
 411 {
 412         int nr = to_sensor_dev_attr(attr)->index;
 413         struct i2c_client *client = to_i2c_client(dev);
 414         struct w83l786ng_data *data = i2c_get_clientdata(client);
 415         u32 val = simple_strtoul(buf, NULL, 10);
 416         u8 reg;
 417
 418         if (val > 1)
 419                 return -EINVAL;
 420         mutex_lock(&data->update_lock);
 421         data->pwm_mode[nr] = val;
 422         reg = w83l786ng_read_value(client, W83L786NG_REG_FAN_CFG);
 423         reg &= ~(1 << W83L786NG_PWM_MODE_SHIFT[nr]);
 424         if (!val)
 425                 reg |= 1 << W83L786NG_PWM_MODE_SHIFT[nr];
 426         w83l786ng_write_value(client, W83L786NG_REG_FAN_CFG, reg);
 427         mutex_unlock(&data->update_lock);
 428         return count;
 429 }
 430
 431 static ssize_t
 432 store_pwm(struct device *dev, struct device_attribute *attr,
 433           const char *buf, size_t count)
 434 {
 435         int nr = to_sensor_dev_attr(attr)->index;
 436         struct i2c_client *client = to_i2c_client(dev);
 437         struct w83l786ng_data *data = i2c_get_clientdata(client);
 438         u32 val = SENSORS_LIMIT(simple_strtoul(buf, NULL, 10), 0, 255);
 439
 440         mutex_lock(&data->update_lock);
 441         data->pwm[nr] = val;
 442         w83l786ng_write_value(client, W83L786NG_REG_PWM[nr], val);
 443         mutex_unlock(&data->update_lock);
 444         return count;
 445 }
 446
 447 static ssize_t
 448 store_pwm_enable(struct device *dev, struct device_attribute *attr,
 449                  const char *buf, size_t count)
 450 {
 451         int nr = to_sensor_dev_attr(attr)->index;
 452         struct i2c_client *client = to_i2c_client(dev);
 453         struct w83l786ng_data *data = i2c_get_clientdata(client);
 454         u32 val = simple_strtoul(buf, NULL, 10);
 455
 456         u8 reg;
 457
 458         if (!val || (val > 2))  /* only modes 1 and 2 are supported */
 459                 return -EINVAL;
 460
 461         mutex_lock(&data->update_lock);
 462         reg = w83l786ng_read_value(client, W83L786NG_REG_FAN_CFG);
 463         data->pwm_enable[nr] = val;
 464         reg &= ~(0x02 << W83L786NG_PWM_ENABLE_SHIFT[nr]);
 465         reg |= (val - 1) << W83L786NG_PWM_ENABLE_SHIFT[nr];
 466         w83l786ng_write_value(client, W83L786NG_REG_FAN_CFG, reg);
 467         mutex_unlock(&data->update_lock);
 468         return count;
 469 }
 470
 471 static struct sensor_device_attribute sda_pwm[] = {
 472         SENSOR_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0),
 473         SENSOR_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1),
 474 };
 475
 476 static struct sensor_device_attribute sda_pwm_mode[] = {
 477         SENSOR_ATTR(pwm1_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
 478                     store_pwm_mode, 0),
 479         SENSOR_ATTR(pwm2_mode, S_IWUSR | S_IRUGO, show_pwm_mode,
 480                     store_pwm_mode, 1),
 481 };
 482
 483 static struct sensor_device_attribute sda_pwm_enable[] = {
 484         SENSOR_ATTR(pwm1_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
 485                     store_pwm_enable, 0),
 486         SENSOR_ATTR(pwm2_enable, S_IWUSR | S_IRUGO, show_pwm_enable,
 487                     store_pwm_enable, 1),
 488 };
 489
 490 /* For Smart Fan I/Thermal Cruise and Smart Fan II */
 491 static ssize_t
 492 show_tolerance(struct device *dev, struct device_attribute *attr, char *buf)
 493 {
 494         int nr = to_sensor_dev_attr(attr)->index;
 495         struct w83l786ng_data *data = w83l786ng_update_device(dev);
 496         return sprintf(buf, "%ld\n", (long)data->tolerance[nr]);
 497 }
 498
 499 static ssize_t
 500 store_tolerance(struct device *dev, struct device_attribute *attr,
 501                 const char *buf, size_t count)
 502 {
 503         int nr = to_sensor_dev_attr(attr)->index;
 504         struct i2c_client *client = to_i2c_client(dev);
 505         struct w83l786ng_data *data = i2c_get_clientdata(client);
 506         u32 val;
 507         u8 tol_tmp, tol_mask;
 508
 509         val = simple_strtoul(buf, NULL, 10);
 510
 511         mutex_lock(&data->update_lock);
 512         tol_mask = w83l786ng_read_value(client,
 513             W83L786NG_REG_TOLERANCE) & ((nr == 1) ? 0x0f : 0xf0);
 514         tol_tmp = SENSORS_LIMIT(val, 0, 15);
 515         tol_tmp &= 0x0f;
 516         data->tolerance[nr] = tol_tmp;
 517         if (nr == 1) {
 518                 tol_tmp <<= 4;
 519         }
 520
 521         w83l786ng_write_value(client, W83L786NG_REG_TOLERANCE,
 522                               tol_mask | tol_tmp);
 523         mutex_unlock(&data->update_lock);
 524         return count;
 525 }
 526
 527 static struct sensor_device_attribute sda_tolerance[] = {
 528         SENSOR_ATTR(pwm1_tolerance, S_IWUSR | S_IRUGO,
 529                     show_tolerance, store_tolerance, 0),
 530         SENSOR_ATTR(pwm2_tolerance, S_IWUSR | S_IRUGO,
 531                     show_tolerance, store_tolerance, 1),
 532 };
 533
 534
 535 #define IN_UNIT_ATTRS(X)        \
 536         &sda_in_input[X].dev_attr.attr,         \
 537         &sda_in_min[X].dev_attr.attr,           \
 538         &sda_in_max[X].dev_attr.attr
 539
 540 #define FAN_UNIT_ATTRS(X)       \
 541         &sda_fan_input[X].dev_attr.attr,        \
 542         &sda_fan_min[X].dev_attr.attr,          \
 543         &sda_fan_div[X].dev_attr.attr
 544
 545 #define TEMP_UNIT_ATTRS(X)      \
 546         &sda_temp_input[X].dev_attr.attr,       \
 547         &sda_temp_max[X].dev_attr.attr,         \
 548         &sda_temp_max_hyst[X].dev_attr.attr
 549
 550 #define PWM_UNIT_ATTRS(X)       \
 551         &sda_pwm[X].dev_attr.attr,              \
 552         &sda_pwm_mode[X].dev_attr.attr,         \
 553         &sda_pwm_enable[X].dev_attr.attr
 554
 555 #define TOLERANCE_UNIT_ATTRS(X) \
 556         &sda_tolerance[X].dev_attr.attr
 557
 558 static struct attribute *w83l786ng_attributes[] = {
 559         IN_UNIT_ATTRS(0),
 560         IN_UNIT_ATTRS(1),
 561         IN_UNIT_ATTRS(2),
 562         FAN_UNIT_ATTRS(0),
 563         FAN_UNIT_ATTRS(1),
 564         TEMP_UNIT_ATTRS(0),
 565         TEMP_UNIT_ATTRS(1),
 566         PWM_UNIT_ATTRS(0),
 567         PWM_UNIT_ATTRS(1),
 568         TOLERANCE_UNIT_ATTRS(0),
 569         TOLERANCE_UNIT_ATTRS(1),
 570         NULL
 571 };
 572
 573 static const struct attribute_group w83l786ng_group = {
 574         .attrs = w83l786ng_attributes,
 575 };
 576
 577 static int
 578 w83l786ng_attach_adapter(struct i2c_adapter *adapter)
 579 {
 580         if (!(adapter->class & I2C_CLASS_HWMON))
 581                 return 0;
 582         return i2c_probe(adapter, &addr_data, w83l786ng_detect);
 583 }
 584
 585 static int
 586 w83l786ng_detect(struct i2c_adapter *adapter, int address, int kind)
 587 {
 588         struct i2c_client *client;
 589         struct device *dev;
 590         struct w83l786ng_data *data;
 591         int i, err = 0;
 592         u8 reg_tmp;
 593
 594         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 595                 goto exit;
 596         }
 597
 598         /* OK. For now, we presume we have a valid client. We now create the
 599            client structure, even though we cannot fill it completely yet.
 600            But it allows us to access w83l786ng_{read,write}_value. */
 601
 602         if (!(data = kzalloc(sizeof(struct w83l786ng_data), GFP_KERNEL))) {
 603                 err = -ENOMEM;
 604                 goto exit;
 605         }
 606
 607         client = &data->client;
 608         dev = &client->dev;
 609         i2c_set_clientdata(client, data);
 610         client->addr = address;
 611         client->adapter = adapter;
 612         client->driver = &w83l786ng_driver;
 613
 614         /*
 615          * Now we do the remaining detection. A negative kind means that
 616          * the driver was loaded with no force parameter (default), so we
 617          * must both detect and identify the chip (actually there is only
 618          * one possible kind of chip for now, W83L786NG). A zero kind means
 619          * that the driver was loaded with the force parameter, the detection
 620          * step shall be skipped. A positive kind means that the driver
 621          * was loaded with the force parameter and a given kind of chip is
 622          * requested, so both the detection and the identification steps
 623          * are skipped.
 624          */
 625         if (kind < 0) { /* detection */
 626                 if (((w83l786ng_read_value(client,
 627                     W83L786NG_REG_CONFIG) & 0x80) != 0x00)) {
 628                         dev_dbg(&adapter->dev,
 629                                 "W83L786NG detection failed at 0x%02x.\n",
 630                                 address);
 631                         goto exit_free;
 632                 }
 633         }
 634
 635         if (kind <= 0) { /* identification */
 636                 u16 man_id;
 637                 u8 chip_id;
 638
 639                 man_id = (w83l786ng_read_value(client,
 640                     W83L786NG_REG_MAN_ID1) << 8) +
 641                     w83l786ng_read_value(client, W83L786NG_REG_MAN_ID2);
 642                 chip_id = w83l786ng_read_value(client, W83L786NG_REG_CHIP_ID);
 643
 644                 if (man_id == 0x5CA3) { /* Winbond */
 645                         if (chip_id == 0x80) { /* W83L786NG */
 646                                 kind = w83l786ng;
 647                         }
 648                 }
 649
 650                 if (kind <= 0) { /* identification failed */
 651                         dev_info(&adapter->dev,
 652                             "Unsupported chip (man_id=0x%04X, "
 653                             "chip_id=0x%02X).\n", man_id, chip_id);
 654                         goto exit_free;
 655                 }
 656         }
 657
 658         /* Fill in the remaining client fields and put into the global list */
 659         strlcpy(client->name, "w83l786ng", I2C_NAME_SIZE);
 660         mutex_init(&data->update_lock);
 661
 662         /* Tell the I2C layer a new client has arrived */
 663         if ((err = i2c_attach_client(client)))
 664                 goto exit_free;
 665
 666         /* Initialize the chip */
 667         w83l786ng_init_client(client);
 668
 669         /* A few vars need to be filled upon startup */
 670         for (i = 0; i < 2; i++) {
 671                 data->fan_min[i] = w83l786ng_read_value(client,
 672                     W83L786NG_REG_FAN_MIN(i));
 673         }
 674
 675         /* Update the fan divisor */
 676         reg_tmp = w83l786ng_read_value(client, W83L786NG_REG_FAN_DIV);
 677         data->fan_div[0] = reg_tmp & 0x07;
 678         data->fan_div[1] = (reg_tmp >> 4) & 0x07;
 679
 680         /* Register sysfs hooks */
 681         if ((err = sysfs_create_group(&client->dev.kobj, &w83l786ng_group)))
 682                 goto exit_remove;
 683
 684         data->hwmon_dev = hwmon_device_register(dev);
 685         if (IS_ERR(data->hwmon_dev)) {
 686                 err = PTR_ERR(data->hwmon_dev);
 687                 goto exit_remove;
 688         }
 689
 690         return 0;
 691
 692         /* Unregister sysfs hooks */
 693
 694 exit_remove:
 695         sysfs_remove_group(&client->dev.kobj, &w83l786ng_group);
 696         i2c_detach_client(client);
 697 exit_free:
 698         kfree(data);
 699 exit:
 700         return err;
 701 }
 702
 703 static int
 704 w83l786ng_detach_client(struct i2c_client *client)
 705 {
 706         struct w83l786ng_data *data = i2c_get_clientdata(client);
 707         int err;
 708
 709         hwmon_device_unregister(data->hwmon_dev);
 710         sysfs_remove_group(&client->dev.kobj, &w83l786ng_group);
 711
 712         if ((err = i2c_detach_client(client)))
 713                 return err;
 714
 715         kfree(data);
 716
 717         return 0;
 718 }
 719
 720 static void
 721 w83l786ng_init_client(struct i2c_client *client)
 722 {
 723         u8 tmp;
 724
 725         if (reset)
 726                 w83l786ng_write_value(client, W83L786NG_REG_CONFIG, 0x80);
 727
 728         /* Start monitoring */
 729         tmp = w83l786ng_read_value(client, W83L786NG_REG_CONFIG);
 730         if (!(tmp & 0x01))
 731                 w83l786ng_write_value(client, W83L786NG_REG_CONFIG, tmp | 0x01);
 732 }
 733
 734 static struct w83l786ng_data *w83l786ng_update_device(struct device *dev)
 735 {
 736         struct i2c_client *client = to_i2c_client(dev);
 737         struct w83l786ng_data *data = i2c_get_clientdata(client);
 738         int i, j;
 739         u8 reg_tmp, pwmcfg;
 740
 741         mutex_lock(&data->update_lock);
 742         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 743             || !data->valid) {
 744                 dev_dbg(&client->dev, "Updating w83l786ng data.\n");
 745
 746                 /* Update the voltages measured value and limits */
 747                 for (i = 0; i < 3; i++) {
 748                         data->in[i] = w83l786ng_read_value(client,
 749                             W83L786NG_REG_IN(i));
 750                         data->in_min[i] = w83l786ng_read_value(client,
 751                             W83L786NG_REG_IN_MIN(i));
 752                         data->in_max[i] = w83l786ng_read_value(client,
 753                             W83L786NG_REG_IN_MAX(i));
 754                 }
 755
 756                 /* Update the fan counts and limits */
 757                 for (i = 0; i < 2; i++) {
 758                         data->fan[i] = w83l786ng_read_value(client,
 759                             W83L786NG_REG_FAN(i));
 760                         data->fan_min[i] = w83l786ng_read_value(client,
 761                             W83L786NG_REG_FAN_MIN(i));
 762                 }
 763
 764                 /* Update the fan divisor */
 765                 reg_tmp = w83l786ng_read_value(client, W83L786NG_REG_FAN_DIV);
 766                 data->fan_div[0] = reg_tmp & 0x07;
 767                 data->fan_div[1] = (reg_tmp >> 4) & 0x07;
 768
 769                 pwmcfg = w83l786ng_read_value(client, W83L786NG_REG_FAN_CFG);
 770                 for (i = 0; i < 2; i++) {
 771                         data->pwm_mode[i] =
 772                             ((pwmcfg >> W83L786NG_PWM_MODE_SHIFT[i]) & 1)
 773                             ? 0 : 1;
 774                         data->pwm_enable[i] =
 775                             ((pwmcfg >> W83L786NG_PWM_ENABLE_SHIFT[i]) & 2) + 1;
 776                         data->pwm[i] = w83l786ng_read_value(client,
 777                             W83L786NG_REG_PWM[i]);
 778                 }
 779
 780
 781                 /* Update the temperature sensors */
 782                 for (i = 0; i < 2; i++) {
 783                         for (j = 0; j < 3; j++) {
 784                                 data->temp[i][j] = w83l786ng_read_value(client,
 785                                     W83L786NG_REG_TEMP[i][j]);
 786                         }
 787                 }
 788
 789                 /* Update Smart Fan I/II tolerance */
 790                 reg_tmp = w83l786ng_read_value(client, W83L786NG_REG_TOLERANCE);
 791                 data->tolerance[0] = reg_tmp & 0x0f;
 792                 data->tolerance[1] = (reg_tmp >> 4) & 0x0f;
 793
 794                 data->last_updated = jiffies;
 795                 data->valid = 1;
 796
 797         }
 798
 799         mutex_unlock(&data->update_lock);
 800
 801         return data;
 802 }
 803
 804 static int __init
 805 sensors_w83l786ng_init(void)
 806 {
 807         return i2c_add_driver(&w83l786ng_driver);
 808 }
 809
 810 static void __exit
 811 sensors_w83l786ng_exit(void)
 812 {
 813         i2c_del_driver(&w83l786ng_driver);
 814 }
 815
 816 MODULE_AUTHOR("Kevin Lo");
 817 MODULE_DESCRIPTION("w83l786ng driver");
 818 MODULE_LICENSE("GPL");
 819
 820 module_init(sensors_w83l786ng_init);
 821 module_exit(sensors_w83l786ng_exit);