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 = clamp_val(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 clamp_val((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 = clamp_val(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,
 390                        "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
 391                        val);
 392                mutex_unlock(&data->update_lock);
 393                return -EINVAL;
 394        }
 395
 396        reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
 397        switch (nr) {
 398        case 0:
 399                reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
 400                break;
 401        case 1:
 402                reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
 403                break;
 404        }
 405        lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
 406
 407        data->fan_min[nr] =
 408                FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 409        lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 410        mutex_unlock(&data->update_lock);
 411
 412        return count;
 413}
 414
 415#define show_fan_offset(offset)                         \
 416static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
 417                show_fan, NULL, offset - 1);                    \
 418static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 419                show_fan_min, set_fan_min, offset - 1);
 420
 421show_fan_offset(1);
 422show_fan_offset(2);
 423show_fan_offset(3);
 424
 425/* Fan 3 divisor is locked in H/W */
 426static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 427                show_fan_div, set_fan_div, 0);
 428static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
 429                show_fan_div, set_fan_div, 1);
 430static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
 431
 432/* VID */
 433static ssize_t show_vid(struct device *dev, struct device_attribute *da,
 434                        char *buf)
 435{
 436        struct lm78_data *data = lm78_update_device(dev);
 437        return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
 438}
 439static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 440
 441/* Alarms */
 442static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
 443                           char *buf)
 444{
 445        struct lm78_data *data = lm78_update_device(dev);
 446        return sprintf(buf, "%u\n", data->alarms);
 447}
 448static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 449
 450static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
 451                          char *buf)
 452{
 453        struct lm78_data *data = lm78_update_device(dev);
 454        int nr = to_sensor_dev_attr(da)->index;
 455        return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
 456}
 457static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 458static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 459static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 460static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 461static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 462static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
 463static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
 464static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
 465static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
 466static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
 467static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 468
 469static struct attribute *lm78_attributes[] = {
 470        &sensor_dev_attr_in0_input.dev_attr.attr,
 471        &sensor_dev_attr_in0_min.dev_attr.attr,
 472        &sensor_dev_attr_in0_max.dev_attr.attr,
 473        &sensor_dev_attr_in0_alarm.dev_attr.attr,
 474        &sensor_dev_attr_in1_input.dev_attr.attr,
 475        &sensor_dev_attr_in1_min.dev_attr.attr,
 476        &sensor_dev_attr_in1_max.dev_attr.attr,
 477        &sensor_dev_attr_in1_alarm.dev_attr.attr,
 478        &sensor_dev_attr_in2_input.dev_attr.attr,
 479        &sensor_dev_attr_in2_min.dev_attr.attr,
 480        &sensor_dev_attr_in2_max.dev_attr.attr,
 481        &sensor_dev_attr_in2_alarm.dev_attr.attr,
 482        &sensor_dev_attr_in3_input.dev_attr.attr,
 483        &sensor_dev_attr_in3_min.dev_attr.attr,
 484        &sensor_dev_attr_in3_max.dev_attr.attr,
 485        &sensor_dev_attr_in3_alarm.dev_attr.attr,
 486        &sensor_dev_attr_in4_input.dev_attr.attr,
 487        &sensor_dev_attr_in4_min.dev_attr.attr,
 488        &sensor_dev_attr_in4_max.dev_attr.attr,
 489        &sensor_dev_attr_in4_alarm.dev_attr.attr,
 490        &sensor_dev_attr_in5_input.dev_attr.attr,
 491        &sensor_dev_attr_in5_min.dev_attr.attr,
 492        &sensor_dev_attr_in5_max.dev_attr.attr,
 493        &sensor_dev_attr_in5_alarm.dev_attr.attr,
 494        &sensor_dev_attr_in6_input.dev_attr.attr,
 495        &sensor_dev_attr_in6_min.dev_attr.attr,
 496        &sensor_dev_attr_in6_max.dev_attr.attr,
 497        &sensor_dev_attr_in6_alarm.dev_attr.attr,
 498        &dev_attr_temp1_input.attr,
 499        &dev_attr_temp1_max.attr,
 500        &dev_attr_temp1_max_hyst.attr,
 501        &sensor_dev_attr_temp1_alarm.dev_attr.attr,
 502        &sensor_dev_attr_fan1_input.dev_attr.attr,
 503        &sensor_dev_attr_fan1_min.dev_attr.attr,
 504        &sensor_dev_attr_fan1_div.dev_attr.attr,
 505        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
 506        &sensor_dev_attr_fan2_input.dev_attr.attr,
 507        &sensor_dev_attr_fan2_min.dev_attr.attr,
 508        &sensor_dev_attr_fan2_div.dev_attr.attr,
 509        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
 510        &sensor_dev_attr_fan3_input.dev_attr.attr,
 511        &sensor_dev_attr_fan3_min.dev_attr.attr,
 512        &sensor_dev_attr_fan3_div.dev_attr.attr,
 513        &sensor_dev_attr_fan3_alarm.dev_attr.attr,
 514        &dev_attr_alarms.attr,
 515        &dev_attr_cpu0_vid.attr,
 516
 517        NULL
 518};
 519
 520static const struct attribute_group lm78_group = {
 521        .attrs = lm78_attributes,
 522};
 523
 524/*
 525 * ISA related code
 526 */
 527#ifdef CONFIG_ISA
 528
 529/* ISA device, if found */
 530static struct platform_device *pdev;
 531
 532static unsigned short isa_address = 0x290;
 533
 534/*
 535 * I2C devices get this name attribute automatically, but for ISA devices
 536 * we must create it by ourselves.
 537 */
 538static ssize_t show_name(struct device *dev, struct device_attribute
 539                         *devattr, char *buf)
 540{
 541        struct lm78_data *data = dev_get_drvdata(dev);
 542
 543        return sprintf(buf, "%s\n", data->name);
 544}
 545static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 546
 547static struct lm78_data *lm78_data_if_isa(void)
 548{
 549        return pdev ? platform_get_drvdata(pdev) : NULL;
 550}
 551
 552/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
 553static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 554{
 555        struct lm78_data *isa;
 556        int i;
 557
 558        if (!pdev)      /* No ISA chip */
 559                return 0;
 560        isa = platform_get_drvdata(pdev);
 561
 562        if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
 563                return 0;       /* Address doesn't match */
 564        if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
 565                return 0;       /* Chip type doesn't match */
 566
 567        /*
 568         * We compare all the limit registers, the config register and the
 569         * interrupt mask registers
 570         */
 571        for (i = 0x2b; i <= 0x3d; i++) {
 572                if (lm78_read_value(isa, i) !=
 573                    i2c_smbus_read_byte_data(client, i))
 574                        return 0;
 575        }
 576        if (lm78_read_value(isa, LM78_REG_CONFIG) !=
 577            i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
 578                return 0;
 579        for (i = 0x43; i <= 0x46; i++) {
 580                if (lm78_read_value(isa, i) !=
 581                    i2c_smbus_read_byte_data(client, i))
 582                        return 0;
 583        }
 584
 585        return 1;
 586}
 587#else /* !CONFIG_ISA */
 588
 589static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
 590{
 591        return 0;
 592}
 593
 594static struct lm78_data *lm78_data_if_isa(void)
 595{
 596        return NULL;
 597}
 598#endif /* CONFIG_ISA */
 599
 600static int lm78_i2c_detect(struct i2c_client *client,
 601                           struct i2c_board_info *info)
 602{
 603        int i;
 604        struct lm78_data *isa = lm78_data_if_isa();
 605        const char *client_name;
 606        struct i2c_adapter *adapter = client->adapter;
 607        int address = client->addr;
 608
 609        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 610                return -ENODEV;
 611
 612        /*
 613         * We block updates of the ISA device to minimize the risk of
 614         * concurrent access to the same LM78 chip through different
 615         * interfaces.
 616         */
 617        if (isa)
 618                mutex_lock(&isa->update_lock);
 619
 620        if ((i2c_smbus_read_byte_data(client, LM78_REG_CONFIG) & 0x80)
 621         || i2c_smbus_read_byte_data(client, LM78_REG_I2C_ADDR) != address)
 622                goto err_nodev;
 623
 624        /* Explicitly prevent the misdetection of Winbond chips */
 625        i = i2c_smbus_read_byte_data(client, 0x4f);
 626        if (i == 0xa3 || i == 0x5c)
 627                goto err_nodev;
 628
 629        /* Determine the chip type. */
 630        i = i2c_smbus_read_byte_data(client, LM78_REG_CHIPID);
 631        if (i == 0x00 || i == 0x20      /* LM78 */
 632         || i == 0x40)                  /* LM78-J */
 633                client_name = "lm78";
 634        else if ((i & 0xfe) == 0xc0)
 635                client_name = "lm79";
 636        else
 637                goto err_nodev;
 638
 639        if (lm78_alias_detect(client, i)) {
 640                dev_dbg(&adapter->dev,
 641                        "Device at 0x%02x appears to be the same as ISA device\n",
 642                        address);
 643                goto err_nodev;
 644        }
 645
 646        if (isa)
 647                mutex_unlock(&isa->update_lock);
 648
 649        strlcpy(info->type, client_name, I2C_NAME_SIZE);
 650
 651        return 0;
 652
 653 err_nodev:
 654        if (isa)
 655                mutex_unlock(&isa->update_lock);
 656        return -ENODEV;
 657}
 658
 659static int lm78_i2c_probe(struct i2c_client *client,
 660                          const struct i2c_device_id *id)
 661{
 662        struct lm78_data *data;
 663        int err;
 664
 665        data = devm_kzalloc(&client->dev, sizeof(struct lm78_data), GFP_KERNEL);
 666        if (!data)
 667                return -ENOMEM;
 668
 669        i2c_set_clientdata(client, data);
 670        data->client = client;
 671        data->type = id->driver_data;
 672
 673        /* Initialize the LM78 chip */
 674        lm78_init_device(data);
 675
 676        /* Register sysfs hooks */
 677        err = sysfs_create_group(&client->dev.kobj, &lm78_group);
 678        if (err)
 679                return err;
 680
 681        data->hwmon_dev = hwmon_device_register(&client->dev);
 682        if (IS_ERR(data->hwmon_dev)) {
 683                err = PTR_ERR(data->hwmon_dev);
 684                goto error;
 685        }
 686
 687        return 0;
 688
 689error:
 690        sysfs_remove_group(&client->dev.kobj, &lm78_group);
 691        return err;
 692}
 693
 694static int lm78_i2c_remove(struct i2c_client *client)
 695{
 696        struct lm78_data *data = i2c_get_clientdata(client);
 697
 698        hwmon_device_unregister(data->hwmon_dev);
 699        sysfs_remove_group(&client->dev.kobj, &lm78_group);
 700
 701        return 0;
 702}
 703
 704static const struct i2c_device_id lm78_i2c_id[] = {
 705        { "lm78", lm78 },
 706        { "lm79", lm79 },
 707        { }
 708};
 709MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
 710
 711static struct i2c_driver lm78_driver = {
 712        .class          = I2C_CLASS_HWMON,
 713        .driver = {
 714                .name   = "lm78",
 715        },
 716        .probe          = lm78_i2c_probe,
 717        .remove         = lm78_i2c_remove,
 718        .id_table       = lm78_i2c_id,
 719        .detect         = lm78_i2c_detect,
 720        .address_list   = normal_i2c,
 721};
 722
 723/*
 724 * The SMBus locks itself, but ISA access must be locked explicitly!
 725 * We don't want to lock the whole ISA bus, so we lock each client
 726 * separately.
 727 * We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 728 * would slow down the LM78 access and should not be necessary.
 729 */
 730static int lm78_read_value(struct lm78_data *data, u8 reg)
 731{
 732        struct i2c_client *client = data->client;
 733
 734#ifdef CONFIG_ISA
 735        if (!client) { /* ISA device */
 736                int res;
 737                mutex_lock(&data->lock);
 738                outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 739                res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
 740                mutex_unlock(&data->lock);
 741                return res;
 742        } else
 743#endif
 744                return i2c_smbus_read_byte_data(client, reg);
 745}
 746
 747static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 748{
 749        struct i2c_client *client = data->client;
 750
 751#ifdef CONFIG_ISA
 752        if (!client) { /* ISA device */
 753                mutex_lock(&data->lock);
 754                outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
 755                outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
 756                mutex_unlock(&data->lock);
 757                return 0;
 758        } else
 759#endif
 760                return i2c_smbus_write_byte_data(client, reg, value);
 761}
 762
 763static void lm78_init_device(struct lm78_data *data)
 764{
 765        u8 config;
 766        int i;
 767
 768        /* Start monitoring */
 769        config = lm78_read_value(data, LM78_REG_CONFIG);
 770        if ((config & 0x09) != 0x01)
 771                lm78_write_value(data, LM78_REG_CONFIG,
 772                                 (config & 0xf7) | 0x01);
 773
 774        /* A few vars need to be filled upon startup */
 775        for (i = 0; i < 3; i++) {
 776                data->fan_min[i] = lm78_read_value(data,
 777                                        LM78_REG_FAN_MIN(i));
 778        }
 779
 780        mutex_init(&data->update_lock);
 781}
 782
 783static struct lm78_data *lm78_update_device(struct device *dev)
 784{
 785        struct lm78_data *data = dev_get_drvdata(dev);
 786        int i;
 787
 788        mutex_lock(&data->update_lock);
 789
 790        if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
 791            || !data->valid) {
 792
 793                dev_dbg(dev, "Starting lm78 update\n");
 794
 795                for (i = 0; i <= 6; i++) {
 796                        data->in[i] =
 797                            lm78_read_value(data, LM78_REG_IN(i));
 798                        data->in_min[i] =
 799                            lm78_read_value(data, LM78_REG_IN_MIN(i));
 800                        data->in_max[i] =
 801                            lm78_read_value(data, LM78_REG_IN_MAX(i));
 802                }
 803                for (i = 0; i < 3; i++) {
 804                        data->fan[i] =
 805                            lm78_read_value(data, LM78_REG_FAN(i));
 806                        data->fan_min[i] =
 807                            lm78_read_value(data, LM78_REG_FAN_MIN(i));
 808                }
 809                data->temp = lm78_read_value(data, LM78_REG_TEMP);
 810                data->temp_over =
 811                    lm78_read_value(data, LM78_REG_TEMP_OVER);
 812                data->temp_hyst =
 813                    lm78_read_value(data, LM78_REG_TEMP_HYST);
 814                i = lm78_read_value(data, LM78_REG_VID_FANDIV);
 815                data->vid = i & 0x0f;
 816                if (data->type == lm79)
 817                        data->vid |=
 818                            (lm78_read_value(data, LM78_REG_CHIPID) &
 819                             0x01) << 4;
 820                else
 821                        data->vid |= 0x10;
 822                data->fan_div[0] = (i >> 4) & 0x03;
 823                data->fan_div[1] = i >> 6;
 824                data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
 825                    (lm78_read_value(data, LM78_REG_ALARM2) << 8);
 826                data->last_updated = jiffies;
 827                data->valid = 1;
 828
 829                data->fan_div[2] = 1;
 830        }
 831
 832        mutex_unlock(&data->update_lock);
 833
 834        return data;
 835}
 836
 837#ifdef CONFIG_ISA
 838static int lm78_isa_probe(struct platform_device *pdev)
 839{
 840        int err;
 841        struct lm78_data *data;
 842        struct resource *res;
 843
 844        /* Reserve the ISA region */
 845        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 846        if (!devm_request_region(&pdev->dev, res->start + LM78_ADDR_REG_OFFSET,
 847                                 2, "lm78"))
 848                return -EBUSY;
 849
 850        data = devm_kzalloc(&pdev->dev, sizeof(struct lm78_data), GFP_KERNEL);
 851        if (!data)
 852                return -ENOMEM;
 853
 854        mutex_init(&data->lock);
 855        data->isa_addr = res->start;
 856        platform_set_drvdata(pdev, data);
 857
 858        if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
 859                data->type = lm79;
 860                data->name = "lm79";
 861        } else {
 862                data->type = lm78;
 863                data->name = "lm78";
 864        }
 865
 866        /* Initialize the LM78 chip */
 867        lm78_init_device(data);
 868
 869        /* Register sysfs hooks */
 870        err = sysfs_create_group(&pdev->dev.kobj, &lm78_group);
 871        if (err)
 872                goto exit_remove_files;
 873        err = device_create_file(&pdev->dev, &dev_attr_name);
 874        if (err)
 875                goto exit_remove_files;
 876
 877        data->hwmon_dev = hwmon_device_register(&pdev->dev);
 878        if (IS_ERR(data->hwmon_dev)) {
 879                err = PTR_ERR(data->hwmon_dev);
 880                goto exit_remove_files;
 881        }
 882
 883        return 0;
 884
 885 exit_remove_files:
 886        sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 887        device_remove_file(&pdev->dev, &dev_attr_name);
 888        return err;
 889}
 890
 891static int lm78_isa_remove(struct platform_device *pdev)
 892{
 893        struct lm78_data *data = platform_get_drvdata(pdev);
 894
 895        hwmon_device_unregister(data->hwmon_dev);
 896        sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 897        device_remove_file(&pdev->dev, &dev_attr_name);
 898
 899        return 0;
 900}
 901
 902static struct platform_driver lm78_isa_driver = {
 903        .driver = {
 904                .owner  = THIS_MODULE,
 905                .name   = "lm78",
 906        },
 907        .probe          = lm78_isa_probe,
 908        .remove         = lm78_isa_remove,
 909};
 910
 911/* return 1 if a supported chip is found, 0 otherwise */
 912static int __init lm78_isa_found(unsigned short address)
 913{
 914        int val, save, found = 0;
 915        int port;
 916
 917        /*
 918         * Some boards declare base+0 to base+7 as a PNP device, some base+4
 919         * to base+7 and some base+5 to base+6. So we better request each port
 920         * individually for the probing phase.
 921         */
 922        for (port = address; port < address + LM78_EXTENT; port++) {
 923                if (!request_region(port, 1, "lm78")) {
 924                        pr_debug("Failed to request port 0x%x\n", port);
 925                        goto release;
 926                }
 927        }
 928
 929#define REALLY_SLOW_IO
 930        /*
 931         * We need the timeouts for at least some LM78-like
 932         * chips. But only if we read 'undefined' registers.
 933         */
 934        val = inb_p(address + 1);
 935        if (inb_p(address + 2) != val
 936         || inb_p(address + 3) != val
 937         || inb_p(address + 7) != val)
 938                goto release;
 939#undef REALLY_SLOW_IO
 940
 941        /*
 942         * We should be able to change the 7 LSB of the address port. The
 943         * MSB (busy flag) should be clear initially, set after the write.
 944         */
 945        save = inb_p(address + LM78_ADDR_REG_OFFSET);
 946        if (save & 0x80)
 947                goto release;
 948        val = ~save & 0x7f;
 949        outb_p(val, address + LM78_ADDR_REG_OFFSET);
 950        if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
 951                outb_p(save, address + LM78_ADDR_REG_OFFSET);
 952                goto release;
 953        }
 954
 955        /* We found a device, now see if it could be an LM78 */
 956        outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
 957        val = inb_p(address + LM78_DATA_REG_OFFSET);
 958        if (val & 0x80)
 959                goto release;
 960        outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
 961        val = inb_p(address + LM78_DATA_REG_OFFSET);
 962        if (val < 0x03 || val > 0x77)   /* Not a valid I2C address */
 963                goto release;
 964
 965        /* The busy flag should be clear again */
 966        if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
 967                goto release;
 968
 969        /* Explicitly prevent the misdetection of Winbond chips */
 970        outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
 971        val = inb_p(address + LM78_DATA_REG_OFFSET);
 972        if (val == 0xa3 || val == 0x5c)
 973                goto release;
 974
 975        /* Explicitly prevent the misdetection of ITE chips */
 976        outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
 977        val = inb_p(address + LM78_DATA_REG_OFFSET);
 978        if (val == 0x90)
 979                goto release;
 980
 981        /* Determine the chip type */
 982        outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
 983        val = inb_p(address + LM78_DATA_REG_OFFSET);
 984        if (val == 0x00 || val == 0x20  /* LM78 */
 985         || val == 0x40                 /* LM78-J */
 986         || (val & 0xfe) == 0xc0)       /* LM79 */
 987                found = 1;
 988
 989        if (found)
 990                pr_info("Found an %s chip at %#x\n",
 991                        val & 0x80 ? "LM79" : "LM78", (int)address);
 992
 993 release:
 994        for (port--; port >= address; port--)
 995                release_region(port, 1);
 996        return found;
 997}
 998
 999static int __init lm78_isa_device_add(unsigned short address)
