blob: ac841fa3a369d6edd6afc6c44dad920403202579 [file] [log] [blame]
Thomas Gleixner74ba9202019-05-20 09:19:02 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Guenter Roeckfbb66702012-01-19 11:02:14 -08003 * adm1031.c - Part of lm_sensors, Linux kernel modules for hardware
4 * monitoring
5 * Based on lm75.c and lm85.c
6 * Supports adm1030 / adm1031
7 * Copyright (C) 2004 Alexandre d'Alton <alex@alexdalton.org>
Jean Delvare7c81c60f2014-01-29 20:40:08 +01008 * Reworked by Jean Delvare <jdelvare@suse.de>
Guenter Roeckfbb66702012-01-19 11:02:14 -08009 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
11#include <linux/module.h>
12#include <linux/init.h>
13#include <linux/slab.h>
14#include <linux/jiffies.h>
15#include <linux/i2c.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040016#include <linux/hwmon.h>
Jean Delvarec8010822007-12-02 23:39:38 +010017#include <linux/hwmon-sysfs.h>
Mark M. Hoffman943b0832005-07-15 21:39:18 -040018#include <linux/err.h>
Ingo Molnar9a61bf62006-01-18 23:19:26 +010019#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
21/* Following macros takes channel parameter starting from 0 to 2 */
22#define ADM1031_REG_FAN_SPEED(nr) (0x08 + (nr))
Jean Delvare6d6006b2007-12-02 23:33:57 +010023#define ADM1031_REG_FAN_DIV(nr) (0x20 + (nr))
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#define ADM1031_REG_PWM (0x22)
25#define ADM1031_REG_FAN_MIN(nr) (0x10 + (nr))
Jean Delvare87c33da2010-05-27 19:58:46 +020026#define ADM1031_REG_FAN_FILTER (0x23)
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Ira Snyder49dc9ef2009-09-23 22:59:41 +020028#define ADM1031_REG_TEMP_OFFSET(nr) (0x0d + (nr))
Jean Delvare6d6006b2007-12-02 23:33:57 +010029#define ADM1031_REG_TEMP_MAX(nr) (0x14 + 4 * (nr))
30#define ADM1031_REG_TEMP_MIN(nr) (0x15 + 4 * (nr))
31#define ADM1031_REG_TEMP_CRIT(nr) (0x16 + 4 * (nr))
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Jean Delvare6d6006b2007-12-02 23:33:57 +010033#define ADM1031_REG_TEMP(nr) (0x0a + (nr))
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#define ADM1031_REG_AUTO_TEMP(nr) (0x24 + (nr))
35
36#define ADM1031_REG_STATUS(nr) (0x2 + (nr))
37
Jean Delvare6d6006b2007-12-02 23:33:57 +010038#define ADM1031_REG_CONF1 0x00
39#define ADM1031_REG_CONF2 0x01
40#define ADM1031_REG_EXT_TEMP 0x06
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42#define ADM1031_CONF1_MONITOR_ENABLE 0x01 /* Monitoring enable */
43#define ADM1031_CONF1_PWM_INVERT 0x08 /* PWM Invert */
44#define ADM1031_CONF1_AUTO_MODE 0x80 /* Auto FAN */
45
46#define ADM1031_CONF2_PWM1_ENABLE 0x01
47#define ADM1031_CONF2_PWM2_ENABLE 0x02
48#define ADM1031_CONF2_TACH1_ENABLE 0x04
49#define ADM1031_CONF2_TACH2_ENABLE 0x08
50#define ADM1031_CONF2_TEMP_ENABLE(chan) (0x10 << (chan))
51
Jean Delvare87c33da2010-05-27 19:58:46 +020052#define ADM1031_UPDATE_RATE_MASK 0x1c
53#define ADM1031_UPDATE_RATE_SHIFT 2
54
Linus Torvalds1da177e2005-04-16 15:20:36 -070055/* Addresses to scan */
Mark M. Hoffman25e9c862008-02-17 22:28:03 -050056static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
Jean Delvaree5e9f442009-12-14 21:17:27 +010058enum chips { adm1030, adm1031 };
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60typedef u8 auto_chan_table_t[8][2];
61
62/* Each client has this additional data */
63struct adm1031_data {
Axel Linb060f3c42014-07-03 21:57:44 +080064 struct i2c_client *client;
65 const struct attribute_group *groups[3];
Ingo Molnar9a61bf62006-01-18 23:19:26 +010066 struct mutex update_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 int chip_type;
Paul Fertser952a11c2021-09-24 22:52:02 +030068 bool valid; /* true if following fields are valid */
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 unsigned long last_updated; /* In jiffies */
Guenter Roecka51b9942010-09-17 17:24:14 +020070 unsigned int update_interval; /* In milliseconds */
Guenter Roeckfbb66702012-01-19 11:02:14 -080071 /*
72 * The chan_select_table contains the possible configurations for
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 * auto fan control.
74 */
Jean Delvare6d6006b2007-12-02 23:33:57 +010075 const auto_chan_table_t *chan_select_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 u16 alarm;
77 u8 conf1;
78 u8 conf2;
79 u8 fan[2];
80 u8 fan_div[2];
81 u8 fan_min[2];
82 u8 pwm[2];
83 u8 old_pwm[2];
84 s8 temp[3];
85 u8 ext_temp[3];
86 u8 auto_temp[3];
87 u8 auto_temp_min[3];
88 u8 auto_temp_off[3];
89 u8 auto_temp_max[3];
Ira Snyder49dc9ef2009-09-23 22:59:41 +020090 s8 temp_offset[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 s8 temp_min[3];
92 s8 temp_max[3];
93 s8 temp_crit[3];
94};
95
Linus Torvalds1da177e2005-04-16 15:20:36 -070096static inline u8 adm1031_read_value(struct i2c_client *client, u8 reg)
97{
98 return i2c_smbus_read_byte_data(client, reg);
99}
100
101static inline int
102adm1031_write_value(struct i2c_client *client, u8 reg, unsigned int value)
103{
104 return i2c_smbus_write_byte_data(client, reg, value);
105}
106
Axel Lin278ee1c2014-07-03 21:56:33 +0800107static struct adm1031_data *adm1031_update_device(struct device *dev)
108{
Axel Linb060f3c42014-07-03 21:57:44 +0800109 struct adm1031_data *data = dev_get_drvdata(dev);
110 struct i2c_client *client = data->client;
Axel Lin278ee1c2014-07-03 21:56:33 +0800111 unsigned long next_update;
112 int chan;
113
114 mutex_lock(&data->update_lock);
115
116 next_update = data->last_updated
117 + msecs_to_jiffies(data->update_interval);
118 if (time_after(jiffies, next_update) || !data->valid) {
119
120 dev_dbg(&client->dev, "Starting adm1031 update\n");
121 for (chan = 0;
122 chan < ((data->chip_type == adm1031) ? 3 : 2); chan++) {
123 u8 oldh, newh;
124
125 oldh =
126 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
127 data->ext_temp[chan] =
128 adm1031_read_value(client, ADM1031_REG_EXT_TEMP);
129 newh =
130 adm1031_read_value(client, ADM1031_REG_TEMP(chan));
131 if (newh != oldh) {
132 data->ext_temp[chan] =
133 adm1031_read_value(client,
134 ADM1031_REG_EXT_TEMP);
135#ifdef DEBUG
136 oldh =
137 adm1031_read_value(client,
138 ADM1031_REG_TEMP(chan));
139
140 /* oldh is actually newer */
141 if (newh != oldh)
142 dev_warn(&client->dev,
143 "Remote temperature may be wrong.\n");
144#endif
145 }
146 data->temp[chan] = newh;
147
148 data->temp_offset[chan] =
149 adm1031_read_value(client,
150 ADM1031_REG_TEMP_OFFSET(chan));
151 data->temp_min[chan] =
152 adm1031_read_value(client,
153 ADM1031_REG_TEMP_MIN(chan));
154 data->temp_max[chan] =
155 adm1031_read_value(client,
156 ADM1031_REG_TEMP_MAX(chan));
157 data->temp_crit[chan] =
158 adm1031_read_value(client,
159 ADM1031_REG_TEMP_CRIT(chan));
160 data->auto_temp[chan] =
161 adm1031_read_value(client,
162 ADM1031_REG_AUTO_TEMP(chan));
163
164 }
165
166 data->conf1 = adm1031_read_value(client, ADM1031_REG_CONF1);
167 data->conf2 = adm1031_read_value(client, ADM1031_REG_CONF2);
168
169 data->alarm = adm1031_read_value(client, ADM1031_REG_STATUS(0))
170 | (adm1031_read_value(client, ADM1031_REG_STATUS(1)) << 8);
171 if (data->chip_type == adm1030)
172 data->alarm &= 0xc0ff;
173
174 for (chan = 0; chan < (data->chip_type == adm1030 ? 1 : 2);
175 chan++) {
176 data->fan_div[chan] =
177 adm1031_read_value(client,
178 ADM1031_REG_FAN_DIV(chan));
179 data->fan_min[chan] =
180 adm1031_read_value(client,
181 ADM1031_REG_FAN_MIN(chan));
182 data->fan[chan] =
183 adm1031_read_value(client,
184 ADM1031_REG_FAN_SPEED(chan));
185 data->pwm[chan] =
186 (adm1031_read_value(client,
187 ADM1031_REG_PWM) >> (4 * chan)) & 0x0f;
188 }
189 data->last_updated = jiffies;
Paul Fertser952a11c2021-09-24 22:52:02 +0300190 data->valid = true;
Axel Lin278ee1c2014-07-03 21:56:33 +0800191 }
192
193 mutex_unlock(&data->update_lock);
194
195 return data;
196}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198#define TEMP_TO_REG(val) (((val) < 0 ? ((val - 500) / 1000) : \
199 ((val + 500) / 1000)))
200
201#define TEMP_FROM_REG(val) ((val) * 1000)
202
203#define TEMP_FROM_REG_EXT(val, ext) (TEMP_FROM_REG(val) + (ext) * 125)
204
Ira Snyder49dc9ef2009-09-23 22:59:41 +0200205#define TEMP_OFFSET_TO_REG(val) (TEMP_TO_REG(val) & 0x8f)
206#define TEMP_OFFSET_FROM_REG(val) TEMP_FROM_REG((val) < 0 ? \
207 (val) | 0x70 : (val))
208
Guenter Roeck1c720092012-01-16 22:51:48 +0100209#define FAN_FROM_REG(reg, div) ((reg) ? \
210 (11250 * 60) / ((reg) * (div)) : 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
212static int FAN_TO_REG(int reg, int div)
213{
214 int tmp;
Guenter Roeck2a844c12013-01-09 08:09:34 -0800215 tmp = FAN_FROM_REG(clamp_val(reg, 0, 65535), div);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 return tmp > 255 ? 255 : tmp;
217}
218
219#define FAN_DIV_FROM_REG(reg) (1<<(((reg)&0xc0)>>6))
220
Guenter Roeck2a844c12013-01-09 08:09:34 -0800221#define PWM_TO_REG(val) (clamp_val((val), 0, 255) >> 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222#define PWM_FROM_REG(val) ((val) << 4)
223
224#define FAN_CHAN_FROM_REG(reg) (((reg) >> 5) & 7)
225#define FAN_CHAN_TO_REG(val, reg) \
226 (((reg) & 0x1F) | (((val) << 5) & 0xe0))
227
228#define AUTO_TEMP_MIN_TO_REG(val, reg) \
Guenter Roeck1c720092012-01-16 22:51:48 +0100229 ((((val) / 500) & 0xf8) | ((reg) & 0x7))
230#define AUTO_TEMP_RANGE_FROM_REG(reg) (5000 * (1 << ((reg) & 0x7)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231#define AUTO_TEMP_MIN_FROM_REG(reg) (1000 * ((((reg) >> 3) & 0x1f) << 2))
232
233#define AUTO_TEMP_MIN_FROM_REG_DEG(reg) ((((reg) >> 3) & 0x1f) << 2)
234
235#define AUTO_TEMP_OFF_FROM_REG(reg) \
236 (AUTO_TEMP_MIN_FROM_REG(reg) - 5000)
237
238#define AUTO_TEMP_MAX_FROM_REG(reg) \
239 (AUTO_TEMP_RANGE_FROM_REG(reg) + \
240 AUTO_TEMP_MIN_FROM_REG(reg))
241
242static int AUTO_TEMP_MAX_TO_REG(int val, int reg, int pwm)
243{
244 int ret;
Colin Ian Kingd7555372021-12-04 23:31:55 +0000245 int range = ((val - AUTO_TEMP_MIN_FROM_REG(reg)) * 10) / (16 - pwm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 ret = ((reg & 0xf8) |
248 (range < 10000 ? 0 :
249 range < 20000 ? 1 :
250 range < 40000 ? 2 : range < 80000 ? 3 : 4));
251 return ret;
252}
253
254/* FAN auto control */
255#define GET_FAN_AUTO_BITFIELD(data, idx) \
Guenter Roeck1c720092012-01-16 22:51:48 +0100256 (*(data)->chan_select_table)[FAN_CHAN_FROM_REG((data)->conf1)][idx % 2]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Guenter Roeckfbb66702012-01-19 11:02:14 -0800258/*
259 * The tables below contains the possible values for the auto fan
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 * control bitfields. the index in the table is the register value.
261 * MSb is the auto fan control enable bit, so the four first entries
262 * in the table disables auto fan control when both bitfields are zero.
263 */
Jean Delvare6d6006b2007-12-02 23:33:57 +0100264static const auto_chan_table_t auto_channel_select_table_adm1031 = {
265 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
266 { 2 /* 0b010 */ , 4 /* 0b100 */ },
267 { 2 /* 0b010 */ , 2 /* 0b010 */ },
268 { 4 /* 0b100 */ , 4 /* 0b100 */ },
269 { 7 /* 0b111 */ , 7 /* 0b111 */ },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270};
271
Jean Delvare6d6006b2007-12-02 23:33:57 +0100272static const auto_chan_table_t auto_channel_select_table_adm1030 = {
273 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
274 { 2 /* 0b10 */ , 0 },
275 { 0xff /* invalid */ , 0 },
276 { 0xff /* invalid */ , 0 },
277 { 3 /* 0b11 */ , 0 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278};
279
Guenter Roeckfbb66702012-01-19 11:02:14 -0800280/*
281 * That function checks if a bitfield is valid and returns the other bitfield
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 * nearest match if no exact match where found.
283 */
284static int
Guenter Roeckce15a812012-03-24 08:51:05 -0700285get_fan_auto_nearest(struct adm1031_data *data, int chan, u8 val, u8 reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
287 int i;
288 int first_match = -1, exact_match = -1;
289 u8 other_reg_val =
290 (*data->chan_select_table)[FAN_CHAN_FROM_REG(reg)][chan ? 0 : 1];
291
Guenter Roeckce15a812012-03-24 08:51:05 -0700292 if (val == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
295 for (i = 0; i < 8; i++) {
296 if ((val == (*data->chan_select_table)[i][chan]) &&
297 ((*data->chan_select_table)[i][chan ? 0 : 1] ==
298 other_reg_val)) {
299 /* We found an exact match */
300 exact_match = i;
301 break;
302 } else if (val == (*data->chan_select_table)[i][chan] &&
303 first_match == -1) {
Guenter Roeckfbb66702012-01-19 11:02:14 -0800304 /*
305 * Save the first match in case of an exact match has
Jean Delvare6d6006b2007-12-02 23:33:57 +0100306 * not been found
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 */
308 first_match = i;
309 }
310 }
311
Guenter Roeck1c720092012-01-16 22:51:48 +0100312 if (exact_match >= 0)
Guenter Roeckce15a812012-03-24 08:51:05 -0700313 return exact_match;
Guenter Roeck1c720092012-01-16 22:51:48 +0100314 else if (first_match >= 0)
Guenter Roeckce15a812012-03-24 08:51:05 -0700315 return first_match;
Guenter Roeck1c720092012-01-16 22:51:48 +0100316
Guenter Roeckce15a812012-03-24 08:51:05 -0700317 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
319
Guenter Roeck8e757e12019-01-21 20:37:22 -0800320static ssize_t fan_auto_channel_show(struct device *dev,
Jean Delvarec8010822007-12-02 23:39:38 +0100321 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322{
Jean Delvarec8010822007-12-02 23:39:38 +0100323 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 struct adm1031_data *data = adm1031_update_device(dev);
325 return sprintf(buf, "%d\n", GET_FAN_AUTO_BITFIELD(data, nr));
326}
327
328static ssize_t
Guenter Roeck8e757e12019-01-21 20:37:22 -0800329fan_auto_channel_store(struct device *dev, struct device_attribute *attr,
330 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331{
Axel Linb060f3c42014-07-03 21:57:44 +0800332 struct adm1031_data *data = dev_get_drvdata(dev);
333 struct i2c_client *client = data->client;
Jean Delvarec8010822007-12-02 23:39:38 +0100334 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100335 long val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 u8 reg;
337 int ret;
338 u8 old_fan_mode;
339
Guenter Roeck1c720092012-01-16 22:51:48 +0100340 ret = kstrtol(buf, 10, &val);
341 if (ret)
342 return ret;
343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 old_fan_mode = data->conf1;
345
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100346 mutex_lock(&data->update_lock);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100347
Guenter Roeckce15a812012-03-24 08:51:05 -0700348 ret = get_fan_auto_nearest(data, nr, val, data->conf1);
349 if (ret < 0) {
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100350 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 return ret;
352 }
Guenter Roeckce15a812012-03-24 08:51:05 -0700353 reg = ret;
Jean Delvare6d6006b2007-12-02 23:33:57 +0100354 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
355 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) ^
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 (old_fan_mode & ADM1031_CONF1_AUTO_MODE)) {
Guenter Roeck1c720092012-01-16 22:51:48 +0100357 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
Guenter Roeckfbb66702012-01-19 11:02:14 -0800358 /*
359 * Switch to Auto Fan Mode
Jean Delvare6d6006b2007-12-02 23:33:57 +0100360 * Save PWM registers
Guenter Roeckfbb66702012-01-19 11:02:14 -0800361 * Set PWM registers to 33% Both
362 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 data->old_pwm[0] = data->pwm[0];
364 data->old_pwm[1] = data->pwm[1];
365 adm1031_write_value(client, ADM1031_REG_PWM, 0x55);
366 } else {
367 /* Switch to Manual Mode */
368 data->pwm[0] = data->old_pwm[0];
369 data->pwm[1] = data->old_pwm[1];
370 /* Restore PWM registers */
Jean Delvare6d6006b2007-12-02 23:33:57 +0100371 adm1031_write_value(client, ADM1031_REG_PWM,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 data->pwm[0] | (data->pwm[1] << 4));
373 }
374 }
375 data->conf1 = FAN_CHAN_TO_REG(reg, data->conf1);
376 adm1031_write_value(client, ADM1031_REG_CONF1, data->conf1);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100377 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 return count;
379}
380
Guenter Roeck8e757e12019-01-21 20:37:22 -0800381static SENSOR_DEVICE_ATTR_RW(auto_fan1_channel, fan_auto_channel, 0);
382static SENSOR_DEVICE_ATTR_RW(auto_fan2_channel, fan_auto_channel, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
384/* Auto Temps */
Guenter Roeck8e757e12019-01-21 20:37:22 -0800385static ssize_t auto_temp_off_show(struct device *dev,
Jean Delvarec8010822007-12-02 23:39:38 +0100386 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
Jean Delvarec8010822007-12-02 23:39:38 +0100388 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 struct adm1031_data *data = adm1031_update_device(dev);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100390 return sprintf(buf, "%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 AUTO_TEMP_OFF_FROM_REG(data->auto_temp[nr]));
392}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800393static ssize_t auto_temp_min_show(struct device *dev,
Jean Delvarec8010822007-12-02 23:39:38 +0100394 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
Jean Delvarec8010822007-12-02 23:39:38 +0100396 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 struct adm1031_data *data = adm1031_update_device(dev);
398 return sprintf(buf, "%d\n",
399 AUTO_TEMP_MIN_FROM_REG(data->auto_temp[nr]));
400}
401static ssize_t
Guenter Roeck8e757e12019-01-21 20:37:22 -0800402auto_temp_min_store(struct device *dev, struct device_attribute *attr,
403 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404{
Axel Linb060f3c42014-07-03 21:57:44 +0800405 struct adm1031_data *data = dev_get_drvdata(dev);
406 struct i2c_client *client = data->client;
Jean Delvarec8010822007-12-02 23:39:38 +0100407 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100408 long val;
409 int ret;
410
411 ret = kstrtol(buf, 10, &val);
412 if (ret)
413 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
Guenter Roeck145e74a42014-07-03 13:44:23 -0700415 val = clamp_val(val, 0, 127000);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100416 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 data->auto_temp[nr] = AUTO_TEMP_MIN_TO_REG(val, data->auto_temp[nr]);
418 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
419 data->auto_temp[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100420 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 return count;
422}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800423static ssize_t auto_temp_max_show(struct device *dev,
Jean Delvarec8010822007-12-02 23:39:38 +0100424 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425{
Jean Delvarec8010822007-12-02 23:39:38 +0100426 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 struct adm1031_data *data = adm1031_update_device(dev);
428 return sprintf(buf, "%d\n",
429 AUTO_TEMP_MAX_FROM_REG(data->auto_temp[nr]));
430}
431static ssize_t
Guenter Roeck8e757e12019-01-21 20:37:22 -0800432auto_temp_max_store(struct device *dev, struct device_attribute *attr,
433 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
Axel Linb060f3c42014-07-03 21:57:44 +0800435 struct adm1031_data *data = dev_get_drvdata(dev);
436 struct i2c_client *client = data->client;
Jean Delvarec8010822007-12-02 23:39:38 +0100437 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100438 long val;
439 int ret;
440
441 ret = kstrtol(buf, 10, &val);
442 if (ret)
443 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Guenter Roeck145e74a42014-07-03 13:44:23 -0700445 val = clamp_val(val, 0, 127000);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100446 mutex_lock(&data->update_lock);
Guenter Roeck1c720092012-01-16 22:51:48 +0100447 data->temp_max[nr] = AUTO_TEMP_MAX_TO_REG(val, data->auto_temp[nr],
448 data->pwm[nr]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 adm1031_write_value(client, ADM1031_REG_AUTO_TEMP(nr),
450 data->temp_max[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100451 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 return count;
453}
454
Guenter Roeck8e757e12019-01-21 20:37:22 -0800455static SENSOR_DEVICE_ATTR_RO(auto_temp1_off, auto_temp_off, 0);
456static SENSOR_DEVICE_ATTR_RW(auto_temp1_min, auto_temp_min, 0);
457static SENSOR_DEVICE_ATTR_RW(auto_temp1_max, auto_temp_max, 0);
458static SENSOR_DEVICE_ATTR_RO(auto_temp2_off, auto_temp_off, 1);
459static SENSOR_DEVICE_ATTR_RW(auto_temp2_min, auto_temp_min, 1);
460static SENSOR_DEVICE_ATTR_RW(auto_temp2_max, auto_temp_max, 1);
461static SENSOR_DEVICE_ATTR_RO(auto_temp3_off, auto_temp_off, 2);
462static SENSOR_DEVICE_ATTR_RW(auto_temp3_min, auto_temp_min, 2);
463static SENSOR_DEVICE_ATTR_RW(auto_temp3_max, auto_temp_max, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465/* pwm */
Guenter Roeck8e757e12019-01-21 20:37:22 -0800466static ssize_t pwm_show(struct device *dev, struct device_attribute *attr,
467 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468{
Jean Delvarec8010822007-12-02 23:39:38 +0100469 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 struct adm1031_data *data = adm1031_update_device(dev);
471 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
472}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800473static ssize_t pwm_store(struct device *dev, struct device_attribute *attr,
474 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
Axel Linb060f3c42014-07-03 21:57:44 +0800476 struct adm1031_data *data = dev_get_drvdata(dev);
477 struct i2c_client *client = data->client;
Jean Delvarec8010822007-12-02 23:39:38 +0100478 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100479 long val;
480 int ret, reg;
481
482 ret = kstrtol(buf, 10, &val);
483 if (ret)
484 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100486 mutex_lock(&data->update_lock);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100487 if ((data->conf1 & ADM1031_CONF1_AUTO_MODE) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 (((val>>4) & 0xf) != 5)) {
489 /* In automatic mode, the only PWM accepted is 33% */
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100490 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 return -EINVAL;
492 }
493 data->pwm[nr] = PWM_TO_REG(val);
494 reg = adm1031_read_value(client, ADM1031_REG_PWM);
495 adm1031_write_value(client, ADM1031_REG_PWM,
496 nr ? ((data->pwm[nr] << 4) & 0xf0) | (reg & 0xf)
497 : (data->pwm[nr] & 0xf) | (reg & 0xf0));
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100498 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 return count;
500}
501
Guenter Roeck8e757e12019-01-21 20:37:22 -0800502static SENSOR_DEVICE_ATTR_RW(pwm1, pwm, 0);
503static SENSOR_DEVICE_ATTR_RW(pwm2, pwm, 1);
504static SENSOR_DEVICE_ATTR_RW(auto_fan1_min_pwm, pwm, 0);
505static SENSOR_DEVICE_ATTR_RW(auto_fan2_min_pwm, pwm, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507/* Fans */
508
509/*
510 * That function checks the cases where the fan reading is not
Steven Cole44bbe872005-05-03 18:21:25 -0600511 * relevant. It is used to provide 0 as fan reading when the fan is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 * not supposed to run
513 */
514static int trust_fan_readings(struct adm1031_data *data, int chan)
515{
516 int res = 0;
517
518 if (data->conf1 & ADM1031_CONF1_AUTO_MODE) {
519 switch (data->conf1 & 0x60) {
Guenter Roeck1c720092012-01-16 22:51:48 +0100520 case 0x00:
521 /*
522 * remote temp1 controls fan1,
523 * remote temp2 controls fan2
524 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 res = data->temp[chan+1] >=
Guenter Roeck1c720092012-01-16 22:51:48 +0100526 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[chan+1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 break;
528 case 0x20: /* remote temp1 controls both fans */
529 res =
530 data->temp[1] >=
531 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1]);
532 break;
533 case 0x40: /* remote temp2 controls both fans */
534 res =
535 data->temp[2] >=
536 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]);
537 break;
538 case 0x60: /* max controls both fans */
539 res =
540 data->temp[0] >=
541 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[0])
542 || data->temp[1] >=
543 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[1])
Jean Delvare6d6006b2007-12-02 23:33:57 +0100544 || (data->chip_type == adm1031
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 && data->temp[2] >=
546 AUTO_TEMP_MIN_FROM_REG_DEG(data->auto_temp[2]));
547 break;
548 }
549 } else {
550 res = data->pwm[chan] > 0;
551 }
552 return res;
553}
554
Guenter Roeck8e757e12019-01-21 20:37:22 -0800555static ssize_t fan_show(struct device *dev, struct device_attribute *attr,
556 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
Jean Delvarec8010822007-12-02 23:39:38 +0100558 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 struct adm1031_data *data = adm1031_update_device(dev);
560 int value;
561
562 value = trust_fan_readings(data, nr) ? FAN_FROM_REG(data->fan[nr],
563 FAN_DIV_FROM_REG(data->fan_div[nr])) : 0;
564 return sprintf(buf, "%d\n", value);
565}
566
Guenter Roeck8e757e12019-01-21 20:37:22 -0800567static ssize_t fan_div_show(struct device *dev, struct device_attribute *attr,
568 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
Jean Delvarec8010822007-12-02 23:39:38 +0100570 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 struct adm1031_data *data = adm1031_update_device(dev);
572 return sprintf(buf, "%d\n", FAN_DIV_FROM_REG(data->fan_div[nr]));
573}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800574static ssize_t fan_min_show(struct device *dev, struct device_attribute *attr,
575 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576{
Jean Delvarec8010822007-12-02 23:39:38 +0100577 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 struct adm1031_data *data = adm1031_update_device(dev);
579 return sprintf(buf, "%d\n",
580 FAN_FROM_REG(data->fan_min[nr],
581 FAN_DIV_FROM_REG(data->fan_div[nr])));
582}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800583static ssize_t fan_min_store(struct device *dev,
584 struct device_attribute *attr, const char *buf,
585 size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
Axel Linb060f3c42014-07-03 21:57:44 +0800587 struct adm1031_data *data = dev_get_drvdata(dev);
588 struct i2c_client *client = data->client;
Jean Delvarec8010822007-12-02 23:39:38 +0100589 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100590 long val;
591 int ret;
592
593 ret = kstrtol(buf, 10, &val);
594 if (ret)
595 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100597 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 if (val) {
Jean Delvare6d6006b2007-12-02 23:33:57 +0100599 data->fan_min[nr] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 FAN_TO_REG(val, FAN_DIV_FROM_REG(data->fan_div[nr]));
601 } else {
602 data->fan_min[nr] = 0xff;
603 }
604 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr), data->fan_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100605 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 return count;
607}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800608static ssize_t fan_div_store(struct device *dev,
609 struct device_attribute *attr, const char *buf,
610 size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611{
Axel Linb060f3c42014-07-03 21:57:44 +0800612 struct adm1031_data *data = dev_get_drvdata(dev);
613 struct i2c_client *client = data->client;
Jean Delvarec8010822007-12-02 23:39:38 +0100614 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100615 long val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 u8 tmp;
617 int old_div;
618 int new_min;
Guenter Roeck1c720092012-01-16 22:51:48 +0100619 int ret;
620
621 ret = kstrtol(buf, 10, &val);
622 if (ret)
623 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625 tmp = val == 8 ? 0xc0 :
626 val == 4 ? 0x80 :
Jean Delvare6d6006b2007-12-02 23:33:57 +0100627 val == 2 ? 0x40 :
628 val == 1 ? 0x00 :
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 0xff;
630 if (tmp == 0xff)
631 return -EINVAL;
Jean Delvare6d6006b2007-12-02 23:33:57 +0100632
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100633 mutex_lock(&data->update_lock);
Jean Delvare38a1f0e2007-12-02 23:32:42 +0100634 /* Get fresh readings */
635 data->fan_div[nr] = adm1031_read_value(client,
636 ADM1031_REG_FAN_DIV(nr));
637 data->fan_min[nr] = adm1031_read_value(client,
638 ADM1031_REG_FAN_MIN(nr));
639
640 /* Write the new clock divider and fan min */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 old_div = FAN_DIV_FROM_REG(data->fan_div[nr]);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100642 data->fan_div[nr] = tmp | (0x3f & data->fan_div[nr]);
643 new_min = data->fan_min[nr] * old_div / val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 data->fan_min[nr] = new_min > 0xff ? 0xff : new_min;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
Jean Delvare6d6006b2007-12-02 23:33:57 +0100646 adm1031_write_value(client, ADM1031_REG_FAN_DIV(nr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 data->fan_div[nr]);
Jean Delvare6d6006b2007-12-02 23:33:57 +0100648 adm1031_write_value(client, ADM1031_REG_FAN_MIN(nr),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 data->fan_min[nr]);
Jean Delvare38a1f0e2007-12-02 23:32:42 +0100650
651 /* Invalidate the cache: fan speed is no longer valid */
Paul Fertser952a11c2021-09-24 22:52:02 +0300652 data->valid = false;
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100653 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 return count;
655}
656
Guenter Roeck8e757e12019-01-21 20:37:22 -0800657static SENSOR_DEVICE_ATTR_RO(fan1_input, fan, 0);
658static SENSOR_DEVICE_ATTR_RW(fan1_min, fan_min, 0);
659static SENSOR_DEVICE_ATTR_RW(fan1_div, fan_div, 0);
660static SENSOR_DEVICE_ATTR_RO(fan2_input, fan, 1);
661static SENSOR_DEVICE_ATTR_RW(fan2_min, fan_min, 1);
662static SENSOR_DEVICE_ATTR_RW(fan2_div, fan_div, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
664/* Temps */
Guenter Roeck8e757e12019-01-21 20:37:22 -0800665static ssize_t temp_show(struct device *dev, struct device_attribute *attr,
666 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
Jean Delvarec8010822007-12-02 23:39:38 +0100668 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 struct adm1031_data *data = adm1031_update_device(dev);
670 int ext;
671 ext = nr == 0 ?
672 ((data->ext_temp[nr] >> 6) & 0x3) * 2 :
673 (((data->ext_temp[nr] >> ((nr - 1) * 3)) & 7));
674 return sprintf(buf, "%d\n", TEMP_FROM_REG_EXT(data->temp[nr], ext));
675}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800676static ssize_t temp_offset_show(struct device *dev,
Ira Snyder49dc9ef2009-09-23 22:59:41 +0200677 struct device_attribute *attr, char *buf)
678{
679 int nr = to_sensor_dev_attr(attr)->index;
680 struct adm1031_data *data = adm1031_update_device(dev);
681 return sprintf(buf, "%d\n",
682 TEMP_OFFSET_FROM_REG(data->temp_offset[nr]));
683}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800684static ssize_t temp_min_show(struct device *dev,
Jean Delvarec8010822007-12-02 23:39:38 +0100685 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686{
Jean Delvarec8010822007-12-02 23:39:38 +0100687 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 struct adm1031_data *data = adm1031_update_device(dev);
689 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
690}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800691static ssize_t temp_max_show(struct device *dev,
Jean Delvarec8010822007-12-02 23:39:38 +0100692 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Jean Delvarec8010822007-12-02 23:39:38 +0100694 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 struct adm1031_data *data = adm1031_update_device(dev);
696 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
697}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800698static ssize_t temp_crit_show(struct device *dev,
Jean Delvarec8010822007-12-02 23:39:38 +0100699 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
Jean Delvarec8010822007-12-02 23:39:38 +0100701 int nr = to_sensor_dev_attr(attr)->index;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 struct adm1031_data *data = adm1031_update_device(dev);
703 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
704}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800705static ssize_t temp_offset_store(struct device *dev,
706 struct device_attribute *attr,
707 const char *buf, size_t count)
Ira Snyder49dc9ef2009-09-23 22:59:41 +0200708{
Axel Linb060f3c42014-07-03 21:57:44 +0800709 struct adm1031_data *data = dev_get_drvdata(dev);
710 struct i2c_client *client = data->client;
Ira Snyder49dc9ef2009-09-23 22:59:41 +0200711 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100712 long val;
713 int ret;
Ira Snyder49dc9ef2009-09-23 22:59:41 +0200714
Guenter Roeck1c720092012-01-16 22:51:48 +0100715 ret = kstrtol(buf, 10, &val);
716 if (ret)
717 return ret;
718
Guenter Roeck2a844c12013-01-09 08:09:34 -0800719 val = clamp_val(val, -15000, 15000);
Ira Snyder49dc9ef2009-09-23 22:59:41 +0200720 mutex_lock(&data->update_lock);
721 data->temp_offset[nr] = TEMP_OFFSET_TO_REG(val);
722 adm1031_write_value(client, ADM1031_REG_TEMP_OFFSET(nr),
723 data->temp_offset[nr]);
724 mutex_unlock(&data->update_lock);
725 return count;
726}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800727static ssize_t temp_min_store(struct device *dev,
728 struct device_attribute *attr, const char *buf,
729 size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
Axel Linb060f3c42014-07-03 21:57:44 +0800731 struct adm1031_data *data = dev_get_drvdata(dev);
732 struct i2c_client *client = data->client;
Jean Delvarec8010822007-12-02 23:39:38 +0100733 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100734 long val;
735 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
Guenter Roeck1c720092012-01-16 22:51:48 +0100737 ret = kstrtol(buf, 10, &val);
738 if (ret)
739 return ret;
740
Guenter Roeck145e74a42014-07-03 13:44:23 -0700741 val = clamp_val(val, -55000, 127000);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100742 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 data->temp_min[nr] = TEMP_TO_REG(val);
744 adm1031_write_value(client, ADM1031_REG_TEMP_MIN(nr),
745 data->temp_min[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100746 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 return count;
748}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800749static ssize_t temp_max_store(struct device *dev,
750 struct device_attribute *attr, const char *buf,
751 size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752{
Axel Linb060f3c42014-07-03 21:57:44 +0800753 struct adm1031_data *data = dev_get_drvdata(dev);
754 struct i2c_client *client = data->client;
Jean Delvarec8010822007-12-02 23:39:38 +0100755 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100756 long val;
757 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
Guenter Roeck1c720092012-01-16 22:51:48 +0100759 ret = kstrtol(buf, 10, &val);
760 if (ret)
761 return ret;
762
Guenter Roeck145e74a42014-07-03 13:44:23 -0700763 val = clamp_val(val, -55000, 127000);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100764 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 data->temp_max[nr] = TEMP_TO_REG(val);
766 adm1031_write_value(client, ADM1031_REG_TEMP_MAX(nr),
767 data->temp_max[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100768 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 return count;
770}
Guenter Roeck8e757e12019-01-21 20:37:22 -0800771static ssize_t temp_crit_store(struct device *dev,
772 struct device_attribute *attr, const char *buf,
773 size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774{
Axel Linb060f3c42014-07-03 21:57:44 +0800775 struct adm1031_data *data = dev_get_drvdata(dev);
776 struct i2c_client *client = data->client;
Jean Delvarec8010822007-12-02 23:39:38 +0100777 int nr = to_sensor_dev_attr(attr)->index;
Guenter Roeck1c720092012-01-16 22:51:48 +0100778 long val;
779 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Guenter Roeck1c720092012-01-16 22:51:48 +0100781 ret = kstrtol(buf, 10, &val);
782 if (ret)
783 return ret;
784
Guenter Roeck145e74a42014-07-03 13:44:23 -0700785 val = clamp_val(val, -55000, 127000);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100786 mutex_lock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 data->temp_crit[nr] = TEMP_TO_REG(val);
788 adm1031_write_value(client, ADM1031_REG_TEMP_CRIT(nr),
789 data->temp_crit[nr]);
Ingo Molnar9a61bf62006-01-18 23:19:26 +0100790 mutex_unlock(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 return count;
792}
793
Guenter Roeck8e757e12019-01-21 20:37:22 -0800794static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0);
795static SENSOR_DEVICE_ATTR_RW(temp1_offset, temp_offset, 0);
796static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0);
797static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0);
798static SENSOR_DEVICE_ATTR_RW(temp1_crit, temp_crit, 0);
799static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1);
800static SENSOR_DEVICE_ATTR_RW(temp2_offset, temp_offset, 1);
801static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1);
802static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1);
803static SENSOR_DEVICE_ATTR_RW(temp2_crit, temp_crit, 1);
804static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2);
805static SENSOR_DEVICE_ATTR_RW(temp3_offset, temp_offset, 2);
806static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2);
807static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2);
808static SENSOR_DEVICE_ATTR_RW(temp3_crit, temp_crit, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
810/* Alarms */
Julia Lawallbfb6b172016-12-22 13:04:32 +0100811static ssize_t alarms_show(struct device *dev, struct device_attribute *attr,
Guenter Roeck1c720092012-01-16 22:51:48 +0100812 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813{
814 struct adm1031_data *data = adm1031_update_device(dev);
815 return sprintf(buf, "%d\n", data->alarm);
816}
817
Julia Lawallbfb6b172016-12-22 13:04:32 +0100818static DEVICE_ATTR_RO(alarms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
Guenter Roeck8e757e12019-01-21 20:37:22 -0800820static ssize_t alarm_show(struct device *dev, struct device_attribute *attr,
821 char *buf)
Jean Delvare050ab872007-12-02 23:42:24 +0100822{
823 int bitnr = to_sensor_dev_attr(attr)->index;
824 struct adm1031_data *data = adm1031_update_device(dev);
825 return sprintf(buf, "%d\n", (data->alarm >> bitnr) & 1);
826}
827
Guenter Roeck8e757e12019-01-21 20:37:22 -0800828static SENSOR_DEVICE_ATTR_RO(fan1_alarm, alarm, 0);
829static SENSOR_DEVICE_ATTR_RO(fan1_fault, alarm, 1);
830static SENSOR_DEVICE_ATTR_RO(temp2_max_alarm, alarm, 2);
831static SENSOR_DEVICE_ATTR_RO(temp2_min_alarm, alarm, 3);
832static SENSOR_DEVICE_ATTR_RO(temp2_crit_alarm, alarm, 4);
833static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 5);
834static SENSOR_DEVICE_ATTR_RO(temp1_max_alarm, alarm, 6);
835static SENSOR_DEVICE_ATTR_RO(temp1_min_alarm, alarm, 7);
836static SENSOR_DEVICE_ATTR_RO(fan2_alarm, alarm, 8);
837static SENSOR_DEVICE_ATTR_RO(fan2_fault, alarm, 9);
838static SENSOR_DEVICE_ATTR_RO(temp3_max_alarm, alarm, 10);
839static SENSOR_DEVICE_ATTR_RO(temp3_min_alarm, alarm, 11);
840static SENSOR_DEVICE_ATTR_RO(temp3_crit_alarm, alarm, 12);
841static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 13);
842static SENSOR_DEVICE_ATTR_RO(temp1_crit_alarm, alarm, 14);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Guenter Roecka51b9942010-09-17 17:24:14 +0200844/* Update Interval */
845static const unsigned int update_intervals[] = {
Jean Delvare87c33da2010-05-27 19:58:46 +0200846 16000, 8000, 4000, 2000, 1000, 500, 250, 125,
847};
848
Julia Lawallbfb6b172016-12-22 13:04:32 +0100849static ssize_t update_interval_show(struct device *dev,
Guenter Roecka51b9942010-09-17 17:24:14 +0200850 struct device_attribute *attr, char *buf)
Jean Delvare87c33da2010-05-27 19:58:46 +0200851{
Axel Linb060f3c42014-07-03 21:57:44 +0800852 struct adm1031_data *data = dev_get_drvdata(dev);
Jean Delvare87c33da2010-05-27 19:58:46 +0200853
Guenter Roecka51b9942010-09-17 17:24:14 +0200854 return sprintf(buf, "%u\n", data->update_interval);
Jean Delvare87c33da2010-05-27 19:58:46 +0200855}
856
Julia Lawallbfb6b172016-12-22 13:04:32 +0100857static ssize_t update_interval_store(struct device *dev,
858 struct device_attribute *attr,
859 const char *buf, size_t count)
Jean Delvare87c33da2010-05-27 19:58:46 +0200860{
Axel Linb060f3c42014-07-03 21:57:44 +0800861 struct adm1031_data *data = dev_get_drvdata(dev);
862 struct i2c_client *client = data->client;
Jean Delvare87c33da2010-05-27 19:58:46 +0200863 unsigned long val;
864 int i, err;
865 u8 reg;
866
Frans Meulenbroeks179c4fd2012-01-04 20:58:52 +0100867 err = kstrtoul(buf, 10, &val);
Jean Delvare87c33da2010-05-27 19:58:46 +0200868 if (err)
869 return err;
870
Guenter Roecka51b9942010-09-17 17:24:14 +0200871 /*
872 * Find the nearest update interval from the table.
873 * Use it to determine the matching update rate.
874 */
875 for (i = 0; i < ARRAY_SIZE(update_intervals) - 1; i++) {
876 if (val >= update_intervals[i])
Jean Delvare87c33da2010-05-27 19:58:46 +0200877 break;
878 }
Guenter Roecka51b9942010-09-17 17:24:14 +0200879 /* if not found, we point to the last entry (lowest update interval) */
Jean Delvare87c33da2010-05-27 19:58:46 +0200880
881 /* set the new update rate while preserving other settings */
882 reg = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
883 reg &= ~ADM1031_UPDATE_RATE_MASK;
884 reg |= i << ADM1031_UPDATE_RATE_SHIFT;
885 adm1031_write_value(client, ADM1031_REG_FAN_FILTER, reg);
886
887 mutex_lock(&data->update_lock);
Guenter Roecka51b9942010-09-17 17:24:14 +0200888 data->update_interval = update_intervals[i];
Jean Delvare87c33da2010-05-27 19:58:46 +0200889 mutex_unlock(&data->update_lock);
890
891 return count;
892}
893
Julia Lawallbfb6b172016-12-22 13:04:32 +0100894static DEVICE_ATTR_RW(update_interval);
Jean Delvare87c33da2010-05-27 19:58:46 +0200895
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200896static struct attribute *adm1031_attributes[] = {
Jean Delvarec8010822007-12-02 23:39:38 +0100897 &sensor_dev_attr_fan1_input.dev_attr.attr,
898 &sensor_dev_attr_fan1_div.dev_attr.attr,
899 &sensor_dev_attr_fan1_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100900 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
901 &sensor_dev_attr_fan1_fault.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100902 &sensor_dev_attr_pwm1.dev_attr.attr,
903 &sensor_dev_attr_auto_fan1_channel.dev_attr.attr,
904 &sensor_dev_attr_temp1_input.dev_attr.attr,
Ira Snyder49dc9ef2009-09-23 22:59:41 +0200905 &sensor_dev_attr_temp1_offset.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100906 &sensor_dev_attr_temp1_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100907 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100908 &sensor_dev_attr_temp1_max.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100909 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100910 &sensor_dev_attr_temp1_crit.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100911 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100912 &sensor_dev_attr_temp2_input.dev_attr.attr,
Ira Snyder49dc9ef2009-09-23 22:59:41 +0200913 &sensor_dev_attr_temp2_offset.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100914 &sensor_dev_attr_temp2_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100915 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100916 &sensor_dev_attr_temp2_max.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100917 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100918 &sensor_dev_attr_temp2_crit.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100919 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
920 &sensor_dev_attr_temp2_fault.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200921
Jean Delvarec8010822007-12-02 23:39:38 +0100922 &sensor_dev_attr_auto_temp1_off.dev_attr.attr,
923 &sensor_dev_attr_auto_temp1_min.dev_attr.attr,
924 &sensor_dev_attr_auto_temp1_max.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200925
Jean Delvarec8010822007-12-02 23:39:38 +0100926 &sensor_dev_attr_auto_temp2_off.dev_attr.attr,
927 &sensor_dev_attr_auto_temp2_min.dev_attr.attr,
928 &sensor_dev_attr_auto_temp2_max.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200929
Jean Delvarec8010822007-12-02 23:39:38 +0100930 &sensor_dev_attr_auto_fan1_min_pwm.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200931
Guenter Roecka51b9942010-09-17 17:24:14 +0200932 &dev_attr_update_interval.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200933 &dev_attr_alarms.attr,
934
935 NULL
936};
937
938static const struct attribute_group adm1031_group = {
939 .attrs = adm1031_attributes,
940};
941
942static struct attribute *adm1031_attributes_opt[] = {
Jean Delvarec8010822007-12-02 23:39:38 +0100943 &sensor_dev_attr_fan2_input.dev_attr.attr,
944 &sensor_dev_attr_fan2_div.dev_attr.attr,
945 &sensor_dev_attr_fan2_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100946 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
947 &sensor_dev_attr_fan2_fault.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100948 &sensor_dev_attr_pwm2.dev_attr.attr,
949 &sensor_dev_attr_auto_fan2_channel.dev_attr.attr,
950 &sensor_dev_attr_temp3_input.dev_attr.attr,
Ira Snyder49dc9ef2009-09-23 22:59:41 +0200951 &sensor_dev_attr_temp3_offset.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100952 &sensor_dev_attr_temp3_min.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100953 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100954 &sensor_dev_attr_temp3_max.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100955 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100956 &sensor_dev_attr_temp3_crit.dev_attr.attr,
Jean Delvare050ab872007-12-02 23:42:24 +0100957 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
958 &sensor_dev_attr_temp3_fault.dev_attr.attr,
Jean Delvarec8010822007-12-02 23:39:38 +0100959 &sensor_dev_attr_auto_temp3_off.dev_attr.attr,
960 &sensor_dev_attr_auto_temp3_min.dev_attr.attr,
961 &sensor_dev_attr_auto_temp3_max.dev_attr.attr,
962 &sensor_dev_attr_auto_fan2_min_pwm.dev_attr.attr,
Mark M. Hoffman681c6f72006-09-24 21:15:35 +0200963 NULL
964};
965
966static const struct attribute_group adm1031_group_opt = {
967 .attrs = adm1031_attributes_opt,
968};
969
Jean Delvareaf200f82008-07-16 19:30:09 +0200970/* Return 0 if detection is successful, -ENODEV otherwise */
Jean Delvare310ec792009-12-14 21:17:23 +0100971static int adm1031_detect(struct i2c_client *client,
Jean Delvareaf200f82008-07-16 19:30:09 +0200972 struct i2c_board_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973{
Jean Delvareaf200f82008-07-16 19:30:09 +0200974 struct i2c_adapter *adapter = client->adapter;
Jean Delvare52df6442009-12-09 20:35:57 +0100975 const char *name;
976 int id, co;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
978 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
Jean Delvareaf200f82008-07-16 19:30:09 +0200979 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980
Jean Delvare52df6442009-12-09 20:35:57 +0100981 id = i2c_smbus_read_byte_data(client, 0x3d);
982 co = i2c_smbus_read_byte_data(client, 0x3e);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
Jean Delvare52df6442009-12-09 20:35:57 +0100984 if (!((id == 0x31 || id == 0x30) && co == 0x41))
985 return -ENODEV;
986 name = (id == 0x30) ? "adm1030" : "adm1031";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987
Jean Delvareaf200f82008-07-16 19:30:09 +0200988 strlcpy(info->type, name, I2C_NAME_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
Jean Delvareaf200f82008-07-16 19:30:09 +0200990 return 0;
991}
992
Axel Lin278ee1c2014-07-03 21:56:33 +0800993static void adm1031_init_client(struct i2c_client *client)
994{
995 unsigned int read_val;
996 unsigned int mask;
997 int i;
998 struct adm1031_data *data = i2c_get_clientdata(client);
999
1000 mask = (ADM1031_CONF2_PWM1_ENABLE | ADM1031_CONF2_TACH1_ENABLE);
1001 if (data->chip_type == adm1031) {
1002 mask |= (ADM1031_CONF2_PWM2_ENABLE |
1003 ADM1031_CONF2_TACH2_ENABLE);
1004 }
1005 /* Initialize the ADM1031 chip (enables fan speed reading ) */
1006 read_val = adm1031_read_value(client, ADM1031_REG_CONF2);
1007 if ((read_val | mask) != read_val)
1008 adm1031_write_value(client, ADM1031_REG_CONF2, read_val | mask);
1009
1010 read_val = adm1031_read_value(client, ADM1031_REG_CONF1);
1011 if ((read_val | ADM1031_CONF1_MONITOR_ENABLE) != read_val) {
1012 adm1031_write_value(client, ADM1031_REG_CONF1,
1013 read_val | ADM1031_CONF1_MONITOR_ENABLE);
1014 }
1015
1016 /* Read the chip's update rate */
1017 mask = ADM1031_UPDATE_RATE_MASK;
1018 read_val = adm1031_read_value(client, ADM1031_REG_FAN_FILTER);
1019 i = (read_val & mask) >> ADM1031_UPDATE_RATE_SHIFT;
1020 /* Save it as update interval */
1021 data->update_interval = update_intervals[i];
1022}
1023
Stephen Kitt67487032020-08-13 18:02:22 +02001024static const struct i2c_device_id adm1031_id[];
1025
1026static int adm1031_probe(struct i2c_client *client)
Jean Delvareaf200f82008-07-16 19:30:09 +02001027{
Axel Linb060f3c42014-07-03 21:57:44 +08001028 struct device *dev = &client->dev;
1029 struct device *hwmon_dev;
Jean Delvareaf200f82008-07-16 19:30:09 +02001030 struct adm1031_data *data;
Jean Delvareaf200f82008-07-16 19:30:09 +02001031
Axel Linb060f3c42014-07-03 21:57:44 +08001032 data = devm_kzalloc(dev, sizeof(struct adm1031_data), GFP_KERNEL);
Guenter Roeckdc2fd662012-06-02 09:57:59 -07001033 if (!data)
1034 return -ENOMEM;
Jean Delvareaf200f82008-07-16 19:30:09 +02001035
1036 i2c_set_clientdata(client, data);
Axel Linb060f3c42014-07-03 21:57:44 +08001037 data->client = client;
Stephen Kitt67487032020-08-13 18:02:22 +02001038 data->chip_type = i2c_match_id(adm1031_id, client)->driver_data;
Ingo Molnar9a61bf62006-01-18 23:19:26 +01001039 mutex_init(&data->update_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040
Jean Delvareaf200f82008-07-16 19:30:09 +02001041 if (data->chip_type == adm1030)
1042 data->chan_select_table = &auto_channel_select_table_adm1030;
1043 else
1044 data->chan_select_table = &auto_channel_select_table_adm1031;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045
1046 /* Initialize the ADM1031 chip */
Jean Delvare6d6006b2007-12-02 23:33:57 +01001047 adm1031_init_client(client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048
Axel Linb060f3c42014-07-03 21:57:44 +08001049 /* sysfs hooks */
1050 data->groups[0] = &adm1031_group;
1051 if (data->chip_type == adm1031)
1052 data->groups[1] = &adm1031_group_opt;
Mark M. Hoffman681c6f72006-09-24 21:15:35 +02001053
Axel Linb060f3c42014-07-03 21:57:44 +08001054 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
1055 data, data->groups);
1056 return PTR_ERR_OR_ZERO(hwmon_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057}
1058
Axel Lin278ee1c2014-07-03 21:56:33 +08001059static const struct i2c_device_id adm1031_id[] = {
1060 { "adm1030", adm1030 },
1061 { "adm1031", adm1031 },
1062 { }
1063};
1064MODULE_DEVICE_TABLE(i2c, adm1031_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Axel Lin278ee1c2014-07-03 21:56:33 +08001066static struct i2c_driver adm1031_driver = {
1067 .class = I2C_CLASS_HWMON,
1068 .driver = {
1069 .name = "adm1031",
1070 },
Stephen Kitt67487032020-08-13 18:02:22 +02001071 .probe_new = adm1031_probe,
Axel Lin278ee1c2014-07-03 21:56:33 +08001072 .id_table = adm1031_id,
1073 .detect = adm1031_detect,
1074 .address_list = normal_i2c,
1075};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
Axel Linf0967ee2012-01-20 15:38:18 +08001077module_i2c_driver(adm1031_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078
1079MODULE_AUTHOR("Alexandre d'Alton <alex@alexdalton.org>");
1080MODULE_DESCRIPTION("ADM1031/ADM1030 driver");
1081MODULE_LICENSE("GPL");