drivers/hwmon/amc6821.c

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