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, 0444);
  48
  49 static int init = 1; /*Power-on initialization.*/
  50 module_param(init, int, 0444);
  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 temp_show(struct device *dev, struct device_attribute *devattr,
 281                          char *buf)
 282 {
 283         struct amc6821_data *data = amc6821_update_device(dev);
 284         int ix = to_sensor_dev_attr(devattr)->index;
 285
 286         return sprintf(buf, "%d\n", data->temp[ix] * 1000);
 287 }
 288
 289 static ssize_t temp_store(struct device *dev, struct device_attribute *attr,
 290                           const char *buf, size_t count)
 291 {
 292         struct amc6821_data *data = dev_get_drvdata(dev);
 293         struct i2c_client *client = data->client;
 294         int ix = to_sensor_dev_attr(attr)->index;
 295         long val;
 296
 297         int ret = kstrtol(buf, 10, &val);
 298         if (ret)
 299                 return ret;
 300         val = clamp_val(val / 1000, -128, 127);
 301
 302         mutex_lock(&data->update_lock);
 303         data->temp[ix] = val;
 304         if (i2c_smbus_write_byte_data(client, temp_reg[ix], data->temp[ix])) {
 305                 dev_err(&client->dev, "Register write error, aborting.\n");
 306                 count = -EIO;
 307         }
 308         mutex_unlock(&data->update_lock);
 309         return count;
 310 }
 311
 312 static ssize_t temp_alarm_show(struct device *dev,
 313                                struct device_attribute *devattr, char *buf)
 314 {
 315         struct amc6821_data *data = amc6821_update_device(dev);
 316         int ix = to_sensor_dev_attr(devattr)->index;
 317         u8 flag;
 318
 319         switch (ix) {
 320         case IDX_TEMP1_MIN:
 321                 flag = data->stat1 & AMC6821_STAT1_LTL;
 322                 break;
 323         case IDX_TEMP1_MAX:
 324                 flag = data->stat1 & AMC6821_STAT1_LTH;
 325                 break;
 326         case IDX_TEMP1_CRIT:
 327                 flag = data->stat2 & AMC6821_STAT2_LTC;
 328                 break;
 329         case IDX_TEMP2_MIN:
 330                 flag = data->stat1 & AMC6821_STAT1_RTL;
 331                 break;
 332         case IDX_TEMP2_MAX:
 333                 flag = data->stat1 & AMC6821_STAT1_RTH;
 334                 break;
 335         case IDX_TEMP2_CRIT:
 336                 flag = data->stat2 & AMC6821_STAT2_RTC;
 337                 break;
 338         default:
 339                 dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
 340                 return -EINVAL;
 341         }
 342         if (flag)
 343                 return sprintf(buf, "1");
 344         else
 345                 return sprintf(buf, "0");
 346 }
 347
 348 static ssize_t temp2_fault_show(struct device *dev,
 349                                 struct device_attribute *devattr, char *buf)
 350 {
 351         struct amc6821_data *data = amc6821_update_device(dev);
 352         if (data->stat1 & AMC6821_STAT1_RTF)
 353                 return sprintf(buf, "1");
 354         else
 355                 return sprintf(buf, "0");
 356 }
 357
 358 static ssize_t pwm1_show(struct device *dev, struct device_attribute *devattr,
 359                          char *buf)
 360 {
 361         struct amc6821_data *data = amc6821_update_device(dev);
 362         return sprintf(buf, "%d\n", data->pwm1);
 363 }
 364
 365 static ssize_t pwm1_store(struct device *dev,
 366                           struct device_attribute *devattr, const char *buf,
 367                           size_t count)
 368 {
 369         struct amc6821_data *data = dev_get_drvdata(dev);
 370         struct i2c_client *client = data->client;
 371         long val;
 372         int ret = kstrtol(buf, 10, &val);
 373         if (ret)
 374                 return ret;
 375
 376         mutex_lock(&data->update_lock);
 377         data->pwm1 = clamp_val(val , 0, 255);
 378         i2c_smbus_write_byte_data(client, AMC6821_REG_DCY, data->pwm1);
 379         mutex_unlock(&data->update_lock);
 380         return count;
 381 }
 382
 383 static ssize_t pwm1_enable_show(struct device *dev,
 384                                 struct device_attribute *devattr, char *buf)
 385 {
 386         struct amc6821_data *data = amc6821_update_device(dev);
 387         return sprintf(buf, "%d\n", data->pwm1_enable);
 388 }
 389
 390 static ssize_t pwm1_enable_store(struct device *dev,
 391                                  struct device_attribute *attr,
 392                                  const char *buf, size_t count)
 393 {
 394         struct amc6821_data *data = dev_get_drvdata(dev);
 395         struct i2c_client *client = data->client;
 396         long val;
 397         int config = kstrtol(buf, 10, &val);
 398         if (config)
 399                 return config;
 400
 401         mutex_lock(&data->update_lock);
 402         config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
 403         if (config < 0) {
 404                         dev_err(&client->dev,
 405                         "Error reading configuration register, aborting.\n");
 406                         count = config;
 407                         goto unlock;
 408         }
 409
 410         switch (val) {
 411         case 1:
 412                 config &= ~AMC6821_CONF1_FDRC0;
 413                 config &= ~AMC6821_CONF1_FDRC1;
 414                 break;
 415         case 2:
 416                 config &= ~AMC6821_CONF1_FDRC0;
 417                 config |= AMC6821_CONF1_FDRC1;
 418                 break;
 419         case 3:
 420                 config |= AMC6821_CONF1_FDRC0;
 421                 config |= AMC6821_CONF1_FDRC1;
 422                 break;
 423         default:
 424                 count = -EINVAL;
 425                 goto unlock;
 426         }
 427         if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF1, config)) {
 428                         dev_err(&client->dev,
 429                         "Configuration register write error, aborting.\n");
 430                         count = -EIO;
 431         }
 432 unlock:
 433         mutex_unlock(&data->update_lock);
 434         return count;
 435 }
 436
 437 static ssize_t pwm1_auto_channels_temp_show(struct device *dev,
 438                                             struct device_attribute *devattr,
 439                                             char *buf)
 440 {
 441         struct amc6821_data *data = amc6821_update_device(dev);
 442         return sprintf(buf, "%d\n", data->pwm1_auto_channels_temp);
 443 }
 444
 445 static ssize_t temp_auto_point_temp_show(struct device *dev,
 446                                          struct device_attribute *devattr,
 447                                          char *buf)
 448 {
 449         int ix = to_sensor_dev_attr_2(devattr)->index;
 450         int nr = to_sensor_dev_attr_2(devattr)->nr;
 451         struct amc6821_data *data = amc6821_update_device(dev);
 452         switch (nr) {
 453         case 1:
 454                 return sprintf(buf, "%d\n",
 455                         data->temp1_auto_point_temp[ix] * 1000);
 456         case 2:
 457                 return sprintf(buf, "%d\n",
 458                         data->temp2_auto_point_temp[ix] * 1000);
 459         default:
 460                 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
 461                 return -EINVAL;
 462         }
 463 }
 464
 465 static ssize_t pwm1_auto_point_pwm_show(struct device *dev,
 466                                         struct device_attribute *devattr,
 467                                         char *buf)
 468 {
 469         int ix = to_sensor_dev_attr(devattr)->index;
 470         struct amc6821_data *data = amc6821_update_device(dev);
 471         return sprintf(buf, "%d\n", data->pwm1_auto_point_pwm[ix]);
 472 }
 473
 474 static inline ssize_t set_slope_register(struct i2c_client *client,
 475                 u8 reg,
 476                 u8 dpwm,
 477                 u8 *ptemp)
 478 {
 479         int dt;
 480         u8 tmp;
 481
 482         dt = ptemp[2]-ptemp[1];
 483         for (tmp = 4; tmp > 0; tmp--) {
 484                 if (dt * (0x20 >> tmp) >= dpwm)
 485                         break;
 486         }
 487         tmp |= (ptemp[1] & 0x7C) << 1;
 488         if (i2c_smbus_write_byte_data(client,
 489                         reg, tmp)) {
 490                 dev_err(&client->dev, "Register write error, aborting.\n");
 491                 return -EIO;
 492         }
 493         return 0;
 494 }
 495
 496 static ssize_t temp_auto_point_temp_store(struct device *dev,
 497                                           struct device_attribute *attr,
 498                                           const char *buf, size_t count)
 499 {
 500         struct amc6821_data *data = amc6821_update_device(dev);
 501         struct i2c_client *client = data->client;
 502         int ix = to_sensor_dev_attr_2(attr)->index;
 503         int nr = to_sensor_dev_attr_2(attr)->nr;
 504         u8 *ptemp;
 505         u8 reg;
 506         int dpwm;
 507         long val;
 508         int ret = kstrtol(buf, 10, &val);
 509         if (ret)
 510                 return ret;
 511
 512         switch (nr) {
 513         case 1:
 514                 ptemp = data->temp1_auto_point_temp;
 515                 reg = AMC6821_REG_LTEMP_FAN_CTRL;
 516                 break;
 517         case 2:
 518                 ptemp = data->temp2_auto_point_temp;
 519                 reg = AMC6821_REG_RTEMP_FAN_CTRL;
 520                 break;
 521         default:
 522                 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
 523                 return -EINVAL;
 524         }
 525
 526         mutex_lock(&data->update_lock);
 527         data->valid = 0;
 528
 529         switch (ix) {
 530         case 0:
 531                 ptemp[0] = clamp_val(val / 1000, 0,
 532                                      data->temp1_auto_point_temp[1]);
 533                 ptemp[0] = clamp_val(ptemp[0], 0,
 534                                      data->temp2_auto_point_temp[1]);
 535                 ptemp[0] = clamp_val(ptemp[0], 0, 63);
 536                 if (i2c_smbus_write_byte_data(
 537                                         client,
 538                                         AMC6821_REG_PSV_TEMP,
 539                                         ptemp[0])) {
 540                                 dev_err(&client->dev,
 541                                         "Register write error, aborting.\n");
 542                                 count = -EIO;
 543                 }
 544                 goto EXIT;
 545         case 1:
 546                 ptemp[1] = clamp_val(val / 1000, (ptemp[0] & 0x7C) + 4, 124);
 547                 ptemp[1] &= 0x7C;
 548                 ptemp[2] = clamp_val(ptemp[2], ptemp[1] + 1, 255);
 549                 break;
 550         case 2:
 551                 ptemp[2] = clamp_val(val / 1000, ptemp[1]+1, 255);
 552                 break;
 553         default:
 554                 dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
 555                 count = -EINVAL;
 556                 goto EXIT;
 557         }
 558         dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
 559         if (set_slope_register(client, reg, dpwm, ptemp))
 560                 count = -EIO;
 561
 562 EXIT:
 563         mutex_unlock(&data->update_lock);
 564         return count;
 565 }
 566
 567 static ssize_t pwm1_auto_point_pwm_store(struct device *dev,
 568                                          struct device_attribute *attr,
 569                                          const char *buf, size_t count)
 570 {
 571         struct amc6821_data *data = dev_get_drvdata(dev);
 572         struct i2c_client *client = data->client;
 573         int dpwm;
 574         long val;
 575         int ret = kstrtol(buf, 10, &val);
 576         if (ret)
 577                 return ret;
 578
 579         mutex_lock(&data->update_lock);
 580         data->pwm1_auto_point_pwm[1] = clamp_val(val, 0, 254);
 581         if (i2c_smbus_write_byte_data(client, AMC6821_REG_DCY_LOW_TEMP,
 582                         data->pwm1_auto_point_pwm[1])) {
 583                 dev_err(&client->dev, "Register write error, aborting.\n");
 584                 count = -EIO;
 585                 goto EXIT;
 586         }
 587         dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
 588         if (set_slope_register(client, AMC6821_REG_LTEMP_FAN_CTRL, dpwm,
 589                         data->temp1_auto_point_temp)) {
 590                 count = -EIO;
 591                 goto EXIT;
 592         }
 593         if (set_slope_register(client, AMC6821_REG_RTEMP_FAN_CTRL, dpwm,
 594                         data->temp2_auto_point_temp)) {
 595                 count = -EIO;
 596                 goto EXIT;
 597         }
 598
 599 EXIT:
 600         data->valid = 0;
 601         mutex_unlock(&data->update_lock);
 602         return count;
 603 }
 604
 605 static ssize_t fan_show(struct device *dev, struct device_attribute *devattr,
 606                         char *buf)
 607 {
 608         struct amc6821_data *data = amc6821_update_device(dev);
 609         int ix = to_sensor_dev_attr(devattr)->index;
 610         if (0 == data->fan[ix])
 611                 return sprintf(buf, "0");
 612         return sprintf(buf, "%d\n", (int)(6000000 / data->fan[ix]));
 613 }
 614
 615 static ssize_t fan1_fault_show(struct device *dev,
 616                                struct device_attribute *devattr, char *buf)
 617 {
 618         struct amc6821_data *data = amc6821_update_device(dev);
 619         if (data->stat1 & AMC6821_STAT1_FANS)
 620                 return sprintf(buf, "1");
 621         else
 622                 return sprintf(buf, "0");
 623 }
 624
 625 static ssize_t fan_store(struct device *dev, struct device_attribute *attr,
 626                          const char *buf, size_t count)
 627 {
 628         struct amc6821_data *data = dev_get_drvdata(dev);
 629         struct i2c_client *client = data->client;
 630         long val;
 631         int ix = to_sensor_dev_attr(attr)->index;
 632         int ret = kstrtol(buf, 10, &val);
 633         if (ret)
 634                 return ret;
 635         val = 1 > val ? 0xFFFF : 6000000/val;
 636
 637         mutex_lock(&data->update_lock);
 638         data->fan[ix] = (u16) clamp_val(val, 1, 0xFFFF);
 639         if (i2c_smbus_write_byte_data(client, fan_reg_low[ix],
 640                         data->fan[ix] & 0xFF)) {
 641                 dev_err(&client->dev, "Register write error, aborting.\n");
 642                 count = -EIO;
 643                 goto EXIT;
 644         }
 645         if (i2c_smbus_write_byte_data(client,
 646                         fan_reg_hi[ix], data->fan[ix] >> 8)) {
 647                 dev_err(&client->dev, "Register write error, aborting.\n");
 648                 count = -EIO;
 649         }
 650 EXIT:
 651         mutex_unlock(&data->update_lock);
 652         return count;
 653 }
 654
 655 static ssize_t fan1_div_show(struct device *dev,
 656                              struct device_attribute *devattr, char *buf)
 657 {
 658         struct amc6821_data *data = amc6821_update_device(dev);
 659         return sprintf(buf, "%d\n", data->fan1_div);
 660 }
 661
 662 static ssize_t fan1_div_store(struct device *dev,
 663                               struct device_attribute *attr, const char *buf,
 664                               size_t count)
 665 {
 666         struct amc6821_data *data = dev_get_drvdata(dev);
 667         struct i2c_client *client = data->client;
 668         long val;
 669         int config = kstrtol(buf, 10, &val);
 670         if (config)
 671                 return config;
 672
 673         mutex_lock(&data->update_lock);
 674         config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
 675         if (config < 0) {
 676                 dev_err(&client->dev,
 677                         "Error reading configuration register, aborting.\n");
 678                 count = config;
 679                 goto EXIT;
 680         }
 681         switch (val) {
 682         case 2:
 683                 config &= ~AMC6821_CONF4_PSPR;
 684                 data->fan1_div = 2;
 685                 break;
 686         case 4:
 687                 config |= AMC6821_CONF4_PSPR;
 688                 data->fan1_div = 4;
 689                 break;
 690         default:
 691                 count = -EINVAL;
 692                 goto EXIT;
 693         }
 694         if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4, config)) {
 695                 dev_err(&client->dev,
 696                         "Configuration register write error, aborting.\n");
 697                 count = -EIO;
 698         }
 699 EXIT:
 700         mutex_unlock(&data->update_lock);
 701         return count;
 702 }
 703
 704 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, IDX_TEMP1_INPUT);
 705 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp, IDX_TEMP1_MIN);
 706 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp, IDX_TEMP1_MAX);
 707 static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp, IDX_TEMP1_CRIT);
 708 static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, temp_alarm, IDX_TEMP1_MIN);
 709 static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, temp_alarm, IDX_TEMP1_MAX);
 710 static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, temp_alarm, IDX_TEMP1_CRIT);
 711 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, IDX_TEMP2_INPUT);
 712 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp, IDX_TEMP2_MIN);
 713 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp, IDX_TEMP2_MAX);
 714 static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp, IDX_TEMP2_CRIT);
 715 static SENSOR_DEVICE_ATTR_RO(temp2_fault, temp2_fault, 0);
 716 static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, temp_alarm, IDX_TEMP2_MIN);
 717 static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, temp_alarm, IDX_TEMP2_MAX);
 718 static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, temp_alarm, IDX_TEMP2_CRIT);
 719 static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, IDX_FAN1_INPUT);
 720 static SENSOR_DEVICE_ATTR_RW(fan1_min, fan, IDX_FAN1_MIN);
 721 static SENSOR_DEVICE_ATTR_RW(fan1_max, fan, IDX_FAN1_MAX);
 722 static SENSOR_DEVICE_ATTR_RO(fan1_fault, fan1_fault, 0);
 723 static SENSOR_DEVICE_ATTR_RW(fan1_div, fan1_div, 0);
 724
 725 static SENSOR_DEVICE_ATTR_RW(pwm1, pwm1, 0);
 726 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, pwm1_enable, 0);
 727 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point1_pwm, pwm1_auto_point_pwm, 0);
 728 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_pwm, pwm1_auto_point_pwm, 1);
 729 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point3_pwm, pwm1_auto_point_pwm, 2);
 730 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_channels_temp, pwm1_auto_channels_temp,
 731                              0);
 732 static SENSOR_DEVICE_ATTR_2_RO(temp1_auto_point1_temp, temp_auto_point_temp,
 733                                1, 0);
 734 static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point2_temp, temp_auto_point_temp,
 735                                1, 1);
 736 static SENSOR_DEVICE_ATTR_2_RW(temp1_auto_point3_temp, temp_auto_point_temp,
 737                                1, 2);
 738
 739 static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point1_temp, temp_auto_point_temp,
 740                                2, 0);
 741 static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point2_temp, temp_auto_point_temp,
 742                                2, 1);
 743 static SENSOR_DEVICE_ATTR_2_RW(temp2_auto_point3_temp, temp_auto_point_temp,
 744                                2, 2);
 745
 746 static struct attribute *amc6821_attrs[] = {
 747         &sensor_dev_attr_temp1_input.dev_attr.attr,
 748         &sensor_dev_attr_temp1_min.dev_attr.attr,
 749         &sensor_dev_attr_temp1_max.dev_attr.attr,
 750         &sensor_dev_attr_temp1_crit.dev_attr.attr,
 751         &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
 752         &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
 753         &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
 754         &sensor_dev_attr_temp2_input.dev_attr.attr,
 755         &sensor_dev_attr_temp2_min.dev_attr.attr,
 756         &sensor_dev_attr_temp2_max.dev_attr.attr,
 757         &sensor_dev_attr_temp2_crit.dev_attr.attr,
 758         &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
 759         &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
 760         &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
 761         &sensor_dev_attr_temp2_fault.dev_attr.attr,
 762         &sensor_dev_attr_fan1_input.dev_attr.attr,
 763         &sensor_dev_attr_fan1_min.dev_attr.attr,
 764         &sensor_dev_attr_fan1_max.dev_attr.attr,
 765         &sensor_dev_attr_fan1_fault.dev_attr.attr,
 766         &sensor_dev_attr_fan1_div.dev_attr.attr,
 767         &sensor_dev_attr_pwm1.dev_attr.attr,
 768         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
 769         &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
 770         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
 771         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
 772         &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
 773         &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
 774         &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
 775         &sensor_dev_attr_temp1_auto_point3_temp.dev_attr.attr,
 776         &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
 777         &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
 778         &sensor_dev_attr_temp2_auto_point3_temp.dev_attr.attr,
 779         NULL
 780 };
 781
 782 ATTRIBUTE_GROUPS(amc6821);
 783
 784 /* Return 0 if detection is successful, -ENODEV otherwise */
 785 static int amc6821_detect(
 786                 struct i2c_client *client,
 787                 struct i2c_board_info *info)
 788 {
 789         struct i2c_adapter *adapter = client->adapter;
 790         int address = client->addr;
 791         int dev_id, comp_id;
 792
 793         dev_dbg(&adapter->dev, "amc6821_detect called.\n");
 794
 795         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 796                 dev_dbg(&adapter->dev,
 797                         "amc6821: I2C bus doesn't support byte mode, "
 798                         "skipping.\n");
 799                 return -ENODEV;
 800         }
 801
 802         dev_id = i2c_smbus_read_byte_data(client, AMC6821_REG_DEV_ID);
 803         comp_id = i2c_smbus_read_byte_data(client, AMC6821_REG_COMP_ID);
 804         if (dev_id != 0x21 || comp_id != 0x49) {
 805                 dev_dbg(&adapter->dev,
 806                         "amc6821: detection failed at 0x%02x.\n",
 807                         address);
 808                 return -ENODEV;
 809         }
 810
 811         /*
 812          * Bit 7 of the address register is ignored, so we can check the
 813          * ID registers again
 814          */
 815         dev_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_DEV_ID);
 816         comp_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_COMP_ID);
 817         if (dev_id != 0x21 || comp_id != 0x49) {
 818                 dev_dbg(&adapter->dev,
 819                         "amc6821: detection failed at 0x%02x.\n",
 820                         address);
 821                 return -ENODEV;
 822         }
 823
 824         dev_info(&adapter->dev, "amc6821: chip found at 0x%02x.\n", address);
 825         strlcpy(info->type, "amc6821", I2C_NAME_SIZE);
 826
 827         return 0;
 828 }
 829
 830 static int amc6821_init_client(struct i2c_client *client)
 831 {
 832         int config;
 833         int err = -EIO;
 834
 835         if (init) {
 836                 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
 837
 838                 if (config < 0) {
 839                                 dev_err(&client->dev,
 840                         "Error reading configuration register, aborting.\n");
 841                                 return err;
 842                 }
 843
 844                 config |= AMC6821_CONF4_MODE;
 845
 846                 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4,
 847                                 config)) {
 848                         dev_err(&client->dev,
 849                         "Configuration register write error, aborting.\n");
 850                         return err;
 851                 }
 852
 853                 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF3);
 854
 855                 if (config < 0) {
 856                         dev_err(&client->dev,
 857                         "Error reading configuration register, aborting.\n");
 858                         return err;
 859                 }
 860
 861                 dev_info(&client->dev, "Revision %d\n", config & 0x0f);
 862
 863                 config &= ~AMC6821_CONF3_THERM_FAN_EN;
 864
 865                 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF3,
 866                                 config)) {
 867                         dev_err(&client->dev,
 868                         "Configuration register write error, aborting.\n");
 869                         return err;
 870                 }
 871
 872                 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF2);
 873
 874                 if (config < 0) {
 875                         dev_err(&client->dev,
 876                         "Error reading configuration register, aborting.\n");
 877                         return err;
 878                 }
 879
 880                 config &= ~AMC6821_CONF2_RTFIE;
 881                 config &= ~AMC6821_CONF2_LTOIE;
 882                 config &= ~AMC6821_CONF2_RTOIE;
 883                 if (i2c_smbus_write_byte_data(client,
 884                                 AMC6821_REG_CONF2, config)) {
 885                         dev_err(&client->dev,
 886                         "Configuration register write error, aborting.\n");
 887                         return err;
 888                 }
 889
 890                 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
 891
 892                 if (config < 0) {
 893                         dev_err(&client->dev,
 894                         "Error reading configuration register, aborting.\n");
 895                         return err;
 896                 }
 897
 898                 config &= ~AMC6821_CONF1_THERMOVIE;
 899                 config &= ~AMC6821_CONF1_FANIE;
 900                 config |= AMC6821_CONF1_START;
 901                 if (pwminv)
 902                         config |= AMC6821_CONF1_PWMINV;
 903                 else
 904                         config &= ~AMC6821_CONF1_PWMINV;
 905
 906                 if (i2c_smbus_write_byte_data(
 907                                 client, AMC6821_REG_CONF1, config)) {
 908                         dev_err(&client->dev,
 909                         "Configuration register write error, aborting.\n");
 910                         return err;
 911                 }
 912         }
 913         return 0;
 914 }
 915
 916 static int amc6821_probe(struct i2c_client *client,
 917                          const struct i2c_device_id *id)
 918 {
 919         struct device *dev = &client->dev;
 920         struct amc6821_data *data;
 921         struct device *hwmon_dev;
 922         int err;
 923
 924         data = devm_kzalloc(dev, sizeof(struct amc6821_data), GFP_KERNEL);
 925         if (!data)
 926                 return -ENOMEM;
 927
 928         data->client = client;
 929         mutex_init(&data->update_lock);
 930
 931         /*
 932          * Initialize the amc6821 chip
 933          */
 934         err = amc6821_init_client(client);
 935         if (err)
 936                 return err;
 937
 938         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
 939                                                            data,
 940                                                            amc6821_groups);
 941         return PTR_ERR_OR_ZERO(hwmon_dev);
 942 }
 943
 944 static const struct i2c_device_id amc6821_id[] = {
 945         { "amc6821", amc6821 },
 946         { }
 947 };
 948
 949 MODULE_DEVICE_TABLE(i2c, amc6821_id);
 950
 951 static struct i2c_driver amc6821_driver = {
 952         .class = I2C_CLASS_HWMON,
 953         .driver = {
 954                 .name   = "amc6821",
 955         },
 956         .probe = amc6821_probe,
 957         .id_table = amc6821_id,
 958         .detect = amc6821_detect,
 959         .address_list = normal_i2c,
 960 };
 961
 962 module_i2c_driver(amc6821_driver);
 963
 964 MODULE_LICENSE("GPL");
 965 MODULE_AUTHOR("T. Mertelj <tomaz.mertelj@guest.arnes.si>");
 966 MODULE_DESCRIPTION("Texas Instruments amc6821 hwmon driver");