linux/drivers/hwmon/lm78.c
<<
>>
Prefs
   1/*
   2 * lm78.c - Part of lm_sensors, Linux kernel modules for hardware
   3 *          monitoring
   4 * Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>
   5 * Copyright (c) 2007, 2011  Jean Delvare <khali@linux-fr.org>
   6 *
   7 * This program is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 2 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24#include <linux/module.h>
  25#include <linux/init.h>
  26#include <linux/slab.h>
  27#include <linux/jiffies.h>
  28#include <linux/i2c.h>
  29#include <linux/hwmon.h>
  30#include <linux/hwmon-vid.h>
  31#include <linux/hwmon-sysfs.h>
  32#include <linux/err.h>
  33#include <linux/mutex.h>
  34
  35#ifdef CONFIG_ISA
  36#include <linux/platform_device.h>
  37#include <linux/ioport.h>
  38#include <linux/io.h>
  39#endif
  40
  41/* Addresses to scan */
  42static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
  43                                                0x2e, 0x2f, I2C_CLIENT_END };
  44enum chips { lm78, lm79 };
  45
  46/* Many LM78 constants specified below */
  47
  48/* Length of ISA address segment */
  49#define LM78_EXTENT 8
  50
  51/* Where are the ISA address/data registers relative to the base address */
  52#define LM78_ADDR_REG_OFFSET 5
  53#define LM78_DATA_REG_OFFSET 6
  54
  55/* The LM78 registers */
  56#define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
  57#define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
  58#define LM78_REG_IN(nr) (0x20 + (nr))
  59
  60#define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
  61#define LM78_REG_FAN(nr) (0x28 + (nr))
  62
  63#define LM78_REG_TEMP 0x27
  64#define LM78_REG_TEMP_OVER 0x39
  65#define LM78_REG_TEMP_HYST 0x3a
  66
  67#define LM78_REG_ALARM1 0x41
  68#define LM78_REG_ALARM2 0x42
  69
  70#define LM78_REG_VID_FANDIV 0x47
  71
  72#define LM78_REG_CONFIG 0x40
  73#define LM78_REG_CHIPID 0x49
  74#define LM78_REG_I2C_ADDR 0x48
  75
  76
  77/*
  78 * Conversions. Rounding and limit checking is only done on the TO_REG
  79 * variants.
  80 */
  81
  82/*
  83 * IN: mV (0V to 4.08V)
  84 * REG: 16mV/bit
  85 */
  86static inline u8 IN_TO_REG(unsigned long val)
  87{
  88        unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
  89        return (nval + 8) / 16;
  90}
  91#define IN_FROM_REG(val) ((val) *  16)
  92
  93static inline u8 FAN_TO_REG(long rpm, int div)
  94{
  95        if (rpm <= 0)
  96                return 255;
  97        return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
  98}
  99
 100static inline int FAN_FROM_REG(u8 val, int div)
 101{
 102        return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
 103}
 104
 105/*
 106 * TEMP: mC (-128C to +127C)
 107 * REG: 1C/bit, two's complement
 108 */
 109static inline s8 TEMP_TO_REG(int val)
 110{
 111        int nval = SENSORS_LIMIT(val, -128000, 127000) ;
 112        return nval < 0 ? (nval - 500) / 1000 : (nval + 500) / 1000;
 113}
 114
 115static inline int TEMP_FROM_REG(s8 val)
 116{
 117        return val * 1000;
 118}
 119
 120#define DIV_FROM_REG(val) (1 << (val))
 121
 122struct lm78_data {
 123        struct i2c_client *client;
 124        struct device *hwmon_dev;
 125        struct mutex lock;
 126        enum chips type;
 127
 128        /* For ISA device only */
 129        const char *name;
 130        int isa_addr;
 131
 132        struct mutex update_lock;
 133        char valid;             /* !=0 if following fields are valid */
 134        unsigned long last_updated;     /* In jiffies */
 135
 136        u8 in[7];               /* Register value */
 137        u8 in_max[7];           /* Register value */
 138        u8 in_min[7];           /* Register value */
 139        u8 fan[3];              /* Register value */
 140        u8 fan_min[3];          /* Register value */
 141        s8 temp;                /* Register value */
 142        s8 temp_over;           /* Register value */
 143        s8 temp_hyst;           /* Register value */
 144        u8 fan_div[3];          /* Register encoding, shifted right */
 145        u8 vid;                 /* Register encoding, combined */
 146        u16 alarms;             /* Register encoding, combined */
 147};
 148
 149
 150static int lm78_read_value(struct lm78_data *data, u8 reg);
 151static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
 152static struct lm78_data *lm78_update_device(struct device *dev);
 153static void lm78_init_device(struct lm78_data *data);
 154
 155
 156/* 7 Voltages */
 157static ssize_t show_in(struct device *dev, struct device_attribute *da,
 158                       char *buf)
 159{
 160        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 161        struct lm78_data *data = lm78_update_device(dev);
 162        return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
 163}
 164
 165static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
 166                           char *buf)
 167{
 168        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 169        struct lm78_data *data = lm78_update_device(dev);
 170        return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
 171}
 172
 173static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
 174                           char *buf)
 175{
 176        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 177        struct lm78_data *data = lm78_update_device(dev);
 178        return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
 179}
 180
 181static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
 182                          const char *buf, size_t count)
 183{
 184        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 185        struct lm78_data *data = dev_get_drvdata(dev);
 186        int nr = attr->index;
 187        unsigned long val;
 188        int err;
 189
 190        err = kstrtoul(buf, 10, &val);
 191        if (err)
 192                return err;
 193
 194        mutex_lock(&data->update_lock);
 195        data->in_min[nr] = IN_TO_REG(val);
 196        lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
 197        mutex_unlock(&data->update_lock);
 198        return count;
 199}
 200
 201static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
 202                          const char *buf, size_t count)
 203{
 204        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 205        struct lm78_data *data = dev_get_drvdata(dev);
 206        int nr = attr->index;
 207        unsigned long val;
 208        int err;
 209
 210        err = kstrtoul(buf, 10, &val);
 211        if (err)
 212                return err;
 213
 214        mutex_lock(&data->update_lock);
 215        data->in_max[nr] = IN_TO_REG(val);
 216        lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
 217        mutex_unlock(&data->update_lock);
 218        return count;
 219}
 220
 221#define show_in_offset(offset)                                  \
 222static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
 223                show_in, NULL, offset);                         \
 224static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
 225                show_in_min, set_in_min, offset);               \
 226static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
 227                show_in_max, set_in_max, offset);
 228
 229show_in_offset(0);
 230show_in_offset(1);
 231show_in_offset(2);
 232show_in_offset(3);
 233show_in_offset(4);
 234show_in_offset(5);
 235show_in_offset(6);
 236
 237/* Temperature */
 238static ssize_t show_temp(struct device *dev, struct device_attribute *da,
 239                         char *buf)
 240{
 241        struct lm78_data *data = lm78_update_device(dev);
 242        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
 243}
 244
 245static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
 246                              char *buf)
 247{
 248        struct lm78_data *data = lm78_update_device(dev);
 249        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
 250}
 251
 252static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
 253                             const char *buf, size_t count)
 254{
 255        struct lm78_data *data = dev_get_drvdata(dev);
 256        long val;
 257        int err;
 258
 259        err = kstrtol(buf, 10, &val);
 260        if (err)
 261                return err;
 262
 263        mutex_lock(&data->update_lock);
 264        data->temp_over = TEMP_TO_REG(val);
 265        lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
 266        mutex_unlock(&data->update_lock);
 267        return count;
 268}
 269
 270static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
 271                              char *buf)
 272{
 273        struct lm78_data *data = lm78_update_device(dev);
 274        return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
 275}
 276
 277static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
 278                             const char *buf, size_t count)
 279{
 280        struct lm78_data *data = dev_get_drvdata(dev);
 281        long val;
 282        int err;
 283
 284        err = kstrtol(buf, 10, &val);
 285        if (err)
 286                return err;
 287
 288        mutex_lock(&data->update_lock);
 289        data->temp_hyst = TEMP_TO_REG(val);
 290        lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
 291        mutex_unlock(&data->update_lock);
 292        return count;
 293}
 294
 295static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
 296static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
 297                show_temp_over, set_temp_over);
 298static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
 299                show_temp_hyst, set_temp_hyst);
 300
 301/* 3 Fans */
 302static ssize_t show_fan(struct device *dev, struct device_attribute *da,
 303                        char *buf)
 304{
 305        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 306        struct lm78_data *data = lm78_update_device(dev);
 307        int nr = attr->index;
 308        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 309                DIV_FROM_REG(data->fan_div[nr])));
 310}
 311
 312static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
 313                            char *buf)
 314{
 315        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 316        struct lm78_data *data = lm78_update_device(dev);
 317        int nr = attr->index;
 318        return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
 319                DIV_FROM_REG(data->fan_div[nr])));
 320}
 321
 322static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
 323                           const char *buf, size_t count)
 324{
 325        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 326        struct lm78_data *data = dev_get_drvdata(dev);
 327        int nr = attr->index;
 328        unsigned long val;
 329        int err;
 330
 331        err = kstrtoul(buf, 10, &val);
 332        if (err)
 333                return err;
 334
 335        mutex_lock(&data->update_lock);
 336        data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 337        lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 338        mutex_unlock(&data->update_lock);
 339        return count;
 340}
 341
 342static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
 343                            char *buf)
 344{
 345        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 346        struct lm78_data *data = lm78_update_device(dev);
 347        return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
 348}
 349
 350/*
 351 * Note: we save and restore the fan minimum here, because its value is
 352 * determined in part by the fan divisor.  This follows the principle of
 353 * least surprise; the user doesn't expect the fan minimum to change just
 354 * because the divisor changed.
 355 */
 356static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
 357                           const char *buf, size_t count)
 358{
 359        struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 360        struct lm78_data *data = dev_get_drvdata(dev);
 361        int nr = attr->index;
 362        unsigned long min;
 363        u8 reg;
 364        unsigned long val;
 365        int err;
 366
 367        err = kstrtoul(buf, 10, &val);
 368        if (err)
 369                return err;
 370
 371        mutex_lock(&data->update_lock);
 372        min = FAN_FROM_REG(data->fan_min[nr],
 373                           DIV_FROM_REG(data->fan_div[nr]));
 374
 375        switch (val) {
 376        case 1:
 377                data->fan_div[nr] = 0;
 378                break;
 379        case 2:
 380                data->fan_div[nr] = 1;
 381                break;
 382        case 4:
 383                data->fan_div[nr] = 2;
 384                break;
 385        case 8:
 386                data->fan_div[nr] = 3;
 387                break;
 388        default:
 389                dev_err(dev, "fan_div value %ld not "
 390                        "supported. Choose one of 1, 2, 4 or 8!\n", val);
 391                mutex_unlock(&data->update_lock);
 392                return -EINVAL;
 393        }
 394
 395        reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
 396        switch (nr) {
 397        case 0:
 398                reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
 399                break;
 400        case 1:
 401                reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
 402                break;
 403        }
 404        lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
 405
 406        data->fan_min[nr] =
 407                FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 408        lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 409        mutex_unlock(&data->update_lock);
 410
 411        return count;
 412}
 413
 414#define show_fan_offset(offset)                         \
 415static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
 416                show_fan, NULL, offset - 1);                    \
 417static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 418                show_fan_min, set_fan_min, offset - 1);
 419
 420show_fan_offset(1);
 421show_fan_offset(2);
 422show_fan_offset(3);
 423
 424/* Fan 3 divisor is locked in H/W */
 425static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 426                show_fan_div, set_fan_div, 0);
 427static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
 428                show_fan_div, set_fan_div, 1);
 429static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
 430
 431/* VID */
 432static ssize_t show_vid(struct device *dev, struct device_attribute *da,
 433                        char *buf)
 434{
 435        struct lm78_data *data = lm78_update_device(dev);
 436        return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
 437}
 438static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 439
 440/* Alarms */
 441static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
 442                           char *buf)
 443{
 444        struct lm78_data *data = lm78_update_device(dev);
 445        return sprintf(buf, "%u\n", data->alarms);
 446}
 447static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 448
 449static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
 450                          char *buf)
 451{
 452        struct lm78_data *data = lm78_update_device(dev);
 453        int nr = to_sensor_dev_attr(da)->index;
 454        return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
 455}
 456static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 457static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 458static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 459static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 460static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 461static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
 462static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
 463static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
 464static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
 465static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
 466static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 467
 468static struct attribute *lm78_attributes[] = {
 469        &sensor_dev_attr_in0_input.dev_attr.attr,
 470        &sensor_dev_attr_in0_min.dev_attr.attr,
 471        &sensor_dev_attr_in0_max.dev_attr.attr,
 472        &sensor_dev_attr_in0_alarm.dev_attr.attr,
 473        &sensor_dev_attr_in1_input.dev_attr.attr,
 474        &sensor_dev_attr_in1_min.dev_attr.attr,
 475        &sensor_dev_attr_in1_max.dev_attr.attr,
 476        &sensor_dev_attr_in1_alarm.dev_attr.attr,
 477        &sensor_dev_attr_in2_input.dev_attr.attr,
 478        &sensor_dev_attr_in2_min.dev_attr.attr,
 479        &sensor_dev_attr_in2_max.dev_attr.attr,
 480        &sensor_dev_attr_in2_alarm.dev_attr.attr,
 481        &sensor_dev_attr_in3_input.dev_attr.attr,
 482        &sensor_dev_attr_in3_min.dev_attr.attr,
 483        &sensor_dev_attr_in3_max.dev_attr.attr,
 484        &sensor_dev_attr_in3_alarm.dev_attr.attr,
 485        &sensor_dev_attr_in4_input.dev_attr.attr,
 486        &sensor_dev_attr_in4_min.dev_attr.attr,
 487        &sensor_dev_attr_in4_max.dev_attr.attr,
 488        &sensor_dev_attr_in4_alarm.dev_attr.attr,
 489        &sensor_dev_attr_in5_input.dev_attr.attr,
 490        &sensor_dev_attr_in5_min.dev_attr.attr,
 491        &sensor_dev_attr_in5_max.dev_attr.attr,
 492        &sensor_dev_attr_in5_alarm.dev_attr.attr,
 493        &sensor_dev_attr_in6_input.dev_attr.attr,
 494        &sensor_dev_attr_in6_min.dev_attr.attr,
 495        &sensor_dev_attr_in6_max.dev_attr.attr,
 496        &sensor_dev_attr_in6_alarm.dev_attr.attr,
 497        &dev_attr_temp1_input.attr,
 498        &dev_attr_temp1_max.attr,
 499        &dev_attr_temp1_max_hyst.attr,
 500        &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 501        &sensor_dev_attr_fan1_input.dev_attr.attr,
 502        &sensor_dev_attr_fan1_min.dev_attr.attr,
 503        &sensor_dev_attr_fan1_div.dev_attr.attr,
 504        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 505        &sensor_dev_attr_fan2_input.dev_attr.attr,
 506        &sensor_dev_attr_fan2_min.dev_attr.attr,
 507        &sensor_dev_attr_fan2_div.dev_attr.attr,
 508        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 509        &sensor_dev_attr_fan3_input.dev_attr.attr,
 510        &sensor_dev_attr_fan3_min.dev_attr.attr,
 511        &sensor_dev_attr_fan3_div.dev_attr.attr,
 512        &sensor_dev_attr_fan3_alarm.dev_attr.attr,
 513        &dev_attr_alarms.attr,
 514        &dev_attr_cpu0_vid.attr,
 515
 516        NULL
 517};
 518
 519static const struct attribute_group lm78_group = {
 520        .attrs = lm78_attributes,
 521};
 522
 523/*
 524 * ISA related code
 525 */
 526#ifdef CONFIG_ISA
 527
 528/* ISA device, if found */
 529static struct platform_device *pdev;
 530
 531static unsigned short isa_address = 0x290;
 532
 533/*
 534 * I2C devices get this name attribute automatically, but for ISA devices
 535 * we must create it by ourselves.
 536 */
 537static ssize_t show_name(struct device *dev, struct device_attribute
 538                         *devattr, char *buf)
 539{
 540        struct lm78_data *data = dev_get_drvdata(dev);
 541
 542        return sprintf(buf, "%s\n", data->name);
 543}
 544static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 545
 546static struct lm78_data *lm78_data_if_isa(void)
 547{
 548        return pdev ? platform_get_drvdata(pdev) : NULL;
 549}
 550
 551/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
 552static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 553{
 554        struct lm78_data *isa;
 555        int i;
 556
 557        if (!pdev)      /* No ISA chip */
 558                return 0;
 559        isa = platform_get_drvdata(pdev);
 560
 561        if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
 562                return 0;       /* Address doesn't match */
 563        if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
 564                return 0;       /* Chip type doesn't match */
 565
 566        /*
 567         * We compare all the limit registers, the config register and the
 568         * interrupt mask registers
 569         */
 570        for (i = 0x2b; i <= 0x3d; i++) {
 571                if (lm78_read_value(isa, i) !=
 572                    i2c_smbus_read_byte_data(client, i))
 573                        return 0;
 574        }
 575        if (lm78_read_value(isa, LM78_REG_CONFIG) !=
 576            i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
 577                return 0;
 578        for (i = 0x43; i <= 0x46; i++) {
 579                if (lm78_read_value(isa, i) !=
 580                    i2c_smbus_read_byte_data(client, i))
 581                        return 0;
 582        }
 583
 584        return 1;
 585}
 586#else /* !CONFIG_ISA */
 587
 588static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 589{
 590        return 0;
 591}
 592
 593static struct lm78_data *lm78_data_if_isa(void)
 594{
 595        return NULL;
 596}
 597#endif /* CONFIG_ISA */
 598
 599static int lm78_i2c_detect(struct i2c_client *client,
 600                           struct i2c_board_info *info)
 601{
 602        int i;
 603        struct lm78_data *isa = lm78_data_if_isa();
 604        const char *client_name;
 605        struct i2c_adapter *adapter = client->adapter;
 606        int address = client->addr;
 607
 608        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 609                return -ENODEV;
 610
 611        /*
 612         * We block updates of the ISA device to minimize the risk of
 613         * concurrent access to the same LM78 chip through different
 614         * interfaces.
 615         */
 616        if (isa)
 617                mutex_lock(&isa->update_lock);
 618
 619        if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
 620         || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
 621                goto err_nodev;
 622
 623        /* Explicitly prevent the misdetection of Winbond chips */
 624        i = i2c_smbus_read_byte_data(client, 0x4f);
 625        if (i == 0xa3 || i == 0x5c)
 626                goto err_nodev;
 627
 628        /* Determine the chip type. */
 629        i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
 630        if (i == 0x00 || i == 0x20      /* LM78 */
 631         || i == 0x40)                  /* LM78-J */
 632                client_name = "lm78";
 633        else if ((i & 0xfe) == 0xc0)
 634                client_name = "lm79";
 635        else
 636                goto err_nodev;
 637
 638        if (lm78_alias_detect(client, i)) {
 639                dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
 640                        "be the same as ISA device\n", address);
 641                goto err_nodev;
 642        }
 643
 644        if (isa)
 645                mutex_unlock(&isa->update_lock);
 646
 647        strlcpy(info->type, client_name, I2C_NAME_SIZE);
 648
 649        return 0;
 650
 651 err_nodev:
 652        if (isa)
 653                mutex_unlock(&isa->update_lock);
 654        return -ENODEV;
 655}
 656
 657static int lm78_i2c_probe(struct i2c_client *client,
 658                          const struct i2c_device_id *id)
 659{
 660        struct lm78_data *data;
 661        int err;
 662
 663        data = devm_kzalloc(&client->dev, sizeof(struct lm78_data), GFP_KERNEL);
 664        if (!data)
 665                return -ENOMEM;
 666
 667        i2c_set_clientdata(client, data);
 668        data->client = client;
 669        data->type = id->driver_data;
 670
 671        /* Initialize the LM78 chip */
 672        lm78_init_device(data);
 673
 674        /* Register sysfs hooks */
 675        err = sysfs_create_group(&client->dev.kobj, &lm78_group);
 676        if (err)
 677                return err;
 678
 679        data->hwmon_dev = hwmon_device_register(&client->dev);
 680        if (IS_ERR(data->hwmon_dev)) {
 681                err = PTR_ERR(data->hwmon_dev);
 682                goto error;
 683        }
 684
 685        return 0;
 686
 687error:
 688        sysfs_remove_group(&client->dev.kobj, &lm78_group);
 689        return err;
 690}
 691
 692static int lm78_i2c_remove(struct i2c_client *client)
 693{
 694        struct lm78_data *data = i2c_get_clientdata(client);
 695
 696        hwmon_device_unregister(data->hwmon_dev);
 697        sysfs_remove_group(&client->dev.kobj, &lm78_group);
 698
 699        return 0;
 700}
 701
 702static const struct i2c_device_id lm78_i2c_id[] = {
 703        { "lm78", lm78 },
 704        { "lm79", lm79 },
 705        { }
 706};
 707MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
 708
 709static struct i2c_driver lm78_driver = {
 710        .class          = I2C_CLASS_HWMON,
 711        .driver = {
 712                .name   = "lm78",
 713        },
 714        .probe          = lm78_i2c_probe,
 715        .remove         = lm78_i2c_remove,
 716        .id_table       = lm78_i2c_id,
 717        .detect         = lm78_i2c_detect,
 718        .address_list   = normal_i2c,
 719};
 720
 721/*
 722 * The SMBus locks itself, but ISA access must be locked explicitly!
 723 * We don't want to lock the whole ISA bus, so we lock each client
 724 * separately.
 725 * We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 726 * would slow down the LM78 access and should not be necessary.
 727 */
 728static int lm78_read_value(struct lm78_data *data, u8 reg)
 729{
 730        struct i2c_client *client = data->client;
 731
 732#ifdef CONFIG_ISA
 733        if (!client) { /* ISA device */
 734                int res;
 735                mutex_lock(&data->lock);
 736                outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 737                res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
 738                mutex_unlock(&data->lock);
 739                return res;
 740        } else
 741#endif
 742                return i2c_smbus_read_byte_data(client, reg);
 743}
 744
 745static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 746{
 747        struct i2c_client *client = data->client;
 748
 749#ifdef CONFIG_ISA
 750        if (!client) { /* ISA device */
 751                mutex_lock(&data->lock);
 752                outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 753                outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
 754                mutex_unlock(&data->lock);
 755                return 0;
 756        } else
 757#endif
 758                return i2c_smbus_write_byte_data(client, reg, value);
 759}
 760
 761static void lm78_init_device(struct lm78_data *data)
 762{
 763        u8 config;
 764        int i;
 765
 766        /* Start monitoring */
 767        config = lm78_read_value(data, LM78_REG_CONFIG);
 768        if ((config & 0x09) != 0x01)
 769                lm78_write_value(data, LM78_REG_CONFIG,
 770                                 (config & 0xf7) | 0x01);
 771
 772        /* A few vars need to be filled upon startup */
 773        for (i = 0; i < 3; i++) {
 774                data->fan_min[i] = lm78_read_value(data,
 775                                        LM78_REG_FAN_MIN(i));
 776        }
 777
 778        mutex_init(&data->update_lock);
 779}
 780
 781static struct lm78_data *lm78_update_device(struct device *dev)
 782{
 783        struct lm78_data *data = dev_get_drvdata(dev);
 784        int i;
 785
 786        mutex_lock(&data->update_lock);
 787
 788        if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 789            || !data->valid) {
 790
 791                dev_dbg(dev, "Starting lm78 update\n");
 792
 793                for (i = 0; i <= 6; i++) {
 794                        data->in[i] =
 795                            lm78_read_value(data, LM78_REG_IN(i));
 796                        data->in_min[i] =
 797                            lm78_read_value(data, LM78_REG_IN_MIN(i));
 798                        data->in_max[i] =
 799                            lm78_read_value(data, LM78_REG_IN_MAX(i));
 800                }
 801                for (i = 0; i < 3; i++) {
 802                        data->fan[i] =
 803                            lm78_read_value(data, LM78_REG_FAN(i));
 804                        data->fan_min[i] =
 805                            lm78_read_value(data, LM78_REG_FAN_MIN(i));
 806                }
 807                data->temp = lm78_read_value(data, LM78_REG_TEMP);
 808                data->temp_over =
 809                    lm78_read_value(data, LM78_REG_TEMP_OVER);
 810                data->temp_hyst =
 811                    lm78_read_value(data, LM78_REG_TEMP_HYST);
 812                i = lm78_read_value(data, LM78_REG_VID_FANDIV);
 813                data->vid = i & 0x0f;
 814                if (data->type == lm79)
 815                        data->vid |=
 816                            (lm78_read_value(data, LM78_REG_CHIPID) &
 817                             0x01) << 4;
 818                else
 819                        data->vid |= 0x10;
 820                data->fan_div[0] = (i >> 4) & 0x03;
 821                data->fan_div[1] = i >> 6;
 822                data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
 823                    (lm78_read_value(data, LM78_REG_ALARM2) << 8);
 824                data->last_updated = jiffies;
 825                data->valid = 1;
 826
 827                data->fan_div[2] = 1;
 828        }
 829
 830        mutex_unlock(&data->update_lock);
 831
 832        return data;
 833}
 834
 835#ifdef CONFIG_ISA
 836static int lm78_isa_probe(struct platform_device *pdev)
 837{
 838        int err;
 839        struct lm78_data *data;
 840        struct resource *res;
 841
 842        /* Reserve the ISA region */
 843        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 844        if (!devm_request_region(&pdev->dev, res->start + LM78_ADDR_REG_OFFSET,
 845                                 2, "lm78"))
 846                return -EBUSY;
 847
 848        data = devm_kzalloc(&pdev->dev, sizeof(struct lm78_data), GFP_KERNEL);
 849        if (!data)
 850                return -ENOMEM;
 851
 852        mutex_init(&data->lock);
 853        data->isa_addr = res->start;
 854        platform_set_drvdata(pdev, data);
 855
 856        if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
 857                data->type = lm79;
 858                data->name = "lm79";
 859        } else {
 860                data->type = lm78;
 861                data->name = "lm78";
 862        }
 863
 864        /* Initialize the LM78 chip */
 865        lm78_init_device(data);
 866
 867        /* Register sysfs hooks */
 868        err = sysfs_create_group(&pdev->dev.kobj, &lm78_group);
 869        if (err)
 870                goto exit_remove_files;
 871        err = device_create_file(&pdev->dev, &dev_attr_name);
 872        if (err)
 873                goto exit_remove_files;
 874
 875        data->hwmon_dev = hwmon_device_register(&pdev->dev);
 876        if (IS_ERR(data->hwmon_dev)) {
 877                err = PTR_ERR(data->hwmon_dev);
 878                goto exit_remove_files;
 879        }
 880
 881        return 0;
 882
 883 exit_remove_files:
 884        sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 885        device_remove_file(&pdev->dev, &dev_attr_name);
 886        return err;
 887}
 888
 889static int lm78_isa_remove(struct platform_device *pdev)
 890{
 891        struct lm78_data *data = platform_get_drvdata(pdev);
 892
 893        hwmon_device_unregister(data->hwmon_dev);
 894        sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 895        device_remove_file(&pdev->dev, &dev_attr_name);
 896
 897        return 0;
 898}
 899
 900static struct platform_driver lm78_isa_driver = {
 901        .driver = {
 902                .owner  = THIS_MODULE,
 903                .name   = "lm78",
 904        },
 905        .probe          = lm78_isa_probe,
 906        .remove         = lm78_isa_remove,
 907};
 908
 909/* return 1 if a supported chip is found, 0 otherwise */
 910static int __init lm78_isa_found(unsigned short address)
 911{
 912        int val, save, found = 0;
 913        int port;
 914
 915        /*
 916         * Some boards declare base+0 to base+7 as a PNP device, some base+4
 917         * to base+7 and some base+5 to base+6. So we better request each port
 918         * individually for the probing phase.
 919         */
 920        for (port = address; port < address + LM78_EXTENT; port++) {
 921                if (!request_region(port, 1, "lm78")) {
 922                        pr_debug("Failed to request port 0x%x\n", port);
 923                        goto release;
 924                }
 925        }
 926
 927#define REALLY_SLOW_IO
 928        /*
 929         * We need the timeouts for at least some LM78-like
 930         * chips. But only if we read 'undefined' registers.
 931         */
 932        val = inb_p(address + 1);
 933        if (inb_p(address + 2) != val
 934         || inb_p(address + 3) != val
 935         || inb_p(address + 7) != val)
 936                goto release;
 937#undef REALLY_SLOW_IO
 938
 939        /*
 940         * We should be able to change the 7 LSB of the address port. The
 941         * MSB (busy flag) should be clear initially, set after the write.
 942         */
 943        save = inb_p(address + LM78_ADDR_REG_OFFSET);
 944        if (save & 0x80)
 945                goto release;
 946        val = ~save & 0x7f;
 947        outb_p(val, address + LM78_ADDR_REG_OFFSET);
 948        if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
 949                outb_p(save, address + LM78_ADDR_REG_OFFSET);
 950                goto release;
 951        }
 952
 953        /* We found a device, now see if it could be an LM78 */
 954        outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
 955        val = inb_p(address + LM78_DATA_REG_OFFSET);
 956        if (val & 0x80)
 957                goto release;
 958        outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
 959        val = inb_p(address + LM78_DATA_REG_OFFSET);
 960        if (val < 0x03 || val > 0x77)   /* Not a valid I2C address */
 961                goto release;
 962
 963        /* The busy flag should be clear again */
 964        if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
 965                goto release;
 966
 967        /* Explicitly prevent the misdetection of Winbond chips */
 968        outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
 969        val = inb_p(address + LM78_DATA_REG_OFFSET);
 970        if (val == 0xa3 || val == 0x5c)
 971                goto release;
 972
 973        /* Explicitly prevent the misdetection of ITE chips */
 974        outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
 975        val = inb_p(address + LM78_DATA_REG_OFFSET);
 976        if (val == 0x90)
 977                goto release;
 978
 979        /* Determine the chip type */
 980        outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
 981        val = inb_p(address + LM78_DATA_REG_OFFSET);
 982        if (val == 0x00 || val == 0x20  /* LM78 */
 983         || val == 0x40                 /* LM78-J */
 984         || (val & 0xfe) == 0xc0)       /* LM79 */
 985                found = 1;
 986
 987        if (found)
 988                pr_info("Found an %s chip at %#x\n",
 989                        val & 0x80 ? "LM79" : "LM78", (int)address);
 990
 991 release:
 992        for (port--; port >= address; port--)
 993                release_region(port, 1);
 994        return found;
 995}
 996
 997static int __init lm78_isa_device_add(unsigned short address)
 998{
 999        struct resource res = {
1000                .start  = address,
1001                .end    = address + LM78_EXTENT - 1,
1002                .name   = "lm78",
1003                .flags  = IORESOURCE_IO,
1004        };
1005        int err;
1006
1007        pdev = platform_device_alloc("lm78", address);
1008        if (!pdev) {
1009                err = -ENOMEM;
1010                pr_err("Device allocation failed\n");
1011                goto exit;
1012        }
1013
1014        err = platform_device_add_resources(pdev, &res, 1);
1015        if (err) {
1016                pr_err("Device resource addition failed (%d)\n", err);
1017                goto exit_device_put;
1018        }
1019
1020        err = platform_device_add(pdev);
1021        if (err) {
1022                pr_err("Device addition failed (%d)\n", err);
1023                goto exit_device_put;
1024        }
1025
1026        return 0;
1027
1028 exit_device_put:
1029        platform_device_put(pdev);
1030 exit:
1031        pdev = NULL;
1032        return err;
1033}
1034
1035static int __init lm78_isa_register(void)
1036{
1037        int res;
1038
1039        if (lm78_isa_found(isa_address)) {
1040                res = platform_driver_register(&lm78_isa_driver);
1041                if (res)
1042                        goto exit;
1043
1044                /* Sets global pdev as a side effect */
1045                res = lm78_isa_device_add(isa_address);
1046                if (res)
1047                        goto exit_unreg_isa_driver;
1048        }
1049
1050        return 0;
1051
1052 exit_unreg_isa_driver:
1053        platform_driver_unregister(&lm78_isa_driver);
1054 exit:
1055        return res;
1056}
1057
1058static void lm78_isa_unregister(void)
1059{
1060        if (pdev) {
1061                platform_device_unregister(pdev);
1062                platform_driver_unregister(&lm78_isa_driver);
1063        }
1064}
1065#else /* !CONFIG_ISA */
1066
1067static int __init lm78_isa_register(void)
1068{
1069        return 0;
1070}
1071
1072static void lm78_isa_unregister(void)
1073{
1074}
1075#endif /* CONFIG_ISA */
1076
1077static int __init sm_lm78_init(void)
1078{
1079        int res;
1080
1081        /*
1082         * We register the ISA device first, so that we can skip the
1083         * registration of an I2C interface to the same device.
1084         */
1085        res = lm78_isa_register();
1086        if (res)
1087                goto exit;
1088
1089        res = i2c_add_driver(&lm78_driver);
1090        if (res)
1091                goto exit_unreg_isa_device;
1092
1093        return 0;
1094
1095 exit_unreg_isa_device:
1096        lm78_isa_unregister();
1097 exit:
1098        return res;
1099}
1100
1101static void __exit sm_lm78_exit(void)
1102{
1103        lm78_isa_unregister();
1104        i2c_del_driver(&lm78_driver);
1105}
1106
1107MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <khali@linux-fr.org>");
1108MODULE_DESCRIPTION("LM78/LM79 driver");
1109MODULE_LICENSE("GPL");
1110
1111module_init(sm_lm78_init);
1112module_exit(sm_lm78_exit);
1113
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.