aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/hwmon
diff options
context:
space:
mode:
authorSteve Glendinning <steve.glendinning@smsc.com>2010-08-14 15:08:54 -0400
committerJean Delvare <khali@linux-fr.org>2010-08-14 15:08:54 -0400
commit9df7305b5a8651eb940e98496bc1d4742379c578 (patch)
treea57f2f4feca16e98da54c9fc39d6f549ce137d1e /drivers/hwmon
parent5a9c2cd881f48d4bec627cccde386f8e3a28bb4a (diff)
hwmon: Add driver for SMSC EMC2103 temperature monitor and fan controller
SMSC's EMC2103 family of temperature/fan controllers have 1 onboard and up to 3 external temperature sensors, and allow closed-loop control of one fan. This patch adds support for them. Signed-off-by: Steve Glendinning <steve.glendinning@smsc.com> Signed-off-by: Jean Delvare <khali@linux-fr.org>
Diffstat (limited to 'drivers/hwmon')
-rw-r--r--drivers/hwmon/Kconfig10
-rw-r--r--drivers/hwmon/Makefile1
-rw-r--r--drivers/hwmon/emc2103.c740
3 files changed, 751 insertions, 0 deletions
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index f3adf18bfa05..d50e9fa8016f 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -804,6 +804,16 @@ config SENSORS_EMC1403
804 Threshold values can be configured using sysfs. 804 Threshold values can be configured using sysfs.
805 Data from the different diodes are accessible via sysfs. 805 Data from the different diodes are accessible via sysfs.
806 806
807config SENSORS_EMC2103
808 tristate "SMSC EMC2103"
809 depends on I2C
810 help
811 If you say yes here you get support for the temperature
812 and fan sensors of the SMSC EMC2103 chips.
813
814 This driver can also be built as a module. If so, the module
815 will be called emc2103.
816
807config SENSORS_SMSC47M1 817config SENSORS_SMSC47M1
808 tristate "SMSC LPC47M10x and compatibles" 818 tristate "SMSC LPC47M10x and compatibles"
809 help 819 help
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 13d913e34dbf..e3c2484f6c5f 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -43,6 +43,7 @@ obj-$(CONFIG_SENSORS_PKGTEMP) += pkgtemp.o
43obj-$(CONFIG_SENSORS_DME1737) += dme1737.o 43obj-$(CONFIG_SENSORS_DME1737) += dme1737.o
44obj-$(CONFIG_SENSORS_DS1621) += ds1621.o 44obj-$(CONFIG_SENSORS_DS1621) += ds1621.o
45obj-$(CONFIG_SENSORS_EMC1403) += emc1403.o 45obj-$(CONFIG_SENSORS_EMC1403) += emc1403.o
46obj-$(CONFIG_SENSORS_EMC2103) += emc2103.o
46obj-$(CONFIG_SENSORS_F71805F) += f71805f.o 47obj-$(CONFIG_SENSORS_F71805F) += f71805f.o
47obj-$(CONFIG_SENSORS_F71882FG) += f71882fg.o 48obj-$(CONFIG_SENSORS_F71882FG) += f71882fg.o
48obj-$(CONFIG_SENSORS_F75375S) += f75375s.o 49obj-$(CONFIG_SENSORS_F75375S) += f75375s.o
diff --git a/drivers/hwmon/emc2103.c b/drivers/hwmon/emc2103.c
new file mode 100644
index 000000000000..af914ad93ece
--- /dev/null
+++ b/drivers/hwmon/emc2103.c
@@ -0,0 +1,740 @@
1/*
2 emc2103.c - Support for SMSC EMC2103
3 Copyright (c) 2010 SMSC
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18*/
19
20#include <linux/module.h>
21#include <linux/init.h>
22#include <linux/slab.h>
23#include <linux/jiffies.h>
24#include <linux/i2c.h>
25#include <linux/hwmon.h>
26#include <linux/hwmon-sysfs.h>
27#include <linux/err.h>
28#include <linux/mutex.h>
29
30/* Addresses scanned */
31static const unsigned short normal_i2c[] = { 0x2E, I2C_CLIENT_END };
32
33static const u8 REG_TEMP[4] = { 0x00, 0x02, 0x04, 0x06 };
34static const u8 REG_TEMP_MIN[4] = { 0x3c, 0x38, 0x39, 0x3a };
35static const u8 REG_TEMP_MAX[4] = { 0x34, 0x30, 0x31, 0x32 };
36
37#define REG_CONF1 0x20
38#define REG_TEMP_MAX_ALARM 0x24
39#define REG_TEMP_MIN_ALARM 0x25
40#define REG_FAN_CONF1 0x42
41#define REG_FAN_TARGET_LO 0x4c
42#define REG_FAN_TARGET_HI 0x4d
43#define REG_FAN_TACH_HI 0x4e
44#define REG_FAN_TACH_LO 0x4f
45#define REG_PRODUCT_ID 0xfd
46#define REG_MFG_ID 0xfe
47
48/* equation 4 from datasheet: rpm = (3932160 * multipler) / count */
49#define FAN_RPM_FACTOR 3932160
50
51/* 2103-2 and 2103-4's 3rd temperature sensor can be connected to two diodes
52 * in anti-parallel mode, and in this configuration both can be read
53 * independently (so we have 4 temperature inputs). The device can't
54 * detect if it's connected in this mode, so we have to manually enable
55 * it. Default is to leave the device in the state it's already in (-1).
56 * This parameter allows APD mode to be optionally forced on or off */
57static int apd = -1;
58module_param(apd, bool, 0);
59MODULE_PARM_DESC(init, "Set to zero to disable anti-parallel diode mode");
60
61struct temperature {
62 s8 degrees;
63 u8 fraction; /* 0-7 multiples of 0.125 */
64};
65
66struct emc2103_data {
67 struct device *hwmon_dev;
68 struct mutex update_lock;
69 bool valid; /* registers are valid */
70 bool fan_rpm_control;
71 int temp_count; /* num of temp sensors */
72 unsigned long last_updated; /* in jiffies */
73 struct temperature temp[4]; /* internal + 3 external */
74 s8 temp_min[4]; /* no fractional part */
75 s8 temp_max[4]; /* no fractional part */
76 u8 temp_min_alarm;
77 u8 temp_max_alarm;
78 u8 fan_multiplier;
79 u16 fan_tach;
80 u16 fan_target;
81};
82
83static int read_u8_from_i2c(struct i2c_client *client, u8 i2c_reg, u8 *output)
84{
85 int status = i2c_smbus_read_byte_data(client, i2c_reg);
86 if (status < 0) {
87 dev_warn(&client->dev, "reg 0x%02x, err %d\n",
88 i2c_reg, status);
89 } else {
90 *output = status;
91 }
92 return status;
93}
94
95static void read_temp_from_i2c(struct i2c_client *client, u8 i2c_reg,
96 struct temperature *temp)
97{
98 u8 degrees, fractional;
99
100 if (read_u8_from_i2c(client, i2c_reg, &degrees) < 0)
101 return;
102
103 if (read_u8_from_i2c(client, i2c_reg + 1, &fractional) < 0)
104 return;
105
106 temp->degrees = degrees;
107 temp->fraction = (fractional & 0xe0) >> 5;
108}
109
110static void read_fan_from_i2c(struct i2c_client *client, u16 *output,
111 u8 hi_addr, u8 lo_addr)
112{
113 u8 high_byte, lo_byte;
114
115 if (read_u8_from_i2c(client, hi_addr, &high_byte) < 0)
116 return;
117
118 if (read_u8_from_i2c(client, lo_addr, &lo_byte) < 0)
119 return;
120
121 *output = ((u16)high_byte << 5) | (lo_byte >> 3);
122}
123
124static void write_fan_target_to_i2c(struct i2c_client *client, u16 new_target)
125{
126 u8 high_byte = (new_target & 0x1fe0) >> 5;
127 u8 low_byte = (new_target & 0x001f) << 3;
128 i2c_smbus_write_byte_data(client, REG_FAN_TARGET_LO, low_byte);
129 i2c_smbus_write_byte_data(client, REG_FAN_TARGET_HI, high_byte);
130}
131
132static void read_fan_config_from_i2c(struct i2c_client *client)
133
134{
135 struct emc2103_data *data = i2c_get_clientdata(client);
136 u8 conf1;
137
138 if (read_u8_from_i2c(client, REG_FAN_CONF1, &conf1) < 0)
139 return;
140
141 data->fan_multiplier = 1 << ((conf1 & 0x60) >> 5);
142 data->fan_rpm_control = (conf1 & 0x80) != 0;
143}
144
145static struct emc2103_data *emc2103_update_device(struct device *dev)
146{
147 struct i2c_client *client = to_i2c_client(dev);
148 struct emc2103_data *data = i2c_get_clientdata(client);
149
150 mutex_lock(&data->update_lock);
151
152 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
153 || !data->valid) {
154 int i;
155
156 for (i = 0; i < data->temp_count; i++) {
157 read_temp_from_i2c(client, REG_TEMP[i], &data->temp[i]);
158 read_u8_from_i2c(client, REG_TEMP_MIN[i],
159 &data->temp_min[i]);
160 read_u8_from_i2c(client, REG_TEMP_MAX[i],
161 &data->temp_max[i]);
162 }
163
164 read_u8_from_i2c(client, REG_TEMP_MIN_ALARM,
165 &data->temp_min_alarm);
166 read_u8_from_i2c(client, REG_TEMP_MAX_ALARM,
167 &data->temp_max_alarm);
168
169 read_fan_from_i2c(client, &data->fan_tach,
170 REG_FAN_TACH_HI, REG_FAN_TACH_LO);
171 read_fan_from_i2c(client, &data->fan_target,
172 REG_FAN_TARGET_HI, REG_FAN_TARGET_LO);
173 read_fan_config_from_i2c(client);
174
175 data->last_updated = jiffies;
176 data->valid = true;
177 }
178
179 mutex_unlock(&data->update_lock);
180
181 return data;
182}
183
184static ssize_t
185show_temp(struct device *dev, struct device_attribute *da, char *buf)
186{
187 int nr = to_sensor_dev_attr(da)->index;
188 struct emc2103_data *data = emc2103_update_device(dev);
189 int millidegrees = data->temp[nr].degrees * 1000
190 + data->temp[nr].fraction * 125;
191 return sprintf(buf, "%d\n", millidegrees);
192}
193
194static ssize_t
195show_temp_min(struct device *dev, struct device_attribute *da, char *buf)
196{
197 int nr = to_sensor_dev_attr(da)->index;
198 struct emc2103_data *data = emc2103_update_device(dev);
199 int millidegrees = data->temp_min[nr] * 1000;
200 return sprintf(buf, "%d\n", millidegrees);
201}
202
203static ssize_t
204show_temp_max(struct device *dev, struct device_attribute *da, char *buf)
205{
206 int nr = to_sensor_dev_attr(da)->index;
207 struct emc2103_data *data = emc2103_update_device(dev);
208 int millidegrees = data->temp_max[nr] * 1000;
209 return sprintf(buf, "%d\n", millidegrees);
210}
211
212static ssize_t
213show_temp_fault(struct device *dev, struct device_attribute *da, char *buf)
214{
215 int nr = to_sensor_dev_attr(da)->index;
216 struct emc2103_data *data = emc2103_update_device(dev);
217 bool fault = (data->temp[nr].degrees == -128);
218 return sprintf(buf, "%d\n", fault ? 1 : 0);
219}
220
221static ssize_t
222show_temp_min_alarm(struct device *dev, struct device_attribute *da, char *buf)
223{
224 int nr = to_sensor_dev_attr(da)->index;
225 struct emc2103_data *data = emc2103_update_device(dev);
226 bool alarm = data->temp_min_alarm & (1 << nr);
227 return sprintf(buf, "%d\n", alarm ? 1 : 0);
228}
229
230static ssize_t
231show_temp_max_alarm(struct device *dev, struct device_attribute *da, char *buf)
232{
233 int nr = to_sensor_dev_attr(da)->index;
234 struct emc2103_data *data = emc2103_update_device(dev);
235 bool alarm = data->temp_max_alarm & (1 << nr);
236 return sprintf(buf, "%d\n", alarm ? 1 : 0);
237}
238
239static ssize_t set_temp_min(struct device *dev, struct device_attribute *da,
240 const char *buf, size_t count)
241{
242 int nr = to_sensor_dev_attr(da)->index;
243 struct i2c_client *client = to_i2c_client(dev);
244 struct emc2103_data *data = i2c_get_clientdata(client);
245 long val;
246
247 int result = strict_strtol(buf, 10, &val);
248 if (result < 0)
249 return -EINVAL;
250
251 val = DIV_ROUND_CLOSEST(val, 1000);
252 if ((val < -63) || (val > 127))
253 return -EINVAL;
254
255 mutex_lock(&data->update_lock);
256 data->temp_min[nr] = val;
257 i2c_smbus_write_byte_data(client, REG_TEMP_MIN[nr], val);
258 mutex_unlock(&data->update_lock);
259
260 return count;
261}
262
263static ssize_t set_temp_max(struct device *dev, struct device_attribute *da,
264 const char *buf, size_t count)
265{
266 int nr = to_sensor_dev_attr(da)->index;
267 struct i2c_client *client = to_i2c_client(dev);
268 struct emc2103_data *data = i2c_get_clientdata(client);
269 long val;
270
271 int result = strict_strtol(buf, 10, &val);
272 if (result < 0)
273 return -EINVAL;
274
275 val = DIV_ROUND_CLOSEST(val, 1000);
276 if ((val < -63) || (val > 127))
277 return -EINVAL;
278
279 mutex_lock(&data->update_lock);
280 data->temp_max[nr] = val;
281 i2c_smbus_write_byte_data(client, REG_TEMP_MAX[nr], val);
282 mutex_unlock(&data->update_lock);
283
284 return count;
285}
286
287static ssize_t
288show_fan(struct device *dev, struct device_attribute *da, char *buf)
289{
290 struct emc2103_data *data = emc2103_update_device(dev);
291 int rpm = 0;
292 if (data->fan_tach != 0)
293 rpm = (FAN_RPM_FACTOR * data->fan_multiplier) / data->fan_tach;
294 return sprintf(buf, "%d\n", rpm);
295}
296
297static ssize_t
298show_fan_div(struct device *dev, struct device_attribute *da, char *buf)
299{
300 struct emc2103_data *data = emc2103_update_device(dev);
301 int fan_div = 8 / data->fan_multiplier;
302 return sprintf(buf, "%d\n", fan_div);
303}
304
305/* Note: we also update the fan target here, because its value is
306 determined in part by the fan clock divider. This follows the principle
307 of least surprise; the user doesn't expect the fan target to change just
308 because the divider changed. */
309static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
310 const char *buf, size_t count)
311{
312 struct emc2103_data *data = emc2103_update_device(dev);
313 struct i2c_client *client = to_i2c_client(dev);
314 int new_range_bits, old_div = 8 / data->fan_multiplier;
315 long new_div;
316
317 int status = strict_strtol(buf, 10, &new_div);
318 if (status < 0)
319 return -EINVAL;
320
321 if (new_div == old_div) /* No change */
322 return count;
323
324 switch (new_div) {
325 case 1:
326 new_range_bits = 3;
327 break;
328 case 2:
329 new_range_bits = 2;
330 break;
331 case 4:
332 new_range_bits = 1;
333 break;
334 case 8:
335 new_range_bits = 0;
336 break;
337 default:
338 return -EINVAL;
339 }
340
341 mutex_lock(&data->update_lock);
342
343 status = i2c_smbus_read_byte_data(client, REG_FAN_CONF1);
344 if (status < 0) {
345 dev_dbg(&client->dev, "reg 0x%02x, err %d\n",
346 REG_FAN_CONF1, status);
347 mutex_unlock(&data->update_lock);
348 return -EIO;
349 }
350 status &= 0x9F;
351 status |= (new_range_bits << 5);
352 i2c_smbus_write_byte_data(client, REG_FAN_CONF1, status);
353
354 data->fan_multiplier = 8 / new_div;
355
356 /* update fan target if high byte is not disabled */
357 if ((data->fan_target & 0x1fe0) != 0x1fe0) {
358 u16 new_target = (data->fan_target * old_div) / new_div;
359 data->fan_target = min(new_target, (u16)0x1fff);
360 write_fan_target_to_i2c(client, data->fan_target);
361 }
362
363 /* invalidate data to force re-read from hardware */
364 data->valid = false;
365
366 mutex_unlock(&data->update_lock);
367 return count;
368}
369
370static ssize_t
371show_fan_target(struct device *dev, struct device_attribute *da, char *buf)
372{
373 struct emc2103_data *data = emc2103_update_device(dev);
374 int rpm = 0;
375
376 /* high byte of 0xff indicates disabled so return 0 */
377 if ((data->fan_target != 0) && ((data->fan_target & 0x1fe0) != 0x1fe0))
378 rpm = (FAN_RPM_FACTOR * data->fan_multiplier)
379 / data->fan_target;
380
381 return sprintf(buf, "%d\n", rpm);
382}
383
384static ssize_t set_fan_target(struct device *dev, struct device_attribute *da,
385 const char *buf, size_t count)
386{
387 struct emc2103_data *data = emc2103_update_device(dev);
388 struct i2c_client *client = to_i2c_client(dev);
389 long rpm_target;
390
391 int result = strict_strtol(buf, 10, &rpm_target);
392 if (result < 0)
393 return -EINVAL;
394
395 /* Datasheet states 16384 as maximum RPM target (table 3.2) */
396 if ((rpm_target < 0) || (rpm_target > 16384))
397 return -EINVAL;
398
399 mutex_lock(&data->update_lock);
400
401 if (rpm_target == 0)
402 data->fan_target = 0x1fff;
403 else
404 data->fan_target = SENSORS_LIMIT(
405 (FAN_RPM_FACTOR * data->fan_multiplier) / rpm_target,
406 0, 0x1fff);
407
408 write_fan_target_to_i2c(client, data->fan_target);
409
410 mutex_unlock(&data->update_lock);
411 return count;
412}
413
414static ssize_t
415show_fan_fault(struct device *dev, struct device_attribute *da, char *buf)
416{
417 struct emc2103_data *data = emc2103_update_device(dev);
418 bool fault = ((data->fan_tach & 0x1fe0) == 0x1fe0);
419 return sprintf(buf, "%d\n", fault ? 1 : 0);
420}
421
422static ssize_t
423show_pwm_enable(struct device *dev, struct device_attribute *da, char *buf)
424{
425 struct emc2103_data *data = emc2103_update_device(dev);
426 return sprintf(buf, "%d\n", data->fan_rpm_control ? 3 : 0);
427}
428
429static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *da,
430 const char *buf, size_t count)
431{
432 struct i2c_client *client = to_i2c_client(dev);
433 struct emc2103_data *data = i2c_get_clientdata(client);
434 long new_value;
435 u8 conf_reg;
436
437 int result = strict_strtol(buf, 10, &new_value);
438 if (result < 0)
439 return -EINVAL;
440
441 mutex_lock(&data->update_lock);
442 switch (new_value) {
443 case 0:
444 data->fan_rpm_control = false;
445 break;
446 case 3:
447 data->fan_rpm_control = true;
448 break;
449 default:
450 mutex_unlock(&data->update_lock);
451 return -EINVAL;
452 }
453
454 read_u8_from_i2c(client, REG_FAN_CONF1, &conf_reg);
455
456 if (data->fan_rpm_control)
457 conf_reg |= 0x80;
458 else
459 conf_reg &= ~0x80;
460
461 i2c_smbus_write_byte_data(client, REG_FAN_CONF1, conf_reg);
462
463 mutex_unlock(&data->update_lock);
464 return count;
465}
466
467static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
468static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, show_temp_min,
469 set_temp_min, 0);
470static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp_max,
471 set_temp_max, 0);
472static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
473static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_temp_min_alarm,
474 NULL, 0);
475static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_temp_max_alarm,
476 NULL, 0);
477
478static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
479static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, show_temp_min,
480 set_temp_min, 1);
481static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, show_temp_max,
482 set_temp_max, 1);
483static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
484static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_temp_min_alarm,
485 NULL, 1);
486static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_temp_max_alarm,
487 NULL, 1);
488
489static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
490static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR, show_temp_min,
491 set_temp_min, 2);
492static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR, show_temp_max,
493 set_temp_max, 2);
494static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2);
495static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_temp_min_alarm,
496 NULL, 2);
497static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_temp_max_alarm,
498 NULL, 2);
499
500static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3);
501static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO | S_IWUSR, show_temp_min,
502 set_temp_min, 3);
503static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO | S_IWUSR, show_temp_max,
504 set_temp_max, 3);
505static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3);
506static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_temp_min_alarm,
507 NULL, 3);
508static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_temp_max_alarm,
509 NULL, 3);
510
511static DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL);
512static DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR, show_fan_div, set_fan_div);
513static DEVICE_ATTR(fan1_target, S_IRUGO | S_IWUSR, show_fan_target,
514 set_fan_target);
515static DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL);
516
517static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR, show_pwm_enable,
518 set_pwm_enable);
519
520/* sensors present on all models */
521static struct attribute *emc2103_attributes[] = {
522 &sensor_dev_attr_temp1_input.dev_attr.attr,
523 &sensor_dev_attr_temp1_min.dev_attr.attr,
524 &sensor_dev_attr_temp1_max.dev_attr.attr,
525 &sensor_dev_attr_temp1_fault.dev_attr.attr,
526 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
527 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
528 &sensor_dev_attr_temp2_input.dev_attr.attr,
529 &sensor_dev_attr_temp2_min.dev_attr.attr,
530 &sensor_dev_attr_temp2_max.dev_attr.attr,
531 &sensor_dev_attr_temp2_fault.dev_attr.attr,
532 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
533 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
534 &dev_attr_fan1_input.attr,
535 &dev_attr_fan1_div.attr,
536 &dev_attr_fan1_target.attr,
537 &dev_attr_fan1_fault.attr,
538 &dev_attr_pwm1_enable.attr,
539 NULL
540};
541
542/* extra temperature sensors only present on 2103-2 and 2103-4 */
543static struct attribute *emc2103_attributes_temp3[] = {
544 &sensor_dev_attr_temp3_input.dev_attr.attr,
545 &sensor_dev_attr_temp3_min.dev_attr.attr,
546 &sensor_dev_attr_temp3_max.dev_attr.attr,
547 &sensor_dev_attr_temp3_fault.dev_attr.attr,
548 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
549 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
550 NULL
551};
552
553/* extra temperature sensors only present on 2103-2 and 2103-4 in APD mode */
554static struct attribute *emc2103_attributes_temp4[] = {
555 &sensor_dev_attr_temp4_input.dev_attr.attr,
556 &sensor_dev_attr_temp4_min.dev_attr.attr,
557 &sensor_dev_attr_temp4_max.dev_attr.attr,
558 &sensor_dev_attr_temp4_fault.dev_attr.attr,
559 &sensor_dev_attr_temp4_min_alarm.dev_attr.attr,
560 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr,
561 NULL
562};
563
564static const struct attribute_group emc2103_group = {
565 .attrs = emc2103_attributes,
566};
567
568static const struct attribute_group emc2103_temp3_group = {
569 .attrs = emc2103_attributes_temp3,
570};
571
572static const struct attribute_group emc2103_temp4_group = {
573 .attrs = emc2103_attributes_temp4,
574};
575
576static int
577emc2103_probe(struct i2c_client *client, const struct i2c_device_id *id)
578{
579 struct emc2103_data *data;
580 int status;
581
582 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
583 return -EIO;
584
585 data = kzalloc(sizeof(struct emc2103_data), GFP_KERNEL);
586 if (!data)
587 return -ENOMEM;
588
589 i2c_set_clientdata(client, data);
590 mutex_init(&data->update_lock);
591
592 /* 2103-2 and 2103-4 have 3 external diodes, 2103-1 has 1 */
593 status = i2c_smbus_read_byte_data(client, REG_PRODUCT_ID);
594 if (status == 0x24) {
595 /* 2103-1 only has 1 external diode */
596 data->temp_count = 2;
597 } else {
598 /* 2103-2 and 2103-4 have 3 or 4 external diodes */
599 status = i2c_smbus_read_byte_data(client, REG_CONF1);
600 if (status < 0) {
601 dev_dbg(&client->dev, "reg 0x%02x, err %d\n", REG_CONF1,
602 status);
603 goto exit_free;
604 }
605
606 /* detect current state of hardware */
607 data->temp_count = (status & 0x01) ? 4 : 3;
608
609 /* force APD state if module parameter is set */
610 if (apd == 0) {
611 /* force APD mode off */
612 data->temp_count = 3;
613 status &= ~(0x01);
614 i2c_smbus_write_byte_data(client, REG_CONF1, status);
615 } else if (apd == 1) {
616 /* force APD mode on */
617 data->temp_count = 4;
618 status |= 0x01;
619 i2c_smbus_write_byte_data(client, REG_CONF1, status);
620 }
621 }
622
623 /* Register sysfs hooks */
624 status = sysfs_create_group(&client->dev.kobj, &emc2103_group);
625 if (status)
626 goto exit_free;
627
628 if (data->temp_count >= 3) {
629 status = sysfs_create_group(&client->dev.kobj,
630 &emc2103_temp3_group);
631 if (status)
632 goto exit_remove;
633 }
634
635 if (data->temp_count == 4) {
636 status = sysfs_create_group(&client->dev.kobj,
637 &emc2103_temp4_group);
638 if (status)
639 goto exit_remove_temp3;
640 }
641
642 data->hwmon_dev = hwmon_device_register(&client->dev);
643 if (IS_ERR(data->hwmon_dev)) {
644 status = PTR_ERR(data->hwmon_dev);
645 goto exit_remove_temp4;
646 }
647
648 dev_info(&client->dev, "%s: sensor '%s'\n",
649 dev_name(data->hwmon_dev), client->name);
650
651 return 0;
652
653exit_remove_temp4:
654 if (data->temp_count == 4)
655 sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
656exit_remove_temp3:
657 if (data->temp_count >= 3)
658 sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
659exit_remove:
660 sysfs_remove_group(&client->dev.kobj, &emc2103_group);
661exit_free:
662 kfree(data);
663 return status;
664}
665
666static int emc2103_remove(struct i2c_client *client)
667{
668 struct emc2103_data *data = i2c_get_clientdata(client);
669
670 hwmon_device_unregister(data->hwmon_dev);
671
672 if (data->temp_count == 4)
673 sysfs_remove_group(&client->dev.kobj, &emc2103_temp4_group);
674
675 if (data->temp_count >= 3)
676 sysfs_remove_group(&client->dev.kobj, &emc2103_temp3_group);
677
678 sysfs_remove_group(&client->dev.kobj, &emc2103_group);
679
680 kfree(data);
681 return 0;
682}
683
684static const struct i2c_device_id emc2103_ids[] = {
685 { "emc2103", 0, },
686 { /* LIST END */ }
687};
688MODULE_DEVICE_TABLE(i2c, emc2103_ids);
689
690/* Return 0 if detection is successful, -ENODEV otherwise */
691static int
692emc2103_detect(struct i2c_client *new_client, struct i2c_board_info *info)
693{
694 struct i2c_adapter *adapter = new_client->adapter;
695 int manufacturer, product;
696
697 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
698 return -ENODEV;
699
700 manufacturer = i2c_smbus_read_byte_data(new_client, REG_MFG_ID);
701 if (manufacturer != 0x5D)
702 return -ENODEV;
703
704 product = i2c_smbus_read_byte_data(new_client, REG_PRODUCT_ID);
705 if ((product != 0x24) && (product != 0x26))
706 return -ENODEV;
707
708 strlcpy(info->type, "emc2103", I2C_NAME_SIZE);
709
710 return 0;
711}
712
713static struct i2c_driver emc2103_driver = {
714 .class = I2C_CLASS_HWMON,
715 .driver = {
716 .name = "emc2103",
717 },
718 .probe = emc2103_probe,
719 .remove = emc2103_remove,
720 .id_table = emc2103_ids,
721 .detect = emc2103_detect,
722 .address_list = normal_i2c,
723};
724
725static int __init sensors_emc2103_init(void)
726{
727 return i2c_add_driver(&emc2103_driver);
728}
729
730static void __exit sensors_emc2103_exit(void)
731{
732 i2c_del_driver(&emc2103_driver);
733}
734
735MODULE_AUTHOR("Steve Glendinning <steve.glendinning@smsc.com>");
736MODULE_DESCRIPTION("SMSC EMC2103 hwmon driver");
737MODULE_LICENSE("GPL");
738
739module_init(sensors_emc2103_init);
740module_exit(sensors_emc2103_exit);