blob: b4ad598feb6c8ee10b7eb3b05ddfef38cf75fc9a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * lm63.c - driver for the National Semiconductor LM63 temperature sensor
3 * with integrated fan control
Jean Delvare7c81c602014-01-29 20:40:08 +01004 * Copyright (C) 2004-2008 Jean Delvare <jdelvare@suse.de>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Based on the lm90 driver.
6 *
7 * The LM63 is a sensor chip made by National Semiconductor. It measures
8 * two temperatures (its own and one external one) and the speed of one
9 * fan, those speed it can additionally control. Complete datasheet can be
10 * obtained from National's website at:
11 * http://www.national.com/pf/LM/LM63.html
12 *
13 * The LM63 is basically an LM86 with fan speed monitoring and control
14 * capabilities added. It misses some of the LM86 features though:
15 * - No low limit for local temperature.
16 * - No critical limit for local temperature.
17 * - Critical limit for remote temperature can be changed only once. We
18 * will consider that the critical limit is read-only.
19 *
20 * The datasheet isn't very clear about what the tachometer reading is.
21 * I had a explanation from National Semiconductor though. The two lower
22 * bits of the read value have to be masked out. The value is still 16 bit
23 * in width.
24 *
25 * This program is free software; you can redistribute it and/or modify
26 * it under the terms of the GNU General Public License as published by
27 * the Free Software Foundation; either version 2 of the License, or
28 * (at your option) any later version.
29 *
30 * This program is distributed in the hope that it will be useful,
31 * but WITHOUT ANY WARRANTY; without even the implied warranty of
32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33 * GNU General Public License for more details.
34 *
35 * You should have received a copy of the GNU General Public License
36 * along with this program; if not, write to the Free Software
37 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
38 */
39
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/module.h>
41#include <linux/init.h>
42#include <linux/slab.h>
43#include <linux/jiffies.h>
44#include <linux/i2c.h>
Jean Delvare10c08f82005-06-06 19:34:45 +020045#include <linux/hwmon-sysfs.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040046#include <linux/hwmon.h>
47#include <linux/err.h>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010048#include <linux/mutex.h>
Jean Delvare0e39e012006-09-24 21:16:40 +020049#include <linux/sysfs.h>
Guenter Roeck210961c2012-01-16 22:51:45 +010050#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52/*
53 * Addresses to scan
Jean Delvared93ab782012-01-16 22:51:47 +010054 * Address is fully defined internally and cannot be changed except for
55 * LM64 which has one pin dedicated to address selection.
56 * LM63 and LM96163 have address 0x4c.
57 * LM64 can have address 0x18 or 0x4e.
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 */
59
Matthew Garrett10f2ed32010-05-27 19:58:38 +020060static const unsigned short normal_i2c[] = { 0x18, 0x4c, 0x4e, I2C_CLIENT_END };
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 * The LM63 registers
64 */
65
66#define LM63_REG_CONFIG1 0x03
Guenter Roeck04738b22012-01-16 22:51:46 +010067#define LM63_REG_CONVRATE 0x04
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#define LM63_REG_CONFIG2 0xBF
69#define LM63_REG_CONFIG_FAN 0x4A
70
71#define LM63_REG_TACH_COUNT_MSB 0x47
72#define LM63_REG_TACH_COUNT_LSB 0x46
73#define LM63_REG_TACH_LIMIT_MSB 0x49
74#define LM63_REG_TACH_LIMIT_LSB 0x48
75
76#define LM63_REG_PWM_VALUE 0x4C
77#define LM63_REG_PWM_FREQ 0x4D
Jean Delvared216f682012-01-16 22:51:47 +010078#define LM63_REG_LUT_TEMP_HYST 0x4F
79#define LM63_REG_LUT_TEMP(nr) (0x50 + 2 * (nr))
80#define LM63_REG_LUT_PWM(nr) (0x51 + 2 * (nr))
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82#define LM63_REG_LOCAL_TEMP 0x00
83#define LM63_REG_LOCAL_HIGH 0x05
84
85#define LM63_REG_REMOTE_TEMP_MSB 0x01
86#define LM63_REG_REMOTE_TEMP_LSB 0x10
87#define LM63_REG_REMOTE_OFFSET_MSB 0x11
88#define LM63_REG_REMOTE_OFFSET_LSB 0x12
89#define LM63_REG_REMOTE_HIGH_MSB 0x07
90#define LM63_REG_REMOTE_HIGH_LSB 0x13
91#define LM63_REG_REMOTE_LOW_MSB 0x08
92#define LM63_REG_REMOTE_LOW_LSB 0x14
93#define LM63_REG_REMOTE_TCRIT 0x19
94#define LM63_REG_REMOTE_TCRIT_HYST 0x21
95
96#define LM63_REG_ALERT_STATUS 0x02
97#define LM63_REG_ALERT_MASK 0x16
98
99#define LM63_REG_MAN_ID 0xFE
100#define LM63_REG_CHIP_ID 0xFF
101
Guenter Roeckf496b2d2012-01-16 22:51:46 +0100102#define LM96163_REG_TRUTHERM 0x30
Guenter Roecke872c912012-01-16 22:51:46 +0100103#define LM96163_REG_REMOTE_TEMP_U_MSB 0x31
104#define LM96163_REG_REMOTE_TEMP_U_LSB 0x32
Guenter Roeck210961c2012-01-16 22:51:45 +0100105#define LM96163_REG_CONFIG_ENHANCED 0x45
106
Guenter Roeck04738b22012-01-16 22:51:46 +0100107#define LM63_MAX_CONVRATE 9
108
109#define LM63_MAX_CONVRATE_HZ 32
110#define LM96163_MAX_CONVRATE_HZ 26
111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112/*
113 * Conversions and various macros
114 * For tachometer counts, the LM63 uses 16-bit values.
115 * For local temperature and high limit, remote critical limit and hysteresis
Steven Cole44bbe872005-05-03 18:21:25 -0600116 * value, it uses signed 8-bit values with LSB = 1 degree Celsius.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 * For remote temperature, low and high limits, it uses signed 11-bit values
Steven Cole44bbe872005-05-03 18:21:25 -0600118 * with LSB = 0.125 degree Celsius, left-justified in 16-bit registers.
Dirk Eibach2778fb12011-02-09 04:51:34 -0500119 * For LM64 the actual remote diode temperature is 16 degree Celsius higher
120 * than the register reading. Remote temperature setpoints have to be
121 * adapted accordingly.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 */
123
124#define FAN_FROM_REG(reg) ((reg) == 0xFFFC || (reg) == 0 ? 0 : \
125 5400000 / (reg))
126#define FAN_TO_REG(val) ((val) <= 82 ? 0xFFFC : \
127 (5400000 / (val)) & 0xFFFC)
128#define TEMP8_FROM_REG(reg) ((reg) * 1000)
129#define TEMP8_TO_REG(val) ((val) <= -128000 ? -128 : \
130 (val) >= 127000 ? 127 : \
131 (val) < 0 ? ((val) - 500) / 1000 : \
132 ((val) + 500) / 1000)
Guenter Roeck94e55df2012-01-16 22:51:46 +0100133#define TEMP8U_TO_REG(val) ((val) <= 0 ? 0 : \
134 (val) >= 255000 ? 255 : \
135 ((val) + 500) / 1000)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136#define TEMP11_FROM_REG(reg) ((reg) / 32 * 125)
137#define TEMP11_TO_REG(val) ((val) <= -128000 ? 0x8000 : \
138 (val) >= 127875 ? 0x7FE0 : \
139 (val) < 0 ? ((val) - 62) / 125 * 32 : \
140 ((val) + 62) / 125 * 32)
Guenter Roecke872c912012-01-16 22:51:46 +0100141#define TEMP11U_TO_REG(val) ((val) <= 0 ? 0 : \
142 (val) >= 255875 ? 0xFFE0 : \
143 ((val) + 62) / 125 * 32)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144#define HYST_TO_REG(val) ((val) <= 0 ? 0 : \
145 (val) >= 127000 ? 127 : \
146 ((val) + 500) / 1000)
147
Guenter Roeck04738b22012-01-16 22:51:46 +0100148#define UPDATE_INTERVAL(max, rate) \
149 ((1000 << (LM63_MAX_CONVRATE - (rate))) / (max))
150
Guenter Roeck210961c2012-01-16 22:51:45 +0100151enum chips { lm63, lm64, lm96163 };
Matthew Garrett10f2ed32010-05-27 19:58:38 +0200152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 * Client data (each client gets its own)
155 */
156
157struct lm63_data {
Tony Jones1beeffe2007-08-20 13:46:20 -0700158 struct device *hwmon_dev;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100159 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 char valid; /* zero until following fields are valid */
Jean Delvared216f682012-01-16 22:51:47 +0100161 char lut_valid; /* zero until lut fields are valid */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 unsigned long last_updated; /* in jiffies */
Jean Delvared216f682012-01-16 22:51:47 +0100163 unsigned long lut_last_updated; /* in jiffies */
Guenter Roeck04738b22012-01-16 22:51:46 +0100164 enum chips kind;
Dirk Eibach2778fb12011-02-09 04:51:34 -0500165 int temp2_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Guenter Roeck04738b22012-01-16 22:51:46 +0100167 int update_interval; /* in milliseconds */
168 int max_convrate_hz;
Jean Delvare2fe28ab2012-01-16 22:51:47 +0100169 int lut_size; /* 8 or 12 */
Guenter Roeck04738b22012-01-16 22:51:46 +0100170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 /* registers values */
172 u8 config, config_fan;
Jean Delvarebc51ae12005-06-05 20:32:27 +0200173 u16 fan[2]; /* 0: input
174 1: low limit */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 u8 pwm1_freq;
Jean Delvare2fe28ab2012-01-16 22:51:47 +0100176 u8 pwm1[13]; /* 0: current output
177 1-12: lookup table */
178 s8 temp8[15]; /* 0: local input
Jean Delvarebc51ae12005-06-05 20:32:27 +0200179 1: local high limit
Jean Delvared216f682012-01-16 22:51:47 +0100180 2: remote critical limit
Jean Delvare2fe28ab2012-01-16 22:51:47 +0100181 3-14: lookup table */
Guenter Roeck786375f2012-01-16 22:51:45 +0100182 s16 temp11[4]; /* 0: remote input
Jean Delvarebc51ae12005-06-05 20:32:27 +0200183 1: remote low limit
Guenter Roeck786375f2012-01-16 22:51:45 +0100184 2: remote high limit
185 3: remote offset */
Guenter Roecke872c912012-01-16 22:51:46 +0100186 u16 temp11u; /* remote input (unsigned) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 u8 temp2_crit_hyst;
Jean Delvared216f682012-01-16 22:51:47 +0100188 u8 lut_temp_hyst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 u8 alarms;
Guenter Roeck210961c2012-01-16 22:51:45 +0100190 bool pwm_highres;
Jean Delvared216f682012-01-16 22:51:47 +0100191 bool lut_temp_highres;
Guenter Roecke872c912012-01-16 22:51:46 +0100192 bool remote_unsigned; /* true if unsigned remote upper limits */
Guenter Roeckf496b2d2012-01-16 22:51:46 +0100193 bool trutherm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194};
195
Guenter Roecke872c912012-01-16 22:51:46 +0100196static inline int temp8_from_reg(struct lm63_data *data, int nr)
197{
198 if (data->remote_unsigned)
199 return TEMP8_FROM_REG((u8)data->temp8[nr]);
200 return TEMP8_FROM_REG(data->temp8[nr]);
201}
202
Jean Delvared216f682012-01-16 22:51:47 +0100203static inline int lut_temp_from_reg(struct lm63_data *data, int nr)
204{
205 return data->temp8[nr] * (data->lut_temp_highres ? 500 : 1000);
206}
207
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100208static inline int lut_temp_to_reg(struct lm63_data *data, long val)
209{
210 val -= data->temp2_offset;
211 if (data->lut_temp_highres)
Guenter Roeck2a844c12013-01-09 08:09:34 -0800212 return DIV_ROUND_CLOSEST(clamp_val(val, 0, 127500), 500);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100213 else
Guenter Roeck2a844c12013-01-09 08:09:34 -0800214 return DIV_ROUND_CLOSEST(clamp_val(val, 0, 127000), 1000);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100215}
216
Jean Delvare817c6cc2012-03-23 10:02:19 +0100217/*
218 * Update the lookup table register cache.
219 * client->update_lock must be held when calling this function.
220 */
221static void lm63_update_lut(struct i2c_client *client)
222{
223 struct lm63_data *data = i2c_get_clientdata(client);
224 int i;
225
226 if (time_after(jiffies, data->lut_last_updated + 5 * HZ) ||
227 !data->lut_valid) {
228 for (i = 0; i < data->lut_size; i++) {
229 data->pwm1[1 + i] = i2c_smbus_read_byte_data(client,
230 LM63_REG_LUT_PWM(i));
231 data->temp8[3 + i] = i2c_smbus_read_byte_data(client,
232 LM63_REG_LUT_TEMP(i));
233 }
234 data->lut_temp_hyst = i2c_smbus_read_byte_data(client,
235 LM63_REG_LUT_TEMP_HYST);
236
237 data->lut_last_updated = jiffies;
238 data->lut_valid = 1;
239 }
240}
241
Jean Delvaredac27dc2012-03-23 10:02:18 +0100242static struct lm63_data *lm63_update_device(struct device *dev)
243{
244 struct i2c_client *client = to_i2c_client(dev);
245 struct lm63_data *data = i2c_get_clientdata(client);
246 unsigned long next_update;
Jean Delvaredac27dc2012-03-23 10:02:18 +0100247
248 mutex_lock(&data->update_lock);
249
Jean Delvare5b0620d2013-07-08 14:18:24 +0200250 next_update = data->last_updated +
251 msecs_to_jiffies(data->update_interval);
Jean Delvaredac27dc2012-03-23 10:02:18 +0100252 if (time_after(jiffies, next_update) || !data->valid) {
253 if (data->config & 0x04) { /* tachometer enabled */
254 /* order matters for fan1_input */
255 data->fan[0] = i2c_smbus_read_byte_data(client,
256 LM63_REG_TACH_COUNT_LSB) & 0xFC;
257 data->fan[0] |= i2c_smbus_read_byte_data(client,
258 LM63_REG_TACH_COUNT_MSB) << 8;
259 data->fan[1] = (i2c_smbus_read_byte_data(client,
260 LM63_REG_TACH_LIMIT_LSB) & 0xFC)
261 | (i2c_smbus_read_byte_data(client,
262 LM63_REG_TACH_LIMIT_MSB) << 8);
263 }
264
265 data->pwm1_freq = i2c_smbus_read_byte_data(client,
266 LM63_REG_PWM_FREQ);
267 if (data->pwm1_freq == 0)
268 data->pwm1_freq = 1;
269 data->pwm1[0] = i2c_smbus_read_byte_data(client,
270 LM63_REG_PWM_VALUE);
271
272 data->temp8[0] = i2c_smbus_read_byte_data(client,
273 LM63_REG_LOCAL_TEMP);
274 data->temp8[1] = i2c_smbus_read_byte_data(client,
275 LM63_REG_LOCAL_HIGH);
276
277 /* order matters for temp2_input */
278 data->temp11[0] = i2c_smbus_read_byte_data(client,
279 LM63_REG_REMOTE_TEMP_MSB) << 8;
280 data->temp11[0] |= i2c_smbus_read_byte_data(client,
281 LM63_REG_REMOTE_TEMP_LSB);
282 data->temp11[1] = (i2c_smbus_read_byte_data(client,
283 LM63_REG_REMOTE_LOW_MSB) << 8)
284 | i2c_smbus_read_byte_data(client,
285 LM63_REG_REMOTE_LOW_LSB);
286 data->temp11[2] = (i2c_smbus_read_byte_data(client,
287 LM63_REG_REMOTE_HIGH_MSB) << 8)
288 | i2c_smbus_read_byte_data(client,
289 LM63_REG_REMOTE_HIGH_LSB);
290 data->temp11[3] = (i2c_smbus_read_byte_data(client,
291 LM63_REG_REMOTE_OFFSET_MSB) << 8)
292 | i2c_smbus_read_byte_data(client,
293 LM63_REG_REMOTE_OFFSET_LSB);
294
295 if (data->kind == lm96163)
296 data->temp11u = (i2c_smbus_read_byte_data(client,
297 LM96163_REG_REMOTE_TEMP_U_MSB) << 8)
298 | i2c_smbus_read_byte_data(client,
299 LM96163_REG_REMOTE_TEMP_U_LSB);
300
301 data->temp8[2] = i2c_smbus_read_byte_data(client,
302 LM63_REG_REMOTE_TCRIT);
303 data->temp2_crit_hyst = i2c_smbus_read_byte_data(client,
304 LM63_REG_REMOTE_TCRIT_HYST);
305
306 data->alarms = i2c_smbus_read_byte_data(client,
307 LM63_REG_ALERT_STATUS) & 0x7F;
308
309 data->last_updated = jiffies;
310 data->valid = 1;
311 }
312
Jean Delvare817c6cc2012-03-23 10:02:19 +0100313 lm63_update_lut(client);
Jean Delvaredac27dc2012-03-23 10:02:18 +0100314
315 mutex_unlock(&data->update_lock);
316
317 return data;
318}
319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320/*
Jean Delvare817c6cc2012-03-23 10:02:19 +0100321 * Trip points in the lookup table should be in ascending order for both
322 * temperatures and PWM output values.
323 */
324static int lm63_lut_looks_bad(struct i2c_client *client)
325{
326 struct lm63_data *data = i2c_get_clientdata(client);
327 int i;
328
329 mutex_lock(&data->update_lock);
330 lm63_update_lut(client);
331
332 for (i = 1; i < data->lut_size; i++) {
333 if (data->pwm1[1 + i - 1] > data->pwm1[1 + i]
334 || data->temp8[3 + i - 1] > data->temp8[3 + i]) {
335 dev_warn(&client->dev,
336 "Lookup table doesn't look sane (check entries %d and %d)\n",
337 i, i + 1);
338 break;
339 }
340 }
341 mutex_unlock(&data->update_lock);
342
343 return i == data->lut_size ? 0 : 1;
344}
345
346/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 * Sysfs callback functions and files
348 */
349
Jean Delvarebc51ae12005-06-05 20:32:27 +0200350static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
351 char *buf)
352{
353 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
354 struct lm63_data *data = lm63_update_device(dev);
355 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Jean Delvarebc51ae12005-06-05 20:32:27 +0200358static ssize_t set_fan(struct device *dev, struct device_attribute *dummy,
359 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
361 struct i2c_client *client = to_i2c_client(dev);
362 struct lm63_data *data = i2c_get_clientdata(client);
Guenter Roeck662bda22012-01-16 22:51:45 +0100363 unsigned long val;
364 int err;
365
366 err = kstrtoul(buf, 10, &val);
367 if (err)
368 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100370 mutex_lock(&data->update_lock);
Jean Delvarebc51ae12005-06-05 20:32:27 +0200371 data->fan[1] = FAN_TO_REG(val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_LSB,
Jean Delvarebc51ae12005-06-05 20:32:27 +0200373 data->fan[1] & 0xFF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 i2c_smbus_write_byte_data(client, LM63_REG_TACH_LIMIT_MSB,
Jean Delvarebc51ae12005-06-05 20:32:27 +0200375 data->fan[1] >> 8);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100376 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return count;
378}
379
Jean Delvared216f682012-01-16 22:51:47 +0100380static ssize_t show_pwm1(struct device *dev, struct device_attribute *devattr,
Jean Delvarebc51ae12005-06-05 20:32:27 +0200381 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382{
Jean Delvared216f682012-01-16 22:51:47 +0100383 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 struct lm63_data *data = lm63_update_device(dev);
Jean Delvared216f682012-01-16 22:51:47 +0100385 int nr = attr->index;
Guenter Roeck210961c2012-01-16 22:51:45 +0100386 int pwm;
387
388 if (data->pwm_highres)
Jean Delvared216f682012-01-16 22:51:47 +0100389 pwm = data->pwm1[nr];
Guenter Roeck210961c2012-01-16 22:51:45 +0100390 else
Jean Delvared216f682012-01-16 22:51:47 +0100391 pwm = data->pwm1[nr] >= 2 * data->pwm1_freq ?
392 255 : (data->pwm1[nr] * 255 + data->pwm1_freq) /
Guenter Roeck210961c2012-01-16 22:51:45 +0100393 (2 * data->pwm1_freq);
394
395 return sprintf(buf, "%d\n", pwm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396}
397
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100398static ssize_t set_pwm1(struct device *dev, struct device_attribute *devattr,
Jean Delvarebc51ae12005-06-05 20:32:27 +0200399 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100401 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 struct i2c_client *client = to_i2c_client(dev);
403 struct lm63_data *data = i2c_get_clientdata(client);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100404 int nr = attr->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 unsigned long val;
Guenter Roeck662bda22012-01-16 22:51:45 +0100406 int err;
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100407 u8 reg;
Guenter Roeck662bda22012-01-16 22:51:45 +0100408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 if (!(data->config_fan & 0x20)) /* register is read-only */
410 return -EPERM;
411
Guenter Roeck662bda22012-01-16 22:51:45 +0100412 err = kstrtoul(buf, 10, &val);
413 if (err)
414 return err;
415
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100416 reg = nr ? LM63_REG_LUT_PWM(nr - 1) : LM63_REG_PWM_VALUE;
Guenter Roeck2a844c12013-01-09 08:09:34 -0800417 val = clamp_val(val, 0, 255);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100418
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100419 mutex_lock(&data->update_lock);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100420 data->pwm1[nr] = data->pwm_highres ? val :
Jean Delvared216f682012-01-16 22:51:47 +0100421 (val * data->pwm1_freq * 2 + 127) / 255;
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100422 i2c_smbus_write_byte_data(client, reg, data->pwm1[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100423 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 return count;
425}
426
Guenter Roeck662bda22012-01-16 22:51:45 +0100427static ssize_t show_pwm1_enable(struct device *dev,
428 struct device_attribute *dummy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429{
430 struct lm63_data *data = lm63_update_device(dev);
431 return sprintf(buf, "%d\n", data->config_fan & 0x20 ? 1 : 2);
432}
433
Jean Delvare817c6cc2012-03-23 10:02:19 +0100434static ssize_t set_pwm1_enable(struct device *dev,
435 struct device_attribute *dummy,
436 const char *buf, size_t count)
437{
438 struct i2c_client *client = to_i2c_client(dev);
439 struct lm63_data *data = i2c_get_clientdata(client);
440 unsigned long val;
441 int err;
442
443 err = kstrtoul(buf, 10, &val);
444 if (err)
445 return err;
446 if (val < 1 || val > 2)
447 return -EINVAL;
448
449 /*
450 * Only let the user switch to automatic mode if the lookup table
451 * looks sane.
452 */
453 if (val == 2 && lm63_lut_looks_bad(client))
454 return -EPERM;
455
456 mutex_lock(&data->update_lock);
457 data->config_fan = i2c_smbus_read_byte_data(client,
458 LM63_REG_CONFIG_FAN);
459 if (val == 1)
460 data->config_fan |= 0x20;
461 else
462 data->config_fan &= ~0x20;
463 i2c_smbus_write_byte_data(client, LM63_REG_CONFIG_FAN,
464 data->config_fan);
465 mutex_unlock(&data->update_lock);
466 return count;
467}
468
Dirk Eibach2778fb12011-02-09 04:51:34 -0500469/*
470 * There are 8bit registers for both local(temp1) and remote(temp2) sensor.
471 * For remote sensor registers temp2_offset has to be considered,
472 * for local sensor it must not.
473 * So we need separate 8bit accessors for local and remote sensor.
474 */
475static ssize_t show_local_temp8(struct device *dev,
476 struct device_attribute *devattr,
477 char *buf)
Jean Delvarebc51ae12005-06-05 20:32:27 +0200478{
479 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
480 struct lm63_data *data = lm63_update_device(dev);
481 return sprintf(buf, "%d\n", TEMP8_FROM_REG(data->temp8[attr->index]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
Dirk Eibach2778fb12011-02-09 04:51:34 -0500484static ssize_t show_remote_temp8(struct device *dev,
485 struct device_attribute *devattr,
486 char *buf)
487{
488 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
489 struct lm63_data *data = lm63_update_device(dev);
Guenter Roecke872c912012-01-16 22:51:46 +0100490 return sprintf(buf, "%d\n", temp8_from_reg(data, attr->index)
Dirk Eibach2778fb12011-02-09 04:51:34 -0500491 + data->temp2_offset);
492}
493
Jean Delvared216f682012-01-16 22:51:47 +0100494static ssize_t show_lut_temp(struct device *dev,
495 struct device_attribute *devattr,
496 char *buf)
497{
498 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
499 struct lm63_data *data = lm63_update_device(dev);
500 return sprintf(buf, "%d\n", lut_temp_from_reg(data, attr->index)
501 + data->temp2_offset);
502}
503
Guenter Roeck94e55df2012-01-16 22:51:46 +0100504static ssize_t set_temp8(struct device *dev, struct device_attribute *devattr,
505 const char *buf, size_t count)
Jean Delvarebc51ae12005-06-05 20:32:27 +0200506{
Guenter Roeck94e55df2012-01-16 22:51:46 +0100507 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
Jean Delvarebc51ae12005-06-05 20:32:27 +0200508 struct i2c_client *client = to_i2c_client(dev);
509 struct lm63_data *data = i2c_get_clientdata(client);
Guenter Roeck94e55df2012-01-16 22:51:46 +0100510 int nr = attr->index;
Guenter Roeck662bda22012-01-16 22:51:45 +0100511 long val;
512 int err;
Guenter Roeck94e55df2012-01-16 22:51:46 +0100513 int temp;
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100514 u8 reg;
Guenter Roeck662bda22012-01-16 22:51:45 +0100515
516 err = kstrtol(buf, 10, &val);
517 if (err)
518 return err;
Jean Delvarebc51ae12005-06-05 20:32:27 +0200519
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100520 mutex_lock(&data->update_lock);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100521 switch (nr) {
522 case 2:
523 reg = LM63_REG_REMOTE_TCRIT;
Guenter Roeck94e55df2012-01-16 22:51:46 +0100524 if (data->remote_unsigned)
525 temp = TEMP8U_TO_REG(val - data->temp2_offset);
526 else
527 temp = TEMP8_TO_REG(val - data->temp2_offset);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100528 break;
529 case 1:
530 reg = LM63_REG_LOCAL_HIGH;
Guenter Roeck94e55df2012-01-16 22:51:46 +0100531 temp = TEMP8_TO_REG(val);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100532 break;
533 default: /* lookup table */
534 reg = LM63_REG_LUT_TEMP(nr - 3);
535 temp = lut_temp_to_reg(data, val);
Guenter Roeck94e55df2012-01-16 22:51:46 +0100536 }
537 data->temp8[nr] = temp;
538 i2c_smbus_write_byte_data(client, reg, temp);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100539 mutex_unlock(&data->update_lock);
Jean Delvarebc51ae12005-06-05 20:32:27 +0200540 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541}
Jean Delvarebc51ae12005-06-05 20:32:27 +0200542
543static ssize_t show_temp11(struct device *dev, struct device_attribute *devattr,
544 char *buf)
545{
546 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
547 struct lm63_data *data = lm63_update_device(dev);
Guenter Roecke872c912012-01-16 22:51:46 +0100548 int nr = attr->index;
549 int temp;
550
551 if (!nr) {
552 /*
553 * Use unsigned temperature unless its value is zero.
554 * If it is zero, use signed temperature.
555 */
556 if (data->temp11u)
557 temp = TEMP11_FROM_REG(data->temp11u);
558 else
559 temp = TEMP11_FROM_REG(data->temp11[nr]);
560 } else {
561 if (data->remote_unsigned && nr == 2)
562 temp = TEMP11_FROM_REG((u16)data->temp11[nr]);
563 else
564 temp = TEMP11_FROM_REG(data->temp11[nr]);
565 }
566 return sprintf(buf, "%d\n", temp + data->temp2_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
Jean Delvarebc51ae12005-06-05 20:32:27 +0200568
569static ssize_t set_temp11(struct device *dev, struct device_attribute *devattr,
570 const char *buf, size_t count)
571{
Guenter Roeck786375f2012-01-16 22:51:45 +0100572 static const u8 reg[6] = {
Jean Delvarebc51ae12005-06-05 20:32:27 +0200573 LM63_REG_REMOTE_LOW_MSB,
574 LM63_REG_REMOTE_LOW_LSB,
575 LM63_REG_REMOTE_HIGH_MSB,
576 LM63_REG_REMOTE_HIGH_LSB,
Guenter Roeck786375f2012-01-16 22:51:45 +0100577 LM63_REG_REMOTE_OFFSET_MSB,
578 LM63_REG_REMOTE_OFFSET_LSB,
Jean Delvarebc51ae12005-06-05 20:32:27 +0200579 };
580
581 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
582 struct i2c_client *client = to_i2c_client(dev);
583 struct lm63_data *data = i2c_get_clientdata(client);
Guenter Roeck662bda22012-01-16 22:51:45 +0100584 long val;
585 int err;
Jean Delvarebc51ae12005-06-05 20:32:27 +0200586 int nr = attr->index;
587
Guenter Roeck662bda22012-01-16 22:51:45 +0100588 err = kstrtol(buf, 10, &val);
589 if (err)
590 return err;
591
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100592 mutex_lock(&data->update_lock);
Guenter Roecke872c912012-01-16 22:51:46 +0100593 if (data->remote_unsigned && nr == 2)
594 data->temp11[nr] = TEMP11U_TO_REG(val - data->temp2_offset);
595 else
596 data->temp11[nr] = TEMP11_TO_REG(val - data->temp2_offset);
597
Jean Delvarebc51ae12005-06-05 20:32:27 +0200598 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2],
599 data->temp11[nr] >> 8);
600 i2c_smbus_write_byte_data(client, reg[(nr - 1) * 2 + 1],
601 data->temp11[nr] & 0xff);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100602 mutex_unlock(&data->update_lock);
Jean Delvarebc51ae12005-06-05 20:32:27 +0200603 return count;
604}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
Guenter Roeck662bda22012-01-16 22:51:45 +0100606/*
607 * Hysteresis register holds a relative value, while we want to present
608 * an absolute to user-space
609 */
610static ssize_t show_temp2_crit_hyst(struct device *dev,
611 struct device_attribute *dummy, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
613 struct lm63_data *data = lm63_update_device(dev);
Guenter Roecke872c912012-01-16 22:51:46 +0100614 return sprintf(buf, "%d\n", temp8_from_reg(data, 2)
Dirk Eibach2778fb12011-02-09 04:51:34 -0500615 + data->temp2_offset
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 - TEMP8_FROM_REG(data->temp2_crit_hyst));
617}
618
Jean Delvared216f682012-01-16 22:51:47 +0100619static ssize_t show_lut_temp_hyst(struct device *dev,
620 struct device_attribute *devattr, char *buf)
621{
622 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
623 struct lm63_data *data = lm63_update_device(dev);
624
625 return sprintf(buf, "%d\n", lut_temp_from_reg(data, attr->index)
626 + data->temp2_offset
627 - TEMP8_FROM_REG(data->lut_temp_hyst));
628}
629
Guenter Roeck662bda22012-01-16 22:51:45 +0100630/*
631 * And now the other way around, user-space provides an absolute
632 * hysteresis value and we have to store a relative one
633 */
634static ssize_t set_temp2_crit_hyst(struct device *dev,
635 struct device_attribute *dummy,
Jean Delvarebc51ae12005-06-05 20:32:27 +0200636 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637{
638 struct i2c_client *client = to_i2c_client(dev);
639 struct lm63_data *data = i2c_get_clientdata(client);
Guenter Roeck662bda22012-01-16 22:51:45 +0100640 long val;
641 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 long hyst;
643
Guenter Roeck662bda22012-01-16 22:51:45 +0100644 err = kstrtol(buf, 10, &val);
645 if (err)
646 return err;
647
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100648 mutex_lock(&data->update_lock);
Guenter Roecke872c912012-01-16 22:51:46 +0100649 hyst = temp8_from_reg(data, 2) + data->temp2_offset - val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 i2c_smbus_write_byte_data(client, LM63_REG_REMOTE_TCRIT_HYST,
651 HYST_TO_REG(hyst));
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100652 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 return count;
654}
655
Guenter Roeck04738b22012-01-16 22:51:46 +0100656/*
657 * Set conversion rate.
658 * client->update_lock must be held when calling this function.
659 */
660static void lm63_set_convrate(struct i2c_client *client, struct lm63_data *data,
661 unsigned int interval)
662{
663 int i;
664 unsigned int update_interval;
665
666 /* Shift calculations to avoid rounding errors */
667 interval <<= 6;
668
669 /* find the nearest update rate */
670 update_interval = (1 << (LM63_MAX_CONVRATE + 6)) * 1000
671 / data->max_convrate_hz;
672 for (i = 0; i < LM63_MAX_CONVRATE; i++, update_interval >>= 1)
673 if (interval >= update_interval * 3 / 4)
674 break;
675
676 i2c_smbus_write_byte_data(client, LM63_REG_CONVRATE, i);
677 data->update_interval = UPDATE_INTERVAL(data->max_convrate_hz, i);
678}
679
680static ssize_t show_update_interval(struct device *dev,
681 struct device_attribute *attr, char *buf)
682{
683 struct lm63_data *data = dev_get_drvdata(dev);
684
685 return sprintf(buf, "%u\n", data->update_interval);
686}
687
688static ssize_t set_update_interval(struct device *dev,
689 struct device_attribute *attr,
690 const char *buf, size_t count)
691{
692 struct i2c_client *client = to_i2c_client(dev);
693 struct lm63_data *data = i2c_get_clientdata(client);
694 unsigned long val;
695 int err;
696
697 err = kstrtoul(buf, 10, &val);
698 if (err)
699 return err;
700
701 mutex_lock(&data->update_lock);
Guenter Roeck2a844c12013-01-09 08:09:34 -0800702 lm63_set_convrate(client, data, clamp_val(val, 0, 100000));
Guenter Roeck04738b22012-01-16 22:51:46 +0100703 mutex_unlock(&data->update_lock);
704
705 return count;
706}
707
Guenter Roeckf496b2d2012-01-16 22:51:46 +0100708static ssize_t show_type(struct device *dev, struct device_attribute *attr,
709 char *buf)
710{
711 struct i2c_client *client = to_i2c_client(dev);
712 struct lm63_data *data = i2c_get_clientdata(client);
713
714 return sprintf(buf, data->trutherm ? "1\n" : "2\n");
715}
716
717static ssize_t set_type(struct device *dev, struct device_attribute *attr,
718 const char *buf, size_t count)
719{
720 struct i2c_client *client = to_i2c_client(dev);
721 struct lm63_data *data = i2c_get_clientdata(client);
722 unsigned long val;
723 int ret;
724 u8 reg;
725
726 ret = kstrtoul(buf, 10, &val);
727 if (ret < 0)
728 return ret;
729 if (val != 1 && val != 2)
730 return -EINVAL;
731
732 mutex_lock(&data->update_lock);
733 data->trutherm = val == 1;
734 reg = i2c_smbus_read_byte_data(client, LM96163_REG_TRUTHERM) & ~0x02;
735 i2c_smbus_write_byte_data(client, LM96163_REG_TRUTHERM,
736 reg | (data->trutherm ? 0x02 : 0x00));
737 data->valid = 0;
738 mutex_unlock(&data->update_lock);
739
740 return count;
741}
742
Jean Delvarebc51ae12005-06-05 20:32:27 +0200743static ssize_t show_alarms(struct device *dev, struct device_attribute *dummy,
744 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745{
746 struct lm63_data *data = lm63_update_device(dev);
747 return sprintf(buf, "%u\n", data->alarms);
748}
749
Jean Delvare2d457712006-09-24 20:52:15 +0200750static ssize_t show_alarm(struct device *dev, struct device_attribute *devattr,
751 char *buf)
752{
753 struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
754 struct lm63_data *data = lm63_update_device(dev);
755 int bitnr = attr->index;
756
757 return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
758}
759
Jean Delvarebc51ae12005-06-05 20:32:27 +0200760static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
761static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO, show_fan,
762 set_fan, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Jean Delvared216f682012-01-16 22:51:47 +0100764static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm1, set_pwm1, 0);
Jean Delvare817c6cc2012-03-23 10:02:19 +0100765static DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
766 show_pwm1_enable, set_pwm1_enable);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100767static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IWUSR | S_IRUGO,
768 show_pwm1, set_pwm1, 1);
769static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp, S_IWUSR | S_IRUGO,
770 show_lut_temp, set_temp8, 3);
Jean Delvared216f682012-01-16 22:51:47 +0100771static SENSOR_DEVICE_ATTR(pwm1_auto_point1_temp_hyst, S_IRUGO,
772 show_lut_temp_hyst, NULL, 3);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100773static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
774 show_pwm1, set_pwm1, 2);
775static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp, S_IWUSR | S_IRUGO,
776 show_lut_temp, set_temp8, 4);
Jean Delvared216f682012-01-16 22:51:47 +0100777static SENSOR_DEVICE_ATTR(pwm1_auto_point2_temp_hyst, S_IRUGO,
778 show_lut_temp_hyst, NULL, 4);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100779static SENSOR_DEVICE_ATTR(pwm1_auto_point3_pwm, S_IWUSR | S_IRUGO,
780 show_pwm1, set_pwm1, 3);
781static SENSOR_DEVICE_ATTR(pwm1_auto_point3_temp, S_IWUSR | S_IRUGO,
782 show_lut_temp, set_temp8, 5);
Jean Delvared216f682012-01-16 22:51:47 +0100783static SENSOR_DEVICE_ATTR(pwm1_auto_point3_temp_hyst, S_IRUGO,
784 show_lut_temp_hyst, NULL, 5);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100785static SENSOR_DEVICE_ATTR(pwm1_auto_point4_pwm, S_IWUSR | S_IRUGO,
786 show_pwm1, set_pwm1, 4);
787static SENSOR_DEVICE_ATTR(pwm1_auto_point4_temp, S_IWUSR | S_IRUGO,
788 show_lut_temp, set_temp8, 6);
Jean Delvared216f682012-01-16 22:51:47 +0100789static SENSOR_DEVICE_ATTR(pwm1_auto_point4_temp_hyst, S_IRUGO,
790 show_lut_temp_hyst, NULL, 6);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100791static SENSOR_DEVICE_ATTR(pwm1_auto_point5_pwm, S_IWUSR | S_IRUGO,
792 show_pwm1, set_pwm1, 5);
793static SENSOR_DEVICE_ATTR(pwm1_auto_point5_temp, S_IWUSR | S_IRUGO,
794 show_lut_temp, set_temp8, 7);
Jean Delvared216f682012-01-16 22:51:47 +0100795static SENSOR_DEVICE_ATTR(pwm1_auto_point5_temp_hyst, S_IRUGO,
796 show_lut_temp_hyst, NULL, 7);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100797static SENSOR_DEVICE_ATTR(pwm1_auto_point6_pwm, S_IWUSR | S_IRUGO,
798 show_pwm1, set_pwm1, 6);
799static SENSOR_DEVICE_ATTR(pwm1_auto_point6_temp, S_IWUSR | S_IRUGO,
800 show_lut_temp, set_temp8, 8);
Jean Delvared216f682012-01-16 22:51:47 +0100801static SENSOR_DEVICE_ATTR(pwm1_auto_point6_temp_hyst, S_IRUGO,
802 show_lut_temp_hyst, NULL, 8);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100803static SENSOR_DEVICE_ATTR(pwm1_auto_point7_pwm, S_IWUSR | S_IRUGO,
804 show_pwm1, set_pwm1, 7);
805static SENSOR_DEVICE_ATTR(pwm1_auto_point7_temp, S_IWUSR | S_IRUGO,
806 show_lut_temp, set_temp8, 9);
Jean Delvared216f682012-01-16 22:51:47 +0100807static SENSOR_DEVICE_ATTR(pwm1_auto_point7_temp_hyst, S_IRUGO,
808 show_lut_temp_hyst, NULL, 9);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100809static SENSOR_DEVICE_ATTR(pwm1_auto_point8_pwm, S_IWUSR | S_IRUGO,
810 show_pwm1, set_pwm1, 8);
811static SENSOR_DEVICE_ATTR(pwm1_auto_point8_temp, S_IWUSR | S_IRUGO,
812 show_lut_temp, set_temp8, 10);
Jean Delvared216f682012-01-16 22:51:47 +0100813static SENSOR_DEVICE_ATTR(pwm1_auto_point8_temp_hyst, S_IRUGO,
814 show_lut_temp_hyst, NULL, 10);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100815static SENSOR_DEVICE_ATTR(pwm1_auto_point9_pwm, S_IWUSR | S_IRUGO,
816 show_pwm1, set_pwm1, 9);
817static SENSOR_DEVICE_ATTR(pwm1_auto_point9_temp, S_IWUSR | S_IRUGO,
818 show_lut_temp, set_temp8, 11);
Jean Delvare2fe28ab2012-01-16 22:51:47 +0100819static SENSOR_DEVICE_ATTR(pwm1_auto_point9_temp_hyst, S_IRUGO,
820 show_lut_temp_hyst, NULL, 11);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100821static SENSOR_DEVICE_ATTR(pwm1_auto_point10_pwm, S_IWUSR | S_IRUGO,
822 show_pwm1, set_pwm1, 10);
823static SENSOR_DEVICE_ATTR(pwm1_auto_point10_temp, S_IWUSR | S_IRUGO,
824 show_lut_temp, set_temp8, 12);
Jean Delvare2fe28ab2012-01-16 22:51:47 +0100825static SENSOR_DEVICE_ATTR(pwm1_auto_point10_temp_hyst, S_IRUGO,
826 show_lut_temp_hyst, NULL, 12);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100827static SENSOR_DEVICE_ATTR(pwm1_auto_point11_pwm, S_IWUSR | S_IRUGO,
828 show_pwm1, set_pwm1, 11);
829static SENSOR_DEVICE_ATTR(pwm1_auto_point11_temp, S_IWUSR | S_IRUGO,
830 show_lut_temp, set_temp8, 13);
Jean Delvare2fe28ab2012-01-16 22:51:47 +0100831static SENSOR_DEVICE_ATTR(pwm1_auto_point11_temp_hyst, S_IRUGO,
832 show_lut_temp_hyst, NULL, 13);
Jean Delvareaf2ef4f2012-03-23 10:02:19 +0100833static SENSOR_DEVICE_ATTR(pwm1_auto_point12_pwm, S_IWUSR | S_IRUGO,
834 show_pwm1, set_pwm1, 12);
835static SENSOR_DEVICE_ATTR(pwm1_auto_point12_temp, S_IWUSR | S_IRUGO,
836 show_lut_temp, set_temp8, 14);
Jean Delvare2fe28ab2012-01-16 22:51:47 +0100837static SENSOR_DEVICE_ATTR(pwm1_auto_point12_temp_hyst, S_IRUGO,
838 show_lut_temp_hyst, NULL, 14);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Dirk Eibach2778fb12011-02-09 04:51:34 -0500840static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_local_temp8, NULL, 0);
841static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_local_temp8,
Guenter Roeck94e55df2012-01-16 22:51:46 +0100842 set_temp8, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Jean Delvarebc51ae12005-06-05 20:32:27 +0200844static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 0);
845static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp11,
846 set_temp11, 1);
847static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp11,
848 set_temp11, 2);
Guenter Roeck786375f2012-01-16 22:51:45 +0100849static SENSOR_DEVICE_ATTR(temp2_offset, S_IWUSR | S_IRUGO, show_temp11,
850 set_temp11, 3);
Dirk Eibach2778fb12011-02-09 04:51:34 -0500851static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO, show_remote_temp8,
Guenter Roeck94e55df2012-01-16 22:51:46 +0100852 set_temp8, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853static DEVICE_ATTR(temp2_crit_hyst, S_IWUSR | S_IRUGO, show_temp2_crit_hyst,
854 set_temp2_crit_hyst);
855
Guenter Roeckf496b2d2012-01-16 22:51:46 +0100856static DEVICE_ATTR(temp2_type, S_IWUSR | S_IRUGO, show_type, set_type);
857
Jean Delvare2d457712006-09-24 20:52:15 +0200858/* Individual alarm files */
859static SENSOR_DEVICE_ATTR(fan1_min_alarm, S_IRUGO, show_alarm, NULL, 0);
860static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 1);
Jean Delvare7817a392007-06-09 10:11:16 -0400861static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);
Jean Delvare2d457712006-09-24 20:52:15 +0200862static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
863static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
864static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
865/* Raw alarm file for compatibility */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
867
Guenter Roeck04738b22012-01-16 22:51:46 +0100868static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
869 set_update_interval);
870
Jean Delvare0e39e012006-09-24 21:16:40 +0200871static struct attribute *lm63_attributes[] = {
Jean Delvared216f682012-01-16 22:51:47 +0100872 &sensor_dev_attr_pwm1.dev_attr.attr,
Jean Delvare0e39e012006-09-24 21:16:40 +0200873 &dev_attr_pwm1_enable.attr,
Jean Delvared216f682012-01-16 22:51:47 +0100874 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
875 &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
876 &sensor_dev_attr_pwm1_auto_point1_temp_hyst.dev_attr.attr,
877 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
878 &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
879 &sensor_dev_attr_pwm1_auto_point2_temp_hyst.dev_attr.attr,
880 &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
881 &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
882 &sensor_dev_attr_pwm1_auto_point3_temp_hyst.dev_attr.attr,
883 &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr,
884 &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr,
885 &sensor_dev_attr_pwm1_auto_point4_temp_hyst.dev_attr.attr,
886 &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr,
887 &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr,
888 &sensor_dev_attr_pwm1_auto_point5_temp_hyst.dev_attr.attr,
889 &sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr,
890 &sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr,
891 &sensor_dev_attr_pwm1_auto_point6_temp_hyst.dev_attr.attr,
892 &sensor_dev_attr_pwm1_auto_point7_pwm.dev_attr.attr,
893 &sensor_dev_attr_pwm1_auto_point7_temp.dev_attr.attr,
894 &sensor_dev_attr_pwm1_auto_point7_temp_hyst.dev_attr.attr,
895 &sensor_dev_attr_pwm1_auto_point8_pwm.dev_attr.attr,
896 &sensor_dev_attr_pwm1_auto_point8_temp.dev_attr.attr,
897 &sensor_dev_attr_pwm1_auto_point8_temp_hyst.dev_attr.attr,
898
Jean Delvare0e39e012006-09-24 21:16:40 +0200899 &sensor_dev_attr_temp1_input.dev_attr.attr,
900 &sensor_dev_attr_temp2_input.dev_attr.attr,
901 &sensor_dev_attr_temp2_min.dev_attr.attr,
902 &sensor_dev_attr_temp1_max.dev_attr.attr,
903 &sensor_dev_attr_temp2_max.dev_attr.attr,
Guenter Roeck786375f2012-01-16 22:51:45 +0100904 &sensor_dev_attr_temp2_offset.dev_attr.attr,
Jean Delvare0e39e012006-09-24 21:16:40 +0200905 &sensor_dev_attr_temp2_crit.dev_attr.attr,
906 &dev_attr_temp2_crit_hyst.attr,
907
908 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
Jean Delvare7817a392007-06-09 10:11:16 -0400909 &sensor_dev_attr_temp2_fault.dev_attr.attr,
Jean Delvare0e39e012006-09-24 21:16:40 +0200910 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
911 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
912 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
913 &dev_attr_alarms.attr,
Guenter Roeck04738b22012-01-16 22:51:46 +0100914 &dev_attr_update_interval.attr,
Jean Delvare0e39e012006-09-24 21:16:40 +0200915 NULL
916};
917
Jean Delvare2fe28ab2012-01-16 22:51:47 +0100918static struct attribute *lm63_attributes_extra_lut[] = {
919 &sensor_dev_attr_pwm1_auto_point9_pwm.dev_attr.attr,
920 &sensor_dev_attr_pwm1_auto_point9_temp.dev_attr.attr,
921 &sensor_dev_attr_pwm1_auto_point9_temp_hyst.dev_attr.attr,
922 &sensor_dev_attr_pwm1_auto_point10_pwm.dev_attr.attr,
923 &sensor_dev_attr_pwm1_auto_point10_temp.dev_attr.attr,
924 &sensor_dev_attr_pwm1_auto_point10_temp_hyst.dev_attr.attr,
925 &sensor_dev_attr_pwm1_auto_point11_pwm.dev_attr.attr,
926 &sensor_dev_attr_pwm1_auto_point11_temp.dev_attr.attr,
927 &sensor_dev_attr_pwm1_auto_point11_temp_hyst.dev_attr.attr,
928 &sensor_dev_attr_pwm1_auto_point12_pwm.dev_attr.attr,
929 &sensor_dev_attr_pwm1_auto_point12_temp.dev_attr.attr,
930 &sensor_dev_attr_pwm1_auto_point12_temp_hyst.dev_attr.attr,
931 NULL
932};
933
934static const struct attribute_group lm63_group_extra_lut = {
935 .attrs = lm63_attributes_extra_lut,
936};
937
Guenter Roeck94e55df2012-01-16 22:51:46 +0100938/*
939 * On LM63, temp2_crit can be set only once, which should be job
940 * of the bootloader.
941 * On LM64, temp2_crit can always be set.
942 * On LM96163, temp2_crit can be set if bit 1 of the configuration
943 * register is true.
944 */
945static umode_t lm63_attribute_mode(struct kobject *kobj,
946 struct attribute *attr, int index)
947{
948 struct device *dev = container_of(kobj, struct device, kobj);
949 struct i2c_client *client = to_i2c_client(dev);
950 struct lm63_data *data = i2c_get_clientdata(client);
951
952 if (attr == &sensor_dev_attr_temp2_crit.dev_attr.attr
953 && (data->kind == lm64 ||
954 (data->kind == lm96163 && (data->config & 0x02))))
955 return attr->mode | S_IWUSR;
956
957 return attr->mode;
958}
959
Jean Delvare0e39e012006-09-24 21:16:40 +0200960static const struct attribute_group lm63_group = {
Guenter Roeck94e55df2012-01-16 22:51:46 +0100961 .is_visible = lm63_attribute_mode,
Jean Delvare0e39e012006-09-24 21:16:40 +0200962 .attrs = lm63_attributes,
963};
964
965static struct attribute *lm63_attributes_fan1[] = {
966 &sensor_dev_attr_fan1_input.dev_attr.attr,
967 &sensor_dev_attr_fan1_min.dev_attr.attr,
968
969 &sensor_dev_attr_fan1_min_alarm.dev_attr.attr,
970 NULL
971};
972
973static const struct attribute_group lm63_group_fan1 = {
974 .attrs = lm63_attributes_fan1,
975};
976
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977/*
978 * Real code
979 */
980
Jean Delvared5957be2008-07-16 19:30:13 +0200981/* Return 0 if detection is successful, -ENODEV otherwise */
Jean Delvaredac27dc2012-03-23 10:02:18 +0100982static int lm63_detect(struct i2c_client *client,
Jean Delvared5957be2008-07-16 19:30:13 +0200983 struct i2c_board_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984{
Jean Delvaredac27dc2012-03-23 10:02:18 +0100985 struct i2c_adapter *adapter = client->adapter;
Jean Delvare52df6442009-12-09 20:35:57 +0100986 u8 man_id, chip_id, reg_config1, reg_config2;
987 u8 reg_alert_status, reg_alert_mask;
Jean Delvaredac27dc2012-03-23 10:02:18 +0100988 int address = client->addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
990 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
Jean Delvared5957be2008-07-16 19:30:13 +0200991 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992
Jean Delvaredac27dc2012-03-23 10:02:18 +0100993 man_id = i2c_smbus_read_byte_data(client, LM63_REG_MAN_ID);
994 chip_id = i2c_smbus_read_byte_data(client, LM63_REG_CHIP_ID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995
Jean Delvaredac27dc2012-03-23 10:02:18 +0100996 reg_config1 = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
997 reg_config2 = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG2);
998 reg_alert_status = i2c_smbus_read_byte_data(client,
Jean Delvare52df6442009-12-09 20:35:57 +0100999 LM63_REG_ALERT_STATUS);
Jean Delvaredac27dc2012-03-23 10:02:18 +01001000 reg_alert_mask = i2c_smbus_read_byte_data(client, LM63_REG_ALERT_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
Jean Delvare52df6442009-12-09 20:35:57 +01001002 if (man_id != 0x01 /* National Semiconductor */
Jean Delvare52df6442009-12-09 20:35:57 +01001003 || (reg_config1 & 0x18) != 0x00
1004 || (reg_config2 & 0xF8) != 0x00
1005 || (reg_alert_status & 0x20) != 0x00
1006 || (reg_alert_mask & 0xA4) != 0xA4) {
1007 dev_dbg(&adapter->dev,
1008 "Unsupported chip (man_id=0x%02X, chip_id=0x%02X)\n",
1009 man_id, chip_id);
1010 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 }
1012
Matthew Garrett10f2ed32010-05-27 19:58:38 +02001013 if (chip_id == 0x41 && address == 0x4c)
1014 strlcpy(info->type, "lm63", I2C_NAME_SIZE);
1015 else if (chip_id == 0x51 && (address == 0x18 || address == 0x4e))
1016 strlcpy(info->type, "lm64", I2C_NAME_SIZE);
Guenter Roeck210961c2012-01-16 22:51:45 +01001017 else if (chip_id == 0x49 && address == 0x4c)
1018 strlcpy(info->type, "lm96163", I2C_NAME_SIZE);
Matthew Garrett10f2ed32010-05-27 19:58:38 +02001019 else
1020 return -ENODEV;
Jean Delvared5957be2008-07-16 19:30:13 +02001021
1022 return 0;
1023}
1024
Guenter Roeck662bda22012-01-16 22:51:45 +01001025/*
1026 * Ideally we shouldn't have to initialize anything, since the BIOS
1027 * should have taken care of everything
1028 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029static void lm63_init_client(struct i2c_client *client)
1030{
1031 struct lm63_data *data = i2c_get_clientdata(client);
Guenter Roeck04738b22012-01-16 22:51:46 +01001032 u8 convrate;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033
1034 data->config = i2c_smbus_read_byte_data(client, LM63_REG_CONFIG1);
1035 data->config_fan = i2c_smbus_read_byte_data(client,
1036 LM63_REG_CONFIG_FAN);
1037
1038 /* Start converting if needed */
1039 if (data->config & 0x40) { /* standby */
Joe Perches898eb712007-10-18 03:06:30 -07001040 dev_dbg(&client->dev, "Switching to operational mode\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 data->config &= 0xA7;
1042 i2c_smbus_write_byte_data(client, LM63_REG_CONFIG1,
1043 data->config);
1044 }
Jean Delvare409c0b52012-01-16 22:51:46 +01001045 /* Tachometer is always enabled on LM64 */
1046 if (data->kind == lm64)
1047 data->config |= 0x04;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048
1049 /* We may need pwm1_freq before ever updating the client data */
1050 data->pwm1_freq = i2c_smbus_read_byte_data(client, LM63_REG_PWM_FREQ);
1051 if (data->pwm1_freq == 0)
1052 data->pwm1_freq = 1;
1053
Guenter Roeck04738b22012-01-16 22:51:46 +01001054 switch (data->kind) {
1055 case lm63:
1056 case lm64:
1057 data->max_convrate_hz = LM63_MAX_CONVRATE_HZ;
Jean Delvare2fe28ab2012-01-16 22:51:47 +01001058 data->lut_size = 8;
Guenter Roeck04738b22012-01-16 22:51:46 +01001059 break;
1060 case lm96163:
1061 data->max_convrate_hz = LM96163_MAX_CONVRATE_HZ;
Jean Delvare2fe28ab2012-01-16 22:51:47 +01001062 data->lut_size = 12;
Guenter Roeckf496b2d2012-01-16 22:51:46 +01001063 data->trutherm
1064 = i2c_smbus_read_byte_data(client,
1065 LM96163_REG_TRUTHERM) & 0x02;
Guenter Roeck04738b22012-01-16 22:51:46 +01001066 break;
1067 }
1068 convrate = i2c_smbus_read_byte_data(client, LM63_REG_CONVRATE);
1069 if (unlikely(convrate > LM63_MAX_CONVRATE))
1070 convrate = LM63_MAX_CONVRATE;
1071 data->update_interval = UPDATE_INTERVAL(data->max_convrate_hz,
1072 convrate);
1073
Guenter Roeck210961c2012-01-16 22:51:45 +01001074 /*
Guenter Roecke872c912012-01-16 22:51:46 +01001075 * For LM96163, check if high resolution PWM
1076 * and unsigned temperature format is enabled.
Guenter Roeck210961c2012-01-16 22:51:45 +01001077 */
1078 if (data->kind == lm96163) {
1079 u8 config_enhanced
1080 = i2c_smbus_read_byte_data(client,
1081 LM96163_REG_CONFIG_ENHANCED);
Jean Delvared216f682012-01-16 22:51:47 +01001082 if (config_enhanced & 0x20)
1083 data->lut_temp_highres = true;
Guenter Roeck210961c2012-01-16 22:51:45 +01001084 if ((config_enhanced & 0x10)
1085 && !(data->config_fan & 0x08) && data->pwm1_freq == 8)
1086 data->pwm_highres = true;
1087 if (config_enhanced & 0x08)
Guenter Roecke872c912012-01-16 22:51:46 +01001088 data->remote_unsigned = true;
Guenter Roeck210961c2012-01-16 22:51:45 +01001089 }
1090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 /* Show some debug info about the LM63 configuration */
Jean Delvare409c0b52012-01-16 22:51:46 +01001092 if (data->kind == lm63)
1093 dev_dbg(&client->dev, "Alert/tach pin configured for %s\n",
1094 (data->config & 0x04) ? "tachometer input" :
1095 "alert output");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 dev_dbg(&client->dev, "PWM clock %s kHz, output frequency %u Hz\n",
1097 (data->config_fan & 0x08) ? "1.4" : "360",
1098 ((data->config_fan & 0x08) ? 700 : 180000) / data->pwm1_freq);
1099 dev_dbg(&client->dev, "PWM output active %s, %s mode\n",
1100 (data->config_fan & 0x10) ? "low" : "high",
1101 (data->config_fan & 0x20) ? "manual" : "auto");
1102}
1103
Jean Delvaredac27dc2012-03-23 10:02:18 +01001104static int lm63_probe(struct i2c_client *client,
1105 const struct i2c_device_id *id)
1106{
1107 struct lm63_data *data;
1108 int err;
1109
Guenter Roeckc5a4a912012-06-02 09:58:08 -07001110 data = devm_kzalloc(&client->dev, sizeof(struct lm63_data), GFP_KERNEL);
1111 if (!data)
1112 return -ENOMEM;
Jean Delvaredac27dc2012-03-23 10:02:18 +01001113
1114 i2c_set_clientdata(client, data);
1115 data->valid = 0;
1116 mutex_init(&data->update_lock);
1117
1118 /* Set the device type */
1119 data->kind = id->driver_data;
1120 if (data->kind == lm64)
1121 data->temp2_offset = 16000;
1122
1123 /* Initialize chip */
1124 lm63_init_client(client);
1125
1126 /* Register sysfs hooks */
1127 err = sysfs_create_group(&client->dev.kobj, &lm63_group);
1128 if (err)
Guenter Roeckc5a4a912012-06-02 09:58:08 -07001129 return err;
Jean Delvaredac27dc2012-03-23 10:02:18 +01001130 if (data->config & 0x04) { /* tachometer enabled */
1131 err = sysfs_create_group(&client->dev.kobj, &lm63_group_fan1);
1132 if (err)
1133 goto exit_remove_files;
1134 }
1135 if (data->kind == lm96163) {
1136 err = device_create_file(&client->dev, &dev_attr_temp2_type);
1137 if (err)
1138 goto exit_remove_files;
1139
1140 err = sysfs_create_group(&client->dev.kobj,
1141 &lm63_group_extra_lut);
1142 if (err)
1143 goto exit_remove_files;
1144 }
1145
1146 data->hwmon_dev = hwmon_device_register(&client->dev);
1147 if (IS_ERR(data->hwmon_dev)) {
1148 err = PTR_ERR(data->hwmon_dev);
1149 goto exit_remove_files;
1150 }
1151
1152 return 0;
1153
1154exit_remove_files:
1155 sysfs_remove_group(&client->dev.kobj, &lm63_group);
1156 sysfs_remove_group(&client->dev.kobj, &lm63_group_fan1);
1157 if (data->kind == lm96163) {
1158 device_remove_file(&client->dev, &dev_attr_temp2_type);
1159 sysfs_remove_group(&client->dev.kobj, &lm63_group_extra_lut);
1160 }
Jean Delvaredac27dc2012-03-23 10:02:18 +01001161 return err;
1162}
1163
Jean Delvared5957be2008-07-16 19:30:13 +02001164static int lm63_remove(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165{
Mark M. Hoffman943b0832005-07-15 21:39:18 -04001166 struct lm63_data *data = i2c_get_clientdata(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
Tony Jones1beeffe2007-08-20 13:46:20 -07001168 hwmon_device_unregister(data->hwmon_dev);
Jean Delvare0e39e012006-09-24 21:16:40 +02001169 sysfs_remove_group(&client->dev.kobj, &lm63_group);
1170 sysfs_remove_group(&client->dev.kobj, &lm63_group_fan1);
Jean Delvare2fe28ab2012-01-16 22:51:47 +01001171 if (data->kind == lm96163) {
1172 device_remove_file(&client->dev, &dev_attr_temp2_type);
1173 sysfs_remove_group(&client->dev.kobj, &lm63_group_extra_lut);
1174 }
Mark M. Hoffman943b0832005-07-15 21:39:18 -04001175
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 return 0;
1177}
1178
Jean Delvaredac27dc2012-03-23 10:02:18 +01001179/*
1180 * Driver data (common to all clients)
1181 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
Jean Delvaredac27dc2012-03-23 10:02:18 +01001183static const struct i2c_device_id lm63_id[] = {
1184 { "lm63", lm63 },
1185 { "lm64", lm64 },
1186 { "lm96163", lm96163 },
1187 { }
1188};
1189MODULE_DEVICE_TABLE(i2c, lm63_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190
Jean Delvaredac27dc2012-03-23 10:02:18 +01001191static struct i2c_driver lm63_driver = {
1192 .class = I2C_CLASS_HWMON,
1193 .driver = {
1194 .name = "lm63",
1195 },
1196 .probe = lm63_probe,
1197 .remove = lm63_remove,
1198 .id_table = lm63_id,
1199 .detect = lm63_detect,
1200 .address_list = normal_i2c,
1201};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202
Axel Linf0967ee2012-01-20 15:38:18 +08001203module_i2c_driver(lm63_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204
Jean Delvare7c81c602014-01-29 20:40:08 +01001205MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206MODULE_DESCRIPTION("LM63 driver");
1207MODULE_LICENSE("GPL");