aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/hwmon/amc6821102
-rw-r--r--drivers/hwmon/Kconfig10
-rw-r--r--drivers/hwmon/Makefile1
-rw-r--r--drivers/hwmon/amc6821.c1116
4 files changed, 1229 insertions, 0 deletions
diff --git a/Documentation/hwmon/amc6821 b/Documentation/hwmon/amc6821
new file mode 100644
index 000000000000..ced8359c50f8
--- /dev/null
+++ b/Documentation/hwmon/amc6821
@@ -0,0 +1,102 @@
1Kernel driver amc6821
2=====================
3
4Supported chips:
5 Texas Instruments AMC6821
6 Prefix: 'amc6821'
7 Addresses scanned: 0x18, 0x19, 0x1a, 0x2c, 0x2d, 0x2e, 0x4c, 0x4d, 0x4e
8 Datasheet: http://focus.ti.com/docs/prod/folders/print/amc6821.html
9
10Authors:
11 Tomaz Mertelj <tomaz.mertelj@guest.arnes.si>
12
13
14Description
15-----------
16
17This driver implements support for the Texas Instruments amc6821 chip.
18The chip has one on-chip and one remote temperature sensor and one pwm fan
19regulator.
20The pwm can be controlled either from software or automatically.
21
22The driver provides the following sensor accesses in sysfs:
23
24temp1_input ro on-chip temperature
25temp1_min rw "
26temp1_max rw "
27temp1_crit rw "
28temp1_min_alarm ro "
29temp1_max_alarm ro "
30temp1_crit_alarm ro "
31
32temp2_input ro remote temperature
33temp2_min rw "
34temp2_max rw "
35temp2_crit rw "
36temp2_min_alarm ro "
37temp2_max_alarm ro "
38temp2_crit_alarm ro "
39temp2_fault ro "
40
41fan1_input ro tachometer speed
42fan1_min rw "
43fan1_max rw "
44fan1_fault ro "
45fan1_div rw Fan divisor can be either 2 or 4.
46
47pwm1 rw pwm1
48pwm1_enable rw regulator mode, 1=open loop, 2=fan controlled
49 by remote temperature, 3=fan controlled by
50 combination of the on-chip temperature and
51 remote-sensor temperature,
52pwm1_auto_channels_temp ro 1 if pwm_enable==2, 3 if pwm_enable==3
53pwm1_auto_point1_pwm ro Hardwired to 0, shared for both
54 temperature channels.
55pwm1_auto_point2_pwm rw This value is shared for both temperature
56 channels.
57pwm1_auto_point3_pwm rw Hardwired to 255, shared for both
58 temperature channels.
59
60temp1_auto_point1_temp ro Hardwired to temp2_auto_point1_temp
61 which is rw. Below this temperature fan stops.
62temp1_auto_point2_temp rw The low-temperature limit of the proportional
63 range. Below this temperature
64 pwm1 = pwm1_auto_point2_pwm. It can go from
65 0 degree C to 124 degree C in steps of
66 4 degree C. Read it out after writing to get
67 the actual value.
68temp1_auto_point3_temp rw Above this temperature fan runs at maximum
69 speed. It can go from temp1_auto_point2_temp.
70 It can only have certain discrete values
71 which depend on temp1_auto_point2_temp and
72 pwm1_auto_point2_pwm. Read it out after
73 writing to get the actual value.
74
75temp2_auto_point1_temp rw Must be between 0 degree C and 63 degree C and
76 it defines the passive cooling temperature.
77 Below this temperature the fan stops in
78 the closed loop mode.
79temp2_auto_point2_temp rw The low-temperature limit of the proportional
80 range. Below this temperature
81 pwm1 = pwm1_auto_point2_pwm. It can go from
82 0 degree C to 124 degree C in steps
83 of 4 degree C.
84
85temp2_auto_point3_temp rw Above this temperature fan runs at maximum
86 speed. It can only have certain discrete
87 values which depend on temp2_auto_point2_temp
88 and pwm1_auto_point2_pwm. Read it out after
89 writing to get actual value.
90
91
92Module parameters
93-----------------
94
95If your board has a BIOS that initializes the amc6821 correctly, you should
96load the module with: init=0.
97
98If your board BIOS doesn't initialize the chip, or you want
99different settings, you can set the following parameters:
100init=1,
101pwminv: 0 default pwm output, 1 inverts pwm output.
102
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 46c3c566307e..07a0f030a3ec 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -792,6 +792,16 @@ config SENSORS_ADS7828
792 This driver can also be built as a module. If so, the module 792 This driver can also be built as a module. If so, the module
793 will be called ads7828. 793 will be called ads7828.
794 794
795config SENSORS_AMC6821
796 tristate "Texas Instruments AMC6821"
797 depends on I2C && EXPERIMENTAL
798 help
799 If you say yes here you get support for the Texas Instruments
800 AMC6821 hardware monitoring chips.
801
802 This driver can also be build as a module. If so, the module
803 will be called amc6821.
804
795config SENSORS_THMC50 805config SENSORS_THMC50
796 tristate "Texas Instruments THMC50 / Analog Devices ADM1022" 806 tristate "Texas Instruments THMC50 / Analog Devices ADM1022"
797 depends on I2C && EXPERIMENTAL 807 depends on I2C && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 450c8e894277..4bc215c0953f 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -86,6 +86,7 @@ obj-$(CONFIG_SENSORS_SIS5595) += sis5595.o
86obj-$(CONFIG_SENSORS_SMSC47B397)+= smsc47b397.o 86obj-$(CONFIG_SENSORS_SMSC47B397)+= smsc47b397.o
87obj-$(CONFIG_SENSORS_SMSC47M1) += smsc47m1.o 87obj-$(CONFIG_SENSORS_SMSC47M1) += smsc47m1.o
88obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o 88obj-$(CONFIG_SENSORS_SMSC47M192)+= smsc47m192.o
89obj-$(CONFIG_SENSORS_AMC6821) += amc6821.o
89obj-$(CONFIG_SENSORS_THMC50) += thmc50.o 90obj-$(CONFIG_SENSORS_THMC50) += thmc50.o
90obj-$(CONFIG_SENSORS_TMP401) += tmp401.o 91obj-$(CONFIG_SENSORS_TMP401) += tmp401.o
91obj-$(CONFIG_SENSORS_TMP421) += tmp421.o 92obj-$(CONFIG_SENSORS_TMP421) += tmp421.o
diff --git a/drivers/hwmon/amc6821.c b/drivers/hwmon/amc6821.c
new file mode 100644
index 000000000000..1c89d922d619
--- /dev/null
+++ b/drivers/hwmon/amc6821.c
@@ -0,0 +1,1116 @@
1/*
2 amc6821.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Copyright (C) 2009 T. Mertelj <tomaz.mertelj@guest.arnes.si>
5
6 Based on max6650.c:
7 Copyright (C) 2007 Hans J. Koch <hjk@linutronix.de>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22*/
23
24
25#include <linux/kernel.h> /* Needed for KERN_INFO */
26#include <linux/module.h>
27#include <linux/init.h>
28#include <linux/slab.h>
29#include <linux/jiffies.h>
30#include <linux/i2c.h>
31#include <linux/hwmon.h>
32#include <linux/hwmon-sysfs.h>
33#include <linux/err.h>
34#include <linux/mutex.h>
35
36
37/*
38 * Addresses to scan.
39 */
40
41static const unsigned short normal_i2c[] = {0x18, 0x19, 0x1a, 0x2c, 0x2d, 0x2e,
42 0x4c, 0x4d, 0x4e, I2C_CLIENT_END};
43
44
45
46/*
47 * Insmod parameters
48 */
49
50static int pwminv = 0; /*Inverted PWM output. */
51module_param(pwminv, int, S_IRUGO);
52
53static int init = 1; /*Power-on initialization.*/
54module_param(init, int, S_IRUGO);
55
56
57enum chips { amc6821 };
58
59#define AMC6821_REG_DEV_ID 0x3D
60#define AMC6821_REG_COMP_ID 0x3E
61#define AMC6821_REG_CONF1 0x00
62#define AMC6821_REG_CONF2 0x01
63#define AMC6821_REG_CONF3 0x3F
64#define AMC6821_REG_CONF4 0x04
65#define AMC6821_REG_STAT1 0x02
66#define AMC6821_REG_STAT2 0x03
67#define AMC6821_REG_TDATA_LOW 0x08
68#define AMC6821_REG_TDATA_HI 0x09
69#define AMC6821_REG_LTEMP_HI 0x0A
70#define AMC6821_REG_RTEMP_HI 0x0B
71#define AMC6821_REG_LTEMP_LIMIT_MIN 0x15
72#define AMC6821_REG_LTEMP_LIMIT_MAX 0x14
73#define AMC6821_REG_RTEMP_LIMIT_MIN 0x19
74#define AMC6821_REG_RTEMP_LIMIT_MAX 0x18
75#define AMC6821_REG_LTEMP_CRIT 0x1B
76#define AMC6821_REG_RTEMP_CRIT 0x1D
77#define AMC6821_REG_PSV_TEMP 0x1C
78#define AMC6821_REG_DCY 0x22
79#define AMC6821_REG_LTEMP_FAN_CTRL 0x24
80#define AMC6821_REG_RTEMP_FAN_CTRL 0x25
81#define AMC6821_REG_DCY_LOW_TEMP 0x21
82
83#define AMC6821_REG_TACH_LLIMITL 0x10
84#define AMC6821_REG_TACH_LLIMITH 0x11
85#define AMC6821_REG_TACH_HLIMITL 0x12
86#define AMC6821_REG_TACH_HLIMITH 0x13
87
88#define AMC6821_CONF1_START 0x01
89#define AMC6821_CONF1_FAN_INT_EN 0x02
90#define AMC6821_CONF1_FANIE 0x04
91#define AMC6821_CONF1_PWMINV 0x08
92#define AMC6821_CONF1_FAN_FAULT_EN 0x10
93#define AMC6821_CONF1_FDRC0 0x20
94#define AMC6821_CONF1_FDRC1 0x40
95#define AMC6821_CONF1_THERMOVIE 0x80
96
97#define AMC6821_CONF2_PWM_EN 0x01
98#define AMC6821_CONF2_TACH_MODE 0x02
99#define AMC6821_CONF2_TACH_EN 0x04
100#define AMC6821_CONF2_RTFIE 0x08
101#define AMC6821_CONF2_LTOIE 0x10
102#define AMC6821_CONF2_RTOIE 0x20
103#define AMC6821_CONF2_PSVIE 0x40
104#define AMC6821_CONF2_RST 0x80
105
106#define AMC6821_CONF3_THERM_FAN_EN 0x80
107#define AMC6821_CONF3_REV_MASK 0x0F
108
109#define AMC6821_CONF4_OVREN 0x10
110#define AMC6821_CONF4_TACH_FAST 0x20
111#define AMC6821_CONF4_PSPR 0x40
112#define AMC6821_CONF4_MODE 0x80
113
114#define AMC6821_STAT1_RPM_ALARM 0x01
115#define AMC6821_STAT1_FANS 0x02
116#define AMC6821_STAT1_RTH 0x04
117#define AMC6821_STAT1_RTL 0x08
118#define AMC6821_STAT1_R_THERM 0x10
119#define AMC6821_STAT1_RTF 0x20
120#define AMC6821_STAT1_LTH 0x40
121#define AMC6821_STAT1_LTL 0x80
122
123#define AMC6821_STAT2_RTC 0x08
124#define AMC6821_STAT2_LTC 0x10
125#define AMC6821_STAT2_LPSV 0x20
126#define AMC6821_STAT2_L_THERM 0x40
127#define AMC6821_STAT2_THERM_IN 0x80
128
129enum {IDX_TEMP1_INPUT = 0, IDX_TEMP1_MIN, IDX_TEMP1_MAX,
130 IDX_TEMP1_CRIT, IDX_TEMP2_INPUT, IDX_TEMP2_MIN,
131 IDX_TEMP2_MAX, IDX_TEMP2_CRIT,
132 TEMP_IDX_LEN, };
133
134static const u8 temp_reg[] = {AMC6821_REG_LTEMP_HI,
135 AMC6821_REG_LTEMP_LIMIT_MIN,
136 AMC6821_REG_LTEMP_LIMIT_MAX,
137 AMC6821_REG_LTEMP_CRIT,
138 AMC6821_REG_RTEMP_HI,
139 AMC6821_REG_RTEMP_LIMIT_MIN,
140 AMC6821_REG_RTEMP_LIMIT_MAX,
141 AMC6821_REG_RTEMP_CRIT, };
142
143enum {IDX_FAN1_INPUT = 0, IDX_FAN1_MIN, IDX_FAN1_MAX,
144 FAN1_IDX_LEN, };
145
146static const u8 fan_reg_low[] = {AMC6821_REG_TDATA_LOW,
147 AMC6821_REG_TACH_LLIMITL,
148 AMC6821_REG_TACH_HLIMITL, };
149
150
151static const u8 fan_reg_hi[] = {AMC6821_REG_TDATA_HI,
152 AMC6821_REG_TACH_LLIMITH,
153 AMC6821_REG_TACH_HLIMITH, };
154
155static int amc6821_probe(
156 struct i2c_client *client,
157 const struct i2c_device_id *id);
158static int amc6821_detect(
159 struct i2c_client *client,
160 struct i2c_board_info *info);
161static int amc6821_init_client(struct i2c_client *client);
162static int amc6821_remove(struct i2c_client *client);
163static struct amc6821_data *amc6821_update_device(struct device *dev);
164
165/*
166 * Driver data (common to all clients)
167 */
168
169static const struct i2c_device_id amc6821_id[] = {
170 { "amc6821", amc6821 },
171 { }
172};
173
174MODULE_DEVICE_TABLE(i2c, amc6821_id);
175
176static struct i2c_driver amc6821_driver = {
177 .class = I2C_CLASS_HWMON,
178 .driver = {
179 .name = "amc6821",
180 },
181 .probe = amc6821_probe,
182 .remove = amc6821_remove,
183 .id_table = amc6821_id,
184 .detect = amc6821_detect,
185 .address_list = normal_i2c,
186};
187
188
189/*
190 * Client data (each client gets its own)
191 */
192
193struct amc6821_data {
194 struct device *hwmon_dev;
195 struct mutex update_lock;
196 char valid; /* zero until following fields are valid */
197 unsigned long last_updated; /* in jiffies */
198
199 /* register values */
200 int temp[TEMP_IDX_LEN];
201
202 u16 fan[FAN1_IDX_LEN];
203 u8 fan1_div;
204
205 u8 pwm1;
206 u8 temp1_auto_point_temp[3];
207 u8 temp2_auto_point_temp[3];
208 u8 pwm1_auto_point_pwm[3];
209 u8 pwm1_enable;
210 u8 pwm1_auto_channels_temp;
211
212 u8 stat1;
213 u8 stat2;
214};
215
216
217static ssize_t get_temp(
218 struct device *dev,
219 struct device_attribute *devattr,
220 char *buf)
221{
222 struct amc6821_data *data = amc6821_update_device(dev);
223 int ix = to_sensor_dev_attr(devattr)->index;
224
225 return sprintf(buf, "%d\n", data->temp[ix] * 1000);
226}
227
228
229
230static ssize_t set_temp(
231 struct device *dev,
232 struct device_attribute *attr,
233 const char *buf,
234 size_t count)
235{
236 struct i2c_client *client = to_i2c_client(dev);
237 struct amc6821_data *data = i2c_get_clientdata(client);
238 int ix = to_sensor_dev_attr(attr)->index;
239 long val;
240
241 int ret = strict_strtol(buf, 10, &val);
242 if (ret)
243 return ret;
244 val = SENSORS_LIMIT(val / 1000, -128, 127);
245
246 mutex_lock(&data->update_lock);
247 data->temp[ix] = val;
248 if (i2c_smbus_write_byte_data(client, temp_reg[ix], data->temp[ix])) {
249 dev_err(&client->dev, "Register write error, aborting.\n");
250 count = -EIO;
251 }
252 mutex_unlock(&data->update_lock);
253 return count;
254}
255
256
257
258
259static ssize_t get_temp_alarm(
260 struct device *dev,
261 struct device_attribute *devattr,
262 char *buf)
263{
264 struct amc6821_data *data = amc6821_update_device(dev);
265 int ix = to_sensor_dev_attr(devattr)->index;
266 u8 flag;
267
268 switch (ix) {
269 case IDX_TEMP1_MIN:
270 flag = data->stat1 & AMC6821_STAT1_LTL;
271 break;
272 case IDX_TEMP1_MAX:
273 flag = data->stat1 & AMC6821_STAT1_LTH;
274 break;
275 case IDX_TEMP1_CRIT:
276 flag = data->stat2 & AMC6821_STAT2_LTC;
277 break;
278 case IDX_TEMP2_MIN:
279 flag = data->stat1 & AMC6821_STAT1_RTL;
280 break;
281 case IDX_TEMP2_MAX:
282 flag = data->stat1 & AMC6821_STAT1_RTH;
283 break;
284 case IDX_TEMP2_CRIT:
285 flag = data->stat2 & AMC6821_STAT2_RTC;
286 break;
287 default:
288 dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
289 return -EINVAL;
290 }
291 if (flag)
292 return sprintf(buf, "1");
293 else
294 return sprintf(buf, "0");
295}
296
297
298
299
300static ssize_t get_temp2_fault(
301 struct device *dev,
302 struct device_attribute *devattr,
303 char *buf)
304{
305 struct amc6821_data *data = amc6821_update_device(dev);
306 if (data->stat1 & AMC6821_STAT1_RTF)
307 return sprintf(buf, "1");
308 else
309 return sprintf(buf, "0");
310}
311
312static ssize_t get_pwm1(
313 struct device *dev,
314 struct device_attribute *devattr,
315 char *buf)
316{
317 struct amc6821_data *data = amc6821_update_device(dev);
318 return sprintf(buf, "%d\n", data->pwm1);
319}
320
321static ssize_t set_pwm1(
322 struct device *dev,
323 struct device_attribute *devattr,
324 const char *buf,
325 size_t count)
326{
327 struct i2c_client *client = to_i2c_client(dev);
328 struct amc6821_data *data = i2c_get_clientdata(client);
329 long val;
330 int ret = strict_strtol(buf, 10, &val);
331 if (ret)
332 return ret;
333
334 mutex_lock(&data->update_lock);
335 data->pwm1 = SENSORS_LIMIT(val , 0, 255);
336 i2c_smbus_write_byte_data(client, AMC6821_REG_DCY, data->pwm1);
337 mutex_unlock(&data->update_lock);
338 return count;
339}
340
341static ssize_t get_pwm1_enable(
342 struct device *dev,
343 struct device_attribute *devattr,
344 char *buf)
345{
346 struct amc6821_data *data = amc6821_update_device(dev);
347 return sprintf(buf, "%d\n", data->pwm1_enable);
348}
349
350static ssize_t set_pwm1_enable(
351 struct device *dev,
352 struct device_attribute *attr,
353 const char *buf,
354 size_t count)
355{
356 struct i2c_client *client = to_i2c_client(dev);
357 struct amc6821_data *data = i2c_get_clientdata(client);
358 long val;
359 int config = strict_strtol(buf, 10, &val);
360 if (config)
361 return config;
362
363 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
364 if (config < 0) {
365 dev_err(&client->dev,
366 "Error reading configuration register, aborting.\n");
367 return -EIO;
368 }
369
370 switch (val) {
371 case 1:
372 config &= ~AMC6821_CONF1_FDRC0;
373 config &= ~AMC6821_CONF1_FDRC1;
374 break;
375 case 2:
376 config &= ~AMC6821_CONF1_FDRC0;
377 config |= AMC6821_CONF1_FDRC1;
378 break;
379 case 3:
380 config |= AMC6821_CONF1_FDRC0;
381 config |= AMC6821_CONF1_FDRC1;
382 break;
383 default:
384 return -EINVAL;
385 }
386 mutex_lock(&data->update_lock);
387 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF1, config)) {
388 dev_err(&client->dev,
389 "Configuration register write error, aborting.\n");
390 count = -EIO;
391 }
392 mutex_unlock(&data->update_lock);
393 return count;
394}
395
396
397static ssize_t get_pwm1_auto_channels_temp(
398 struct device *dev,
399 struct device_attribute *devattr,
400 char *buf)
401{
402 struct amc6821_data *data = amc6821_update_device(dev);
403 return sprintf(buf, "%d\n", data->pwm1_auto_channels_temp);
404}
405
406
407static ssize_t get_temp_auto_point_temp(
408 struct device *dev,
409 struct device_attribute *devattr,
410 char *buf)
411{
412 int ix = to_sensor_dev_attr_2(devattr)->index;
413 int nr = to_sensor_dev_attr_2(devattr)->nr;
414 struct amc6821_data *data = amc6821_update_device(dev);
415 switch (nr) {
416 case 1:
417 return sprintf(buf, "%d\n",
418 data->temp1_auto_point_temp[ix] * 1000);
419 break;
420 case 2:
421 return sprintf(buf, "%d\n",
422 data->temp2_auto_point_temp[ix] * 1000);
423 break;
424 default:
425 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
426 return -EINVAL;
427 }
428}
429
430
431static ssize_t get_pwm1_auto_point_pwm(
432 struct device *dev,
433 struct device_attribute *devattr,
434 char *buf)
435{
436 int ix = to_sensor_dev_attr(devattr)->index;
437 struct amc6821_data *data = amc6821_update_device(dev);
438 return sprintf(buf, "%d\n", data->pwm1_auto_point_pwm[ix]);
439}
440
441
442static inline ssize_t set_slope_register(struct i2c_client *client,
443 u8 reg,
444 u8 dpwm,
445 u8 *ptemp)
446{
447 int dt;
448 u8 tmp;
449
450 dt = ptemp[2]-ptemp[1];
451 for (tmp = 4; tmp > 0; tmp--) {
452 if (dt * (0x20 >> tmp) >= dpwm)
453 break;
454 }
455 tmp |= (ptemp[1] & 0x7C) << 1;
456 if (i2c_smbus_write_byte_data(client,
457 reg, tmp)) {
458 dev_err(&client->dev, "Register write error, aborting.\n");
459 return -EIO;
460 }
461 return 0;
462}
463
464
465
466static ssize_t set_temp_auto_point_temp(
467 struct device *dev,
468 struct device_attribute *attr,
469 const char *buf,
470 size_t count)
471{
472 struct i2c_client *client = to_i2c_client(dev);
473 struct amc6821_data *data = amc6821_update_device(dev);
474 int ix = to_sensor_dev_attr_2(attr)->index;
475 int nr = to_sensor_dev_attr_2(attr)->nr;
476 u8 *ptemp;
477 u8 reg;
478 int dpwm;
479 long val;
480 int ret = strict_strtol(buf, 10, &val);
481 if (ret)
482 return ret;
483
484 switch (nr) {
485 case 1:
486 ptemp = data->temp1_auto_point_temp;
487 reg = AMC6821_REG_LTEMP_FAN_CTRL;
488 break;
489 case 2:
490 ptemp = data->temp2_auto_point_temp;
491 reg = AMC6821_REG_RTEMP_FAN_CTRL;
492 break;
493 default:
494 dev_dbg(dev, "Unknown attr->nr (%d).\n", nr);
495 return -EINVAL;
496 }
497
498 data->valid = 0;
499 mutex_lock(&data->update_lock);
500 switch (ix) {
501 case 0:
502 ptemp[0] = SENSORS_LIMIT(val / 1000, 0,
503 data->temp1_auto_point_temp[1]);
504 ptemp[0] = SENSORS_LIMIT(ptemp[0], 0,
505 data->temp2_auto_point_temp[1]);
506 ptemp[0] = SENSORS_LIMIT(ptemp[0], 0, 63);
507 if (i2c_smbus_write_byte_data(
508 client,
509 AMC6821_REG_PSV_TEMP,
510 ptemp[0])) {
511 dev_err(&client->dev,
512 "Register write error, aborting.\n");
513 count = -EIO;
514 }
515 goto EXIT;
516 break;
517 case 1:
518 ptemp[1] = SENSORS_LIMIT(
519 val / 1000,
520 (ptemp[0] & 0x7C) + 4,
521 124);
522 ptemp[1] &= 0x7C;
523 ptemp[2] = SENSORS_LIMIT(
524 ptemp[2], ptemp[1] + 1,
525 255);
526 break;
527 case 2:
528 ptemp[2] = SENSORS_LIMIT(
529 val / 1000,
530 ptemp[1]+1,
531 255);
532 break;
533 default:
534 dev_dbg(dev, "Unknown attr->index (%d).\n", ix);
535 count = -EINVAL;
536 goto EXIT;
537 }
538 dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
539 if (set_slope_register(client, reg, dpwm, ptemp))
540 count = -EIO;
541
542EXIT:
543 mutex_unlock(&data->update_lock);
544 return count;
545}
546
547
548
549static ssize_t set_pwm1_auto_point_pwm(
550 struct device *dev,
551 struct device_attribute *attr,
552 const char *buf,
553 size_t count)
554{
555 struct i2c_client *client = to_i2c_client(dev);
556 struct amc6821_data *data = i2c_get_clientdata(client);
557 int dpwm;
558 long val;
559 int ret = strict_strtol(buf, 10, &val);
560 if (ret)
561 return ret;
562
563 mutex_lock(&data->update_lock);
564 data->pwm1_auto_point_pwm[1] = SENSORS_LIMIT(val, 0, 254);
565 if (i2c_smbus_write_byte_data(client, AMC6821_REG_DCY_LOW_TEMP,
566 data->pwm1_auto_point_pwm[1])) {
567 dev_err(&client->dev, "Register write error, aborting.\n");
568 count = -EIO;
569 goto EXIT;
570 }
571 dpwm = data->pwm1_auto_point_pwm[2] - data->pwm1_auto_point_pwm[1];
572 if (set_slope_register(client, AMC6821_REG_LTEMP_FAN_CTRL, dpwm,
573 data->temp1_auto_point_temp)) {
574 count = -EIO;
575 goto EXIT;
576 }
577 if (set_slope_register(client, AMC6821_REG_RTEMP_FAN_CTRL, dpwm,
578 data->temp2_auto_point_temp)) {
579 count = -EIO;
580 goto EXIT;
581 }
582
583EXIT:
584 data->valid = 0;
585 mutex_unlock(&data->update_lock);
586 return count;
587}
588
589static ssize_t get_fan(
590 struct device *dev,
591 struct device_attribute *devattr,
592 char *buf)
593{
594 struct amc6821_data *data = amc6821_update_device(dev);
595 int ix = to_sensor_dev_attr(devattr)->index;
596 if (0 == data->fan[ix])
597 return sprintf(buf, "0");
598 return sprintf(buf, "%d\n", (int)(6000000 / data->fan[ix]));
599}
600
601
602
603static ssize_t get_fan1_fault(
604 struct device *dev,
605 struct device_attribute *devattr,
606 char *buf)
607{
608 struct amc6821_data *data = amc6821_update_device(dev);
609 if (data->stat1 & AMC6821_STAT1_FANS)
610 return sprintf(buf, "1");
611 else
612 return sprintf(buf, "0");
613}
614
615
616
617static ssize_t set_fan(
618 struct device *dev,
619 struct device_attribute *attr,
620 const char *buf, size_t count)
621{
622 struct i2c_client *client = to_i2c_client(dev);
623 struct amc6821_data *data = i2c_get_clientdata(client);
624 long val;
625 int ix = to_sensor_dev_attr(attr)->index;
626 int ret = strict_strtol(buf, 10, &val);
627 if (ret)
628 return ret;
629 val = 1 > val ? 0xFFFF : 6000000/val;
630
631 mutex_lock(&data->update_lock);
632 data->fan[ix] = (u16) SENSORS_LIMIT(val, 1, 0xFFFF);
633 if (i2c_smbus_write_byte_data(client, fan_reg_low[ix],
634 data->fan[ix] & 0xFF)) {
635 dev_err(&client->dev, "Register write error, aborting.\n");
636 count = -EIO;
637 goto EXIT;
638 }
639 if (i2c_smbus_write_byte_data(client,
640 fan_reg_hi[ix], data->fan[ix] >> 8)) {
641 dev_err(&client->dev, "Register write error, aborting.\n");
642 count = -EIO;
643 }
644EXIT:
645 mutex_unlock(&data->update_lock);
646 return count;
647}
648
649
650
651static ssize_t get_fan1_div(
652 struct device *dev,
653 struct device_attribute *devattr,
654 char *buf)
655{
656 struct amc6821_data *data = amc6821_update_device(dev);
657 return sprintf(buf, "%d\n", data->fan1_div);
658}
659
660static ssize_t set_fan1_div(
661 struct device *dev,
662 struct device_attribute *attr,
663 const char *buf, size_t count)
664{
665 struct i2c_client *client = to_i2c_client(dev);
666 struct amc6821_data *data = i2c_get_clientdata(client);
667 long val;
668 int config = strict_strtol(buf, 10, &val);
669 if (config)
670 return config;
671
672 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
673 if (config < 0) {
674 dev_err(&client->dev,
675 "Error reading configuration register, aborting.\n");
676 return -EIO;
677 }
678 mutex_lock(&data->update_lock);
679 switch (val) {
680 case 2:
681 config &= ~AMC6821_CONF4_PSPR;
682 data->fan1_div = 2;
683 break;
684 case 4:
685 config |= AMC6821_CONF4_PSPR;
686 data->fan1_div = 4;
687 break;
688 default:
689 mutex_unlock(&data->update_lock);
690 count = -EINVAL;
691 goto EXIT;
692 }
693 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4, config)) {
694 dev_err(&client->dev,
695 "Configuration register write error, aborting.\n");
696 count = -EIO;
697 }
698EXIT:
699 mutex_unlock(&data->update_lock);
700 return count;
701}
702
703
704
705static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
706 get_temp, NULL, IDX_TEMP1_INPUT);
707static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, get_temp,
708 set_temp, IDX_TEMP1_MIN);
709static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, get_temp,
710 set_temp, IDX_TEMP1_MAX);
711static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, get_temp,
712 set_temp, IDX_TEMP1_CRIT);
713static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO,
714 get_temp_alarm, NULL, IDX_TEMP1_MIN);
715static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
716 get_temp_alarm, NULL, IDX_TEMP1_MAX);
717static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO,
718 get_temp_alarm, NULL, IDX_TEMP1_CRIT);
719static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO | S_IWUSR,
720 get_temp, NULL, IDX_TEMP2_INPUT);
721static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, get_temp,
722 set_temp, IDX_TEMP2_MIN);
723static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, get_temp,
724 set_temp, IDX_TEMP2_MAX);
725static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR, get_temp,
726 set_temp, IDX_TEMP2_CRIT);
727static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO,
728 get_temp2_fault, NULL, 0);
729static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO,
730 get_temp_alarm, NULL, IDX_TEMP2_MIN);
731static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO,
732 get_temp_alarm, NULL, IDX_TEMP2_MAX);
733static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO,
734 get_temp_alarm, NULL, IDX_TEMP2_CRIT);
735static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan, NULL, IDX_FAN1_INPUT);
736static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
737 get_fan, set_fan, IDX_FAN1_MIN);
738static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO | S_IWUSR,
739 get_fan, set_fan, IDX_FAN1_MAX);
740static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, get_fan1_fault, NULL, 0);
741static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
742 get_fan1_div, set_fan1_div, 0);
743
744static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, get_pwm1, set_pwm1, 0);
745static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
746 get_pwm1_enable, set_pwm1_enable, 0);
747static SENSOR_DEVICE_ATTR(pwm1_auto_point1_pwm, S_IRUGO,
748 get_pwm1_auto_point_pwm, NULL, 0);
749static SENSOR_DEVICE_ATTR(pwm1_auto_point2_pwm, S_IWUSR | S_IRUGO,
750 get_pwm1_auto_point_pwm, set_pwm1_auto_point_pwm, 1);
751static SENSOR_DEVICE_ATTR(pwm1_auto_point3_pwm, S_IRUGO,
752 get_pwm1_auto_point_pwm, NULL, 2);
753static SENSOR_DEVICE_ATTR(pwm1_auto_channels_temp, S_IRUGO,
754 get_pwm1_auto_channels_temp, NULL, 0);
755static SENSOR_DEVICE_ATTR_2(temp1_auto_point1_temp, S_IRUGO,
756 get_temp_auto_point_temp, NULL, 1, 0);
757static SENSOR_DEVICE_ATTR_2(temp1_auto_point2_temp, S_IWUSR | S_IRUGO,
758 get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 1);
759static SENSOR_DEVICE_ATTR_2(temp1_auto_point3_temp, S_IWUSR | S_IRUGO,
760 get_temp_auto_point_temp, set_temp_auto_point_temp, 1, 2);
761
762static SENSOR_DEVICE_ATTR_2(temp2_auto_point1_temp, S_IWUSR | S_IRUGO,
763 get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 0);
764static SENSOR_DEVICE_ATTR_2(temp2_auto_point2_temp, S_IWUSR | S_IRUGO,
765 get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 1);
766static SENSOR_DEVICE_ATTR_2(temp2_auto_point3_temp, S_IWUSR | S_IRUGO,
767 get_temp_auto_point_temp, set_temp_auto_point_temp, 2, 2);
768
769
770
771static struct attribute *amc6821_attrs[] = {
772 &sensor_dev_attr_temp1_input.dev_attr.attr,
773 &sensor_dev_attr_temp1_min.dev_attr.attr,
774 &sensor_dev_attr_temp1_max.dev_attr.attr,
775 &sensor_dev_attr_temp1_crit.dev_attr.attr,
776 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
777 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
778 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
779 &sensor_dev_attr_temp2_input.dev_attr.attr,
780 &sensor_dev_attr_temp2_min.dev_attr.attr,
781 &sensor_dev_attr_temp2_max.dev_attr.attr,
782 &sensor_dev_attr_temp2_crit.dev_attr.attr,
783 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
784 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
785 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
786 &sensor_dev_attr_temp2_fault.dev_attr.attr,
787 &sensor_dev_attr_fan1_input.dev_attr.attr,
788 &sensor_dev_attr_fan1_min.dev_attr.attr,
789 &sensor_dev_attr_fan1_max.dev_attr.attr,
790 &sensor_dev_attr_fan1_fault.dev_attr.attr,
791 &sensor_dev_attr_fan1_div.dev_attr.attr,
792 &sensor_dev_attr_pwm1.dev_attr.attr,
793 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
794 &sensor_dev_attr_pwm1_auto_channels_temp.dev_attr.attr,
795 &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
796 &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
797 &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
798 &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
799 &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
800 &sensor_dev_attr_temp1_auto_point3_temp.dev_attr.attr,
801 &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
802 &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
803 &sensor_dev_attr_temp2_auto_point3_temp.dev_attr.attr,
804 NULL
805};
806
807static struct attribute_group amc6821_attr_grp = {
808 .attrs = amc6821_attrs,
809};
810
811
812
813/* Return 0 if detection is successful, -ENODEV otherwise */
814static int amc6821_detect(
815 struct i2c_client *client,
816 struct i2c_board_info *info)
817{
818 struct i2c_adapter *adapter = client->adapter;
819 int address = client->addr;
820 int dev_id, comp_id;
821
822 dev_dbg(&adapter->dev, "amc6821_detect called.\n");
823
824 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
825 dev_dbg(&adapter->dev,
826 "amc6821: I2C bus doesn't support byte mode, "
827 "skipping.\n");
828 return -ENODEV;
829 }
830
831 dev_id = i2c_smbus_read_byte_data(client, AMC6821_REG_DEV_ID);
832 comp_id = i2c_smbus_read_byte_data(client, AMC6821_REG_COMP_ID);
833 if (dev_id != 0x21 || comp_id != 0x49) {
834 dev_dbg(&adapter->dev,
835 "amc6821: detection failed at 0x%02x.\n",
836 address);
837 return -ENODEV;
838 }
839
840 /* Bit 7 of the address register is ignored, so we can check the
841 ID registers again */
842 dev_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_DEV_ID);
843 comp_id = i2c_smbus_read_byte_data(client, 0x80 | AMC6821_REG_COMP_ID);
844 if (dev_id != 0x21 || comp_id != 0x49) {
845 dev_dbg(&adapter->dev,
846 "amc6821: detection failed at 0x%02x.\n",
847 address);
848 return -ENODEV;
849 }
850
851 dev_info(&adapter->dev, "amc6821: chip found at 0x%02x.\n", address);
852 strlcpy(info->type, "amc6821", I2C_NAME_SIZE);
853
854 return 0;
855}
856
857static int amc6821_probe(
858 struct i2c_client *client,
859 const struct i2c_device_id *id)
860{
861 struct amc6821_data *data;
862 int err;
863
864 data = kzalloc(sizeof(struct amc6821_data), GFP_KERNEL);
865 if (!data) {
866 dev_err(&client->dev, "out of memory.\n");
867 return -ENOMEM;
868 }
869
870
871 i2c_set_clientdata(client, data);
872 mutex_init(&data->update_lock);
873
874 /*
875 * Initialize the amc6821 chip
876 */
877 err = amc6821_init_client(client);
878 if (err)
879 goto err_free;
880
881 err = sysfs_create_group(&client->dev.kobj, &amc6821_attr_grp);
882 if (err)
883 goto err_free;
884
885 data->hwmon_dev = hwmon_device_register(&client->dev);
886 if (!IS_ERR(data->hwmon_dev))
887 return 0;
888
889 err = PTR_ERR(data->hwmon_dev);
890 dev_err(&client->dev, "error registering hwmon device.\n");
891 sysfs_remove_group(&client->dev.kobj, &amc6821_attr_grp);
892err_free:
893 kfree(data);
894 return err;
895}
896
897static int amc6821_remove(struct i2c_client *client)
898{
899 struct amc6821_data *data = i2c_get_clientdata(client);
900
901 hwmon_device_unregister(data->hwmon_dev);
902 sysfs_remove_group(&client->dev.kobj, &amc6821_attr_grp);
903
904 kfree(data);
905
906 return 0;
907}
908
909
910static int amc6821_init_client(struct i2c_client *client)
911{
912 int config;
913 int err = -EIO;
914
915 if (init) {
916 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF4);
917
918 if (config < 0) {
919 dev_err(&client->dev,
920 "Error reading configuration register, aborting.\n");
921 return err;
922 }
923
924 config |= AMC6821_CONF4_MODE;
925
926 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF4,
927 config)) {
928 dev_err(&client->dev,
929 "Configuration register write error, aborting.\n");
930 return err;
931 }
932
933 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF3);
934
935 if (config < 0) {
936 dev_err(&client->dev,
937 "Error reading configuration register, aborting.\n");
938 return err;
939 }
940
941 dev_info(&client->dev, "Revision %d\n", config & 0x0f);
942
943 config &= ~AMC6821_CONF3_THERM_FAN_EN;
944
945 if (i2c_smbus_write_byte_data(client, AMC6821_REG_CONF3,
946 config)) {
947 dev_err(&client->dev,
948 "Configuration register write error, aborting.\n");
949 return err;
950 }
951
952 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF2);
953
954 if (config < 0) {
955 dev_err(&client->dev,
956 "Error reading configuration register, aborting.\n");
957 return err;
958 }
959
960 config &= ~AMC6821_CONF2_RTFIE;
961 config &= ~AMC6821_CONF2_LTOIE;
962 config &= ~AMC6821_CONF2_RTOIE;
963 if (i2c_smbus_write_byte_data(client,
964 AMC6821_REG_CONF2, config)) {
965 dev_err(&client->dev,
966 "Configuration register write error, aborting.\n");
967 return err;
968 }
969
970 config = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
971
972 if (config < 0) {
973 dev_err(&client->dev,
974 "Error reading configuration register, aborting.\n");
975 return err;
976 }
977
978 config &= ~AMC6821_CONF1_THERMOVIE;
979 config &= ~AMC6821_CONF1_FANIE;
980 config |= AMC6821_CONF1_START;
981 if (pwminv)
982 config |= AMC6821_CONF1_PWMINV;
983 else
984 config &= ~AMC6821_CONF1_PWMINV;
985
986 if (i2c_smbus_write_byte_data(
987 client, AMC6821_REG_CONF1, config)) {
988 dev_err(&client->dev,
989 "Configuration register write error, aborting.\n");
990 return err;
991 }
992 }
993 return 0;
994}
995
996
997static struct amc6821_data *amc6821_update_device(struct device *dev)
998{
999 struct i2c_client *client = to_i2c_client(dev);
1000 struct amc6821_data *data = i2c_get_clientdata(client);
1001 int timeout = HZ;
1002 u8 reg;
1003 int i;
1004
1005 mutex_lock(&data->update_lock);
1006
1007 if (time_after(jiffies, data->last_updated + timeout) ||
1008 !data->valid) {
1009
1010 for (i = 0; i < TEMP_IDX_LEN; i++)
1011 data->temp[i] = i2c_smbus_read_byte_data(client,
1012 temp_reg[i]);
1013
1014 data->stat1 = i2c_smbus_read_byte_data(client,
1015 AMC6821_REG_STAT1);
1016 data->stat2 = i2c_smbus_read_byte_data(client,
1017 AMC6821_REG_STAT2);
1018
1019 data->pwm1 = i2c_smbus_read_byte_data(client,
1020 AMC6821_REG_DCY);
1021 for (i = 0; i < FAN1_IDX_LEN; i++) {
1022 data->fan[i] = i2c_smbus_read_byte_data(
1023 client,
1024 fan_reg_low[i]);
1025 data->fan[i] += i2c_smbus_read_byte_data(
1026 client,
1027 fan_reg_hi[i]) << 8;
1028 }
1029 data->fan1_div = i2c_smbus_read_byte_data(client,
1030 AMC6821_REG_CONF4);
1031 data->fan1_div = data->fan1_div & AMC6821_CONF4_PSPR ? 4 : 2;
1032
1033 data->pwm1_auto_point_pwm[0] = 0;
1034 data->pwm1_auto_point_pwm[2] = 255;
1035 data->pwm1_auto_point_pwm[1] = i2c_smbus_read_byte_data(client,
1036 AMC6821_REG_DCY_LOW_TEMP);
1037
1038 data->temp1_auto_point_temp[0] =
1039 i2c_smbus_read_byte_data(client,
1040 AMC6821_REG_PSV_TEMP);
1041 data->temp2_auto_point_temp[0] =
1042 data->temp1_auto_point_temp[0];
1043 reg = i2c_smbus_read_byte_data(client,
1044 AMC6821_REG_LTEMP_FAN_CTRL);
1045 data->temp1_auto_point_temp[1] = (reg & 0xF8) >> 1;
1046 reg &= 0x07;
1047 reg = 0x20 >> reg;
1048 if (reg > 0)
1049 data->temp1_auto_point_temp[2] =
1050 data->temp1_auto_point_temp[1] +
1051 (data->pwm1_auto_point_pwm[2] -
1052 data->pwm1_auto_point_pwm[1]) / reg;
1053 else
1054 data->temp1_auto_point_temp[2] = 255;
1055
1056 reg = i2c_smbus_read_byte_data(client,
1057 AMC6821_REG_RTEMP_FAN_CTRL);
1058 data->temp2_auto_point_temp[1] = (reg & 0xF8) >> 1;
1059 reg &= 0x07;
1060 reg = 0x20 >> reg;
1061 if (reg > 0)
1062 data->temp2_auto_point_temp[2] =
1063 data->temp2_auto_point_temp[1] +
1064 (data->pwm1_auto_point_pwm[2] -
1065 data->pwm1_auto_point_pwm[1]) / reg;
1066 else
1067 data->temp2_auto_point_temp[2] = 255;
1068
1069 reg = i2c_smbus_read_byte_data(client, AMC6821_REG_CONF1);
1070 reg = (reg >> 5) & 0x3;
1071 switch (reg) {
1072 case 0: /*open loop: software sets pwm1*/
1073 data->pwm1_auto_channels_temp = 0;
1074 data->pwm1_enable = 1;
1075 break;
1076 case 2: /*closed loop: remote T (temp2)*/
1077 data->pwm1_auto_channels_temp = 2;
1078 data->pwm1_enable = 2;
1079 break;
1080 case 3: /*closed loop: local and remote T (temp2)*/
1081 data->pwm1_auto_channels_temp = 3;
1082 data->pwm1_enable = 3;
1083 break;
1084 case 1: /*semi-open loop: software sets rpm, chip controls pwm1,
1085 *currently not implemented
1086 */
1087 data->pwm1_auto_channels_temp = 0;
1088 data->pwm1_enable = 0;
1089 break;
1090 }
1091
1092 data->last_updated = jiffies;
1093 data->valid = 1;
1094 }
1095 mutex_unlock(&data->update_lock);
1096 return data;
1097}
1098
1099
1100static int __init amc6821_init(void)
1101{
1102 return i2c_add_driver(&amc6821_driver);
1103}
1104
1105static void __exit amc6821_exit(void)
1106{
1107 i2c_del_driver(&amc6821_driver);
1108}
1109
1110module_init(amc6821_init);
1111module_exit(amc6821_exit);
1112
1113
1114MODULE_LICENSE("GPL");
1115MODULE_AUTHOR("T. Mertelj <tomaz.mertelj@guest.arnes.si>");
1116MODULE_DESCRIPTION("Texas Instruments amc6821 hwmon driver");
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-05 23:44:08 -0500