linux/drivers/hwmon/amc6821.c
<<
>>
Prefs
   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
  39static 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
  46static int pwminv;      /*Inverted PWM output. */
  47module_param(pwminv, int, S_IRUGO);
  48
  49static int init = 1; /*Power-on initialization.*/
  50module_param(init, int, S_IRUGO);
  51
  52enum 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
 124enum {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
 129static 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
 138enum {IDX_FAN1_INPUT = 0, IDX_FAN1_MIN, IDX_FAN1_MAX,
 139        FAN1_IDX_LEN, };
 140
 141static const u8 fan_reg_low[] = {AMC6821_REG_TDATA_LOW,
 142                        AMC6821_REG_TACH_LLIMITL,
 143                        AMC6821_REG_TACH_HLIMITL, };
 144
 145
 146static 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
 154struct 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
 177static 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
 280static 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
 291static 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
 317static 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
 355static 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
 367static 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
 376static 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
 396static 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
 405static 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        }
 449unlock:
 450        mutex_unlock(&data->update_lock);
 451        return count;
 452}
 453
 454static 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
 463static 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
 484static 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
 494static 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
 516static 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
 584EXIT:
 585        mutex_unlock(&data->update_lock);
 586        return count;
 587}
 588
 589static 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
 623EXIT:
 624        data->valid = 0;
 625        mutex_unlock(&data->update_lock);
 626        return count;
 627}
 628
 629static 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
 641static 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
 653static 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        }
 680EXIT:
 681        mutex_unlock(&data->update_lock);
 682        return count;
 683}
 684
 685static 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
 694static 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        }
 732EXIT:
 733        mutex_unlock(&data->update_lock);
 734        return count;
 735}
 736
 737static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
 738        get_temp, NULL, IDX_TEMP1_INPUT);
 739static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, get_temp,
 740        set_temp, IDX_TEMP1_MIN);
 741static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, get_temp,
 742        set_temp, IDX_TEMP1_MAX);
 743static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, get_temp,
 744        set_temp, IDX_TEMP1_CRIT);
 745static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO,
 746        get_temp_alarm, NULL, IDX_TEMP1_MIN);
 747static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
 748        get_temp_alarm, NULL, IDX_TEMP1_MAX);
 749static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO,
 750        get_temp_alarm, NULL, IDX_TEMP1_CRIT);
 751static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO,
 752        get_temp, NULL, IDX_TEMP2_INPUT);
 753static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, get_temp,
 754        set_temp, IDX_TEMP2_MIN);
 755static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, get_temp,
 756        set_temp, IDX_TEMP2_MAX);
 757static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR, get_temp,
 758        set_temp, IDX_TEMP2_CRIT);
 759static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO,
 760        get_temp2_fault, NULL, 0);
 761static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO,
 762        get_temp_alarm, NULL, IDX_TEMP2_MIN);
 763static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO,
 764        get_temp_alarm, NULL, IDX_TEMP2_MAX);
 765static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO,
 766        get_temp_alarm, NULL, IDX_TEMP2_CRIT);
 767static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, IDX_FAN1_INPUT);
 768static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
 769        get_fan, set_fan, IDX_FAN1_MIN);
 770static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO | S_IWUSR,
 771        get_fan, set_fan, IDX_FAN1_MAX);
 772static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_fan1_fault, NULL, 0);
 773static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 774        get_fan1_div, set_fan1_div, 0);
 775
 776static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm1, set_pwm1, 0);
 777static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
 778        get_pwm1_enable, set_pwm1_enable, 0);
 779static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IRUGO,
 780        get_pwm1_auto_point_pwm, NULL, 0);
 781static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
 782        get_pwm1_auto_point_pwm, set_pwm1_auto_point_pwm, 1);
 783static SENSOR_DEVICE_ATTR(pwm1_auto_point3_pwm, S_IRUGO,
 784        get_pwm1_auto_point_pwm, NULL, 2);
 785static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IRUGO,
 786        get_pwm1_auto_channels_temp, NULL, 0);
 787static SENSOR_DEVICE_ATTR_2(temp1_auto_point1_temp, S_IRUGO,
 788        get_temp_auto_point_temp, NULL, 1, 0);
 789static 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);
 791static 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
 794static 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);
 796static 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);
 798static 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
 801static 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
 837ATTRIBUTE_GROUPS(amc6821);
 838
 839/* Return 0 if detection is successful, -ENODEV otherwise */
 840static 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
 885static 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
 971static 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
 999static const struct i2c_device_id amc6821_id[] = {
1000        { "amc6821", amc6821 },
1001        { }
1002};
1003
1004MODULE_DEVICE_TABLE(i2c, amc6821_id);
1005
1006static 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
1017module_i2c_driver(amc6821_driver);
1018
1019MODULE_LICENSE("GPL");
1020MODULE_AUTHOR("T. Mertelj <tomaz.mertelj@guest.arnes.si>");
1021MODULE_DESCRIPTION("Texas Instruments amc6821 hwmon driver");
1022