drivers/hwmon/amc6821.c

   1 /*
   2  * amc6821.c - Part of lm_sensors, Linux kernel modules for hardware
   3  *             monitoring
   4  * Copyright (C) 2009 T. Mertelj <tomaz.mertelj@guest.arnes.si>
   5  *
   6  * Based on max6650.c:
   7  * Copyright (C) 2007 Hans J. Koch <hjk@hansjkoch.de>
   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 as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/kernel.h>       /* Needed for KERN_INFO */
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/slab.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/i2c.h>
  30 #include <linux/hwmon.h>
  31 #include <linux/hwmon-sysfs.h>
  32 #include <linux/err.h>
  33 #include <linux/mutex.h>
  34
  35 /*
  36  * Addresses to scan.
  37  */
  38
  39 static const unsigned short normal_i2c[] = {0x18, 0x19, 0x1a, 0x2c, 0x2d, 0x2e,
  40         0x4c, 0x4d, 0x4e, I2C_CLIENT_END};
  41
  42 /*
  43  * Insmod parameters
  44  */
  45
  46 static int pwminv;      /*Inverted PWM output. */
  47 module_param(pwminv, int, S_IRUGO);
  48
  49 static int init = 1; /*Power-on initialization.*/
  50 module_param(init, int, S_IRUGO);
  51
  52 enum chips { amc6821 };
  53
  54 #define AMC6821_REG_DEV_ID 0x3D
  55 #define AMC6821_REG_COMP_ID 0x3E
  56 #define AMC6821_REG_CONF1 0x00
  57 #define AMC6821_REG_CONF2 0x01
  58 #define AMC6821_REG_CONF3 0x3F
  59 #define AMC6821_REG_CONF4 0x04
  60 #define AMC6821_REG_STAT1 0x02
  61 #define AMC6821_REG_STAT2 0x03
  62 #define AMC6821_REG_TDATA_LOW 0x08
  63 #define AMC6821_REG_TDATA_HI 0x09
  64 #define AMC6821_REG_LTEMP_HI 0x0A
  65 #define AMC6821_REG_RTEMP_HI 0x0B
  66 #define AMC6821_REG_LTEMP_LIMIT_MIN 0x15
  67 #define AMC6821_REG_LTEMP_LIMIT_MAX 0x14
  68 #define AMC6821_REG_RTEMP_LIMIT_MIN 0x19
  69 #define AMC6821_REG_RTEMP_LIMIT_MAX 0x18
  70 #define AMC6821_REG_LTEMP_CRIT 0x1B
  71 #define AMC6821_REG_RTEMP_CRIT 0x1D
  72 #define AMC6821_REG_PSV_TEMP 0x1C
  73 #define AMC6821_REG_DCY 0x22
  74 #define AMC6821_REG_LTEMP_FAN_CTRL 0x24
  75 #define AMC6821_REG_RTEMP_FAN_CTRL 0x25
  76 #define AMC6821_REG_DCY_LOW_TEMP 0x21
  77
  78 #define AMC6821_REG_TACH_LLIMITL 0x10
  79 #define AMC6821_REG_TACH_LLIMITH 0x11
  80 #define AMC6821_REG_TACH_HLIMITL 0x12
  81 #define AMC6821_REG_TACH_HLIMITH 0x13
  82
  83 #define AMC6821_CONF1_START 0x01
  84 #define AMC6821_CONF1_FAN_INT_EN 0x02
  85 #define AMC6821_CONF1_FANIE 0x04
  86 #define AMC6821_CONF1_PWMINV 0x08
  87 #define AMC6821_CONF1_FAN_FAULT_EN 0x10
  88 #define AMC6821_CONF1_FDRC0 0x20
  89 #define AMC6821_CONF1_FDRC1 0x40
  90 #define AMC6821_CONF1_THERMOVIE 0x80
  91
  92 #define AMC6821_CONF2_PWM_EN 0x01
  93 #define AMC6821_CONF2_TACH_MODE 0x02
  94 #define AMC6821_CONF2_TACH_EN 0x04
  95 #define AMC6821_CONF2_RTFIE 0x08
  96 #define AMC6821_CONF2_LTOIE 0x10
  97 #define AMC6821_CONF2_RTOIE 0x20
  98 #define AMC6821_CONF2_PSVIE 0x40
  99 #define AMC6821_CONF2_RST 0x80
 100
 101 #define AMC6821_CONF3_THERM_FAN_EN 0x80
 102 #define AMC6821_CONF3_REV_MASK 0x0F
 103
 104 #define AMC6821_CONF4_OVREN 0x10
 105 #define AMC6821_CONF4_TACH_FAST 0x20
 106 #define AMC6821_CONF4_PSPR 0x40
 107 #define AMC6821_CONF4_MODE 0x80
 108
 109 #define AMC6821_STAT1_RPM_ALARM 0x01
 110 #define AMC6821_STAT1_FANS 0x02
 111 #define AMC6821_STAT1_RTH 0x04
 112 #define AMC6821_STAT1_RTL 0x08
 113 #define AMC6821_STAT1_R_THERM 0x10
 114 #define AMC6821_STAT1_RTF 0x20
 115 #define AMC6821_STAT1_LTH 0x40
 116 #define AMC6821_STAT1_LTL 0x80
 117
 118 #define AMC6821_STAT2_RTC 0x08
 119 #define AMC6821_STAT2_LTC 0x10
 120 #define AMC6821_STAT2_LPSV 0x20
 121 #define AMC6821_STAT2_L_THERM 0x40
 122 #define AMC6821_STAT2_THERM_IN 0x80
 123
 124 enum {IDX_TEMP1_INPUT = 0, IDX_TEMP1_MIN, IDX_TEMP1_MAX,
 125         IDX_TEMP1_CRIT, IDX_TEMP2_INPUT, IDX_TEMP2_MIN,
 126         IDX_TEMP2_MAX, IDX_TEMP2_CRIT,
 127         TEMP_IDX_LEN, };
 128
 129 static const u8 temp_reg[] = {AMC6821_REG_LTEMP_HI,
 130                         AMC6821_REG_LTEMP_LIMIT_MIN,
 131                         AMC6821_REG_LTEMP_LIMIT_MAX,
 132                         AMC6821_REG_LTEMP_CRIT,
 133                         AMC6821_REG_RTEMP_HI,
 134                         AMC6821_REG_RTEMP_LIMIT_MIN,
 135                         AMC6821_REG_RTEMP_LIMIT_MAX,
 136                         AMC6821_REG_RTEMP_CRIT, };
 137
 138 enum {IDX_FAN1_INPUT = 0, IDX_FAN1_MIN, IDX_FAN1_MAX,
 139         FAN1_IDX_LEN, };
 140
 141 static const u8 fan_reg_low[] = {AMC6821_REG_TDATA_LOW,
 142                         AMC6821_REG_TACH_LLIMITL,
 143                         AMC6821_REG_TACH_HLIMITL, };
 144
 145
 146 static const u8 fan_reg_hi[] = {AMC6821_REG_TDATA_HI,
 147                         AMC6821_REG_TACH_LLIMITH,
 148                         AMC6821_REG_TACH_HLIMITH, };
 149
 150 /*
 151  * Client data (each client gets its own)
 152  */
 153
 154 struct amc6821_data {
 155         struct i2c_client *client;
 156         struct mutex update_lock;
 157         char valid; /* zero until following fields are valid */
 158         unsigned long last_updated; /* in jiffies */
 159
 160         /* register values */
 161         int temp[TEMP_IDX_LEN];
 162
 163         u16 fan[FAN1_IDX_LEN];
 164         u8 fan1_div;
 165
 166         u8 pwm1;
 167         u8 temp1_auto_point_temp[3];
 168         u8 temp2_auto_point_temp[3];
 169         u8 pwm1_auto_point_pwm[3];
 170         u8 pwm1_enable;
 171         u8 pwm1_auto_channels_temp;
 172
 173         u8 stat1;
 174         u8 stat2;
 175 };
 176
 177 static struct amc6821_data *amc6821_update_device(struct device *dev)
 178 {
 179         struct amc6821_data *data = dev_get_drvdata(dev);
 180         struct i2c_client *client = data->client;
 181         int timeout = HZ;
 182         u8 reg;
 183         int i;
 184
 185         mutex_lock(&data->update_lock);
 186
 187         if (time_after(jiffies, data->last_updated + timeout) ||
 188                         !data->valid) {
 189
 190                 for (i = 0; i < TEMP_IDX_LEN; i++)
 191                         data->temp[i] = (int8_t)i2c_smbus_read_byte_data(
 192                                 client, temp_reg[i]);
 193
 194                 data->stat1 = i2c_smbus_read_byte_data(client,
 195                         AMC6821_REG_STAT1);
 196                 data->stat2 = i2c_smbus_read_byte_data(client,
 197                         AMC6821_REG_STAT2);
 198
 199                 data->pwm1 = i2c_smbus_read_byte_data(client,
 200                         AMC6821_REG_DCY);
 201                 for (i = 0; i < FAN1_IDX_LEN; i++) {
 202                         data->fan[i] = i2c_smbus_read_byte_data(
 203                                         client,
 204                                         fan_reg_low[i]);
 205                         data->fan[i] += i2c_smbus_read_byte_data(
 206                                         client,
 207                                         fan_reg_hi[i]) << 8;
 208                 }
 209                 data->fan1_div = i2c_smbus_read_byte_data(client,
 210                         AMC6821_REG_CONF4);
 211                 data->fan1_div = data->fan1_div & AMC6821_CONF4_PSPR ? 4 : 2;
 212
 213                 data->pwm1_auto_point_pwm[0] = 0;
 214                 data->pwm1_auto_point_pwm[2] = 255;
 215                 data->pwm1_auto_point_pwm[1] = i2c_smbus_read_byte_data(client,
 216                         AMC6821_REG_DCY_LOW_TEMP);
 217
 218                 data->temp1_auto_point_temp[0] =
 219                         i2c_smbus_read_byte_data(client,
 220                                         AMC6821_REG_PSV_TEMP);
 221                 data->temp2_auto_point_temp[0] =
 222                                 data->temp1_auto_point_temp[0];
 223                 reg = i2c_smbus_read_byte_data(client,
 224                         AMC6821_REG_LTEMP_FAN_CTRL);
 225                 data->temp1_auto_point_temp[1] = (reg & 0xF8) >> 1;
 226                 reg &= 0x07;
 227                 reg = 0x20 >> reg;
 228                 if (reg > 0)
 229                         data->temp1_auto_point_temp[2] =
 230                                 data->temp1_auto_point_temp[1] +
 231                                 (data->pwm1_auto_point_pwm[2] -
 232                                 data->pwm1_auto_point_pwm[1]) / reg;
 233                 else
 234                         data->temp1_auto_point_temp[2] = 255;
 235
 236                 reg = i2c_smbus_read_byte_data(client,
 237                         AMC6821_REG_RTEMP_FAN_CTRL);
 238                 data->temp2_auto_point_temp[1] = (reg & 0xF8) >> 1;
 239                 reg &= 0x07;
 240                 reg = 0x20 >> reg;
 241                 if (reg > 0)
 242                         data->temp2_auto_point_temp[2] =
 243                                 data->temp2_auto_point_temp[1] +
 244                                 (data->pwm1_auto_point_pwm[2] -
 245                                 data->pwm1_auto_point_pwm[1]) / reg;
 246                 else
 247                         data->temp2_auto_point_temp[2] = 255;
 248
 249                 reg = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
 250                 reg = (reg >> 5) & 0x3;
 251                 switch (reg) {
 252                 case 0: /*open loop: software sets pwm1*/
 253                         data->pwm1_auto_channels_temp = 0;
 254                         data->pwm1_enable = 1;
 255                         break;
 256                 case 2: /*closed loop: remote T (temp2)*/
 257                         data->pwm1_auto_channels_temp = 2;
 258                         data->pwm1_enable = 2;
 259                         break;
 260                 case 3: /*closed loop: local and remote T (temp2)*/
 261                         data->pwm1_auto_channels_temp = 3;
 262                         data->pwm1_enable = 3;
 263                         break;
 264                 case 1: /*
 265                          * semi-open loop: software sets rpm, chip controls
 266                          * pwm1, currently not implemented
 267                          */
 268                         data->pwm1_auto_channels_temp = 0;
 269                         data->pwm1_enable = 0;
 270                         break;
 271                 }
 272
 273                 data->last_updated = jiffies;
 274                 data->valid = 1;
 275         }
 276         mutex_unlock(&data->update_lock);
 277         return data;
 278 }
 279
 280 static ssize_t get_temp(
 281                 struct device *dev,
 282                 struct device_attribute *devattr,
 283                 char *buf)
 284 {
 285         struct amc6821_data *data = amc6821_update_device(dev);
 286         int ix = to_sensor_dev_attr(devattr)->index;
 287
 288         return sprintf(buf, "%d\n", data->temp[ix] * 1000);
 289 }
 290
 291 static ssize_t set_temp(
 292                 struct device *dev,
 293                 struct device_attribute *attr,
 294                 const char *buf,
 295                 size_t count)
 296 {
 297         struct amc6821_data *data = dev_get_drvdata(dev);
 298         struct i2c_client *client = data->client;
 299         int ix = to_sensor_dev_attr(attr)->index;
 300         long val;
 301
 302         int ret = kstrtol(buf, 10, &val);
 303         if (ret)
 304                 return ret;
 305         val = clamp_val(val / 1000, -128, 127);
 306
 307         mutex_lock(&data->update_lock);
 308         data->temp[ix] = val;
 309         if (i2c_smbus_write_byte_data(client, temp_reg[ix], data->temp[ix])) {
 310                 dev_err(&client->dev, "Register write error, aborting.\n");
 311                 count = -EIO;
 312         }
 313         mutex_unlock(&data->update_lock);
 314         return count;
 315 }
 316
 317 static ssize_t get_temp_alarm(
 318         struct device *dev,
 319         struct device_attribute *devattr,
 320         char *buf)
 321 {
 322         struct amc6821_data *data = amc6821_update_device(dev);
 323         int ix = to_sensor_dev_attr(devattr)->index;
 324         u8 flag;
 325
 326         switch (ix) {
 327         case IDX_TEMP1_MIN:
 328                 flag = data->stat1 & AMC6821_STAT1_LTL;
 329                 break;
 330         case IDX_TEMP1_MAX:
 331                 flag = data->stat1 & AMC6821_STAT1_LTH;
 332                 break;
 333         case IDX_TEMP1_CRIT:
 334                 flag = data->stat2 & AMC6821_STAT2_LTC;
 335                 break;
 336         case IDX_TEMP2_MIN:
 337                 flag = data->stat1 & AMC6821_STAT1_RTL;
 338                 break;
 339         case IDX_TEMP2_MAX:
 340                 flag = data->stat1 & AMC6821_STAT1_RTH;
 341                 break;
 342         case IDX_TEMP2_CRIT:
 343                 flag = data->stat2 & AMC6821_STAT2_RTC;
 344                 break;
 345         default:
 346                 dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
 347                 return -EINVAL;
 348         }
 349         if (flag)
 350                 return sprintf(buf, "1");
 351         else
 352                 return sprintf(buf, "0");
 353 }
 354
 355 static ssize_t get_temp2_fault(
 356                 struct device *dev,
 357                 struct device_attribute *devattr,
 358                 char *buf)
 359 {
 360         struct amc6821_data *data = amc6821_update_device(dev);
 361         if (data->stat1 & AMC6821_STAT1_RTF)
 362                 return sprintf(buf, "1");
 363         else
 364                 return sprintf(buf, "0");
 365 }
 366
 367 static ssize_t get_pwm1(
 368                 struct device *dev,
 369                 struct device_attribute *devattr,
 370                 char *buf)
 371 {
 372         struct amc6821_data *data = amc6821_update_device(dev);
 373         return sprintf(buf, "%d\n", data->pwm1);
 374 }
 375
 376 static ssize_t set_pwm1(
 377                 struct device *dev,
 378                 struct device_attribute *devattr,
 379                 const char *buf,
 380                 size_t count)
 381 {
 382         struct amc6821_data *data = dev_get_drvdata(dev);
 383         struct i2c_client *client = data->client;
 384         long val;
 385         int ret = kstrtol(buf, 10, &val);
 386         if (ret)
 387                 return ret;
 388
 389         mutex_lock(&data->update_lock);
 390         data->pwm1 = clamp_val(val , 0, 255);
 391         i2c_smbus_write_byte_data(client, AMC6821_REG_DCY, data->pwm1);
 392         mutex_unlock(&data->update_lock);
 393         return count;
 394 }
 395
 396 static ssize_t get_pwm1_enable(
 397                 struct device *dev,
 398                 struct device_attribute *devattr,
 399                 char *buf)
 400 {
 401         struct amc6821_data *data = amc6821_update_device(dev);
 402         return sprintf(buf, "%d\n", data->pwm1_enable);
 403 }
 404
 405 static ssize_t set_pwm1_enable(
 406                 struct device *dev,
 407                 struct device_attribute *attr,
 408                 const char *buf,
 409                 size_t count)
 410 {
 411         struct amc6821_data *data = dev_get_drvdata(dev);
 412         struct i2c_client *client = data->client;
 413         long val;
 414         int config = kstrtol(buf, 10, &val);
 415         if (config)
 416                 return config;
 417
 418         mutex_lock(&data->update_lock);
 419         config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
 420         if (config < 0) {
 421                         dev_err(&client->dev,
 422                         "Error reading configuration register, aborting.\n");
 423                         count = config;
 424                         goto unlock;
 425         }
 426
 427         switch (val) {
 428         case 1:
 429                 config &= ~AMC6821_CONF1_FDRC0;
 430                 config &= ~AMC6821_CONF1_FDRC1;
 431                 break;
 432         case 2:
 433                 config &= ~AMC6821_CONF1_FDRC0;
 434                 config |= AMC6821_CONF1_FDRC1;
 435                 break;
 436         case 3:
 437                 config |= AMC6821_CONF1_FDRC0;
 438                 config |= AMC6821_CONF1_FDRC1;
 439                 break;
 440         default:
 441                 count = -EINVAL;
 442                 goto unlock;
 443         }
 444         if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF1, config)) {
 445                         dev_err(&client->dev,
 446                         "Configuration register write error, aborting.\n");
 447                         count = -EIO;
 448         }
 449 unlock:
 450         mutex_unlock(&data->update_lock);
 451         return count;
 452 }
 453
 454 static ssize_t get_pwm1_auto_channels_temp(
 455                 struct device *dev,
 456                 struct device_attribute *devattr,
 457                 char *buf)
 458 {
 459         struct amc6821_data *data = amc6821_update_device(dev);
 460         return sprintf(buf, "%d\n", data->pwm1_auto_channels_temp);
 461 }
 462
 463 static ssize_t get_temp_auto_point_temp(
 464                 struct device *dev,
 465                 struct device_attribute *devattr,
 466                 char *buf)
 467 {
 468         int ix = to_sensor_dev_attr_2(devattr)->index;
 469         int nr = to_sensor_dev_attr_2(devattr)->nr;
 470         struct amc6821_data *data = amc6821_update_device(dev);
 471         switch (nr) {
 472         case 1:
 473                 return sprintf(buf, "%d\n",
 474                         data->temp1_auto_point_temp[ix] * 1000);
 475         case 2:
 476                 return sprintf(buf, "%d\n",
 477                         data->temp2_auto_point_temp[ix] * 1000);
 478         default:
 479                 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
 480                 return -EINVAL;
 481         }
 482 }
 483
 484 static ssize_t get_pwm1_auto_point_pwm(
 485                 struct device *dev,
 486                 struct device_attribute *devattr,
 487                 char *buf)
 488 {
 489         int ix = to_sensor_dev_attr(devattr)->index;
 490         struct amc6821_data *data = amc6821_update_device(dev);
 491         return sprintf(buf, "%d\n", data->pwm1_auto_point_pwm[ix]);
 492 }
 493
 494 static inline ssize_t set_slope_register(struct i2c_client *client,
 495                 u8 reg,
 496                 u8 dpwm,
 497                 u8 *ptemp)
 498 {
 499         int dt;
 500         u8 tmp;
 501
 502         dt = ptemp[2]-ptemp[1];
 503         for (tmp = 4; tmp > 0; tmp--) {
 504                 if (dt * (0x20 >> tmp) >= dpwm)
 505                         break;
 506         }
 507         tmp |= (ptemp[1] & 0x7C) << 1;
 508         if (i2c_smbus_write_byte_data(client,
 509                         reg, tmp)) {
 510                 dev_err(&client->dev, "Register write error, aborting.\n");
 511                 return -EIO;
 512         }
 513         return 0;
 514 }
 515
 516 static ssize_t set_temp_auto_point_temp(
 517                 struct device *dev,
 518                 struct device_attribute *attr,
 519                 const char *buf,
 520                 size_t count)
 521 {
 522         struct amc6821_data *data = amc6821_update_device(dev);
 523         struct i2c_client *client = data->client;
 524         int ix = to_sensor_dev_attr_2(attr)->index;
 525         int nr = to_sensor_dev_attr_2(attr)->nr;
 526         u8 *ptemp;
 527         u8 reg;
 528         int dpwm;
 529         long val;
 530         int ret = kstrtol(buf, 10, &val);
 531         if (ret)
 532                 return ret;
 533
 534         switch (nr) {
 535         case 1:
 536                 ptemp = data->temp1_auto_point_temp;
 537                 reg = AMC6821_REG_LTEMP_FAN_CTRL;
 538                 break;
 539         case 2:
 540                 ptemp = data->temp2_auto_point_temp;
 541                 reg = AMC6821_REG_RTEMP_FAN_CTRL;
 542                 break;
 543         default:
 544                 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
 545                 return -EINVAL;
 546         }
 547
 548         mutex_lock(&data->update_lock);
 549         data->valid = 0;
 550
 551         switch (ix) {
 552         case 0:
 553                 ptemp[0] = clamp_val(val / 1000, 0,
 554                                      data->temp1_auto_point_temp[1]);
 555                 ptemp[0] = clamp_val(ptemp[0], 0,
 556                                      data->temp2_auto_point_temp[1]);
 557                 ptemp[0] = clamp_val(ptemp[0], 0, 63);
 558                 if (i2c_smbus_write_byte_data(
 559                                         client,
 560                                         AMC6821_REG_PSV_TEMP,
 561                                         ptemp[0])) {
 562                                 dev_err(&client->dev,
 563                                         "Register write error, aborting.\n");
 564                                 count = -EIO;
 565                 }
 566                 goto EXIT;
 567         case 1:
 568                 ptemp[1] = clamp_val(val / 1000, (ptemp[0] & 0x7C) + 4, 124);
 569                 ptemp[1] &= 0x7C;
 570                 ptemp[2] = clamp_val(ptemp[2], ptemp[1] + 1, 255);
 571                 break;
 572         case 2:
 573                 ptemp[2] = clamp_val(val / 1000, ptemp[1]+1, 255);
 574                 break;
 575         default:
 576                 dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
 577                 count = -EINVAL;
 578                 goto EXIT;
 579         }
 580         dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
 581         if (set_slope_register(client, reg, dpwm, ptemp))
 582                 count = -EIO;
 583
 584 EXIT:
 585         mutex_unlock(&data->update_lock);
 586         return count;
 587 }
 588
 589 static ssize_t set_pwm1_auto_point_pwm(
 590                 struct device *dev,
 591                 struct device_attribute *attr,
 592                 const char *buf,
 593                 size_t count)
 594 {
 595         struct amc6821_data *data = dev_get_drvdata(dev);
 596         struct i2c_client *client = data->client;
 597         int dpwm;
 598         long val;
 599         int ret = kstrtol(buf, 10, &val);
 600         if (ret)
 601                 return ret;
 602
 603         mutex_lock(&data->update_lock);
 604         data->pwm1_auto_point_pwm[1] = clamp_val(val, 0, 254);
 605         if (i2c_smbus_write_byte_data(client, AMC6821_REG_DCY_LOW_TEMP,
 606                         data->pwm1_auto_point_pwm[1])) {
 607                 dev_err(&client->dev, "Register write error, aborting.\n");
 608                 count = -EIO;
 609                 goto EXIT;
 610         }
 611         dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
 612         if (set_slope_register(client, AMC6821_REG_LTEMP_FAN_CTRL, dpwm,
 613                         data->temp1_auto_point_temp)) {
 614                 count = -EIO;
 615                 goto EXIT;
 616         }
 617         if (set_slope_register(client, AMC6821_REG_RTEMP_FAN_CTRL, dpwm,
 618                         data->temp2_auto_point_temp)) {
 619                 count = -EIO;
 620                 goto EXIT;
 621         }
 622
 623 EXIT:
 624         data->valid = 0;
 625         mutex_unlock(&data->update_lock);
 626         return count;
 627 }
 628
 629 static ssize_t get_fan(
 630                 struct device *dev,
 631                 struct device_attribute *devattr,
 632                 char *buf)
 633 {
 634         struct amc6821_data *data = amc6821_update_device(dev);
 635         int ix = to_sensor_dev_attr(devattr)->index;
 636         if (0 == data->fan[ix])
 637                 return sprintf(buf, "0");
 638         return sprintf(buf, "%d\n", (int)(6000000 / data->fan[ix]));
 639 }
 640
 641 static ssize_t get_fan1_fault(
 642                 struct device *dev,
 643                 struct device_attribute *devattr,
 644                 char *buf)
 645 {
 646         struct amc6821_data *data = amc6821_update_device(dev);
 647         if (data->stat1 & AMC6821_STAT1_FANS)
 648                 return sprintf(buf, "1");
 649         else
 650                 return sprintf(buf, "0");
 651 }
 652
 653 static ssize_t set_fan(
 654                 struct device *dev,
 655                 struct device_attribute *attr,
 656                 const char *buf, size_t count)
 657 {
 658         struct amc6821_data *data = dev_get_drvdata(dev);
 659         struct i2c_client *client = data->client;
 660         long val;
 661         int ix = to_sensor_dev_attr(attr)->index;
 662         int ret = kstrtol(buf, 10, &val);
 663         if (ret)
 664                 return ret;
 665         val = 1 > val ? 0xFFFF : 6000000/val;
 666
 667         mutex_lock(&data->update_lock);
 668         data->fan[ix] = (u16) clamp_val(val, 1, 0xFFFF);
 669         if (i2c_smbus_write_byte_data(client, fan_reg_low[ix],
 670                         data->fan[ix] & 0xFF)) {
 671                 dev_err(&client->dev, "Register write error, aborting.\n");
 672                 count = -EIO;
 673                 goto EXIT;
 674         }
 675         if (i2c_smbus_write_byte_data(client,
 676                         fan_reg_hi[ix], data->fan[ix] >> 8)) {
 677                 dev_err(&client->dev, "Register write error, aborting.\n");
 678                 count = -EIO;
 679         }
 680 EXIT:
 681         mutex_unlock(&data->update_lock);
 682         return count;
 683 }
 684
 685 static ssize_t get_fan1_div(
 686                 struct device *dev,
 687                 struct device_attribute *devattr,
 688                 char *buf)
 689 {
 690         struct amc6821_data *data = amc6821_update_device(dev);
 691         return sprintf(buf, "%d\n", data->fan1_div);
 692 }
 693
 694 static ssize_t set_fan1_div(
 695                 struct device *dev,
 696                 struct device_attribute *attr,
 697                 const char *buf, size_t count)
 698 {
 699         struct amc6821_data *data = dev_get_drvdata(dev);
 700         struct i2c_client *client = data->client;
 701         long val;
 702         int config = kstrtol(buf, 10, &val);
 703         if (config)
 704                 return config;
 705
 706         mutex_lock(&data->update_lock);
 707         config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
 708         if (config < 0) {
 709                 dev_err(&client->dev,
 710                         "Error reading configuration register, aborting.\n");
 711                 count = config;
 712                 goto EXIT;
 713         }
 714         switch (val) {
 715         case 2:
 716                 config &= ~AMC6821_CONF4_PSPR;
 717                 data->fan1_div = 2;
 718                 break;
 719         case 4:
 720                 config |= AMC6821_CONF4_PSPR;
 721                 data->fan1_div = 4;
 722                 break;
 723         default:
 724                 count = -EINVAL;
 725                 goto EXIT;
 726         }
 727         if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4, config)) {
 728                 dev_err(&client->dev,
 729                         "Configuration register write error, aborting.\n");
 730                 count = -EIO;
 731         }
 732 EXIT:
 733         mutex_unlock(&data->update_lock);
 734         return count;
 735 }
 736
 737 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
 738         get_temp, NULL, IDX_TEMP1_INPUT);
 739 static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, get_temp,
 740         set_temp, IDX_TEMP1_MIN);
 741 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, get_temp,
 742         set_temp, IDX_TEMP1_MAX);
 743 static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, get_temp,
 744         set_temp, IDX_TEMP1_CRIT);
 745 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO,
 746         get_temp_alarm, NULL, IDX_TEMP1_MIN);
 747 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
 748         get_temp_alarm, NULL, IDX_TEMP1_MAX);
 749 static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO,
 750         get_temp_alarm, NULL, IDX_TEMP1_CRIT);
 751 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO,
 752         get_temp, NULL, IDX_TEMP2_INPUT);
 753 static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, get_temp,
 754         set_temp, IDX_TEMP2_MIN);
 755 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, get_temp,
 756         set_temp, IDX_TEMP2_MAX);
 757 static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR, get_temp,
 758         set_temp, IDX_TEMP2_CRIT);
 759 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO,
 760         get_temp2_fault, NULL, 0);
 761 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO,
 762         get_temp_alarm, NULL, IDX_TEMP2_MIN);
 763 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO,
 764         get_temp_alarm, NULL, IDX_TEMP2_MAX);
 765 static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO,
 766         get_temp_alarm, NULL, IDX_TEMP2_CRIT);
 767 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, IDX_FAN1_INPUT);
 768 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
 769         get_fan, set_fan, IDX_FAN1_MIN);
 770 static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO | S_IWUSR,
 771         get_fan, set_fan, IDX_FAN1_MAX);
 772 static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_fan1_fault, NULL, 0);
 773 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 774         get_fan1_div, set_fan1_div, 0);
 775
 776 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm1, set_pwm1, 0);
 777 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
 778         get_pwm1_enable, set_pwm1_enable, 0);
 779 static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IRUGO,
 780         get_pwm1_auto_point_pwm, NULL, 0);
 781 static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
 782         get_pwm1_auto_point_pwm, set_pwm1_auto_point_pwm, 1);
 783 static SENSOR_DEVICE_ATTR(pwm1_auto_point3_pwm, S_IRUGO,
 784         get_pwm1_auto_point_pwm, NULL, 2);
 785 static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IRUGO,
 786         get_pwm1_auto_channels_temp, NULL, 0);
 787 static SENSOR_DEVICE_ATTR_2(temp1_auto_point1_temp, S_IRUGO,
 788         get_temp_auto_point_temp, NULL, 1, 0);
 789 static SENSOR_DEVICE_ATTR_2(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
 790         get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 1);
 791 static SENSOR_DEVICE_ATTR_2(temp1_auto_point3_temp, S_IWUSR | S_IRUGO,
 792         get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 2);
 793
 794 static SENSOR_DEVICE_ATTR_2(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
 795         get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 0);
 796 static SENSOR_DEVICE_ATTR_2(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
 797         get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 1);
 798 static SENSOR_DEVICE_ATTR_2(temp2_auto_point3_temp, S_IWUSR | S_IRUGO,
 799         get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 2);
 800
 801 static struct attribute *amc6821_attrs[] = {
 802         &sensor_dev_attr_temp1_input.dev_attr.attr,
 803         &sensor_dev_attr_temp1_min.dev_attr.attr,
 804         &sensor_dev_attr_temp1_max.dev_attr.attr,
 805         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 806         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 807         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 808         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 809         &sensor_dev_attr_temp2_input.dev_attr.attr,
 810         &sensor_dev_attr_temp2_min.dev_attr.attr,
 811         &sensor_dev_attr_temp2_max.dev_attr.attr,
 812         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 813         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 814         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 815         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 816         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 817         &sensor_dev_attr_fan1_input.dev_attr.attr,
 818         &sensor_dev_attr_fan1_min.dev_attr.attr,
 819         &sensor_dev_attr_fan1_max.dev_attr.attr,
 820         &sensor_dev_attr_fan1_fault.dev_attr.attr,
 821         &sensor_dev_attr_fan1_div.dev_attr.attr,
 822         &sensor_dev_attr_pwm1.dev_attr.attr,
 823         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
 824         &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
 825         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
 826         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
 827         &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
 828         &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
 829         &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
 830         &sensor_dev_attr_temp1_auto_point3_temp.dev_attr.attr,
 831         &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
 832         &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
 833         &sensor_dev_attr_temp2_auto_point3_temp.dev_attr.attr,
 834         NULL
 835 };
 836
 837 ATTRIBUTE_GROUPS(amc6821);
 838
 839 /* Return 0 if detection is successful, -ENODEV otherwise */
 840 static int amc6821_detect(
 841                 struct i2c_client *client,
 842                 struct i2c_board_info *info)
 843 {
 844         struct i2c_adapter *adapter = client->adapter;
 845         int address = client->addr;
 846         int dev_id, comp_id;
 847
 848         dev_dbg(&adapter->dev, "amc6821_detect called.\n");
 849
 850         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 851                 dev_dbg(&adapter->dev,
 852                         "amc6821: I2C bus doesn't support byte mode, "
 853                         "skipping.\n");
 854                 return -ENODEV;
 855         }
 856
 857         dev_id = i2c_smbus_read_byte_data(client, AMC6821_REG_DEV_ID);
 858         comp_id = i2c_smbus_read_byte_data(client, AMC6821_REG_COMP_ID);
 859         if (dev_id != 0x21 || comp_id != 0x49) {
 860                 dev_dbg(&adapter->dev,
 861                         "amc6821: detection failed at 0x%02x.\n",
 862                         address);
 863                 return -ENODEV;
 864         }
 865
 866         /*
 867          * Bit 7 of the address register is ignored, so we can check the
 868          * ID registers again
 869          */
 870         dev_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_DEV_ID);
 871         comp_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_COMP_ID);
 872         if (dev_id != 0x21 || comp_id != 0x49) {
 873                 dev_dbg(&adapter->dev,
 874                         "amc6821: detection failed at 0x%02x.\n",
 875                         address);
 876                 return -ENODEV;
 877         }
 878
 879         dev_info(&adapter->dev, "amc6821: chip found at 0x%02x.\n", address);
 880         strlcpy(info->type, "amc6821", I2C_NAME_SIZE);
 881
 882         return 0;
 883 }
 884
 885 static int amc6821_init_client(struct i2c_client *client)
 886 {
 887         int config;
 888         int err = -EIO;
 889
 890         if (init) {
 891                 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
 892
 893                 if (config < 0) {
 894                                 dev_err(&client->dev,
 895                         "Error reading configuration register, aborting.\n");
 896                                 return err;
 897                 }
 898
 899                 config |= AMC6821_CONF4_MODE;
 900
 901                 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4,
 902                                 config)) {
 903                         dev_err(&client->dev,
 904                         "Configuration register write error, aborting.\n");
 905                         return err;
 906                 }
 907
 908                 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF3);
 909
 910                 if (config < 0) {
 911                         dev_err(&client->dev,
 912                         "Error reading configuration register, aborting.\n");
 913                         return err;
 914                 }
 915
 916                 dev_info(&client->dev, "Revision %d\n", config & 0x0f);
 917
 918                 config &= ~AMC6821_CONF3_THERM_FAN_EN;
 919
 920                 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF3,
 921                                 config)) {
 922                         dev_err(&client->dev,
 923                         "Configuration register write error, aborting.\n");
 924                         return err;
 925                 }
 926
 927                 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF2);
 928
 929                 if (config < 0) {
 930                         dev_err(&client->dev,
 931                         "Error reading configuration register, aborting.\n");
 932                         return err;
 933                 }
 934
 935                 config &= ~AMC6821_CONF2_RTFIE;
 936                 config &= ~AMC6821_CONF2_LTOIE;
 937                 config &= ~AMC6821_CONF2_RTOIE;
 938                 if (i2c_smbus_write_byte_data(client,
 939                                 AMC6821_REG_CONF2, config)) {
 940                         dev_err(&client->dev,
 941                         "Configuration register write error, aborting.\n");
 942                         return err;
 943                 }
 944
 945                 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
 946
 947                 if (config < 0) {
 948                         dev_err(&client->dev,
 949                         "Error reading configuration register, aborting.\n");
 950                         return err;
 951                 }
 952
 953                 config &= ~AMC6821_CONF1_THERMOVIE;
 954                 config &= ~AMC6821_CONF1_FANIE;
 955                 config |= AMC6821_CONF1_START;
 956                 if (pwminv)
 957                         config |= AMC6821_CONF1_PWMINV;
 958                 else
 959                         config &= ~AMC6821_CONF1_PWMINV;
 960
 961                 if (i2c_smbus_write_byte_data(
 962                                 client, AMC6821_REG_CONF1, config)) {
 963                         dev_err(&client->dev,
 964                         "Configuration register write error, aborting.\n");
 965                         return err;
 966                 }
 967         }
 968         return 0;
 969 }
 970
 971 static int amc6821_probe(struct i2c_client *client,
 972                          const struct i2c_device_id *id)
 973 {
 974         struct device *dev = &client->dev;
 975         struct amc6821_data *data;
 976         struct device *hwmon_dev;
 977         int err;
 978
 979         data = devm_kzalloc(dev, sizeof(struct amc6821_data), GFP_KERNEL);
 980         if (!data)
 981                 return -ENOMEM;
 982
 983         data->client = client;
 984         mutex_init(&data->update_lock);
 985
 986         /*
 987          * Initialize the amc6821 chip
 988          */
 989         err = amc6821_init_client(client);
 990         if (err)
 991                 return err;
 992
 993         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
 994                                                            data,
 995                                                            amc6821_groups);
 996         return PTR_ERR_OR_ZERO(hwmon_dev);
 997 }
 998
 999 static const struct i2c_device_id amc6821_id[] = {
1000         { "amc6821", amc6821 },
1001         { }
1002 };
1003
1004 MODULE_DEVICE_TABLE(i2c, amc6821_id);
1005
1006 static struct i2c_driver amc6821_driver = {
1007         .class = I2C_CLASS_HWMON,
1008         .driver = {
1009                 .name   = "amc6821",
1010         },
1011         .probe = amc6821_probe,
1012         .id_table = amc6821_id,
1013         .detect = amc6821_detect,
1014         .address_list = normal_i2c,
1015 };
1016
1017 module_i2c_driver(amc6821_driver);
1018
1019 MODULE_LICENSE("GPL");
1020 MODULE_AUTHOR("T. Mertelj <tomaz.mertelj@guest.arnes.si>");
1021 MODULE_DESCRIPTION("Texas Instruments amc6821 hwmon driver");