blob: 483538fa1bd58644b68607039be7ef8ca0cb8ed5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Guenter Roeck9b030792012-01-14 20:39:24 -08002 * 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Joe Perchesce47da72011-01-12 21:55:10 +010022#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/module.h>
25#include <linux/init.h>
26#include <linux/slab.h>
27#include <linux/jiffies.h>
28#include <linux/i2c.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040029#include <linux/hwmon.h>
Jean Delvare19f673e2005-07-31 22:12:09 +020030#include <linux/hwmon-vid.h>
Jean Delvare247dde42007-05-08 17:22:01 +020031#include <linux/hwmon-sysfs.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040032#include <linux/err.h>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010033#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Jean Delvare90534c52011-07-25 21:46:11 +020035#ifdef CONFIG_ISA
36#include <linux/platform_device.h>
37#include <linux/ioport.h>
38#include <linux/io.h>
39#endif
Jean Delvarec40769f2007-05-08 17:22:00 +020040
Linus Torvalds1da177e2005-04-16 15:20:36 -070041/* Addresses to scan */
Mark M. Hoffman25e9c862008-02-17 22:28:03 -050042static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
43 0x2e, 0x2f, I2C_CLIENT_END };
Jean Delvaree5e9f442009-12-14 21:17:27 +010044enum chips { lm78, lm79 };
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
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
Guenter Roeck9b030792012-01-14 20:39:24 -080077/*
78 * Conversions. Rounding and limit checking is only done on the TO_REG
79 * variants.
80 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Guenter Roeck9b030792012-01-14 20:39:24 -080082/*
83 * IN: mV (0V to 4.08V)
84 * REG: 16mV/bit
85 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070086static inline u8 IN_TO_REG(unsigned long val)
87{
Guenter Roeck2a844c12013-01-09 08:09:34 -080088 unsigned long nval = clamp_val(val, 0, 4080);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 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;
Guenter Roeck2a844c12013-01-09 08:09:34 -080097 return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098}
99
100static inline int FAN_FROM_REG(u8 val, int div)
101{
Guenter Roeck9b030792012-01-14 20:39:24 -0800102 return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103}
104
Guenter Roeck9b030792012-01-14 20:39:24 -0800105/*
106 * TEMP: mC (-128C to +127C)
107 * REG: 1C/bit, two's complement
108 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109static inline s8 TEMP_TO_REG(int val)
110{
Guenter Roeck2a844c12013-01-09 08:09:34 -0800111 int nval = clamp_val(val, -128000, 127000) ;
Guenter Roeck9b030792012-01-14 20:39:24 -0800112 return nval < 0 ? (nval - 500) / 1000 : (nval + 500) / 1000;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113}
114
115static inline int TEMP_FROM_REG(s8 val)
116{
117 return val * 1000;
118}
119
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120#define DIV_FROM_REG(val) (1 << (val))
121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122struct lm78_data {
Jean Delvare0c6e9732008-10-17 17:51:16 +0200123 struct i2c_client *client;
Tony Jones1beeffe2007-08-20 13:46:20 -0700124 struct device *hwmon_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100125 struct mutex lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 enum chips type;
127
Jean Delvare6e1b5022008-10-17 17:51:15 +0200128 /* For ISA device only */
129 const char *name;
130 int isa_addr;
131
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100132 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 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
Jean Delvarec59cc302007-05-08 17:22:01 +0200150static int lm78_read_value(struct lm78_data *data, u8 reg);
151static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152static struct lm78_data *lm78_update_device(struct device *dev);
Jean Delvarec59cc302007-05-08 17:22:01 +0200153static void lm78_init_device(struct lm78_data *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156/* 7 Voltages */
Jean Delvare247dde42007-05-08 17:22:01 +0200157static ssize_t show_in(struct device *dev, struct device_attribute *da,
158 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159{
Jean Delvare247dde42007-05-08 17:22:01 +0200160 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 struct lm78_data *data = lm78_update_device(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200162 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163}
164
Jean Delvare247dde42007-05-08 17:22:01 +0200165static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
166 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167{
Jean Delvare247dde42007-05-08 17:22:01 +0200168 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 struct lm78_data *data = lm78_update_device(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200170 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
Jean Delvare247dde42007-05-08 17:22:01 +0200173static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
174 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175{
Jean Delvare247dde42007-05-08 17:22:01 +0200176 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 struct lm78_data *data = lm78_update_device(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200178 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179}
180
Jean Delvare247dde42007-05-08 17:22:01 +0200181static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
182 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183{
Jean Delvare247dde42007-05-08 17:22:01 +0200184 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Jean Delvarec40769f2007-05-08 17:22:00 +0200185 struct lm78_data *data = dev_get_drvdata(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200186 int nr = attr->index;
Guenter Roeck9b030792012-01-14 20:39:24 -0800187 unsigned long val;
188 int err;
189
190 err = kstrtoul(buf, 10, &val);
191 if (err)
192 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100194 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 data->in_min[nr] = IN_TO_REG(val);
Jean Delvarec59cc302007-05-08 17:22:01 +0200196 lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100197 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 return count;
199}
200
Jean Delvare247dde42007-05-08 17:22:01 +0200201static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
202 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203{
Jean Delvare247dde42007-05-08 17:22:01 +0200204 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Jean Delvarec40769f2007-05-08 17:22:00 +0200205 struct lm78_data *data = dev_get_drvdata(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200206 int nr = attr->index;
Guenter Roeck9b030792012-01-14 20:39:24 -0800207 unsigned long val;
208 int err;
209
210 err = kstrtoul(buf, 10, &val);
211 if (err)
212 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100214 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 data->in_max[nr] = IN_TO_REG(val);
Jean Delvarec59cc302007-05-08 17:22:01 +0200216 lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100217 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 return count;
219}
Guenter Roeck9b030792012-01-14 20:39:24 -0800220
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221#define show_in_offset(offset) \
Jean Delvare247dde42007-05-08 17:22:01 +0200222static 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
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 */
Jean Delvare247dde42007-05-08 17:22:01 +0200238static ssize_t show_temp(struct device *dev, struct device_attribute *da,
239 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
241 struct lm78_data *data = lm78_update_device(dev);
242 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
243}
244
Jean Delvare247dde42007-05-08 17:22:01 +0200245static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
246 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
248 struct lm78_data *data = lm78_update_device(dev);
249 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
250}
251
Jean Delvare247dde42007-05-08 17:22:01 +0200252static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
253 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
Jean Delvarec40769f2007-05-08 17:22:00 +0200255 struct lm78_data *data = dev_get_drvdata(dev);
Guenter Roeck9b030792012-01-14 20:39:24 -0800256 long val;
257 int err;
258
259 err = kstrtol(buf, 10, &val);
260 if (err)
261 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100263 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 data->temp_over = TEMP_TO_REG(val);
Jean Delvarec59cc302007-05-08 17:22:01 +0200265 lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100266 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 return count;
268}
269
Jean Delvare247dde42007-05-08 17:22:01 +0200270static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
271 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
273 struct lm78_data *data = lm78_update_device(dev);
274 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
275}
276
Jean Delvare247dde42007-05-08 17:22:01 +0200277static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
278 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279{
Jean Delvarec40769f2007-05-08 17:22:00 +0200280 struct lm78_data *data = dev_get_drvdata(dev);
Guenter Roeck9b030792012-01-14 20:39:24 -0800281 long val;
282 int err;
283
284 err = kstrtol(buf, 10, &val);
285 if (err)
286 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100288 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 data->temp_hyst = TEMP_TO_REG(val);
Jean Delvarec59cc302007-05-08 17:22:01 +0200290 lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100291 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 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 */
Jean Delvare247dde42007-05-08 17:22:01 +0200302static ssize_t show_fan(struct device *dev, struct device_attribute *da,
303 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304{
Jean Delvare247dde42007-05-08 17:22:01 +0200305 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 struct lm78_data *data = lm78_update_device(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200307 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
Guenter Roeck9b030792012-01-14 20:39:24 -0800309 DIV_FROM_REG(data->fan_div[nr])));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310}
311
Jean Delvare247dde42007-05-08 17:22:01 +0200312static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
313 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314{
Jean Delvare247dde42007-05-08 17:22:01 +0200315 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 struct lm78_data *data = lm78_update_device(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200317 int nr = attr->index;
Guenter Roeck9b030792012-01-14 20:39:24 -0800318 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
319 DIV_FROM_REG(data->fan_div[nr])));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320}
321
Jean Delvare247dde42007-05-08 17:22:01 +0200322static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
323 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
Jean Delvare247dde42007-05-08 17:22:01 +0200325 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Jean Delvarec40769f2007-05-08 17:22:00 +0200326 struct lm78_data *data = dev_get_drvdata(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200327 int nr = attr->index;
Guenter Roeck9b030792012-01-14 20:39:24 -0800328 unsigned long val;
329 int err;
330
331 err = kstrtoul(buf, 10, &val);
332 if (err)
333 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100335 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
Jean Delvarec59cc302007-05-08 17:22:01 +0200337 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100338 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 return count;
340}
341
Jean Delvare247dde42007-05-08 17:22:01 +0200342static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
343 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344{
Jean Delvare247dde42007-05-08 17:22:01 +0200345 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 struct lm78_data *data = lm78_update_device(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200347 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348}
349
Guenter Roeck9b030792012-01-14 20:39:24 -0800350/*
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 */
Jean Delvare247dde42007-05-08 17:22:01 +0200356static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
357 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
Jean Delvare247dde42007-05-08 17:22:01 +0200359 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
Jean Delvarec40769f2007-05-08 17:22:00 +0200360 struct lm78_data *data = dev_get_drvdata(dev);
Jean Delvare247dde42007-05-08 17:22:01 +0200361 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 unsigned long min;
363 u8 reg;
Guenter Roeck9b030792012-01-14 20:39:24 -0800364 unsigned long val;
365 int err;
366
367 err = kstrtoul(buf, 10, &val);
368 if (err)
369 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100371 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 min = FAN_FROM_REG(data->fan_min[nr],
373 DIV_FROM_REG(data->fan_div[nr]));
374
375 switch (val) {
Guenter Roeck9b030792012-01-14 20:39:24 -0800376 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 default:
Jean Delvarec40769f2007-05-08 17:22:00 +0200389 dev_err(dev, "fan_div value %ld not "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 "supported. Choose one of 1, 2, 4 or 8!\n", val);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100391 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 return -EINVAL;
393 }
394
Jean Delvarec59cc302007-05-08 17:22:01 +0200395 reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 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 }
Jean Delvarec59cc302007-05-08 17:22:01 +0200404 lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406 data->fan_min[nr] =
407 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
Jean Delvarec59cc302007-05-08 17:22:01 +0200408 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100409 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
411 return count;
412}
413
Jean Delvare247dde42007-05-08 17:22:01 +0200414#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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
420show_fan_offset(1);
421show_fan_offset(2);
422show_fan_offset(3);
423
424/* Fan 3 divisor is locked in H/W */
Jean Delvare247dde42007-05-08 17:22:01 +0200425static 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431/* VID */
Jean Delvare247dde42007-05-08 17:22:01 +0200432static ssize_t show_vid(struct device *dev, struct device_attribute *da,
433 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
435 struct lm78_data *data = lm78_update_device(dev);
Jean Delvared0d3cd62005-11-23 15:44:26 -0800436 return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437}
438static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
439
440/* Alarms */
Jean Delvare247dde42007-05-08 17:22:01 +0200441static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
442 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443{
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
Jean Delvare428a7032007-09-04 23:25:33 +0200449static 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
Mark M. Hoffmanc1685f62006-09-24 20:59:49 +0200468static struct attribute *lm78_attributes[] = {
Jean Delvare247dde42007-05-08 17:22:01 +0200469 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200472 &sensor_dev_attr_in0_alarm.dev_attr.attr,
Jean Delvare247dde42007-05-08 17:22:01 +0200473 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200476 &sensor_dev_attr_in1_alarm.dev_attr.attr,
Jean Delvare247dde42007-05-08 17:22:01 +0200477 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200480 &sensor_dev_attr_in2_alarm.dev_attr.attr,
Jean Delvare247dde42007-05-08 17:22:01 +0200481 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200484 &sensor_dev_attr_in3_alarm.dev_attr.attr,
Jean Delvare247dde42007-05-08 17:22:01 +0200485 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200488 &sensor_dev_attr_in4_alarm.dev_attr.attr,
Jean Delvare247dde42007-05-08 17:22:01 +0200489 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200492 &sensor_dev_attr_in5_alarm.dev_attr.attr,
Jean Delvare247dde42007-05-08 17:22:01 +0200493 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200496 &sensor_dev_attr_in6_alarm.dev_attr.attr,
Mark M. Hoffmanc1685f62006-09-24 20:59:49 +0200497 &dev_attr_temp1_input.attr,
498 &dev_attr_temp1_max.attr,
499 &dev_attr_temp1_max_hyst.attr,
Jean Delvare428a7032007-09-04 23:25:33 +0200500 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
Jean Delvare247dde42007-05-08 17:22:01 +0200501 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200504 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
Jean Delvare247dde42007-05-08 17:22:01 +0200505 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200508 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
Jean Delvare247dde42007-05-08 17:22:01 +0200509 &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,
Jean Delvare428a7032007-09-04 23:25:33 +0200512 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
Mark M. Hoffmanc1685f62006-09-24 20:59:49 +0200513 &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
Jean Delvare90534c52011-07-25 21:46:11 +0200523/*
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
Guenter Roeck9b030792012-01-14 20:39:24 -0800533/*
534 * I2C devices get this name attribute automatically, but for ISA devices
535 * we must create it by ourselves.
536 */
Jean Delvarec40769f2007-05-08 17:22:00 +0200537static 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
Jean Delvare6e1b5022008-10-17 17:51:15 +0200542 return sprintf(buf, "%s\n", data->name);
Jean Delvarec40769f2007-05-08 17:22:00 +0200543}
544static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
545
Jean Delvare90534c52011-07-25 21:46:11 +0200546static struct lm78_data *lm78_data_if_isa(void)
547{
548 return pdev ? platform_get_drvdata(pdev) : NULL;
549}
550
Jean Delvare18c73f92008-10-17 17:51:15 +0200551/* 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{
Jean Delvare0c6e9732008-10-17 17:51:16 +0200554 struct lm78_data *isa;
Jean Delvare18c73f92008-10-17 17:51:15 +0200555 int i;
556
557 if (!pdev) /* No ISA chip */
558 return 0;
Jean Delvare18c73f92008-10-17 17:51:15 +0200559 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
Guenter Roeck9b030792012-01-14 20:39:24 -0800566 /*
567 * We compare all the limit registers, the config register and the
568 * interrupt mask registers
569 */
Jean Delvare18c73f92008-10-17 17:51:15 +0200570 for (i = 0x2b; i <= 0x3d; i++) {
Jean Delvare0c6e9732008-10-17 17:51:16 +0200571 if (lm78_read_value(isa, i) !=
572 i2c_smbus_read_byte_data(client, i))
Jean Delvare18c73f92008-10-17 17:51:15 +0200573 return 0;
574 }
575 if (lm78_read_value(isa, LM78_REG_CONFIG) !=
Jean Delvare0c6e9732008-10-17 17:51:16 +0200576 i2c_smbus_read_byte_data(client, LM78_REG_CONFIG))
Jean Delvare18c73f92008-10-17 17:51:15 +0200577 return 0;
578 for (i = 0x43; i <= 0x46; i++) {
Jean Delvare0c6e9732008-10-17 17:51:16 +0200579 if (lm78_read_value(isa, i) !=
580 i2c_smbus_read_byte_data(client, i))
Jean Delvare18c73f92008-10-17 17:51:15 +0200581 return 0;
582 }
583
584 return 1;
585}
Jean Delvare90534c52011-07-25 21:46:11 +0200586#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 */
Jean Delvare18c73f92008-10-17 17:51:15 +0200598
Jean Delvare310ec792009-12-14 21:17:23 +0100599static int lm78_i2c_detect(struct i2c_client *client,
Jean Delvare0c6e9732008-10-17 17:51:16 +0200600 struct i2c_board_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
Jean Delvare0c6e9732008-10-17 17:51:16 +0200602 int i;
Jean Delvare90534c52011-07-25 21:46:11 +0200603 struct lm78_data *isa = lm78_data_if_isa();
Jean Delvare0c6e9732008-10-17 17:51:16 +0200604 const char *client_name;
605 struct i2c_adapter *adapter = client->adapter;
606 int address = client->addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Jean Delvare0c6e9732008-10-17 17:51:16 +0200608 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
609 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
Guenter Roeck9b030792012-01-14 20:39:24 -0800611 /*
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 */
Jean Delvare0c6e9732008-10-17 17:51:16 +0200616 if (isa)
617 mutex_lock(&isa->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Jean Delvare52df6442009-12-09 20:35:57 +0100619 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;
Jean Delvare0c6e9732008-10-17 17:51:16 +0200622
Jean Delvare52df6442009-12-09 20:35:57 +0100623 /* 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
628 /* Determine the chip type. */
Jean Delvare52df6442009-12-09 20:35:57 +0100629 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;
Jean Delvare18c73f92008-10-17 17:51:15 +0200637
Jean Delvare52df6442009-12-09 20:35:57 +0100638 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 }
643
Jean Delvare0c6e9732008-10-17 17:51:16 +0200644 if (isa)
645 mutex_unlock(&isa->update_lock);
646
Jean Delvare0c6e9732008-10-17 17:51:16 +0200647 strlcpy(info->type, client_name, I2C_NAME_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
Jean Delvare0c6e9732008-10-17 17:51:16 +0200649 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Jean Delvare0c6e9732008-10-17 17:51:16 +0200651 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
Guenter Roeck7b7bb902012-06-02 09:58:09 -0700663 data = devm_kzalloc(&client->dev, sizeof(struct lm78_data), GFP_KERNEL);
Jean Delvare0c6e9732008-10-17 17:51:16 +0200664 if (!data)
665 return -ENOMEM;
666
667 i2c_set_clientdata(client, data);
668 data->client = client;
669 data->type = id->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
671 /* Initialize the LM78 chip */
Jean Delvarec59cc302007-05-08 17:22:01 +0200672 lm78_init_device(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 /* Register sysfs hooks */
Jean Delvare0c6e9732008-10-17 17:51:16 +0200675 err = sysfs_create_group(&client->dev.kobj, &lm78_group);
676 if (err)
Guenter Roeck7b7bb902012-06-02 09:58:09 -0700677 return err;
Mark M. Hoffmanc1685f62006-09-24 20:59:49 +0200678
Jean Delvare0c6e9732008-10-17 17:51:16 +0200679 data->hwmon_dev = hwmon_device_register(&client->dev);
Tony Jones1beeffe2007-08-20 13:46:20 -0700680 if (IS_ERR(data->hwmon_dev)) {
681 err = PTR_ERR(data->hwmon_dev);
Guenter Roeck7b7bb902012-06-02 09:58:09 -0700682 goto error;
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400683 }
684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 return 0;
686
Guenter Roeck7b7bb902012-06-02 09:58:09 -0700687error:
Jean Delvare0c6e9732008-10-17 17:51:16 +0200688 sysfs_remove_group(&client->dev.kobj, &lm78_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 return err;
690}
691
Jean Delvare0c6e9732008-10-17 17:51:16 +0200692static int lm78_i2c_remove(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Mark M. Hoffman943b0832005-07-15 21:39:18 -0400694 struct lm78_data *data = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
Tony Jones1beeffe2007-08-20 13:46:20 -0700696 hwmon_device_unregister(data->hwmon_dev);
Mark M. Hoffmanc1685f62006-09-24 20:59:49 +0200697 sysfs_remove_group(&client->dev.kobj, &lm78_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
Jean Delvarec40769f2007-05-08 17:22:00 +0200699 return 0;
700}
701
Jean Delvareed4cebd2011-07-25 21:46:11 +0200702static const struct i2c_device_id lm78_i2c_id[] = {
703 { "lm78", lm78 },
704 { "lm79", lm79 },
705 { }
706};
707MODULE_DEVICE_TABLE(i2c, lm78_i2c_id);
Jean Delvarec40769f2007-05-08 17:22:00 +0200708
Jean Delvareed4cebd2011-07-25 21:46:11 +0200709static 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};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
Guenter Roeck9b030792012-01-14 20:39:24 -0800721/*
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 */
Jean Delvarec59cc302007-05-08 17:22:01 +0200728static int lm78_read_value(struct lm78_data *data, u8 reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729{
Jean Delvare0c6e9732008-10-17 17:51:16 +0200730 struct i2c_client *client = data->client;
Jean Delvarec59cc302007-05-08 17:22:01 +0200731
Jean Delvare90534c52011-07-25 21:46:11 +0200732#ifdef CONFIG_ISA
Jean Delvare0c6e9732008-10-17 17:51:16 +0200733 if (!client) { /* ISA device */
Jean Delvarec59cc302007-05-08 17:22:01 +0200734 int res;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100735 mutex_lock(&data->lock);
Jean Delvare6e1b5022008-10-17 17:51:15 +0200736 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
737 res = inb_p(data->isa_addr + LM78_DATA_REG_OFFSET);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100738 mutex_unlock(&data->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 return res;
740 } else
Jean Delvare90534c52011-07-25 21:46:11 +0200741#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 return i2c_smbus_read_byte_data(client, reg);
743}
744
Jean Delvarec59cc302007-05-08 17:22:01 +0200745static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
Jean Delvare0c6e9732008-10-17 17:51:16 +0200747 struct i2c_client *client = data->client;
Jean Delvarec59cc302007-05-08 17:22:01 +0200748
Jean Delvare90534c52011-07-25 21:46:11 +0200749#ifdef CONFIG_ISA
Jean Delvare0c6e9732008-10-17 17:51:16 +0200750 if (!client) { /* ISA device */
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100751 mutex_lock(&data->lock);
Jean Delvare6e1b5022008-10-17 17:51:15 +0200752 outb_p(reg, data->isa_addr + LM78_ADDR_REG_OFFSET);
753 outb_p(value, data->isa_addr + LM78_DATA_REG_OFFSET);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100754 mutex_unlock(&data->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 return 0;
756 } else
Jean Delvare90534c52011-07-25 21:46:11 +0200757#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 return i2c_smbus_write_byte_data(client, reg, value);
759}
760
Jean Delvarec59cc302007-05-08 17:22:01 +0200761static void lm78_init_device(struct lm78_data *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
Jean Delvarec40769f2007-05-08 17:22:00 +0200763 u8 config;
764 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
766 /* Start monitoring */
Jean Delvarec59cc302007-05-08 17:22:01 +0200767 config = lm78_read_value(data, LM78_REG_CONFIG);
Jean Delvarec40769f2007-05-08 17:22:00 +0200768 if ((config & 0x09) != 0x01)
Jean Delvarec59cc302007-05-08 17:22:01 +0200769 lm78_write_value(data, LM78_REG_CONFIG,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 (config & 0xf7) | 0x01);
Jean Delvarec40769f2007-05-08 17:22:00 +0200771
772 /* A few vars need to be filled upon startup */
773 for (i = 0; i < 3; i++) {
Jean Delvarec59cc302007-05-08 17:22:01 +0200774 data->fan_min[i] = lm78_read_value(data,
Jean Delvarec40769f2007-05-08 17:22:00 +0200775 LM78_REG_FAN_MIN(i));
776 }
777
778 mutex_init(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779}
780
781static struct lm78_data *lm78_update_device(struct device *dev)
782{
Jean Delvarec40769f2007-05-08 17:22:00 +0200783 struct lm78_data *data = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 int i;
785
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100786 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787
788 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
789 || !data->valid) {
790
Jean Delvarec40769f2007-05-08 17:22:00 +0200791 dev_dbg(dev, "Starting lm78 update\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792
793 for (i = 0; i <= 6; i++) {
794 data->in[i] =
Jean Delvarec59cc302007-05-08 17:22:01 +0200795 lm78_read_value(data, LM78_REG_IN(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 data->in_min[i] =
Jean Delvarec59cc302007-05-08 17:22:01 +0200797 lm78_read_value(data, LM78_REG_IN_MIN(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 data->in_max[i] =
Jean Delvarec59cc302007-05-08 17:22:01 +0200799 lm78_read_value(data, LM78_REG_IN_MAX(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 }
801 for (i = 0; i < 3; i++) {
802 data->fan[i] =
Jean Delvarec59cc302007-05-08 17:22:01 +0200803 lm78_read_value(data, LM78_REG_FAN(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 data->fan_min[i] =
Jean Delvarec59cc302007-05-08 17:22:01 +0200805 lm78_read_value(data, LM78_REG_FAN_MIN(i));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 }
Jean Delvarec59cc302007-05-08 17:22:01 +0200807 data->temp = lm78_read_value(data, LM78_REG_TEMP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 data->temp_over =
Jean Delvarec59cc302007-05-08 17:22:01 +0200809 lm78_read_value(data, LM78_REG_TEMP_OVER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 data->temp_hyst =
Jean Delvarec59cc302007-05-08 17:22:01 +0200811 lm78_read_value(data, LM78_REG_TEMP_HYST);
812 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 data->vid = i & 0x0f;
814 if (data->type == lm79)
815 data->vid |=
Jean Delvarec59cc302007-05-08 17:22:01 +0200816 (lm78_read_value(data, LM78_REG_CHIPID) &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 0x01) << 4;
818 else
819 data->vid |= 0x10;
820 data->fan_div[0] = (i >> 4) & 0x03;
821 data->fan_div[1] = i >> 6;
Jean Delvarec59cc302007-05-08 17:22:01 +0200822 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
823 (lm78_read_value(data, LM78_REG_ALARM2) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 data->last_updated = jiffies;
825 data->valid = 1;
826
827 data->fan_div[2] = 1;
828 }
829
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100830 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
832 return data;
833}
834
Jean Delvare90534c52011-07-25 21:46:11 +0200835#ifdef CONFIG_ISA
Bill Pemberton6c931ae2012-11-19 13:22:35 -0500836static int lm78_isa_probe(struct platform_device *pdev)
Jean Delvareed4cebd2011-07-25 21:46:11 +0200837{
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);
Guenter Roeck7b7bb902012-06-02 09:58:09 -0700844 if (!devm_request_region(&pdev->dev, res->start + LM78_ADDR_REG_OFFSET,
845 2, "lm78"))
846 return -EBUSY;
Jean Delvareed4cebd2011-07-25 21:46:11 +0200847
Guenter Roeck7b7bb902012-06-02 09:58:09 -0700848 data = devm_kzalloc(&pdev->dev, sizeof(struct lm78_data), GFP_KERNEL);
849 if (!data)
850 return -ENOMEM;
851
Jean Delvareed4cebd2011-07-25 21:46:11 +0200852 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 */
Guenter Roeck9b030792012-01-14 20:39:24 -0800868 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)
Jean Delvareed4cebd2011-07-25 21:46:11 +0200873 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);
Jean Delvareed4cebd2011-07-25 21:46:11 +0200886 return err;
887}
888
Bill Pemberton281dfd02012-11-19 13:25:51 -0500889static int lm78_isa_remove(struct platform_device *pdev)
Jean Delvareed4cebd2011-07-25 21:46:11 +0200890{
891 struct lm78_data *data = platform_get_drvdata(pdev);
Jean Delvareed4cebd2011-07-25 21:46:11 +0200892
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);
Jean Delvareed4cebd2011-07-25 21:46:11 +0200896
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,
Bill Pemberton9e5e9b72012-11-19 13:21:20 -0500906 .remove = lm78_isa_remove,
Jean Delvareed4cebd2011-07-25 21:46:11 +0200907};
908
Jean Delvarec40769f2007-05-08 17:22:00 +0200909/* 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;
Jean Delvare197027e2010-02-05 19:58:36 +0100913 int port;
Jean Delvarec40769f2007-05-08 17:22:00 +0200914
Guenter Roeck9b030792012-01-14 20:39:24 -0800915 /*
916 * Some boards declare base+0 to base+7 as a PNP device, some base+4
Jean Delvare197027e2010-02-05 19:58:36 +0100917 * to base+7 and some base+5 to base+6. So we better request each port
Guenter Roeck9b030792012-01-14 20:39:24 -0800918 * individually for the probing phase.
919 */
Jean Delvare197027e2010-02-05 19:58:36 +0100920 for (port = address; port < address + LM78_EXTENT; port++) {
921 if (!request_region(port, 1, "lm78")) {
Joe Perchesce47da72011-01-12 21:55:10 +0100922 pr_debug("Failed to request port 0x%x\n", port);
Jean Delvare197027e2010-02-05 19:58:36 +0100923 goto release;
924 }
Jean Delvare47c15532008-10-17 17:51:15 +0200925 }
Jean Delvarec40769f2007-05-08 17:22:00 +0200926
927#define REALLY_SLOW_IO
Guenter Roeck9b030792012-01-14 20:39:24 -0800928 /*
929 * We need the timeouts for at least some LM78-like
930 * chips. But only if we read 'undefined' registers.
931 */
Jean Delvarec40769f2007-05-08 17:22:00 +0200932 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
Guenter Roeck9b030792012-01-14 20:39:24 -0800939 /*
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 */
Jean Delvarec40769f2007-05-08 17:22:00 +0200943 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);
Hans de Goedeacf346a2007-07-24 23:36:00 +0200982 if (val == 0x00 || val == 0x20 /* LM78 */
Jean Delvarec40769f2007-05-08 17:22:00 +0200983 || val == 0x40 /* LM78-J */
984 || (val & 0xfe) == 0xc0) /* LM79 */
985 found = 1;
986
987 if (found)
Joe Perchesce47da72011-01-12 21:55:10 +0100988 pr_info("Found an %s chip at %#x\n",
Jean Delvarec40769f2007-05-08 17:22:00 +0200989 val & 0x80 ? "LM79" : "LM78", (int)address);
990
991 release:
Jean Delvare197027e2010-02-05 19:58:36 +0100992 for (port--; port >= address; port--)
993 release_region(port, 1);
Jean Delvarec40769f2007-05-08 17:22:00 +0200994 return found;
995}
996
997static int __init lm78_isa_device_add(unsigned short address)
998{
999 struct resource res = {
1000 .start = address,
Jean Delvare15bde2f2007-08-29 10:39:57 +02001001 .end = address + LM78_EXTENT - 1,
Jean Delvarec40769f2007-05-08 17:22:00 +02001002 .name = "lm78",
1003 .flags = IORESOURCE_IO,
1004 };
1005 int err;
1006
1007 pdev = platform_device_alloc("lm78", address);
1008 if (!pdev) {
1009 err = -ENOMEM;
Joe Perchesce47da72011-01-12 21:55:10 +01001010 pr_err("Device allocation failed\n");
Jean Delvarec40769f2007-05-08 17:22:00 +02001011 goto exit;
1012 }
1013
1014 err = platform_device_add_resources(pdev, &res, 1);
1015 if (err) {
Joe Perchesce47da72011-01-12 21:55:10 +01001016 pr_err("Device resource addition failed (%d)\n", err);
Jean Delvarec40769f2007-05-08 17:22:00 +02001017 goto exit_device_put;
1018 }
1019
1020 err = platform_device_add(pdev);
1021 if (err) {
Joe Perchesce47da72011-01-12 21:55:10 +01001022 pr_err("Device addition failed (%d)\n", err);
Jean Delvarec40769f2007-05-08 17:22:00 +02001023 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
Jean Delvare90534c52011-07-25 21:46:11 +02001035static int __init lm78_isa_register(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036{
Jean Delvarefde09502005-07-19 23:51:07 +02001037 int res;
1038
Jean Delvarec40769f2007-05-08 17:22:00 +02001039 if (lm78_isa_found(isa_address)) {
1040 res = platform_driver_register(&lm78_isa_driver);
1041 if (res)
Jean Delvare18c73f92008-10-17 17:51:15 +02001042 goto exit;
Jean Delvarec40769f2007-05-08 17:22:00 +02001043
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 }
Jean Delvarefde09502005-07-19 23:51:07 +02001049
Jean Delvare90534c52011-07-25 21:46:11 +02001050 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
Guenter Roeck9b030792012-01-14 20:39:24 -08001081 /*
1082 * We register the ISA device first, so that we can skip the
1083 * registration of an I2C interface to the same device.
1084 */
Jean Delvare90534c52011-07-25 21:46:11 +02001085 res = lm78_isa_register();
1086 if (res)
1087 goto exit;
1088
Jean Delvare18c73f92008-10-17 17:51:15 +02001089 res = i2c_add_driver(&lm78_driver);
1090 if (res)
1091 goto exit_unreg_isa_device;
1092
Jean Delvarefde09502005-07-19 23:51:07 +02001093 return 0;
Jean Delvarec40769f2007-05-08 17:22:00 +02001094
Jean Delvare18c73f92008-10-17 17:51:15 +02001095 exit_unreg_isa_device:
Jean Delvare90534c52011-07-25 21:46:11 +02001096 lm78_isa_unregister();
Jean Delvarec40769f2007-05-08 17:22:00 +02001097 exit:
1098 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099}
1100
1101static void __exit sm_lm78_exit(void)
1102{
Jean Delvare90534c52011-07-25 21:46:11 +02001103 lm78_isa_unregister();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 i2c_del_driver(&lm78_driver);
1105}
1106
Jean Delvare156e2d12011-07-25 21:46:11 +02001107MODULE_AUTHOR("Frodo Looijaard, Jean Delvare <khali@linux-fr.org>");
Jean Delvare27fe0482005-07-27 21:30:16 +02001108MODULE_DESCRIPTION("LM78/LM79 driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109MODULE_LICENSE("GPL");
1110
1111module_init(sm_lm78_init);
1112module_exit(sm_lm78_exit);