SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/hwmon/adt7475.c

   1 /*
   2  * adt7475 - Thermal sensor driver for the ADT7475 chip and derivatives
   3  * Copyright (C) 2007-2008, Advanced Micro Devices, Inc.
   4  * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
   5  * Copyright (C) 2008 Hans de Goede <hdegoede@redhat.com>
   6
   7  * Derived from the lm83 driver by Jean Delvare
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/slab.h>
  17 #include <linux/i2c.h>
  18 #include <linux/hwmon.h>
  19 #include <linux/hwmon-sysfs.h>
  20 #include <linux/err.h>
  21
  22 /* Indexes for the sysfs hooks */
  23
  24 #define INPUT           0
  25 #define MIN             1
  26 #define MAX             2
  27 #define CONTROL         3
  28 #define OFFSET          3
  29 #define AUTOMIN         4
  30 #define THERM           5
  31 #define HYSTERSIS       6
  32
  33 /* These are unique identifiers for the sysfs functions - unlike the
  34    numbers above, these are not also indexes into an array
  35 */
  36
  37 #define ALARM           9
  38 #define FAULT           10
  39
  40 /* 7475 Common Registers */
  41
  42 #define REG_VOLTAGE_BASE        0x20
  43 #define REG_TEMP_BASE           0x25
  44 #define REG_TACH_BASE           0x28
  45 #define REG_PWM_BASE            0x30
  46 #define REG_PWM_MAX_BASE        0x38
  47
  48 #define REG_DEVID               0x3D
  49 #define REG_VENDID              0x3E
  50
  51 #define REG_STATUS1             0x41
  52 #define REG_STATUS2             0x42
  53
  54 #define REG_VOLTAGE_MIN_BASE    0x44
  55 #define REG_VOLTAGE_MAX_BASE    0x45
  56
  57 #define REG_TEMP_MIN_BASE       0x4E
  58 #define REG_TEMP_MAX_BASE       0x4F
  59
  60 #define REG_TACH_MIN_BASE       0x54
  61
  62 #define REG_PWM_CONFIG_BASE     0x5C
  63
  64 #define REG_TEMP_TRANGE_BASE    0x5F
  65
  66 #define REG_PWM_MIN_BASE        0x64
  67
  68 #define REG_TEMP_TMIN_BASE      0x67
  69 #define REG_TEMP_THERM_BASE     0x6A
  70
  71 #define REG_REMOTE1_HYSTERSIS   0x6D
  72 #define REG_REMOTE2_HYSTERSIS   0x6E
  73
  74 #define REG_TEMP_OFFSET_BASE    0x70
  75
  76 #define REG_EXTEND1             0x76
  77 #define REG_EXTEND2             0x77
  78 #define REG_CONFIG5             0x7C
  79 #define REG_CONFIG4             0x7D
  80
  81 #define CONFIG4_MAXDUTY         0x08
  82
  83 #define CONFIG5_TWOSCOMP        0x01
  84 #define CONFIG5_TEMPOFFSET      0x02
  85
  86 /* ADT7475 Settings */
  87
  88 #define ADT7475_VOLTAGE_COUNT   5       /* Not counting Vtt */
  89 #define ADT7475_TEMP_COUNT      3
  90 #define ADT7475_TACH_COUNT      4
  91 #define ADT7475_PWM_COUNT       3
  92
  93 /* Macro to read the registers */
  94
  95 #define adt7475_read(reg) i2c_smbus_read_byte_data(client, (reg))
  96
  97 /* Macros to easily index the registers */
  98
  99 #define TACH_REG(idx) (REG_TACH_BASE + ((idx) * 2))
 100 #define TACH_MIN_REG(idx) (REG_TACH_MIN_BASE + ((idx) * 2))
 101
 102 #define PWM_REG(idx) (REG_PWM_BASE + (idx))
 103 #define PWM_MAX_REG(idx) (REG_PWM_MAX_BASE + (idx))
 104 #define PWM_MIN_REG(idx) (REG_PWM_MIN_BASE + (idx))
 105 #define PWM_CONFIG_REG(idx) (REG_PWM_CONFIG_BASE + (idx))
 106
 107 #define VOLTAGE_REG(idx) (REG_VOLTAGE_BASE + (idx))
 108 #define VOLTAGE_MIN_REG(idx) (REG_VOLTAGE_MIN_BASE + ((idx) * 2))
 109 #define VOLTAGE_MAX_REG(idx) (REG_VOLTAGE_MAX_BASE + ((idx) * 2))
 110
 111 #define TEMP_REG(idx) (REG_TEMP_BASE + (idx))
 112 #define TEMP_MIN_REG(idx) (REG_TEMP_MIN_BASE + ((idx) * 2))
 113 #define TEMP_MAX_REG(idx) (REG_TEMP_MAX_BASE + ((idx) * 2))
 114 #define TEMP_TMIN_REG(idx) (REG_TEMP_TMIN_BASE + (idx))
 115 #define TEMP_THERM_REG(idx) (REG_TEMP_THERM_BASE + (idx))
 116 #define TEMP_OFFSET_REG(idx) (REG_TEMP_OFFSET_BASE + (idx))
 117 #define TEMP_TRANGE_REG(idx) (REG_TEMP_TRANGE_BASE + (idx))
 118
 119 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
 120
 121 I2C_CLIENT_INSMOD_2(adt7473, adt7475);
 122
 123 static const struct i2c_device_id adt7475_id[] = {
 124         { "adt7473", adt7473 },
 125         { "adt7475", adt7475 },
 126         { }
 127 };
 128 MODULE_DEVICE_TABLE(i2c, adt7475_id);
 129
 130 struct adt7475_data {
 131         struct device *hwmon_dev;
 132         struct mutex lock;
 133
 134         unsigned long measure_updated;
 135         unsigned long limits_updated;
 136         char valid;
 137
 138         u8 config4;
 139         u8 config5;
 140         u8 has_voltage;
 141         u16 alarms;
 142         u16 voltage[3][6];
 143         u16 temp[7][3];
 144         u16 tach[2][4];
 145         u8 pwm[4][3];
 146         u8 range[3];
 147         u8 pwmctl[3];
 148         u8 pwmchan[3];
 149 };
 150
 151 static struct i2c_driver adt7475_driver;
 152 static struct adt7475_data *adt7475_update_device(struct device *dev);
 153 static void adt7475_read_hystersis(struct i2c_client *client);
 154 static void adt7475_read_pwm(struct i2c_client *client, int index);
 155
 156 /* Given a temp value, convert it to register value */
 157
 158 static inline u16 temp2reg(struct adt7475_data *data, long val)
 159 {
 160         u16 ret;
 161
 162         if (!(data->config5 & CONFIG5_TWOSCOMP)) {
 163                 val = SENSORS_LIMIT(val, -64000, 191000);
 164                 ret = (val + 64500) / 1000;
 165         } else {
 166                 val = SENSORS_LIMIT(val, -128000, 127000);
 167                 if (val < -500)
 168                         ret = (256500 + val) / 1000;
 169                 else
 170                         ret = (val + 500) / 1000;
 171         }
 172
 173         return ret << 2;
 174 }
 175
 176 /* Given a register value, convert it to a real temp value */
 177
 178 static inline int reg2temp(struct adt7475_data *data, u16 reg)
 179 {
 180         if (data->config5 & CONFIG5_TWOSCOMP) {
 181                 if (reg >= 512)
 182                         return (reg - 1024) * 250;
 183                 else
 184                         return reg * 250;
 185         } else
 186                 return (reg - 256) * 250;
 187 }
 188
 189 static inline int tach2rpm(u16 tach)
 190 {
 191         if (tach == 0 || tach == 0xFFFF)
 192                 return 0;
 193
 194         return (90000 * 60) / tach;
 195 }
 196
 197 static inline u16 rpm2tach(unsigned long rpm)
 198 {
 199         if (rpm == 0)
 200                 return 0;
 201
 202         return SENSORS_LIMIT((90000 * 60) / rpm, 1, 0xFFFF);
 203 }
 204
 205 /* Scaling factors for voltage inputs, taken from the ADT7490 datasheet */
 206 static const int adt7473_in_scaling[ADT7475_VOLTAGE_COUNT + 1][2] = {
 207         { 45, 94 },     /* +2.5V */
 208         { 175, 525 },   /* Vccp */
 209         { 68, 71 },     /* Vcc */
 210         { 93, 47 },     /* +5V */
 211         { 120, 20 },    /* +12V */
 212         { 45, 45 },     /* Vtt */
 213 };
 214
 215 static inline int reg2volt(int channel, u16 reg)
 216 {
 217         const int *r = adt7473_in_scaling[channel];
 218
 219         return DIV_ROUND_CLOSEST(reg * (r[0] + r[1]) * 2250, r[1] * 1024);
 220 }
 221
 222 static inline u16 volt2reg(int channel, long volt)
 223 {
 224         const int *r = adt7473_in_scaling[channel];
 225         long reg;
 226
 227         reg = (volt * r[1] * 1024) / ((r[0] + r[1]) * 2250);
 228         return SENSORS_LIMIT(reg, 0, 1023) & (0xff << 2);
 229 }
 230
 231 static u16 adt7475_read_word(struct i2c_client *client, int reg)
 232 {
 233         u16 val;
 234
 235         val = i2c_smbus_read_byte_data(client, reg);
 236         val |= (i2c_smbus_read_byte_data(client, reg + 1) << 8);
 237
 238         return val;
 239 }
 240
 241 static void adt7475_write_word(struct i2c_client *client, int reg, u16 val)
 242 {
 243         i2c_smbus_write_byte_data(client, reg + 1, val >> 8);
 244         i2c_smbus_write_byte_data(client, reg, val & 0xFF);
 245 }
 246
 247 /* Find the nearest value in a table - used for pwm frequency and
 248    auto temp range */
 249 static int find_nearest(long val, const int *array, int size)
 250 {
 251         int i;
 252
 253         if (val < array[0])
 254                 return 0;
 255
 256         if (val > array[size - 1])
 257                 return size - 1;
 258
 259         for (i = 0; i < size - 1; i++) {
 260                 int a, b;
 261
 262                 if (val > array[i + 1])
 263                         continue;
 264
 265                 a = val - array[i];
 266                 b = array[i + 1] - val;
 267
 268                 return (a <= b) ? i : i + 1;
 269         }
 270
 271         return 0;
 272 }
 273
 274 static ssize_t show_voltage(struct device *dev, struct device_attribute *attr,
 275                             char *buf)
 276 {
 277         struct adt7475_data *data = adt7475_update_device(dev);
 278         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 279         unsigned short val;
 280
 281         switch (sattr->nr) {
 282         case ALARM:
 283                 return sprintf(buf, "%d\n",
 284                                (data->alarms >> sattr->index) & 1);
 285         default:
 286                 val = data->voltage[sattr->nr][sattr->index];
 287                 return sprintf(buf, "%d\n", reg2volt(sattr->index, val));
 288         }
 289 }
 290
 291 static ssize_t set_voltage(struct device *dev, struct device_attribute *attr,
 292                            const char *buf, size_t count)
 293 {
 294
 295         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 296         struct i2c_client *client = to_i2c_client(dev);
 297         struct adt7475_data *data = i2c_get_clientdata(client);
 298         unsigned char reg;
 299         long val;
 300
 301         if (strict_strtol(buf, 10, &val))
 302                 return -EINVAL;
 303
 304         mutex_lock(&data->lock);
 305
 306         data->voltage[sattr->nr][sattr->index] = volt2reg(sattr->index, val);
 307
 308         if (sattr->nr == MIN)
 309                 reg = VOLTAGE_MIN_REG(sattr->index);
 310         else
 311                 reg = VOLTAGE_MAX_REG(sattr->index);
 312
 313         i2c_smbus_write_byte_data(client, reg,
 314                                   data->voltage[sattr->nr][sattr->index] >> 2);
 315         mutex_unlock(&data->lock);
 316
 317         return count;
 318 }
 319
 320 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
 321                          char *buf)
 322 {
 323         struct adt7475_data *data = adt7475_update_device(dev);
 324         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 325         int out;
 326
 327         switch (sattr->nr) {
 328         case HYSTERSIS:
 329                 mutex_lock(&data->lock);
 330                 out = data->temp[sattr->nr][sattr->index];
 331                 if (sattr->index != 1)
 332                         out = (out >> 4) & 0xF;
 333                 else
 334                         out = (out & 0xF);
 335                 /* Show the value as an absolute number tied to
 336                  * THERM */
 337                 out = reg2temp(data, data->temp[THERM][sattr->index]) -
 338                         out * 1000;
 339                 mutex_unlock(&data->lock);
 340                 break;
 341
 342         case OFFSET:
 343                 /* Offset is always 2's complement, regardless of the
 344                  * setting in CONFIG5 */
 345                 mutex_lock(&data->lock);
 346                 out = (s8)data->temp[sattr->nr][sattr->index];
 347                 if (data->config5 & CONFIG5_TEMPOFFSET)
 348                         out *= 1000;
 349                 else
 350                         out *= 500;
 351                 mutex_unlock(&data->lock);
 352                 break;
 353
 354         case ALARM:
 355                 out = (data->alarms >> (sattr->index + 4)) & 1;
 356                 break;
 357
 358         case FAULT:
 359                 /* Note - only for remote1 and remote2 */
 360                 out = !!(data->alarms & (sattr->index ? 0x8000 : 0x4000));
 361                 break;
 362
 363         default:
 364                 /* All other temp values are in the configured format */
 365                 out = reg2temp(data, data->temp[sattr->nr][sattr->index]);
 366         }
 367
 368         return sprintf(buf, "%d\n", out);
 369 }
 370
 371 static ssize_t set_temp(struct device *dev, struct device_attribute *attr,
 372                         const char *buf, size_t count)
 373 {
 374         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 375         struct i2c_client *client = to_i2c_client(dev);
 376         struct adt7475_data *data = i2c_get_clientdata(client);
 377         unsigned char reg = 0;
 378         u8 out;
 379         int temp;
 380         long val;
 381
 382         if (strict_strtol(buf, 10, &val))
 383                 return -EINVAL;
 384
 385         mutex_lock(&data->lock);
 386
 387         /* We need the config register in all cases for temp <-> reg conv. */
 388         data->config5 = adt7475_read(REG_CONFIG5);
 389
 390         switch (sattr->nr) {
 391         case OFFSET:
 392                 if (data->config5 & CONFIG5_TEMPOFFSET) {
 393                         val = SENSORS_LIMIT(val, -63000, 127000);
 394                         out = data->temp[OFFSET][sattr->index] = val / 1000;
 395                 } else {
 396                         val = SENSORS_LIMIT(val, -63000, 64000);
 397                         out = data->temp[OFFSET][sattr->index] = val / 500;
 398                 }
 399                 break;
 400
 401         case HYSTERSIS:
 402                 /* The value will be given as an absolute value, turn it
 403                    into an offset based on THERM */
 404
 405                 /* Read fresh THERM and HYSTERSIS values from the chip */
 406                 data->temp[THERM][sattr->index] =
 407                         adt7475_read(TEMP_THERM_REG(sattr->index)) << 2;
 408                 adt7475_read_hystersis(client);
 409
 410                 temp = reg2temp(data, data->temp[THERM][sattr->index]);
 411                 val = SENSORS_LIMIT(val, temp - 15000, temp);
 412                 val = (temp - val) / 1000;
 413
 414                 if (sattr->index != 1) {
 415                         data->temp[HYSTERSIS][sattr->index] &= 0xF0;
 416                         data->temp[HYSTERSIS][sattr->index] |= (val & 0xF) << 4;
 417                 } else {
 418                         data->temp[HYSTERSIS][sattr->index] &= 0x0F;
 419                         data->temp[HYSTERSIS][sattr->index] |= (val & 0xF);
 420                 }
 421
 422                 out = data->temp[HYSTERSIS][sattr->index];
 423                 break;
 424
 425         default:
 426                 data->temp[sattr->nr][sattr->index] = temp2reg(data, val);
 427
 428                 /* We maintain an extra 2 digits of precision for simplicity
 429                  * - shift those back off before writing the value */
 430                 out = (u8) (data->temp[sattr->nr][sattr->index] >> 2);
 431         }
 432
 433         switch (sattr->nr) {
 434         case MIN:
 435                 reg = TEMP_MIN_REG(sattr->index);
 436                 break;
 437         case MAX:
 438                 reg = TEMP_MAX_REG(sattr->index);
 439                 break;
 440         case OFFSET:
 441                 reg = TEMP_OFFSET_REG(sattr->index);
 442                 break;
 443         case AUTOMIN:
 444                 reg = TEMP_TMIN_REG(sattr->index);
 445                 break;
 446         case THERM:
 447                 reg = TEMP_THERM_REG(sattr->index);
 448                 break;
 449         case HYSTERSIS:
 450                 if (sattr->index != 2)
 451                         reg = REG_REMOTE1_HYSTERSIS;
 452                 else
 453                         reg = REG_REMOTE2_HYSTERSIS;
 454
 455                 break;
 456         }
 457
 458         i2c_smbus_write_byte_data(client, reg, out);
 459
 460         mutex_unlock(&data->lock);
 461         return count;
 462 }
 463
 464 /* Table of autorange values - the user will write the value in millidegrees,
 465    and we'll convert it */
 466 static const int autorange_table[] = {
 467         2000, 2500, 3330, 4000, 5000, 6670, 8000,
 468         10000, 13330, 16000, 20000, 26670, 32000, 40000,
 469         53330, 80000
 470 };
 471
 472 static ssize_t show_point2(struct device *dev, struct device_attribute *attr,
 473                            char *buf)
 474 {
 475         struct adt7475_data *data = adt7475_update_device(dev);
 476         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 477         int out, val;
 478
 479         mutex_lock(&data->lock);
 480         out = (data->range[sattr->index] >> 4) & 0x0F;
 481         val = reg2temp(data, data->temp[AUTOMIN][sattr->index]);
 482         mutex_unlock(&data->lock);
 483
 484         return sprintf(buf, "%d\n", val + autorange_table[out]);
 485 }
 486
 487 static ssize_t set_point2(struct device *dev, struct device_attribute *attr,
 488                           const char *buf, size_t count)
 489 {
 490         struct i2c_client *client = to_i2c_client(dev);
 491         struct adt7475_data *data = i2c_get_clientdata(client);
 492         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 493         int temp;
 494         long val;
 495
 496         if (strict_strtol(buf, 10, &val))
 497                 return -EINVAL;
 498
 499         mutex_lock(&data->lock);
 500
 501         /* Get a fresh copy of the needed registers */
 502         data->config5 = adt7475_read(REG_CONFIG5);
 503         data->temp[AUTOMIN][sattr->index] =
 504                 adt7475_read(TEMP_TMIN_REG(sattr->index)) << 2;
 505         data->range[sattr->index] =
 506                 adt7475_read(TEMP_TRANGE_REG(sattr->index));
 507
 508         /* The user will write an absolute value, so subtract the start point
 509            to figure the range */
 510         temp = reg2temp(data, data->temp[AUTOMIN][sattr->index]);
 511         val = SENSORS_LIMIT(val, temp + autorange_table[0],
 512                 temp + autorange_table[ARRAY_SIZE(autorange_table) - 1]);
 513         val -= temp;
 514
 515         /* Find the nearest table entry to what the user wrote */
 516         val = find_nearest(val, autorange_table, ARRAY_SIZE(autorange_table));
 517
 518         data->range[sattr->index] &= ~0xF0;
 519         data->range[sattr->index] |= val << 4;
 520
 521         i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
 522                                   data->range[sattr->index]);
 523
 524         mutex_unlock(&data->lock);
 525         return count;
 526 }
 527
 528 static ssize_t show_tach(struct device *dev, struct device_attribute *attr,
 529                          char *buf)
 530 {
 531         struct adt7475_data *data = adt7475_update_device(dev);
 532         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 533         int out;
 534
 535         if (sattr->nr == ALARM)
 536                 out = (data->alarms >> (sattr->index + 10)) & 1;
 537         else
 538                 out = tach2rpm(data->tach[sattr->nr][sattr->index]);
 539
 540         return sprintf(buf, "%d\n", out);
 541 }
 542
 543 static ssize_t set_tach(struct device *dev, struct device_attribute *attr,
 544                         const char *buf, size_t count)
 545 {
 546
 547         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 548         struct i2c_client *client = to_i2c_client(dev);
 549         struct adt7475_data *data = i2c_get_clientdata(client);
 550         unsigned long val;
 551
 552         if (strict_strtoul(buf, 10, &val))
 553                 return -EINVAL;
 554
 555         mutex_lock(&data->lock);
 556
 557         data->tach[MIN][sattr->index] = rpm2tach(val);
 558
 559         adt7475_write_word(client, TACH_MIN_REG(sattr->index),
 560                            data->tach[MIN][sattr->index]);
 561
 562         mutex_unlock(&data->lock);
 563         return count;
 564 }
 565
 566 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
 567                         char *buf)
 568 {
 569         struct adt7475_data *data = adt7475_update_device(dev);
 570         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 571
 572         return sprintf(buf, "%d\n", data->pwm[sattr->nr][sattr->index]);
 573 }
 574
 575 static ssize_t show_pwmchan(struct device *dev, struct device_attribute *attr,
 576                             char *buf)
 577 {
 578         struct adt7475_data *data = adt7475_update_device(dev);
 579         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 580
 581         return sprintf(buf, "%d\n", data->pwmchan[sattr->index]);
 582 }
 583
 584 static ssize_t show_pwmctrl(struct device *dev, struct device_attribute *attr,
 585                             char *buf)
 586 {
 587         struct adt7475_data *data = adt7475_update_device(dev);
 588         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 589
 590         return sprintf(buf, "%d\n", data->pwmctl[sattr->index]);
 591 }
 592
 593 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
 594                        const char *buf, size_t count)
 595 {
 596
 597         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 598         struct i2c_client *client = to_i2c_client(dev);
 599         struct adt7475_data *data = i2c_get_clientdata(client);
 600         unsigned char reg = 0;
 601         long val;
 602
 603         if (strict_strtol(buf, 10, &val))
 604                 return -EINVAL;
 605
 606         mutex_lock(&data->lock);
 607
 608         switch (sattr->nr) {
 609         case INPUT:
 610                 /* Get a fresh value for CONTROL */
 611                 data->pwm[CONTROL][sattr->index] =
 612                         adt7475_read(PWM_CONFIG_REG(sattr->index));
 613
 614                 /* If we are not in manual mode, then we shouldn't allow
 615                  * the user to set the pwm speed */
 616                 if (((data->pwm[CONTROL][sattr->index] >> 5) & 7) != 7) {
 617                         mutex_unlock(&data->lock);
 618                         return count;
 619                 }
 620
 621                 reg = PWM_REG(sattr->index);
 622                 break;
 623
 624         case MIN:
 625                 reg = PWM_MIN_REG(sattr->index);
 626                 break;
 627
 628         case MAX:
 629                 reg = PWM_MAX_REG(sattr->index);
 630                 break;
 631         }
 632
 633         data->pwm[sattr->nr][sattr->index] = SENSORS_LIMIT(val, 0, 0xFF);
 634         i2c_smbus_write_byte_data(client, reg,
 635                                   data->pwm[sattr->nr][sattr->index]);
 636
 637         mutex_unlock(&data->lock);
 638
 639         return count;
 640 }
 641
 642 /* Called by set_pwmctrl and set_pwmchan */
 643
 644 static int hw_set_pwm(struct i2c_client *client, int index,
 645                       unsigned int pwmctl, unsigned int pwmchan)
 646 {
 647         struct adt7475_data *data = i2c_get_clientdata(client);
 648         long val = 0;
 649
 650         switch (pwmctl) {
 651         case 0:
 652                 val = 0x03;     /* Run at full speed */
 653                 break;
 654         case 1:
 655                 val = 0x07;     /* Manual mode */
 656                 break;
 657         case 2:
 658                 switch (pwmchan) {
 659                 case 1:
 660                         /* Remote1 controls PWM */
 661                         val = 0x00;
 662                         break;
 663                 case 2:
 664                         /* local controls PWM */
 665                         val = 0x01;
 666                         break;
 667                 case 4:
 668                         /* remote2 controls PWM */
 669                         val = 0x02;
 670                         break;
 671                 case 6:
 672                         /* local/remote2 control PWM */
 673                         val = 0x05;
 674                         break;
 675                 case 7:
 676                         /* All three control PWM */
 677                         val = 0x06;
 678                         break;
 679                 default:
 680                         return -EINVAL;
 681                 }
 682                 break;
 683         default:
 684                 return -EINVAL;
 685         }
 686
 687         data->pwmctl[index] = pwmctl;
 688         data->pwmchan[index] = pwmchan;
 689
 690         data->pwm[CONTROL][index] &= ~0xE0;
 691         data->pwm[CONTROL][index] |= (val & 7) << 5;
 692
 693         i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
 694                                   data->pwm[CONTROL][index]);
 695
 696         return 0;
 697 }
 698
 699 static ssize_t set_pwmchan(struct device *dev, struct device_attribute *attr,
 700                            const char *buf, size_t count)
 701 {
 702         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 703         struct i2c_client *client = to_i2c_client(dev);
 704         struct adt7475_data *data = i2c_get_clientdata(client);
 705         int r;
 706         long val;
 707
 708         if (strict_strtol(buf, 10, &val))
 709                 return -EINVAL;
 710
 711         mutex_lock(&data->lock);
 712         /* Read Modify Write PWM values */
 713         adt7475_read_pwm(client, sattr->index);
 714         r = hw_set_pwm(client, sattr->index, data->pwmctl[sattr->index], val);
 715         if (r)
 716                 count = r;
 717         mutex_unlock(&data->lock);
 718
 719         return count;
 720 }
 721
 722 static ssize_t set_pwmctrl(struct device *dev, struct device_attribute *attr,
 723                            const char *buf, size_t count)
 724 {
 725         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 726         struct i2c_client *client = to_i2c_client(dev);
 727         struct adt7475_data *data = i2c_get_clientdata(client);
 728         int r;
 729         long val;
 730
 731         if (strict_strtol(buf, 10, &val))
 732                 return -EINVAL;
 733
 734         mutex_lock(&data->lock);
 735         /* Read Modify Write PWM values */
 736         adt7475_read_pwm(client, sattr->index);
 737         r = hw_set_pwm(client, sattr->index, val, data->pwmchan[sattr->index]);
 738         if (r)
 739                 count = r;
 740         mutex_unlock(&data->lock);
 741
 742         return count;
 743 }
 744
 745 /* List of frequencies for the PWM */
 746 static const int pwmfreq_table[] = {
 747         11, 14, 22, 29, 35, 44, 58, 88
 748 };
 749
 750 static ssize_t show_pwmfreq(struct device *dev, struct device_attribute *attr,
 751                             char *buf)
 752 {
 753         struct adt7475_data *data = adt7475_update_device(dev);
 754         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 755
 756         return sprintf(buf, "%d\n",
 757                        pwmfreq_table[data->range[sattr->index] & 7]);
 758 }
 759
 760 static ssize_t set_pwmfreq(struct device *dev, struct device_attribute *attr,
 761                            const char *buf, size_t count)
 762 {
 763         struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
 764         struct i2c_client *client = to_i2c_client(dev);
 765         struct adt7475_data *data = i2c_get_clientdata(client);
 766         int out;
 767         long val;
 768
 769         if (strict_strtol(buf, 10, &val))
 770                 return -EINVAL;
 771
 772         out = find_nearest(val, pwmfreq_table, ARRAY_SIZE(pwmfreq_table));
 773
 774         mutex_lock(&data->lock);
 775
 776         data->range[sattr->index] =
 777                 adt7475_read(TEMP_TRANGE_REG(sattr->index));
 778         data->range[sattr->index] &= ~7;
 779         data->range[sattr->index] |= out;
 780
 781         i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
 782                                   data->range[sattr->index]);
 783
 784         mutex_unlock(&data->lock);
 785         return count;
 786 }
 787
 788 static ssize_t show_pwm_at_crit(struct device *dev,
 789                                 struct device_attribute *devattr, char *buf)
 790 {
 791         struct adt7475_data *data = adt7475_update_device(dev);
 792         return sprintf(buf, "%d\n", !!(data->config4 & CONFIG4_MAXDUTY));
 793 }
 794
 795 static ssize_t set_pwm_at_crit(struct device *dev,
 796                                struct device_attribute *devattr,
 797                                const char *buf, size_t count)
 798 {
 799         struct i2c_client *client = to_i2c_client(dev);
 800         struct adt7475_data *data = i2c_get_clientdata(client);
 801         long val;
 802
 803         if (strict_strtol(buf, 10, &val))
 804                 return -EINVAL;
 805         if (val != 0 && val != 1)
 806                 return -EINVAL;
 807
 808         mutex_lock(&data->lock);
 809         data->config4 = i2c_smbus_read_byte_data(client, REG_CONFIG4);
 810         if (val)
 811                 data->config4 |= CONFIG4_MAXDUTY;
 812         else
 813                 data->config4 &= ~CONFIG4_MAXDUTY;
 814         i2c_smbus_write_byte_data(client, REG_CONFIG4, data->config4);
 815         mutex_unlock(&data->lock);
 816
 817         return count;
 818 }
 819
 820 static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, show_voltage, NULL, INPUT, 1);
 821 static SENSOR_DEVICE_ATTR_2(in1_max, S_IRUGO | S_IWUSR, show_voltage,
 822                             set_voltage, MAX, 1);
 823 static SENSOR_DEVICE_ATTR_2(in1_min, S_IRUGO | S_IWUSR, show_voltage,
 824                             set_voltage, MIN, 1);
 825 static SENSOR_DEVICE_ATTR_2(in1_alarm, S_IRUGO, show_voltage, NULL, ALARM, 1);
 826 static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, show_voltage, NULL, INPUT, 2);
 827 static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_voltage,
 828                             set_voltage, MAX, 2);
 829 static SENSOR_DEVICE_ATTR_2(in2_min, S_IRUGO | S_IWUSR, show_voltage,
 830                             set_voltage, MIN, 2);
 831 static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_voltage, NULL, ALARM, 2);
 832 static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, INPUT, 0);
 833 static SENSOR_DEVICE_ATTR_2(temp1_alarm, S_IRUGO, show_temp, NULL, ALARM, 0);
 834 static SENSOR_DEVICE_ATTR_2(temp1_fault, S_IRUGO, show_temp, NULL, FAULT, 0);
 835 static SENSOR_DEVICE_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
 836                             MAX, 0);
 837 static SENSOR_DEVICE_ATTR_2(temp1_min, S_IRUGO | S_IWUSR, show_temp, set_temp,
 838                             MIN, 0);
 839 static SENSOR_DEVICE_ATTR_2(temp1_offset, S_IRUGO | S_IWUSR, show_temp,
 840                             set_temp, OFFSET, 0);
 841 static SENSOR_DEVICE_ATTR_2(temp1_auto_point1_temp, S_IRUGO | S_IWUSR,
 842                             show_temp, set_temp, AUTOMIN, 0);
 843 static SENSOR_DEVICE_ATTR_2(temp1_auto_point2_temp, S_IRUGO | S_IWUSR,
 844                             show_point2, set_point2, 0, 0);
 845 static SENSOR_DEVICE_ATTR_2(temp1_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
 846                             THERM, 0);
 847 static SENSOR_DEVICE_ATTR_2(temp1_crit_hyst, S_IRUGO | S_IWUSR, show_temp,
 848                             set_temp, HYSTERSIS, 0);
 849 static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, INPUT, 1);
 850 static SENSOR_DEVICE_ATTR_2(temp2_alarm, S_IRUGO, show_temp, NULL, ALARM, 1);
 851 static SENSOR_DEVICE_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
 852                             MAX, 1);
 853 static SENSOR_DEVICE_ATTR_2(temp2_min, S_IRUGO | S_IWUSR, show_temp, set_temp,
 854                             MIN, 1);
 855 static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IRUGO | S_IWUSR, show_temp,
 856                             set_temp, OFFSET, 1);
 857 static SENSOR_DEVICE_ATTR_2(temp2_auto_point1_temp, S_IRUGO | S_IWUSR,
 858                             show_temp, set_temp, AUTOMIN, 1);
 859 static SENSOR_DEVICE_ATTR_2(temp2_auto_point2_temp, S_IRUGO | S_IWUSR,
 860                             show_point2, set_point2, 0, 1);
 861 static SENSOR_DEVICE_ATTR_2(temp2_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
 862                             THERM, 1);
 863 static SENSOR_DEVICE_ATTR_2(temp2_crit_hyst, S_IRUGO | S_IWUSR, show_temp,
 864                             set_temp, HYSTERSIS, 1);
 865 static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, INPUT, 2);
 866 static SENSOR_DEVICE_ATTR_2(temp3_alarm, S_IRUGO, show_temp, NULL, ALARM, 2);
 867 static SENSOR_DEVICE_ATTR_2(temp3_fault, S_IRUGO, show_temp, NULL, FAULT, 2);
 868 static SENSOR_DEVICE_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
 869                             MAX, 2);
 870 static SENSOR_DEVICE_ATTR_2(temp3_min, S_IRUGO | S_IWUSR, show_temp, set_temp,
 871                             MIN, 2);
 872 static SENSOR_DEVICE_ATTR_2(temp3_offset, S_IRUGO | S_IWUSR, show_temp,
 873                             set_temp, OFFSET, 2);
 874 static SENSOR_DEVICE_ATTR_2(temp3_auto_point1_temp, S_IRUGO | S_IWUSR,
 875                             show_temp, set_temp, AUTOMIN, 2);
 876 static SENSOR_DEVICE_ATTR_2(temp3_auto_point2_temp, S_IRUGO | S_IWUSR,
 877                             show_point2, set_point2, 0, 2);
 878 static SENSOR_DEVICE_ATTR_2(temp3_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
 879                             THERM, 2);
 880 static SENSOR_DEVICE_ATTR_2(temp3_crit_hyst, S_IRUGO | S_IWUSR, show_temp,
 881                             set_temp, HYSTERSIS, 2);
 882 static SENSOR_DEVICE_ATTR_2(fan1_input, S_IRUGO, show_tach, NULL, INPUT, 0);
 883 static SENSOR_DEVICE_ATTR_2(fan1_min, S_IRUGO | S_IWUSR, show_tach, set_tach,
 884                             MIN, 0);
 885 static SENSOR_DEVICE_ATTR_2(fan1_alarm, S_IRUGO, show_tach, NULL, ALARM, 0);
 886 static SENSOR_DEVICE_ATTR_2(fan2_input, S_IRUGO, show_tach, NULL, INPUT, 1);
 887 static SENSOR_DEVICE_ATTR_2(fan2_min, S_IRUGO | S_IWUSR, show_tach, set_tach,
 888                             MIN, 1);
 889 static SENSOR_DEVICE_ATTR_2(fan2_alarm, S_IRUGO, show_tach, NULL, ALARM, 1);
 890 static SENSOR_DEVICE_ATTR_2(fan3_input, S_IRUGO, show_tach, NULL, INPUT, 2);
 891 static SENSOR_DEVICE_ATTR_2(fan3_min, S_IRUGO | S_IWUSR, show_tach, set_tach,
 892                             MIN, 2);
 893 static SENSOR_DEVICE_ATTR_2(fan3_alarm, S_IRUGO, show_tach, NULL, ALARM, 2);
 894 static SENSOR_DEVICE_ATTR_2(fan4_input, S_IRUGO, show_tach, NULL, INPUT, 3);
 895 static SENSOR_DEVICE_ATTR_2(fan4_min, S_IRUGO | S_IWUSR, show_tach, set_tach,
 896                             MIN, 3);
 897 static SENSOR_DEVICE_ATTR_2(fan4_alarm, S_IRUGO, show_tach, NULL, ALARM, 3);
 898 static SENSOR_DEVICE_ATTR_2(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, INPUT,
 899                             0);
 900 static SENSOR_DEVICE_ATTR_2(pwm1_freq, S_IRUGO | S_IWUSR, show_pwmfreq,
 901                             set_pwmfreq, INPUT, 0);
 902 static SENSOR_DEVICE_ATTR_2(pwm1_enable, S_IRUGO | S_IWUSR, show_pwmctrl,
 903                             set_pwmctrl, INPUT, 0);
 904 static SENSOR_DEVICE_ATTR_2(pwm1_auto_channels_temp, S_IRUGO | S_IWUSR,
 905                             show_pwmchan, set_pwmchan, INPUT, 0);
 906 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_pwm, S_IRUGO | S_IWUSR, show_pwm,
 907                             set_pwm, MIN, 0);
 908 static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_pwm, S_IRUGO | S_IWUSR, show_pwm,
 909                             set_pwm, MAX, 0);
 910 static SENSOR_DEVICE_ATTR_2(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, INPUT,
 911                             1);
 912 static SENSOR_DEVICE_ATTR_2(pwm2_freq, S_IRUGO | S_IWUSR, show_pwmfreq,
 913                             set_pwmfreq, INPUT, 1);
 914 static SENSOR_DEVICE_ATTR_2(pwm2_enable, S_IRUGO | S_IWUSR, show_pwmctrl,
 915                             set_pwmctrl, INPUT, 1);
 916 static SENSOR_DEVICE_ATTR_2(pwm2_auto_channels_temp, S_IRUGO | S_IWUSR,
 917                             show_pwmchan, set_pwmchan, INPUT, 1);
 918 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_pwm, S_IRUGO | S_IWUSR, show_pwm,
 919                             set_pwm, MIN, 1);
 920 static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_pwm, S_IRUGO | S_IWUSR, show_pwm,
 921                             set_pwm, MAX, 1);
 922 static SENSOR_DEVICE_ATTR_2(pwm3, S_IRUGO | S_IWUSR, show_pwm, set_pwm, INPUT,
 923                             2);
 924 static SENSOR_DEVICE_ATTR_2(pwm3_freq, S_IRUGO | S_IWUSR, show_pwmfreq,
 925                             set_pwmfreq, INPUT, 2);
 926 static SENSOR_DEVICE_ATTR_2(pwm3_enable, S_IRUGO | S_IWUSR, show_pwmctrl,
 927                             set_pwmctrl, INPUT, 2);
 928 static SENSOR_DEVICE_ATTR_2(pwm3_auto_channels_temp, S_IRUGO | S_IWUSR,
 929                             show_pwmchan, set_pwmchan, INPUT, 2);
 930 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_pwm, S_IRUGO | S_IWUSR, show_pwm,
 931                             set_pwm, MIN, 2);
 932 static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_pwm, S_IRUGO | S_IWUSR, show_pwm,
 933                             set_pwm, MAX, 2);
 934
 935 /* Non-standard name, might need revisiting */
 936 static DEVICE_ATTR(pwm_use_point2_pwm_at_crit, S_IWUSR | S_IRUGO,
 937                    show_pwm_at_crit, set_pwm_at_crit);
 938
 939 static struct attribute *adt7475_attrs[] = {
 940         &sensor_dev_attr_in1_input.dev_attr.attr,
 941         &sensor_dev_attr_in1_max.dev_attr.attr,
 942         &sensor_dev_attr_in1_min.dev_attr.attr,
 943         &sensor_dev_attr_in1_alarm.dev_attr.attr,
 944         &sensor_dev_attr_in2_input.dev_attr.attr,
 945         &sensor_dev_attr_in2_max.dev_attr.attr,
 946         &sensor_dev_attr_in2_min.dev_attr.attr,
 947         &sensor_dev_attr_in2_alarm.dev_attr.attr,
 948         &sensor_dev_attr_temp1_input.dev_attr.attr,
 949         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 950         &sensor_dev_attr_temp1_fault.dev_attr.attr,
 951         &sensor_dev_attr_temp1_max.dev_attr.attr,
 952         &sensor_dev_attr_temp1_min.dev_attr.attr,
 953         &sensor_dev_attr_temp1_offset.dev_attr.attr,
 954         &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
 955         &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
 956         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 957         &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
 958         &sensor_dev_attr_temp2_input.dev_attr.attr,
 959         &sensor_dev_attr_temp2_alarm.dev_attr.attr,
 960         &sensor_dev_attr_temp2_max.dev_attr.attr,
 961         &sensor_dev_attr_temp2_min.dev_attr.attr,
 962         &sensor_dev_attr_temp2_offset.dev_attr.attr,
 963         &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
 964         &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
 965         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 966         &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
 967         &sensor_dev_attr_temp3_input.dev_attr.attr,
 968         &sensor_dev_attr_temp3_fault.dev_attr.attr,
 969         &sensor_dev_attr_temp3_alarm.dev_attr.attr,
 970         &sensor_dev_attr_temp3_max.dev_attr.attr,
 971         &sensor_dev_attr_temp3_min.dev_attr.attr,
 972         &sensor_dev_attr_temp3_offset.dev_attr.attr,
 973         &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
 974         &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
 975         &sensor_dev_attr_temp3_crit.dev_attr.attr,
 976         &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
 977         &sensor_dev_attr_fan1_input.dev_attr.attr,
 978         &sensor_dev_attr_fan1_min.dev_attr.attr,
 979         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 980         &sensor_dev_attr_fan2_input.dev_attr.attr,
 981         &sensor_dev_attr_fan2_min.dev_attr.attr,
 982         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 983         &sensor_dev_attr_fan3_input.dev_attr.attr,
 984         &sensor_dev_attr_fan3_min.dev_attr.attr,
 985         &sensor_dev_attr_fan3_alarm.dev_attr.attr,
 986         &sensor_dev_attr_fan4_input.dev_attr.attr,
 987         &sensor_dev_attr_fan4_min.dev_attr.attr,
 988         &sensor_dev_attr_fan4_alarm.dev_attr.attr,
 989         &sensor_dev_attr_pwm1.dev_attr.attr,
 990         &sensor_dev_attr_pwm1_freq.dev_attr.attr,
 991         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
 992         &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
 993         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
 994         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
 995         &sensor_dev_attr_pwm2.dev_attr.attr,
 996         &sensor_dev_attr_pwm2_freq.dev_attr.attr,
 997         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
 998         &sensor_dev_attr_pwm2_auto_channels_temp.dev_attr.attr,
 999         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
1000         &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
1001         &sensor_dev_attr_pwm3.dev_attr.attr,
1002         &sensor_dev_attr_pwm3_freq.dev_attr.attr,
1003         &sensor_dev_attr_pwm3_enable.dev_attr.attr,
1004         &sensor_dev_attr_pwm3_auto_channels_temp.dev_attr.attr,
1005         &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
1006         &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
1007         &dev_attr_pwm_use_point2_pwm_at_crit.attr,
1008         NULL,
1009 };
1010
1011 static struct attribute_group adt7475_attr_group = { .attrs = adt7475_attrs };
1012
1013 static int adt7475_detect(struct i2c_client *client, int kind,
1014                           struct i2c_board_info *info)
1015 {
1016         struct i2c_adapter *adapter = client->adapter;
1017         int vendid, devid;
1018         const char *name;
1019
1020         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1021                 return -ENODEV;
1022
1023         vendid = adt7475_read(REG_VENDID);
1024         devid = adt7475_read(REG_DEVID);
1025
1026         if (vendid == 0x41 && devid == 0x73)
1027                 name = "adt7473";
1028         else if (vendid == 0x41 && devid == 0x75 && client->addr == 0x2e)
1029                 name = "adt7475";
1030         else {
1031                 dev_dbg(&adapter->dev,
1032                         "Couldn't detect an ADT7473 or ADT7475 part at "
1033                         "0x%02x\n", (unsigned int)client->addr);
1034                 return -ENODEV;
1035         }
1036
1037         strlcpy(info->type, name, I2C_NAME_SIZE);
1038
1039         return 0;
1040 }
1041
1042 static int adt7475_probe(struct i2c_client *client,
1043                          const struct i2c_device_id *id)
1044 {
1045         struct adt7475_data *data;
1046         int i, ret = 0;
1047
1048         data = kzalloc(sizeof(*data), GFP_KERNEL);
1049         if (data == NULL)
1050                 return -ENOMEM;
1051
1052         mutex_init(&data->lock);
1053         i2c_set_clientdata(client, data);
1054
1055         /* Initialize device-specific values */
1056         switch (id->driver_data) {
1057         default:
1058                 data->has_voltage = 0x06;       /* in1, in2 */
1059         }
1060
1061         /* Call adt7475_read_pwm for all pwm's as this will reprogram any
1062            pwm's which are disabled to manual mode with 0% duty cycle */
1063         for (i = 0; i < ADT7475_PWM_COUNT; i++)
1064                 adt7475_read_pwm(client, i);
1065
1066         ret = sysfs_create_group(&client->dev.kobj, &adt7475_attr_group);
1067         if (ret)
1068                 goto efree;
1069
1070         data->hwmon_dev = hwmon_device_register(&client->dev);
1071         if (IS_ERR(data->hwmon_dev)) {
1072                 ret = PTR_ERR(data->hwmon_dev);
1073                 goto eremove;
1074         }
1075
1076         return 0;
1077
1078 eremove:
1079         sysfs_remove_group(&client->dev.kobj, &adt7475_attr_group);
1080 efree:
1081         kfree(data);
1082         return ret;
1083 }
1084
1085 static int adt7475_remove(struct i2c_client *client)
1086 {
1087         struct adt7475_data *data = i2c_get_clientdata(client);
1088
1089         hwmon_device_unregister(data->hwmon_dev);
1090         sysfs_remove_group(&client->dev.kobj, &adt7475_attr_group);
1091         kfree(data);
1092
1093         return 0;
1094 }
1095
1096 static struct i2c_driver adt7475_driver = {
1097         .class          = I2C_CLASS_HWMON,
1098         .driver = {
1099                 .name   = "adt7475",
1100         },
1101         .probe          = adt7475_probe,
1102         .remove         = adt7475_remove,
1103         .id_table       = adt7475_id,
1104         .detect         = adt7475_detect,
1105         .address_data   = &addr_data,
1106 };
1107
1108 static void adt7475_read_hystersis(struct i2c_client *client)
1109 {
1110         struct adt7475_data *data = i2c_get_clientdata(client);
1111
1112         data->temp[HYSTERSIS][0] = (u16) adt7475_read(REG_REMOTE1_HYSTERSIS);
1113         data->temp[HYSTERSIS][1] = data->temp[HYSTERSIS][0];
1114         data->temp[HYSTERSIS][2] = (u16) adt7475_read(REG_REMOTE2_HYSTERSIS);
1115 }
1116
1117 static void adt7475_read_pwm(struct i2c_client *client, int index)
1118 {
1119         struct adt7475_data *data = i2c_get_clientdata(client);
1120         unsigned int v;
1121
1122         data->pwm[CONTROL][index] = adt7475_read(PWM_CONFIG_REG(index));
1123
1124         /* Figure out the internal value for pwmctrl and pwmchan
1125            based on the current settings */
1126         v = (data->pwm[CONTROL][index] >> 5) & 7;
1127
1128         if (v == 3)
1129                 data->pwmctl[index] = 0;
1130         else if (v == 7)
1131                 data->pwmctl[index] = 1;
1132         else if (v == 4) {
1133                 /* The fan is disabled - we don't want to
1134                    support that, so change to manual mode and
1135                    set the duty cycle to 0 instead
1136                 */
1137                 data->pwm[INPUT][index] = 0;
1138                 data->pwm[CONTROL][index] &= ~0xE0;
1139                 data->pwm[CONTROL][index] |= (7 << 5);
1140
1141                 i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
1142                                           data->pwm[INPUT][index]);
1143
1144                 i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
1145                                           data->pwm[CONTROL][index]);
1146
1147                 data->pwmctl[index] = 1;
1148         } else {
1149                 data->pwmctl[index] = 2;
1150
1151                 switch (v) {
1152                 case 0:
1153                         data->pwmchan[index] = 1;
1154                         break;
1155                 case 1:
1156                         data->pwmchan[index] = 2;
1157                         break;
1158                 case 2:
1159                         data->pwmchan[index] = 4;
1160                         break;
1161                 case 5:
1162                         data->pwmchan[index] = 6;
1163                         break;
1164                 case 6:
1165                         data->pwmchan[index] = 7;
1166                         break;
1167                 }
1168         }
1169 }
1170
1171 static struct adt7475_data *adt7475_update_device(struct device *dev)
1172 {
1173         struct i2c_client *client = to_i2c_client(dev);
1174         struct adt7475_data *data = i2c_get_clientdata(client);
1175         u8 ext;
1176         int i;
1177
1178         mutex_lock(&data->lock);
1179
1180         /* Measurement values update every 2 seconds */
1181         if (time_after(jiffies, data->measure_updated + HZ * 2) ||
1182             !data->valid) {
1183                 data->alarms = adt7475_read(REG_STATUS2) << 8;
1184                 data->alarms |= adt7475_read(REG_STATUS1);
1185
1186                 ext = adt7475_read(REG_EXTEND1);
1187                 for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
1188                         if (!(data->has_voltage & (1 << i)))
1189                                 continue;
1190                         data->voltage[INPUT][i] =
1191                                 (adt7475_read(VOLTAGE_REG(i)) << 2) |
1192                                 ((ext >> (i * 2)) & 3);
1193                 }
1194
1195                 ext = adt7475_read(REG_EXTEND2);
1196                 for (i = 0; i < ADT7475_TEMP_COUNT; i++)
1197                         data->temp[INPUT][i] =
1198                                 (adt7475_read(TEMP_REG(i)) << 2) |
1199                                 ((ext >> ((i + 1) * 2)) & 3);
1200
1201                 for (i = 0; i < ADT7475_TACH_COUNT; i++)
1202                         data->tach[INPUT][i] =
1203                                 adt7475_read_word(client, TACH_REG(i));
1204
1205                 /* Updated by hw when in auto mode */
1206                 for (i = 0; i < ADT7475_PWM_COUNT; i++)
1207                         data->pwm[INPUT][i] = adt7475_read(PWM_REG(i));
1208
1209                 data->measure_updated = jiffies;
1210         }
1211
1212         /* Limits and settings, should never change update every 60 seconds */
1213         if (time_after(jiffies, data->limits_updated + HZ * 60) ||
1214             !data->valid) {
1215                 data->config4 = adt7475_read(REG_CONFIG4);
1216                 data->config5 = adt7475_read(REG_CONFIG5);
1217
1218                 for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
1219                         if (!(data->has_voltage & (1 << i)))
1220                                 continue;
1221                         /* Adjust values so they match the input precision */
1222                         data->voltage[MIN][i] =
1223                                 adt7475_read(VOLTAGE_MIN_REG(i)) << 2;
1224                         data->voltage[MAX][i] =
1225                                 adt7475_read(VOLTAGE_MAX_REG(i)) << 2;
1226                 }
1227
1228                 for (i = 0; i < ADT7475_TEMP_COUNT; i++) {
1229                         /* Adjust values so they match the input precision */
1230                         data->temp[MIN][i] =
1231                                 adt7475_read(TEMP_MIN_REG(i)) << 2;
1232                         data->temp[MAX][i] =
1233                                 adt7475_read(TEMP_MAX_REG(i)) << 2;
1234                         data->temp[AUTOMIN][i] =
1235                                 adt7475_read(TEMP_TMIN_REG(i)) << 2;
1236                         data->temp[THERM][i] =
1237                                 adt7475_read(TEMP_THERM_REG(i)) << 2;
1238                         data->temp[OFFSET][i] =
1239                                 adt7475_read(TEMP_OFFSET_REG(i));
1240                 }
1241                 adt7475_read_hystersis(client);
1242
1243                 for (i = 0; i < ADT7475_TACH_COUNT; i++)
1244                         data->tach[MIN][i] =
1245                                 adt7475_read_word(client, TACH_MIN_REG(i));
1246
1247                 for (i = 0; i < ADT7475_PWM_COUNT; i++) {
1248                         data->pwm[MAX][i] = adt7475_read(PWM_MAX_REG(i));
1249                         data->pwm[MIN][i] = adt7475_read(PWM_MIN_REG(i));
1250                         /* Set the channel and control information */
1251                         adt7475_read_pwm(client, i);
1252                 }
1253
1254                 data->range[0] = adt7475_read(TEMP_TRANGE_REG(0));
1255                 data->range[1] = adt7475_read(TEMP_TRANGE_REG(1));
1256                 data->range[2] = adt7475_read(TEMP_TRANGE_REG(2));
1257
1258                 data->limits_updated = jiffies;
1259                 data->valid = 1;
1260         }
1261
1262         mutex_unlock(&data->lock);
1263
1264         return data;
1265 }
1266
1267 static int __init sensors_adt7475_init(void)
1268 {
1269         return i2c_add_driver(&adt7475_driver);
1270 }
1271
1272 static void __exit sensors_adt7475_exit(void)
1273 {
1274         i2c_del_driver(&adt7475_driver);
1275 }
1276
1277 MODULE_AUTHOR("Advanced Micro Devices, Inc");
1278 MODULE_DESCRIPTION("adt7475 driver");
1279 MODULE_LICENSE("GPL");
1280
1281 module_init(sensors_adt7475_init);
1282 module_exit(sensors_adt7475_exit);