git.oblomov.eu Git - linux-2.6/blob - drivers/hwmon/lm78.c

   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        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 #include <linux/module.h>
  23 #include <linux/init.h>
  24 #include <linux/slab.h>
  25 #include <linux/jiffies.h>
  26 #include <linux/i2c.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/ioport.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 #include <asm/io.h>
  35
  36 /* ISA device, if found */
  37 static struct platform_device *pdev;
  38
  39 /* Addresses to scan */
  40 static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
  41                                                 0x2e, 0x2f, I2C_CLIENT_END };
  42 static unsigned short isa_address = 0x290;
  43
  44 /* Insmod parameters */
  45 I2C_CLIENT_INSMOD_2(lm78, lm79);
  46
  47 /* Many LM78 constants specified below */
  48
  49 /* Length of ISA address segment */
  50 #define LM78_EXTENT 8
  51
  52 /* Where are the ISA address/data registers relative to the base address */
  53 #define LM78_ADDR_REG_OFFSET 5
  54 #define LM78_DATA_REG_OFFSET 6
  55
  56 /* The LM78 registers */
  57 #define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
  58 #define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
  59 #define LM78_REG_IN(nr) (0x20 + (nr))
  60
  61 #define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
  62 #define LM78_REG_FAN(nr) (0x28 + (nr))
  63
  64 #define LM78_REG_TEMP 0x27
  65 #define LM78_REG_TEMP_OVER 0x39
  66 #define LM78_REG_TEMP_HYST 0x3a
  67
  68 #define LM78_REG_ALARM1 0x41
  69 #define LM78_REG_ALARM2 0x42
  70
  71 #define LM78_REG_VID_FANDIV 0x47
  72
  73 #define LM78_REG_CONFIG 0x40
  74 #define LM78_REG_CHIPID 0x49
  75 #define LM78_REG_I2C_ADDR 0x48
  76
  77
  78 /* Conversions. Rounding and limit checking is only done on the TO_REG
  79    variants. */
  80
  81 /* IN: mV, (0V to 4.08V)
  82    REG: 16mV/bit */
  83 static inline u8 IN_TO_REG(unsigned long val)
  84 {
  85         unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
  86         return (nval + 8) / 16;
  87 }
  88 #define IN_FROM_REG(val) ((val) *  16)
  89
  90 static inline u8 FAN_TO_REG(long rpm, int div)
  91 {
  92         if (rpm <= 0)
  93                 return 255;
  94         return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
  95 }
  96
  97 static inline int FAN_FROM_REG(u8 val, int div)
  98 {
  99         return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
 100 }
 101
 102 /* TEMP: mC (-128C to +127C)
 103    REG: 1C/bit, two's complement */
 104 static inline s8 TEMP_TO_REG(int val)
 105 {
 106         int nval = SENSORS_LIMIT(val, -128000, 127000) ;
 107         return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
 108 }
 109
 110 static inline int TEMP_FROM_REG(s8 val)
 111 {
 112         return val * 1000;
 113 }
 114
 115 #define DIV_FROM_REG(val) (1 << (val))
 116
 117 /* There are some complications in a module like this. First off, LM78 chips
 118    may be both present on the SMBus and the ISA bus, and we have to handle
 119    those cases separately at some places. Second, there might be several
 120    LM78 chips available (well, actually, that is probably never done; but
 121    it is a clean illustration of how to handle a case like that). Finally,
 122    a specific chip may be attached to *both* ISA and SMBus, and we would
 123    not like to detect it double. Fortunately, in the case of the LM78 at
 124    least, a register tells us what SMBus address we are on, so that helps
 125    a bit - except if there could be more than one SMBus. Groan. No solution
 126    for this yet. */
 127
 128 /* For ISA chips, we abuse the i2c_client addr and name fields. We also use
 129    the driver field to differentiate between I2C and ISA chips. */
 130 struct lm78_data {
 131         struct i2c_client client;
 132         struct device *hwmon_dev;
 133         struct mutex lock;
 134         enum chips type;
 135
 136         struct mutex update_lock;
 137         char valid;             /* !=0 if following fields are valid */
 138         unsigned long last_updated;     /* In jiffies */
 139
 140         u8 in[7];               /* Register value */
 141         u8 in_max[7];           /* Register value */
 142         u8 in_min[7];           /* Register value */
 143         u8 fan[3];              /* Register value */
 144         u8 fan_min[3];          /* Register value */
 145         s8 temp;                /* Register value */
 146         s8 temp_over;           /* Register value */
 147         s8 temp_hyst;           /* Register value */
 148         u8 fan_div[3];          /* Register encoding, shifted right */
 149         u8 vid;                 /* Register encoding, combined */
 150         u16 alarms;             /* Register encoding, combined */
 151 };
 152
 153
 154 static int lm78_attach_adapter(struct i2c_adapter *adapter);
 155 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind);
 156 static int lm78_detach_client(struct i2c_client *client);
 157
 158 static int __devinit lm78_isa_probe(struct platform_device *pdev);
 159 static int __devexit lm78_isa_remove(struct platform_device *pdev);
 160
 161 static int lm78_read_value(struct lm78_data *data, u8 reg);
 162 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
 163 static struct lm78_data *lm78_update_device(struct device *dev);
 164 static void lm78_init_device(struct lm78_data *data);
 165
 166
 167 static struct i2c_driver lm78_driver = {
 168         .driver = {
 169                 .name   = "lm78",
 170         },
 171         .attach_adapter = lm78_attach_adapter,
 172         .detach_client  = lm78_detach_client,
 173 };
 174
 175 static struct platform_driver lm78_isa_driver = {
 176         .driver = {
 177                 .owner  = THIS_MODULE,
 178                 .name   = "lm78",
 179         },
 180         .probe          = lm78_isa_probe,
 181         .remove         = lm78_isa_remove,
 182 };
 183
 184
 185 /* 7 Voltages */
 186 static ssize_t show_in(struct device *dev, struct device_attribute *da,
 187                        char *buf)
 188 {
 189         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 190         struct lm78_data *data = lm78_update_device(dev);
 191         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
 192 }
 193
 194 static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
 195                            char *buf)
 196 {
 197         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 198         struct lm78_data *data = lm78_update_device(dev);
 199         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
 200 }
 201
 202 static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
 203                            char *buf)
 204 {
 205         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 206         struct lm78_data *data = lm78_update_device(dev);
 207         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
 208 }
 209
 210 static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
 211                           const char *buf, size_t count)
 212 {
 213         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 214         struct lm78_data *data = dev_get_drvdata(dev);
 215         unsigned long val = simple_strtoul(buf, NULL, 10);
 216         int nr = attr->index;
 217
 218         mutex_lock(&data->update_lock);
 219         data->in_min[nr] = IN_TO_REG(val);
 220         lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
 221         mutex_unlock(&data->update_lock);
 222         return count;
 223 }
 224
 225 static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
 226                           const char *buf, size_t count)
 227 {
 228         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 229         struct lm78_data *data = dev_get_drvdata(dev);
 230         unsigned long val = simple_strtoul(buf, NULL, 10);
 231         int nr = attr->index;
 232
 233         mutex_lock(&data->update_lock);
 234         data->in_max[nr] = IN_TO_REG(val);
 235         lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
 236         mutex_unlock(&data->update_lock);
 237         return count;
 238 }
 239
 240 #define show_in_offset(offset)                                  \
 241 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
 242                 show_in, NULL, offset);                         \
 243 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
 244                 show_in_min, set_in_min, offset);               \
 245 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
 246                 show_in_max, set_in_max, offset);
 247
 248 show_in_offset(0);
 249 show_in_offset(1);
 250 show_in_offset(2);
 251 show_in_offset(3);
 252 show_in_offset(4);
 253 show_in_offset(5);
 254 show_in_offset(6);
 255
 256 /* Temperature */
 257 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
 258                          char *buf)
 259 {
 260         struct lm78_data *data = lm78_update_device(dev);
 261         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
 262 }
 263
 264 static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
 265                               char *buf)
 266 {
 267         struct lm78_data *data = lm78_update_device(dev);
 268         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
 269 }
 270
 271 static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
 272                              const char *buf, size_t count)
 273 {
 274         struct lm78_data *data = dev_get_drvdata(dev);
 275         long val = simple_strtol(buf, NULL, 10);
 276
 277         mutex_lock(&data->update_lock);
 278         data->temp_over = TEMP_TO_REG(val);
 279         lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
 280         mutex_unlock(&data->update_lock);
 281         return count;
 282 }
 283
 284 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
 285                               char *buf)
 286 {
 287         struct lm78_data *data = lm78_update_device(dev);
 288         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
 289 }
 290
 291 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
 292                              const char *buf, size_t count)
 293 {
 294         struct lm78_data *data = dev_get_drvdata(dev);
 295         long val = simple_strtol(buf, NULL, 10);
 296
 297         mutex_lock(&data->update_lock);
 298         data->temp_hyst = TEMP_TO_REG(val);
 299         lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
 300         mutex_unlock(&data->update_lock);
 301         return count;
 302 }
 303
 304 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
 305 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
 306                 show_temp_over, set_temp_over);
 307 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
 308                 show_temp_hyst, set_temp_hyst);
 309
 310 /* 3 Fans */
 311 static ssize_t show_fan(struct device *dev, struct device_attribute *da,
 312                         char *buf)
 313 {
 314         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 315         struct lm78_data *data = lm78_update_device(dev);
 316         int nr = attr->index;
 317         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
 318                 DIV_FROM_REG(data->fan_div[nr])) );
 319 }
 320
 321 static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
 322                             char *buf)
 323 {
 324         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 325         struct lm78_data *data = lm78_update_device(dev);
 326         int nr = attr->index;
 327         return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
 328                 DIV_FROM_REG(data->fan_div[nr])) );
 329 }
 330
 331 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
 332                            const char *buf, size_t count)
 333 {
 334         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 335         struct lm78_data *data = dev_get_drvdata(dev);
 336         int nr = attr->index;
 337         unsigned long val = simple_strtoul(buf, NULL, 10);
 338
 339         mutex_lock(&data->update_lock);
 340         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
 341         lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 342         mutex_unlock(&data->update_lock);
 343         return count;
 344 }
 345
 346 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
 347                             char *buf)
 348 {
 349         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 350         struct lm78_data *data = lm78_update_device(dev);
 351         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
 352 }
 353
 354 /* Note: we save and restore the fan minimum here, because its value is
 355    determined in part by the fan divisor.  This follows the principle of
 356    least surprise; the user doesn't expect the fan minimum to change just
 357    because the divisor changed. */
 358 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
 359                            const char *buf, size_t count)
 360 {
 361         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 362         struct lm78_data *data = dev_get_drvdata(dev);
 363         int nr = attr->index;
 364         unsigned long val = simple_strtoul(buf, NULL, 10);
 365         unsigned long min;
 366         u8 reg;
 367
 368         mutex_lock(&data->update_lock);
 369         min = FAN_FROM_REG(data->fan_min[nr],
 370                            DIV_FROM_REG(data->fan_div[nr]));
 371
 372         switch (val) {
 373         case 1: data->fan_div[nr] = 0; break;
 374         case 2: data->fan_div[nr] = 1; break;
 375         case 4: data->fan_div[nr] = 2; break;
 376         case 8: data->fan_div[nr] = 3; break;
 377         default:
 378                 dev_err(dev, "fan_div value %ld not "
 379                         "supported. Choose one of 1, 2, 4 or 8!\n", val);
 380                 mutex_unlock(&data->update_lock);
 381                 return -EINVAL;
 382         }
 383
 384         reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
 385         switch (nr) {
 386         case 0:
 387                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
 388                 break;
 389         case 1:
 390                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
 391                 break;
 392         }
 393         lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
 394
 395         data->fan_min[nr] =
 396                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
 397         lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
 398         mutex_unlock(&data->update_lock);
 399
 400         return count;
 401 }
 402
 403 #define show_fan_offset(offset)                         \
 404 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
 405                 show_fan, NULL, offset - 1);                    \
 406 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
 407                 show_fan_min, set_fan_min, offset - 1);
 408
 409 show_fan_offset(1);
 410 show_fan_offset(2);
 411 show_fan_offset(3);
 412
 413 /* Fan 3 divisor is locked in H/W */
 414 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
 415                 show_fan_div, set_fan_div, 0);
 416 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
 417                 show_fan_div, set_fan_div, 1);
 418 static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
 419
 420 /* VID */
 421 static ssize_t show_vid(struct device *dev, struct device_attribute *da,
 422                         char *buf)
 423 {
 424         struct lm78_data *data = lm78_update_device(dev);
 425         return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
 426 }
 427 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
 428
 429 /* Alarms */
 430 static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
 431                            char *buf)
 432 {
 433         struct lm78_data *data = lm78_update_device(dev);
 434         return sprintf(buf, "%u\n", data->alarms);
 435 }
 436 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
 437
 438 static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
 439                           char *buf)
 440 {
 441         struct lm78_data *data = lm78_update_device(dev);
 442         int nr = to_sensor_dev_attr(da)->index;
 443         return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
 444 }
 445 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
 446 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
 447 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
 448 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
 449 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
 450 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
 451 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
 452 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
 453 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
 454 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
 455 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
 456
 457 /* This function is called when:
 458      * lm78_driver is inserted (when this module is loaded), for each
 459        available adapter
 460      * when a new adapter is inserted (and lm78_driver is still present) */
 461 static int lm78_attach_adapter(struct i2c_adapter *adapter)
 462 {
 463         if (!(adapter->class & I2C_CLASS_HWMON))
 464                 return 0;
 465         return i2c_probe(adapter, &addr_data, lm78_detect);
 466 }
 467
 468 static 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
 519 static const struct attribute_group lm78_group = {
 520         .attrs = lm78_attributes,
 521 };
 522
 523 /* I2C devices get this name attribute automatically, but for ISA devices
 524    we must create it by ourselves. */
 525 static ssize_t show_name(struct device *dev, struct device_attribute
 526                          *devattr, char *buf)
 527 {
 528         struct lm78_data *data = dev_get_drvdata(dev);
 529
 530         return sprintf(buf, "%s\n", data->client.name);
 531 }
 532 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 533
 534 /* This function is called by i2c_probe */
 535 static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
 536 {
 537         int i, err;
 538         struct i2c_client *new_client;
 539         struct lm78_data *data;
 540         const char *client_name = "";
 541
 542         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 543                 err = -ENODEV;
 544                 goto ERROR1;
 545         }
 546
 547         /* OK. For now, we presume we have a valid client. We now create the
 548            client structure, even though we cannot fill it completely yet.
 549            But it allows us to access lm78_{read,write}_value. */
 550
 551         if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
 552                 err = -ENOMEM;
 553                 goto ERROR1;
 554         }
 555
 556         new_client = &data->client;
 557         i2c_set_clientdata(new_client, data);
 558         new_client->addr = address;
 559         new_client->adapter = adapter;
 560         new_client->driver = &lm78_driver;
 561
 562         /* Now, we do the remaining detection. */
 563         if (kind < 0) {
 564                 if (lm78_read_value(data, LM78_REG_CONFIG) & 0x80) {
 565                         err = -ENODEV;
 566                         goto ERROR2;
 567                 }
 568                 if (lm78_read_value(data, LM78_REG_I2C_ADDR) !=
 569                     address) {
 570                         err = -ENODEV;
 571                         goto ERROR2;
 572                 }
 573         }
 574
 575         /* Determine the chip type. */
 576         if (kind <= 0) {
 577                 i = lm78_read_value(data, LM78_REG_CHIPID);
 578                 if (i == 0x00 || i == 0x20      /* LM78 */
 579                  || i == 0x40)                  /* LM78-J */
 580                         kind = lm78;
 581                 else if ((i & 0xfe) == 0xc0)
 582                         kind = lm79;
 583                 else {
 584                         if (kind == 0)
 585                                 dev_warn(&adapter->dev, "Ignoring 'force' "
 586                                         "parameter for unknown chip at "
 587                                         "adapter %d, address 0x%02x\n",
 588                                         i2c_adapter_id(adapter), address);
 589                         err = -ENODEV;
 590                         goto ERROR2;
 591                 }
 592         }
 593
 594         if (kind == lm78) {
 595                 client_name = "lm78";
 596         } else if (kind == lm79) {
 597                 client_name = "lm79";
 598         }
 599
 600         /* Fill in the remaining client fields and put into the global list */
 601         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
 602         data->type = kind;
 603
 604         /* Tell the I2C layer a new client has arrived */
 605         if ((err = i2c_attach_client(new_client)))
 606                 goto ERROR2;
 607
 608         /* Initialize the LM78 chip */
 609         lm78_init_device(data);
 610
 611         /* Register sysfs hooks */
 612         if ((err = sysfs_create_group(&new_client->dev.kobj, &lm78_group)))
 613                 goto ERROR3;
 614
 615         data->hwmon_dev = hwmon_device_register(&new_client->dev);
 616         if (IS_ERR(data->hwmon_dev)) {
 617                 err = PTR_ERR(data->hwmon_dev);
 618                 goto ERROR4;
 619         }
 620
 621         return 0;
 622
 623 ERROR4:
 624         sysfs_remove_group(&new_client->dev.kobj, &lm78_group);
 625 ERROR3:
 626         i2c_detach_client(new_client);
 627 ERROR2:
 628         kfree(data);
 629 ERROR1:
 630         return err;
 631 }
 632
 633 static int lm78_detach_client(struct i2c_client *client)
 634 {
 635         struct lm78_data *data = i2c_get_clientdata(client);
 636         int err;
 637
 638         hwmon_device_unregister(data->hwmon_dev);
 639         sysfs_remove_group(&client->dev.kobj, &lm78_group);
 640
 641         if ((err = i2c_detach_client(client)))
 642                 return err;
 643
 644         kfree(data);
 645
 646         return 0;
 647 }
 648
 649 static int __devinit lm78_isa_probe(struct platform_device *pdev)
 650 {
 651         int err;
 652         struct lm78_data *data;
 653         struct resource *res;
 654         const char *name;
 655
 656         /* Reserve the ISA region */
 657         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 658         if (!request_region(res->start, LM78_EXTENT, "lm78")) {
 659                 err = -EBUSY;
 660                 goto exit;
 661         }
 662
 663         if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
 664                 err = -ENOMEM;
 665                 goto exit_release_region;
 666         }
 667         mutex_init(&data->lock);
 668         data->client.addr = res->start;
 669         i2c_set_clientdata(&data->client, data);
 670         platform_set_drvdata(pdev, data);
 671
 672         if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
 673                 data->type = lm79;
 674                 name = "lm79";
 675         } else {
 676                 data->type = lm78;
 677                 name = "lm78";
 678         }
 679         strlcpy(data->client.name, name, I2C_NAME_SIZE);
 680
 681         /* Initialize the LM78 chip */
 682         lm78_init_device(data);
 683
 684         /* Register sysfs hooks */
 685         if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
 686          || (err = device_create_file(&pdev->dev, &dev_attr_name)))
 687                 goto exit_remove_files;
 688
 689         data->hwmon_dev = hwmon_device_register(&pdev->dev);
 690         if (IS_ERR(data->hwmon_dev)) {
 691                 err = PTR_ERR(data->hwmon_dev);
 692                 goto exit_remove_files;
 693         }
 694
 695         return 0;
 696
 697  exit_remove_files:
 698         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 699         device_remove_file(&pdev->dev, &dev_attr_name);
 700         kfree(data);
 701  exit_release_region:
 702         release_region(res->start, LM78_EXTENT);
 703  exit:
 704         return err;
 705 }
 706
 707 static int __devexit lm78_isa_remove(struct platform_device *pdev)
 708 {
 709         struct lm78_data *data = platform_get_drvdata(pdev);
 710
 711         hwmon_device_unregister(data->hwmon_dev);
 712         sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
 713         device_remove_file(&pdev->dev, &dev_attr_name);
 714         release_region(data->client.addr, LM78_EXTENT);
 715         kfree(data);
 716
 717         return 0;
 718 }
 719
 720 /* The SMBus locks itself, but ISA access must be locked explicitly!
 721    We don't want to lock the whole ISA bus, so we lock each client
 722    separately.
 723    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 724    would slow down the LM78 access and should not be necessary.  */
 725 static int lm78_read_value(struct lm78_data *data, u8 reg)
 726 {
 727         struct i2c_client *client = &data->client;
 728
 729         if (!client->driver) { /* ISA device */
 730                 int res;
 731                 mutex_lock(&data->lock);
 732                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 733                 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
 734                 mutex_unlock(&data->lock);
 735                 return res;
 736         } else
 737                 return i2c_smbus_read_byte_data(client, reg);
 738 }
 739
 740 /* The SMBus locks itself, but ISA access muse be locked explicitly!
 741    We don't want to lock the whole ISA bus, so we lock each client
 742    separately.
 743    We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
 744    would slow down the LM78 access and should not be necessary.
 745    There are some ugly typecasts here, but the good new is - they should
 746    nowhere else be necessary! */
 747 static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
 748 {
 749         struct i2c_client *client = &data->client;
 750
 751         if (!client->driver) { /* ISA device */
 752                 mutex_lock(&data->lock);
 753                 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
 754                 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
 755                 mutex_unlock(&data->lock);
 756                 return 0;
 757         } else
 758                 return i2c_smbus_write_byte_data(client, reg, value);
 759 }
 760
 761 static 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
 781 static 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 /* return 1 if a supported chip is found, 0 otherwise */
 836 static int __init lm78_isa_found(unsigned short address)
 837 {
 838         int val, save, found = 0;
 839
 840         if (!request_region(address, LM78_EXTENT, "lm78"))
 841                 return 0;
 842
 843 #define REALLY_SLOW_IO
 844         /* We need the timeouts for at least some LM78-like
 845            chips. But only if we read 'undefined' registers. */
 846         val = inb_p(address + 1);
 847         if (inb_p(address + 2) != val
 848          || inb_p(address + 3) != val
 849          || inb_p(address + 7) != val)
 850                 goto release;
 851 #undef REALLY_SLOW_IO
 852
 853         /* We should be able to change the 7 LSB of the address port. The
 854            MSB (busy flag) should be clear initially, set after the write. */
 855         save = inb_p(address + LM78_ADDR_REG_OFFSET);
 856         if (save & 0x80)
 857                 goto release;
 858         val = ~save & 0x7f;
 859         outb_p(val, address + LM78_ADDR_REG_OFFSET);
 860         if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
 861                 outb_p(save, address + LM78_ADDR_REG_OFFSET);
 862                 goto release;
 863         }
 864
 865         /* We found a device, now see if it could be an LM78 */
 866         outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
 867         val = inb_p(address + LM78_DATA_REG_OFFSET);
 868         if (val & 0x80)
 869                 goto release;
 870         outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
 871         val = inb_p(address + LM78_DATA_REG_OFFSET);
 872         if (val < 0x03 || val > 0x77)   /* Not a valid I2C address */
 873                 goto release;
 874
 875         /* The busy flag should be clear again */
 876         if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
 877                 goto release;
 878
 879         /* Explicitly prevent the misdetection of Winbond chips */
 880         outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
 881         val = inb_p(address + LM78_DATA_REG_OFFSET);
 882         if (val == 0xa3 || val == 0x5c)
 883                 goto release;
 884
 885         /* Explicitly prevent the misdetection of ITE chips */
 886         outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
 887         val = inb_p(address + LM78_DATA_REG_OFFSET);
 888         if (val == 0x90)
 889                 goto release;
 890
 891         /* Determine the chip type */
 892         outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
 893         val = inb_p(address + LM78_DATA_REG_OFFSET);
 894         if (val == 0x00 || val == 0x20  /* LM78 */
 895          || val == 0x40                 /* LM78-J */
 896          || (val & 0xfe) == 0xc0)       /* LM79 */
 897                 found = 1;
 898
 899         if (found)
 900                 pr_info("lm78: Found an %s chip at %#x\n",
 901                         val & 0x80 ? "LM79" : "LM78", (int)address);
 902
 903  release:
 904         release_region(address, LM78_EXTENT);
 905         return found;
 906 }
 907
 908 static int __init lm78_isa_device_add(unsigned short address)
 909 {
 910         struct resource res = {
 911                 .start  = address,
 912                 .end    = address + LM78_EXTENT - 1,
 913                 .name   = "lm78",
 914                 .flags  = IORESOURCE_IO,
 915         };
 916         int err;
 917
 918         pdev = platform_device_alloc("lm78", address);
 919         if (!pdev) {
 920                 err = -ENOMEM;
 921                 printk(KERN_ERR "lm78: Device allocation failed\n");
 922                 goto exit;
 923         }
 924
 925         err = platform_device_add_resources(pdev, &res, 1);
 926         if (err) {
 927                 printk(KERN_ERR "lm78: Device resource addition failed "
 928                        "(%d)\n", err);
 929                 goto exit_device_put;
 930         }
 931
 932         err = platform_device_add(pdev);
 933         if (err) {
 934                 printk(KERN_ERR "lm78: Device addition failed (%d)\n",
 935                        err);
 936                 goto exit_device_put;
 937         }
 938
 939         return 0;
 940
 941  exit_device_put:
 942         platform_device_put(pdev);
 943  exit:
 944         pdev = NULL;
 945         return err;
 946 }
 947
 948 static int __init sm_lm78_init(void)
 949 {
 950         int res;
 951
 952         res = i2c_add_driver(&lm78_driver);
 953         if (res)
 954                 goto exit;
 955
 956         if (lm78_isa_found(isa_address)) {
 957                 res = platform_driver_register(&lm78_isa_driver);
 958                 if (res)
 959                         goto exit_unreg_i2c_driver;
 960
 961                 /* Sets global pdev as a side effect */
 962                 res = lm78_isa_device_add(isa_address);
 963                 if (res)
 964                         goto exit_unreg_isa_driver;
 965         }
 966
 967         return 0;
 968
 969  exit_unreg_isa_driver:
 970         platform_driver_unregister(&lm78_isa_driver);
 971  exit_unreg_i2c_driver:
 972         i2c_del_driver(&lm78_driver);
 973  exit:
 974         return res;
 975 }
 976
 977 static void __exit sm_lm78_exit(void)
 978 {
 979         if (pdev) {
 980                 platform_device_unregister(pdev);
 981                 platform_driver_unregister(&lm78_isa_driver);
 982         }
 983         i2c_del_driver(&lm78_driver);
 984 }
 985
 986
 987
 988 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
 989 MODULE_DESCRIPTION("LM78/LM79 driver");
 990 MODULE_LICENSE("GPL");
 991
 992 module_init(sm_lm78_init);
 993 module_exit(sm_lm78_exit);