1000{
1001        struct resource res = {
1002                .start  = address,
1003                .end    = address + LM78_EXTENT - 1,
1004                .name   = "lm78",
1005                .flags  = IORESOURCE_IO,
1006        };
1007        int err;
1008
1009        pdev = platform_device_alloc("lm78", address);
1010        if (!pdev) {
1011                err = -ENOMEM;
1012                pr_err("Device allocation failed\n");
1013                goto exit;
1014        }
1015
1016        err = platform_device_add_resources(pdev, &res, 1);
1017        if (err) {
1018                pr_err("Device resource addition failed (%d)\n", err);
1019                goto exit_device_put;
1020        }
1021
1022        err = platform_device_add(pdev);
1023        if (err) {
1024                pr_err("Device addition failed (%d)\n", err);
1025                goto exit_device_put;
1026        }
1027
1028        return 0;
1029
1030 exit_device_put:
1031        platform_device_put(pdev);
1032 exit:
1033        pdev = NULL;
1034        return err;
1035}
1036
1037static int __init lm78_isa_register(void)
1038{
1039        int res;
1040
1041        if (lm78_isa_found(isa_address)) {
1042                res = platform_driver_register(&lm78_isa_driver);
1043                if (res)
1044                        goto exit;
1045
1046                /* Sets global pdev as a side effect */
1047                res = lm78_isa_device_add(isa_address);
1048                if (res)
1049                        goto exit_unreg_isa_driver;
1050        }
1051
1052        return 0;
1053
1054 exit_unreg_isa_driver:
1055        platform_driver_unregister(&lm78_isa_driver);
1056 exit:
1057        return res;
1058}
1059
1060static void lm78_isa_unregister(void)
1061{
1062        if (pdev) {
1063                platform_device_unregister(pdev);
1064                platform_driver_unregister(&lm78_isa_driver);
1065        }
1066}
1067#else /* !CONFIG_ISA */
1068
1069static int __init lm78_isa_register(void)
1070{
1071        return 0;
1072}
1073
1074static void lm78_isa_unregister(void)
1075{
1076}
1077#endif /* CONFIG_ISA */
1078
1079static int __init sm_lm78_init(void)
1080{
1081        int res;
1082
1083        /*
1084         * We register the ISA device first, so that we can skip the
1085         * registration of an I2C interface to the same device.
1086         */
1087        res = lm78_isa_register();
1088        if (res)
1089                goto exit;
1090
1091        res = i2c_add_driver(&lm78_driver);
1092        if (res)
1093                goto exit_unreg_isa_device;
1094
1095        return 0;
1096
1097 exit_unreg_isa_device:
1098        lm78_isa_unregister();
1099 exit:
1100        return res;
1101}
1102
1103static void __exit sm_lm78_exit(void)
1104{
1105        lm78_isa_unregister();
1106        i2c_del_driver(&lm78_driver);
1107}
1108
1109MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <khali@linux-fr.org>");
1110MODULE_DESCRIPTION("LM78/LM79 driver");
1111MODULE_LICENSE("GPL");
1112
1113module_init(sm_lm78_init);
1114module_exit(sm_lm78_exit);
1115
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.