Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit c2df1591df3ea83b4a5890a1131dd821ca07e761

Authored by Jean Delvare
Committed by Jean Delvare
1 parent 935ada8c44
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

hwmon: (fscher) Convert to a new-style i2c driver 

The new-style fscher driver implements the optional detect() callback
to cover the use cases of the legacy driver.

Signed-off-by: Jean Delvare <khali@linux-fr.org>
Cc: Reinhard Nissl <rnissl@gmx.de>

Showing 1 changed file with 42 additions and 51 deletions Inline Diff

drivers/hwmon/fscher.c
Diff comments   View file @ c2df159
1 /* 1 /*
2 * fscher.c - Part of lm_sensors, Linux kernel modules for hardware 2 * fscher.c - Part of lm_sensors, Linux kernel modules for hardware
3 * monitoring 3 * monitoring
4 * Copyright (C) 2003, 2004 Reinhard Nissl <rnissl@gmx.de> 4 * Copyright (C) 2003, 2004 Reinhard Nissl <rnissl@gmx.de>
5 * 5 *
6 * This program is free software; you can redistribute it and/or modify 6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by 7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or 8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version. 9 * (at your option) any later version.
10 * 10 *
11 * This program is distributed in the hope that it will be useful, 11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details. 14 * GNU General Public License for more details.
15 * 15 *
16 * You should have received a copy of the GNU General Public License 16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software 17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */ 19 */
20 20
21 /* 21 /*
22 * fujitsu siemens hermes chip, 22 * fujitsu siemens hermes chip,
23 * module based on fscpos.c 23 * module based on fscpos.c
24 * Copyright (C) 2000 Hermann Jung <hej@odn.de> 24 * Copyright (C) 2000 Hermann Jung <hej@odn.de>
25 * Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl> 25 * Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
26 * and Philip Edelbrock <phil@netroedge.com> 26 * and Philip Edelbrock <phil@netroedge.com>
27 */ 27 */
28 28
29 #include <linux/module.h> 29 #include <linux/module.h>
30 #include <linux/init.h> 30 #include <linux/init.h>
31 #include <linux/slab.h> 31 #include <linux/slab.h>
32 #include <linux/jiffies.h> 32 #include <linux/jiffies.h>
33 #include <linux/i2c.h> 33 #include <linux/i2c.h>
34 #include <linux/hwmon.h> 34 #include <linux/hwmon.h>
35 #include <linux/err.h> 35 #include <linux/err.h>
36 #include <linux/mutex.h> 36 #include <linux/mutex.h>
37 #include <linux/sysfs.h> 37 #include <linux/sysfs.h>
38 38
39 /* 39 /*
40 * Addresses to scan 40 * Addresses to scan
41 */ 41 */
42 42
43 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END }; 43 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
44 44
45 /* 45 /*
46 * Insmod parameters 46 * Insmod parameters
47 */ 47 */
48 48
49 I2C_CLIENT_INSMOD_1(fscher); 49 I2C_CLIENT_INSMOD_1(fscher);
50 50
51 /* 51 /*
52 * The FSCHER registers 52 * The FSCHER registers
53 */ 53 */
54 54
55 /* chip identification */ 55 /* chip identification */
56 #define FSCHER_REG_IDENT_0 0x00 56 #define FSCHER_REG_IDENT_0 0x00
57 #define FSCHER_REG_IDENT_1 0x01 57 #define FSCHER_REG_IDENT_1 0x01
58 #define FSCHER_REG_IDENT_2 0x02 58 #define FSCHER_REG_IDENT_2 0x02
59 #define FSCHER_REG_REVISION 0x03 59 #define FSCHER_REG_REVISION 0x03
60 60
61 /* global control and status */ 61 /* global control and status */
62 #define FSCHER_REG_EVENT_STATE 0x04 62 #define FSCHER_REG_EVENT_STATE 0x04
63 #define FSCHER_REG_CONTROL 0x05 63 #define FSCHER_REG_CONTROL 0x05
64 64
65 /* watchdog */ 65 /* watchdog */
66 #define FSCHER_REG_WDOG_PRESET 0x28 66 #define FSCHER_REG_WDOG_PRESET 0x28
67 #define FSCHER_REG_WDOG_STATE 0x23 67 #define FSCHER_REG_WDOG_STATE 0x23
68 #define FSCHER_REG_WDOG_CONTROL 0x21 68 #define FSCHER_REG_WDOG_CONTROL 0x21
69 69
70 /* fan 0 */ 70 /* fan 0 */
71 #define FSCHER_REG_FAN0_MIN 0x55 71 #define FSCHER_REG_FAN0_MIN 0x55
72 #define FSCHER_REG_FAN0_ACT 0x0e 72 #define FSCHER_REG_FAN0_ACT 0x0e
73 #define FSCHER_REG_FAN0_STATE 0x0d 73 #define FSCHER_REG_FAN0_STATE 0x0d
74 #define FSCHER_REG_FAN0_RIPPLE 0x0f 74 #define FSCHER_REG_FAN0_RIPPLE 0x0f
75 75
76 /* fan 1 */ 76 /* fan 1 */
77 #define FSCHER_REG_FAN1_MIN 0x65 77 #define FSCHER_REG_FAN1_MIN 0x65
78 #define FSCHER_REG_FAN1_ACT 0x6b 78 #define FSCHER_REG_FAN1_ACT 0x6b
79 #define FSCHER_REG_FAN1_STATE 0x62 79 #define FSCHER_REG_FAN1_STATE 0x62
80 #define FSCHER_REG_FAN1_RIPPLE 0x6f 80 #define FSCHER_REG_FAN1_RIPPLE 0x6f
81 81
82 /* fan 2 */ 82 /* fan 2 */
83 #define FSCHER_REG_FAN2_MIN 0xb5 83 #define FSCHER_REG_FAN2_MIN 0xb5
84 #define FSCHER_REG_FAN2_ACT 0xbb 84 #define FSCHER_REG_FAN2_ACT 0xbb
85 #define FSCHER_REG_FAN2_STATE 0xb2 85 #define FSCHER_REG_FAN2_STATE 0xb2
86 #define FSCHER_REG_FAN2_RIPPLE 0xbf 86 #define FSCHER_REG_FAN2_RIPPLE 0xbf
87 87
88 /* voltage supervision */ 88 /* voltage supervision */
89 #define FSCHER_REG_VOLT_12 0x45 89 #define FSCHER_REG_VOLT_12 0x45
90 #define FSCHER_REG_VOLT_5 0x42 90 #define FSCHER_REG_VOLT_5 0x42
91 #define FSCHER_REG_VOLT_BATT 0x48 91 #define FSCHER_REG_VOLT_BATT 0x48
92 92
93 /* temperature 0 */ 93 /* temperature 0 */
94 #define FSCHER_REG_TEMP0_ACT 0x64 94 #define FSCHER_REG_TEMP0_ACT 0x64
95 #define FSCHER_REG_TEMP0_STATE 0x71 95 #define FSCHER_REG_TEMP0_STATE 0x71
96 96
97 /* temperature 1 */ 97 /* temperature 1 */
98 #define FSCHER_REG_TEMP1_ACT 0x32 98 #define FSCHER_REG_TEMP1_ACT 0x32
99 #define FSCHER_REG_TEMP1_STATE 0x81 99 #define FSCHER_REG_TEMP1_STATE 0x81
100 100
101 /* temperature 2 */ 101 /* temperature 2 */
102 #define FSCHER_REG_TEMP2_ACT 0x35 102 #define FSCHER_REG_TEMP2_ACT 0x35
103 #define FSCHER_REG_TEMP2_STATE 0x91 103 #define FSCHER_REG_TEMP2_STATE 0x91
104 104
105 /* 105 /*
106 * Functions declaration 106 * Functions declaration
107 */ 107 */
108 108
109 static int fscher_attach_adapter(struct i2c_adapter *adapter); 109 static int fscher_probe(struct i2c_client *client,
110 static int fscher_detect(struct i2c_adapter *adapter, int address, int kind); 110 const struct i2c_device_id *id);
111 static int fscher_detach_client(struct i2c_client *client); 111 static int fscher_detect(struct i2c_client *client, int kind,
112 struct i2c_board_info *info);
113 static int fscher_remove(struct i2c_client *client);
112 static struct fscher_data *fscher_update_device(struct device *dev); 114 static struct fscher_data *fscher_update_device(struct device *dev);
113 static void fscher_init_client(struct i2c_client *client); 115 static void fscher_init_client(struct i2c_client *client);
114 116
115 static int fscher_read_value(struct i2c_client *client, u8 reg); 117 static int fscher_read_value(struct i2c_client *client, u8 reg);
116 static int fscher_write_value(struct i2c_client *client, u8 reg, u8 value); 118 static int fscher_write_value(struct i2c_client *client, u8 reg, u8 value);
117 119
118 /* 120 /*
119 * Driver data (common to all clients) 121 * Driver data (common to all clients)
120 */ 122 */
121 123
124 static const struct i2c_device_id fscher_id[] = {
125 { "fscher", fscher },
126 { }
127 };
128
122 static struct i2c_driver fscher_driver = { 129 static struct i2c_driver fscher_driver = {
130 .class = I2C_CLASS_HWMON,
123 .driver = { 131 .driver = {
124 .name = "fscher", 132 .name = "fscher",
125 }, 133 },
126 .attach_adapter = fscher_attach_adapter, 134 .probe = fscher_probe,
127 .detach_client = fscher_detach_client, 135 .remove = fscher_remove,
136 .id_table = fscher_id,
137 .detect = fscher_detect,
138 .address_data = &addr_data,
128 }; 139 };
129 140
130 /* 141 /*
131 * Client data (each client gets its own) 142 * Client data (each client gets its own)
132 */ 143 */
133 144
134 struct fscher_data { 145 struct fscher_data {
135 struct i2c_client client;
136 struct device *hwmon_dev; 146 struct device *hwmon_dev;
137 struct mutex update_lock; 147 struct mutex update_lock;
138 char valid; /* zero until following fields are valid */ 148 char valid; /* zero until following fields are valid */
139 unsigned long last_updated; /* in jiffies */ 149 unsigned long last_updated; /* in jiffies */
140 150
141 /* register values */ 151 /* register values */
142 u8 revision; /* revision of chip */ 152 u8 revision; /* revision of chip */
143 u8 global_event; /* global event status */ 153 u8 global_event; /* global event status */
144 u8 global_control; /* global control register */ 154 u8 global_control; /* global control register */
145 u8 watchdog[3]; /* watchdog */ 155 u8 watchdog[3]; /* watchdog */
146 u8 volt[3]; /* 12, 5, battery voltage */ 156 u8 volt[3]; /* 12, 5, battery voltage */
147 u8 temp_act[3]; /* temperature */ 157 u8 temp_act[3]; /* temperature */
148 u8 temp_status[3]; /* status of sensor */ 158 u8 temp_status[3]; /* status of sensor */
149 u8 fan_act[3]; /* fans revolutions per second */ 159 u8 fan_act[3]; /* fans revolutions per second */
150 u8 fan_status[3]; /* fan status */ 160 u8 fan_status[3]; /* fan status */
151 u8 fan_min[3]; /* fan min value for rps */ 161 u8 fan_min[3]; /* fan min value for rps */
152 u8 fan_ripple[3]; /* divider for rps */ 162 u8 fan_ripple[3]; /* divider for rps */
153 }; 163 };
154 164
155 /* 165 /*
156 * Sysfs stuff 166 * Sysfs stuff
157 */ 167 */
158 168
159 #define sysfs_r(kind, sub, offset, reg) \ 169 #define sysfs_r(kind, sub, offset, reg) \
160 static ssize_t show_##kind##sub (struct fscher_data *, char *, int); \ 170 static ssize_t show_##kind##sub (struct fscher_data *, char *, int); \
161 static ssize_t show_##kind##offset##sub (struct device *, struct device_attribute *attr, char *); \ 171 static ssize_t show_##kind##offset##sub (struct device *, struct device_attribute *attr, char *); \
162 static ssize_t show_##kind##offset##sub (struct device *dev, struct device_attribute *attr, char *buf) \ 172 static ssize_t show_##kind##offset##sub (struct device *dev, struct device_attribute *attr, char *buf) \
163 { \ 173 { \
164 struct fscher_data *data = fscher_update_device(dev); \ 174 struct fscher_data *data = fscher_update_device(dev); \
165 return show_##kind##sub(data, buf, (offset)); \ 175 return show_##kind##sub(data, buf, (offset)); \
166 } 176 }
167 177
168 #define sysfs_w(kind, sub, offset, reg) \ 178 #define sysfs_w(kind, sub, offset, reg) \
169 static ssize_t set_##kind##sub (struct i2c_client *, struct fscher_data *, const char *, size_t, int, int); \ 179 static ssize_t set_##kind##sub (struct i2c_client *, struct fscher_data *, const char *, size_t, int, int); \
170 static ssize_t set_##kind##offset##sub (struct device *, struct device_attribute *attr, const char *, size_t); \ 180 static ssize_t set_##kind##offset##sub (struct device *, struct device_attribute *attr, const char *, size_t); \
171 static ssize_t set_##kind##offset##sub (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ 181 static ssize_t set_##kind##offset##sub (struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \
172 { \ 182 { \
173 struct i2c_client *client = to_i2c_client(dev); \ 183 struct i2c_client *client = to_i2c_client(dev); \
174 struct fscher_data *data = i2c_get_clientdata(client); \ 184 struct fscher_data *data = i2c_get_clientdata(client); \
175 return set_##kind##sub(client, data, buf, count, (offset), reg); \ 185 return set_##kind##sub(client, data, buf, count, (offset), reg); \
176 } 186 }
177 187
178 #define sysfs_rw_n(kind, sub, offset, reg) \ 188 #define sysfs_rw_n(kind, sub, offset, reg) \
179 sysfs_r(kind, sub, offset, reg) \ 189 sysfs_r(kind, sub, offset, reg) \
180 sysfs_w(kind, sub, offset, reg) \ 190 sysfs_w(kind, sub, offset, reg) \
181 static DEVICE_ATTR(kind##offset##sub, S_IRUGO | S_IWUSR, show_##kind##offset##sub, set_##kind##offset##sub); 191 static DEVICE_ATTR(kind##offset##sub, S_IRUGO | S_IWUSR, show_##kind##offset##sub, set_##kind##offset##sub);
182 192
183 #define sysfs_rw(kind, sub, reg) \ 193 #define sysfs_rw(kind, sub, reg) \
184 sysfs_r(kind, sub, 0, reg) \ 194 sysfs_r(kind, sub, 0, reg) \
185 sysfs_w(kind, sub, 0, reg) \ 195 sysfs_w(kind, sub, 0, reg) \
186 static DEVICE_ATTR(kind##sub, S_IRUGO | S_IWUSR, show_##kind##0##sub, set_##kind##0##sub); 196 static DEVICE_ATTR(kind##sub, S_IRUGO | S_IWUSR, show_##kind##0##sub, set_##kind##0##sub);
187 197
188 #define sysfs_ro_n(kind, sub, offset, reg) \ 198 #define sysfs_ro_n(kind, sub, offset, reg) \
189 sysfs_r(kind, sub, offset, reg) \ 199 sysfs_r(kind, sub, offset, reg) \
190 static DEVICE_ATTR(kind##offset##sub, S_IRUGO, show_##kind##offset##sub, NULL); 200 static DEVICE_ATTR(kind##offset##sub, S_IRUGO, show_##kind##offset##sub, NULL);
191 201
192 #define sysfs_ro(kind, sub, reg) \ 202 #define sysfs_ro(kind, sub, reg) \
193 sysfs_r(kind, sub, 0, reg) \ 203 sysfs_r(kind, sub, 0, reg) \
194 static DEVICE_ATTR(kind, S_IRUGO, show_##kind##0##sub, NULL); 204 static DEVICE_ATTR(kind, S_IRUGO, show_##kind##0##sub, NULL);
195 205
196 #define sysfs_fan(offset, reg_status, reg_min, reg_ripple, reg_act) \ 206 #define sysfs_fan(offset, reg_status, reg_min, reg_ripple, reg_act) \
197 sysfs_rw_n(pwm, , offset, reg_min) \ 207 sysfs_rw_n(pwm, , offset, reg_min) \
198 sysfs_rw_n(fan, _status, offset, reg_status) \ 208 sysfs_rw_n(fan, _status, offset, reg_status) \
199 sysfs_rw_n(fan, _div , offset, reg_ripple) \ 209 sysfs_rw_n(fan, _div , offset, reg_ripple) \
200 sysfs_ro_n(fan, _input , offset, reg_act) 210 sysfs_ro_n(fan, _input , offset, reg_act)
201 211
202 #define sysfs_temp(offset, reg_status, reg_act) \ 212 #define sysfs_temp(offset, reg_status, reg_act) \
203 sysfs_rw_n(temp, _status, offset, reg_status) \ 213 sysfs_rw_n(temp, _status, offset, reg_status) \
204 sysfs_ro_n(temp, _input , offset, reg_act) 214 sysfs_ro_n(temp, _input , offset, reg_act)
205 215
206 #define sysfs_in(offset, reg_act) \ 216 #define sysfs_in(offset, reg_act) \
207 sysfs_ro_n(in, _input, offset, reg_act) 217 sysfs_ro_n(in, _input, offset, reg_act)
208 218
209 #define sysfs_revision(reg_revision) \ 219 #define sysfs_revision(reg_revision) \
210 sysfs_ro(revision, , reg_revision) 220 sysfs_ro(revision, , reg_revision)
211 221
212 #define sysfs_alarms(reg_events) \ 222 #define sysfs_alarms(reg_events) \
213 sysfs_ro(alarms, , reg_events) 223 sysfs_ro(alarms, , reg_events)
214 224
215 #define sysfs_control(reg_control) \ 225 #define sysfs_control(reg_control) \
216 sysfs_rw(control, , reg_control) 226 sysfs_rw(control, , reg_control)
217 227
218 #define sysfs_watchdog(reg_control, reg_status, reg_preset) \ 228 #define sysfs_watchdog(reg_control, reg_status, reg_preset) \
219 sysfs_rw(watchdog, _control, reg_control) \ 229 sysfs_rw(watchdog, _control, reg_control) \
220 sysfs_rw(watchdog, _status , reg_status) \ 230 sysfs_rw(watchdog, _status , reg_status) \
221 sysfs_rw(watchdog, _preset , reg_preset) 231 sysfs_rw(watchdog, _preset , reg_preset)
222 232
223 sysfs_fan(1, FSCHER_REG_FAN0_STATE, FSCHER_REG_FAN0_MIN, 233 sysfs_fan(1, FSCHER_REG_FAN0_STATE, FSCHER_REG_FAN0_MIN,
224 FSCHER_REG_FAN0_RIPPLE, FSCHER_REG_FAN0_ACT) 234 FSCHER_REG_FAN0_RIPPLE, FSCHER_REG_FAN0_ACT)
225 sysfs_fan(2, FSCHER_REG_FAN1_STATE, FSCHER_REG_FAN1_MIN, 235 sysfs_fan(2, FSCHER_REG_FAN1_STATE, FSCHER_REG_FAN1_MIN,
226 FSCHER_REG_FAN1_RIPPLE, FSCHER_REG_FAN1_ACT) 236 FSCHER_REG_FAN1_RIPPLE, FSCHER_REG_FAN1_ACT)
227 sysfs_fan(3, FSCHER_REG_FAN2_STATE, FSCHER_REG_FAN2_MIN, 237 sysfs_fan(3, FSCHER_REG_FAN2_STATE, FSCHER_REG_FAN2_MIN,
228 FSCHER_REG_FAN2_RIPPLE, FSCHER_REG_FAN2_ACT) 238 FSCHER_REG_FAN2_RIPPLE, FSCHER_REG_FAN2_ACT)
229 239
230 sysfs_temp(1, FSCHER_REG_TEMP0_STATE, FSCHER_REG_TEMP0_ACT) 240 sysfs_temp(1, FSCHER_REG_TEMP0_STATE, FSCHER_REG_TEMP0_ACT)
231 sysfs_temp(2, FSCHER_REG_TEMP1_STATE, FSCHER_REG_TEMP1_ACT) 241 sysfs_temp(2, FSCHER_REG_TEMP1_STATE, FSCHER_REG_TEMP1_ACT)
232 sysfs_temp(3, FSCHER_REG_TEMP2_STATE, FSCHER_REG_TEMP2_ACT) 242 sysfs_temp(3, FSCHER_REG_TEMP2_STATE, FSCHER_REG_TEMP2_ACT)
233 243
234 sysfs_in(0, FSCHER_REG_VOLT_12) 244 sysfs_in(0, FSCHER_REG_VOLT_12)
235 sysfs_in(1, FSCHER_REG_VOLT_5) 245 sysfs_in(1, FSCHER_REG_VOLT_5)
236 sysfs_in(2, FSCHER_REG_VOLT_BATT) 246 sysfs_in(2, FSCHER_REG_VOLT_BATT)
237 247
238 sysfs_revision(FSCHER_REG_REVISION) 248 sysfs_revision(FSCHER_REG_REVISION)
239 sysfs_alarms(FSCHER_REG_EVENTS) 249 sysfs_alarms(FSCHER_REG_EVENTS)
240 sysfs_control(FSCHER_REG_CONTROL) 250 sysfs_control(FSCHER_REG_CONTROL)
241 sysfs_watchdog(FSCHER_REG_WDOG_CONTROL, FSCHER_REG_WDOG_STATE, FSCHER_REG_WDOG_PRESET) 251 sysfs_watchdog(FSCHER_REG_WDOG_CONTROL, FSCHER_REG_WDOG_STATE, FSCHER_REG_WDOG_PRESET)
242 252
243 static struct attribute *fscher_attributes[] = { 253 static struct attribute *fscher_attributes[] = {
244 &dev_attr_revision.attr, 254 &dev_attr_revision.attr,
245 &dev_attr_alarms.attr, 255 &dev_attr_alarms.attr,
246 &dev_attr_control.attr, 256 &dev_attr_control.attr,
247 257
248 &dev_attr_watchdog_status.attr, 258 &dev_attr_watchdog_status.attr,
249 &dev_attr_watchdog_control.attr, 259 &dev_attr_watchdog_control.attr,
250 &dev_attr_watchdog_preset.attr, 260 &dev_attr_watchdog_preset.attr,
251 261
252 &dev_attr_in0_input.attr, 262 &dev_attr_in0_input.attr,
253 &dev_attr_in1_input.attr, 263 &dev_attr_in1_input.attr,
254 &dev_attr_in2_input.attr, 264 &dev_attr_in2_input.attr,
255 265
256 &dev_attr_fan1_status.attr, 266 &dev_attr_fan1_status.attr,
257 &dev_attr_fan1_div.attr, 267 &dev_attr_fan1_div.attr,
258 &dev_attr_fan1_input.attr, 268 &dev_attr_fan1_input.attr,
259 &dev_attr_pwm1.attr, 269 &dev_attr_pwm1.attr,
260 &dev_attr_fan2_status.attr, 270 &dev_attr_fan2_status.attr,
261 &dev_attr_fan2_div.attr, 271 &dev_attr_fan2_div.attr,
262 &dev_attr_fan2_input.attr, 272 &dev_attr_fan2_input.attr,
263 &dev_attr_pwm2.attr, 273 &dev_attr_pwm2.attr,
264 &dev_attr_fan3_status.attr, 274 &dev_attr_fan3_status.attr,
265 &dev_attr_fan3_div.attr, 275 &dev_attr_fan3_div.attr,
266 &dev_attr_fan3_input.attr, 276 &dev_attr_fan3_input.attr,
267 &dev_attr_pwm3.attr, 277 &dev_attr_pwm3.attr,
268 278
269 &dev_attr_temp1_status.attr, 279 &dev_attr_temp1_status.attr,
270 &dev_attr_temp1_input.attr, 280 &dev_attr_temp1_input.attr,
271 &dev_attr_temp2_status.attr, 281 &dev_attr_temp2_status.attr,
272 &dev_attr_temp2_input.attr, 282 &dev_attr_temp2_input.attr,
273 &dev_attr_temp3_status.attr, 283 &dev_attr_temp3_status.attr,
274 &dev_attr_temp3_input.attr, 284 &dev_attr_temp3_input.attr,
275 NULL 285 NULL
276 }; 286 };
277 287
278 static const struct attribute_group fscher_group = { 288 static const struct attribute_group fscher_group = {
279 .attrs = fscher_attributes, 289 .attrs = fscher_attributes,
280 }; 290 };
281 291
282 /* 292 /*
283 * Real code 293 * Real code
284 */ 294 */
285 295
286 static int fscher_attach_adapter(struct i2c_adapter *adapter) 296 /* Return 0 if detection is successful, -ENODEV otherwise */
297 static int fscher_detect(struct i2c_client *new_client, int kind,
298 struct i2c_board_info *info)
287 { 299 {
288 if (!(adapter->class & I2C_CLASS_HWMON)) 300 struct i2c_adapter *adapter = new_client->adapter;
289 return 0;
290 return i2c_probe(adapter, &addr_data, fscher_detect);
291 }
292 301
293 static int fscher_detect(struct i2c_adapter *adapter, int address, int kind)
294 {
295 struct i2c_client *new_client;
296 struct fscher_data *data;
297 int err = 0;
298
299 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 302 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
300 goto exit; 303 return -ENODEV;
301 304
302 /* OK. For now, we presume we have a valid client. We now create the
303 * client structure, even though we cannot fill it completely yet.
304 * But it allows us to access i2c_smbus_read_byte_data. */
305 if (!(data = kzalloc(sizeof(struct fscher_data), GFP_KERNEL))) {
306 err = -ENOMEM;
307 goto exit;
308 }
309
310 /* The common I2C client data is placed right before the
311 * Hermes-specific data. */
312 new_client = &data->client;
313 i2c_set_clientdata(new_client, data);
314 new_client->addr = address;
315 new_client->adapter = adapter;
316 new_client->driver = &fscher_driver;
317 new_client->flags = 0;
318
319 /* Do the remaining detection unless force or force_fscher parameter */ 305 /* Do the remaining detection unless force or force_fscher parameter */
320 if (kind < 0) { 306 if (kind < 0) {
321 if ((i2c_smbus_read_byte_data(new_client, 307 if ((i2c_smbus_read_byte_data(new_client,
322 FSCHER_REG_IDENT_0) != 0x48) /* 'H' */ 308 FSCHER_REG_IDENT_0) != 0x48) /* 'H' */
323 || (i2c_smbus_read_byte_data(new_client, 309 || (i2c_smbus_read_byte_data(new_client,
324 FSCHER_REG_IDENT_1) != 0x45) /* 'E' */ 310 FSCHER_REG_IDENT_1) != 0x45) /* 'E' */
325 || (i2c_smbus_read_byte_data(new_client, 311 || (i2c_smbus_read_byte_data(new_client,
326 FSCHER_REG_IDENT_2) != 0x52)) /* 'R' */ 312 FSCHER_REG_IDENT_2) != 0x52)) /* 'R' */
327 goto exit_free; 313 return -ENODEV;
328 } 314 }
329 315
330 /* Fill in the remaining client fields and put it into the 316 strlcpy(info->type, "fscher", I2C_NAME_SIZE);
331 * global list */ 317
332 strlcpy(new_client->name, "fscher", I2C_NAME_SIZE); 318 return 0;
319 }
320
321 static int fscher_probe(struct i2c_client *new_client,
322 const struct i2c_device_id *id)
323 {
324 struct fscher_data *data;
325 int err;
326
327 data = kzalloc(sizeof(struct fscher_data), GFP_KERNEL);
328 if (!data) {
329 err = -ENOMEM;
330 goto exit;
331 }
332
333 i2c_set_clientdata(new_client, data);
333 data->valid = 0; 334 data->valid = 0;
334 mutex_init(&data->update_lock); 335 mutex_init(&data->update_lock);
335 336
336 /* Tell the I2C layer a new client has arrived */
337 if ((err = i2c_attach_client(new_client)))
338 goto exit_free;
339
340 fscher_init_client(new_client); 337 fscher_init_client(new_client);
341 338
342 /* Register sysfs hooks */ 339 /* Register sysfs hooks */
343 if ((err = sysfs_create_group(&new_client->dev.kobj, &fscher_group))) 340 if ((err = sysfs_create_group(&new_client->dev.kobj, &fscher_group)))
344 goto exit_detach; 341 goto exit_free;
345 342
346 data->hwmon_dev = hwmon_device_register(&new_client->dev); 343 data->hwmon_dev = hwmon_device_register(&new_client->dev);
347 if (IS_ERR(data->hwmon_dev)) { 344 if (IS_ERR(data->hwmon_dev)) {
348 err = PTR_ERR(data->hwmon_dev); 345 err = PTR_ERR(data->hwmon_dev);
349 goto exit_remove_files; 346 goto exit_remove_files;
350 } 347 }
351 348
352 return 0; 349 return 0;
353 350
354 exit_remove_files: 351 exit_remove_files:
355 sysfs_remove_group(&new_client->dev.kobj, &fscher_group); 352 sysfs_remove_group(&new_client->dev.kobj, &fscher_group);
356 exit_detach:
357 i2c_detach_client(new_client);
358 exit_free: 353 exit_free:
359 kfree(data); 354 kfree(data);
360 exit: 355 exit:
361 return err; 356 return err;
362 } 357 }
363 358
364 static int fscher_detach_client(struct i2c_client *client) 359 static int fscher_remove(struct i2c_client *client)
365 { 360 {
366 struct fscher_data *data = i2c_get_clientdata(client); 361 struct fscher_data *data = i2c_get_clientdata(client);
367 int err;
368 362
369 hwmon_device_unregister(data->hwmon_dev); 363 hwmon_device_unregister(data->hwmon_dev);
370 sysfs_remove_group(&client->dev.kobj, &fscher_group); 364 sysfs_remove_group(&client->dev.kobj, &fscher_group);
371
372 if ((err = i2c_detach_client(client)))
373 return err;
374 365
375 kfree(data); 366 kfree(data);
376 return 0; 367 return 0;
377 } 368 }
378 369
379 static int fscher_read_value(struct i2c_client *client, u8 reg) 370 static int fscher_read_value(struct i2c_client *client, u8 reg)
380 { 371 {
381 dev_dbg(&client->dev, "read reg 0x%02x\n", reg); 372 dev_dbg(&client->dev, "read reg 0x%02x\n", reg);
382 373
383 return i2c_smbus_read_byte_data(client, reg); 374 return i2c_smbus_read_byte_data(client, reg);
384 } 375 }
385 376
386 static int fscher_write_value(struct i2c_client *client, u8 reg, u8 value) 377 static int fscher_write_value(struct i2c_client *client, u8 reg, u8 value)
387 { 378 {
388 dev_dbg(&client->dev, "write reg 0x%02x, val 0x%02x\n", 379 dev_dbg(&client->dev, "write reg 0x%02x, val 0x%02x\n",
389 reg, value); 380 reg, value);
390 381
391 return i2c_smbus_write_byte_data(client, reg, value); 382 return i2c_smbus_write_byte_data(client, reg, value);
392 } 383 }
393 384
394 /* Called when we have found a new FSC Hermes. */ 385 /* Called when we have found a new FSC Hermes. */
395 static void fscher_init_client(struct i2c_client *client) 386 static void fscher_init_client(struct i2c_client *client)
396 { 387 {
397 struct fscher_data *data = i2c_get_clientdata(client); 388 struct fscher_data *data = i2c_get_clientdata(client);
398 389
399 /* Read revision from chip */ 390 /* Read revision from chip */
400 data->revision = fscher_read_value(client, FSCHER_REG_REVISION); 391 data->revision = fscher_read_value(client, FSCHER_REG_REVISION);
401 } 392 }
402 393
403 static struct fscher_data *fscher_update_device(struct device *dev) 394 static struct fscher_data *fscher_update_device(struct device *dev)
404 { 395 {
405 struct i2c_client *client = to_i2c_client(dev); 396 struct i2c_client *client = to_i2c_client(dev);
406 struct fscher_data *data = i2c_get_clientdata(client); 397 struct fscher_data *data = i2c_get_clientdata(client);
407 398
408 mutex_lock(&data->update_lock); 399 mutex_lock(&data->update_lock);
409 400
410 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) { 401 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
411 402
412 dev_dbg(&client->dev, "Starting fscher update\n"); 403 dev_dbg(&client->dev, "Starting fscher update\n");
413 404
414 data->temp_act[0] = fscher_read_value(client, FSCHER_REG_TEMP0_ACT); 405 data->temp_act[0] = fscher_read_value(client, FSCHER_REG_TEMP0_ACT);
415 data->temp_act[1] = fscher_read_value(client, FSCHER_REG_TEMP1_ACT); 406 data->temp_act[1] = fscher_read_value(client, FSCHER_REG_TEMP1_ACT);
416 data->temp_act[2] = fscher_read_value(client, FSCHER_REG_TEMP2_ACT); 407 data->temp_act[2] = fscher_read_value(client, FSCHER_REG_TEMP2_ACT);
417 data->temp_status[0] = fscher_read_value(client, FSCHER_REG_TEMP0_STATE); 408 data->temp_status[0] = fscher_read_value(client, FSCHER_REG_TEMP0_STATE);
418 data->temp_status[1] = fscher_read_value(client, FSCHER_REG_TEMP1_STATE); 409 data->temp_status[1] = fscher_read_value(client, FSCHER_REG_TEMP1_STATE);
419 data->temp_status[2] = fscher_read_value(client, FSCHER_REG_TEMP2_STATE); 410 data->temp_status[2] = fscher_read_value(client, FSCHER_REG_TEMP2_STATE);
420 411
421 data->volt[0] = fscher_read_value(client, FSCHER_REG_VOLT_12); 412 data->volt[0] = fscher_read_value(client, FSCHER_REG_VOLT_12);
422 data->volt[1] = fscher_read_value(client, FSCHER_REG_VOLT_5); 413 data->volt[1] = fscher_read_value(client, FSCHER_REG_VOLT_5);
423 data->volt[2] = fscher_read_value(client, FSCHER_REG_VOLT_BATT); 414 data->volt[2] = fscher_read_value(client, FSCHER_REG_VOLT_BATT);
424 415
425 data->fan_act[0] = fscher_read_value(client, FSCHER_REG_FAN0_ACT); 416 data->fan_act[0] = fscher_read_value(client, FSCHER_REG_FAN0_ACT);
426 data->fan_act[1] = fscher_read_value(client, FSCHER_REG_FAN1_ACT); 417 data->fan_act[1] = fscher_read_value(client, FSCHER_REG_FAN1_ACT);
427 data->fan_act[2] = fscher_read_value(client, FSCHER_REG_FAN2_ACT); 418 data->fan_act[2] = fscher_read_value(client, FSCHER_REG_FAN2_ACT);
428 data->fan_status[0] = fscher_read_value(client, FSCHER_REG_FAN0_STATE); 419 data->fan_status[0] = fscher_read_value(client, FSCHER_REG_FAN0_STATE);
429 data->fan_status[1] = fscher_read_value(client, FSCHER_REG_FAN1_STATE); 420 data->fan_status[1] = fscher_read_value(client, FSCHER_REG_FAN1_STATE);
430 data->fan_status[2] = fscher_read_value(client, FSCHER_REG_FAN2_STATE); 421 data->fan_status[2] = fscher_read_value(client, FSCHER_REG_FAN2_STATE);
431 data->fan_min[0] = fscher_read_value(client, FSCHER_REG_FAN0_MIN); 422 data->fan_min[0] = fscher_read_value(client, FSCHER_REG_FAN0_MIN);
432 data->fan_min[1] = fscher_read_value(client, FSCHER_REG_FAN1_MIN); 423 data->fan_min[1] = fscher_read_value(client, FSCHER_REG_FAN1_MIN);
433 data->fan_min[2] = fscher_read_value(client, FSCHER_REG_FAN2_MIN); 424 data->fan_min[2] = fscher_read_value(client, FSCHER_REG_FAN2_MIN);
434 data->fan_ripple[0] = fscher_read_value(client, FSCHER_REG_FAN0_RIPPLE); 425 data->fan_ripple[0] = fscher_read_value(client, FSCHER_REG_FAN0_RIPPLE);
435 data->fan_ripple[1] = fscher_read_value(client, FSCHER_REG_FAN1_RIPPLE); 426 data->fan_ripple[1] = fscher_read_value(client, FSCHER_REG_FAN1_RIPPLE);
436 data->fan_ripple[2] = fscher_read_value(client, FSCHER_REG_FAN2_RIPPLE); 427 data->fan_ripple[2] = fscher_read_value(client, FSCHER_REG_FAN2_RIPPLE);
437 428
438 data->watchdog[0] = fscher_read_value(client, FSCHER_REG_WDOG_PRESET); 429 data->watchdog[0] = fscher_read_value(client, FSCHER_REG_WDOG_PRESET);
439 data->watchdog[1] = fscher_read_value(client, FSCHER_REG_WDOG_STATE); 430 data->watchdog[1] = fscher_read_value(client, FSCHER_REG_WDOG_STATE);
440 data->watchdog[2] = fscher_read_value(client, FSCHER_REG_WDOG_CONTROL); 431 data->watchdog[2] = fscher_read_value(client, FSCHER_REG_WDOG_CONTROL);
441 432
442 data->global_event = fscher_read_value(client, FSCHER_REG_EVENT_STATE); 433 data->global_event = fscher_read_value(client, FSCHER_REG_EVENT_STATE);
443 data->global_control = fscher_read_value(client, 434 data->global_control = fscher_read_value(client,
444 FSCHER_REG_CONTROL); 435 FSCHER_REG_CONTROL);
445 436
446 data->last_updated = jiffies; 437 data->last_updated = jiffies;
447 data->valid = 1; 438 data->valid = 1;
448 } 439 }
449 440
450 mutex_unlock(&data->update_lock); 441 mutex_unlock(&data->update_lock);
451 442
452 return data; 443 return data;
453 } 444 }
454 445
455 446
456 447
457 #define FAN_INDEX_FROM_NUM(nr) ((nr) - 1) 448 #define FAN_INDEX_FROM_NUM(nr) ((nr) - 1)
458 449
459 static ssize_t set_fan_status(struct i2c_client *client, struct fscher_data *data, 450 static ssize_t set_fan_status(struct i2c_client *client, struct fscher_data *data,
460 const char *buf, size_t count, int nr, int reg) 451 const char *buf, size_t count, int nr, int reg)
461 { 452 {
462 /* bits 0..1, 3..7 reserved => mask with 0x04 */ 453 /* bits 0..1, 3..7 reserved => mask with 0x04 */
463 unsigned long v = simple_strtoul(buf, NULL, 10) & 0x04; 454 unsigned long v = simple_strtoul(buf, NULL, 10) & 0x04;
464 455
465 mutex_lock(&data->update_lock); 456 mutex_lock(&data->update_lock);
466 data->fan_status[FAN_INDEX_FROM_NUM(nr)] &= ~v; 457 data->fan_status[FAN_INDEX_FROM_NUM(nr)] &= ~v;
467 fscher_write_value(client, reg, v); 458 fscher_write_value(client, reg, v);
468 mutex_unlock(&data->update_lock); 459 mutex_unlock(&data->update_lock);
469 return count; 460 return count;
470 } 461 }
471 462
472 static ssize_t show_fan_status(struct fscher_data *data, char *buf, int nr) 463 static ssize_t show_fan_status(struct fscher_data *data, char *buf, int nr)
473 { 464 {
474 /* bits 0..1, 3..7 reserved => mask with 0x04 */ 465 /* bits 0..1, 3..7 reserved => mask with 0x04 */
475 return sprintf(buf, "%u\n", data->fan_status[FAN_INDEX_FROM_NUM(nr)] & 0x04); 466 return sprintf(buf, "%u\n", data->fan_status[FAN_INDEX_FROM_NUM(nr)] & 0x04);
476 } 467 }
477 468
478 static ssize_t set_pwm(struct i2c_client *client, struct fscher_data *data, 469 static ssize_t set_pwm(struct i2c_client *client, struct fscher_data *data,
479 const char *buf, size_t count, int nr, int reg) 470 const char *buf, size_t count, int nr, int reg)
480 { 471 {
481 unsigned long v = simple_strtoul(buf, NULL, 10); 472 unsigned long v = simple_strtoul(buf, NULL, 10);
482 473
483 mutex_lock(&data->update_lock); 474 mutex_lock(&data->update_lock);
484 data->fan_min[FAN_INDEX_FROM_NUM(nr)] = v > 0xff ? 0xff : v; 475 data->fan_min[FAN_INDEX_FROM_NUM(nr)] = v > 0xff ? 0xff : v;
485 fscher_write_value(client, reg, data->fan_min[FAN_INDEX_FROM_NUM(nr)]); 476 fscher_write_value(client, reg, data->fan_min[FAN_INDEX_FROM_NUM(nr)]);
486 mutex_unlock(&data->update_lock); 477 mutex_unlock(&data->update_lock);
487 return count; 478 return count;
488 } 479 }
489 480
490 static ssize_t show_pwm(struct fscher_data *data, char *buf, int nr) 481 static ssize_t show_pwm(struct fscher_data *data, char *buf, int nr)
491 { 482 {
492 return sprintf(buf, "%u\n", data->fan_min[FAN_INDEX_FROM_NUM(nr)]); 483 return sprintf(buf, "%u\n", data->fan_min[FAN_INDEX_FROM_NUM(nr)]);
493 } 484 }
494 485
495 static ssize_t set_fan_div(struct i2c_client *client, struct fscher_data *data, 486 static ssize_t set_fan_div(struct i2c_client *client, struct fscher_data *data,
496 const char *buf, size_t count, int nr, int reg) 487 const char *buf, size_t count, int nr, int reg)
497 { 488 {
498 /* supported values: 2, 4, 8 */ 489 /* supported values: 2, 4, 8 */
499 unsigned long v = simple_strtoul(buf, NULL, 10); 490 unsigned long v = simple_strtoul(buf, NULL, 10);
500 491
501 switch (v) { 492 switch (v) {
502 case 2: v = 1; break; 493 case 2: v = 1; break;
503 case 4: v = 2; break; 494 case 4: v = 2; break;
504 case 8: v = 3; break; 495 case 8: v = 3; break;
505 default: 496 default:
506 dev_err(&client->dev, "fan_div value %ld not " 497 dev_err(&client->dev, "fan_div value %ld not "
507 "supported. Choose one of 2, 4 or 8!\n", v); 498 "supported. Choose one of 2, 4 or 8!\n", v);
508 return -EINVAL; 499 return -EINVAL;
509 } 500 }
510 501
511 mutex_lock(&data->update_lock); 502 mutex_lock(&data->update_lock);
512 503
513 /* bits 2..7 reserved => mask with 0x03 */ 504 /* bits 2..7 reserved => mask with 0x03 */
514 data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] &= ~0x03; 505 data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] &= ~0x03;
515 data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] |= v; 506 data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] |= v;
516 507
517 fscher_write_value(client, reg, data->fan_ripple[FAN_INDEX_FROM_NUM(nr)]); 508 fscher_write_value(client, reg, data->fan_ripple[FAN_INDEX_FROM_NUM(nr)]);
518 mutex_unlock(&data->update_lock); 509 mutex_unlock(&data->update_lock);
519 return count; 510 return count;
520 } 511 }
521 512
522 static ssize_t show_fan_div(struct fscher_data *data, char *buf, int nr) 513 static ssize_t show_fan_div(struct fscher_data *data, char *buf, int nr)
523 { 514 {
524 /* bits 2..7 reserved => mask with 0x03 */ 515 /* bits 2..7 reserved => mask with 0x03 */
525 return sprintf(buf, "%u\n", 1 << (data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] & 0x03)); 516 return sprintf(buf, "%u\n", 1 << (data->fan_ripple[FAN_INDEX_FROM_NUM(nr)] & 0x03));
526 } 517 }
527 518
528 #define RPM_FROM_REG(val) (val*60) 519 #define RPM_FROM_REG(val) (val*60)
529 520
530 static ssize_t show_fan_input (struct fscher_data *data, char *buf, int nr) 521 static ssize_t show_fan_input (struct fscher_data *data, char *buf, int nr)
531 { 522 {
532 return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[FAN_INDEX_FROM_NUM(nr)])); 523 return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[FAN_INDEX_FROM_NUM(nr)]));
533 } 524 }
534 525
535 526
536 527
537 #define TEMP_INDEX_FROM_NUM(nr) ((nr) - 1) 528 #define TEMP_INDEX_FROM_NUM(nr) ((nr) - 1)
538 529
539 static ssize_t set_temp_status(struct i2c_client *client, struct fscher_data *data, 530 static ssize_t set_temp_status(struct i2c_client *client, struct fscher_data *data,
540 const char *buf, size_t count, int nr, int reg) 531 const char *buf, size_t count, int nr, int reg)
541 { 532 {
542 /* bits 2..7 reserved, 0 read only => mask with 0x02 */ 533 /* bits 2..7 reserved, 0 read only => mask with 0x02 */
543 unsigned long v = simple_strtoul(buf, NULL, 10) & 0x02; 534 unsigned long v = simple_strtoul(buf, NULL, 10) & 0x02;
544 535
545 mutex_lock(&data->update_lock); 536 mutex_lock(&data->update_lock);
546 data->temp_status[TEMP_INDEX_FROM_NUM(nr)] &= ~v; 537 data->temp_status[TEMP_INDEX_FROM_NUM(nr)] &= ~v;
547 fscher_write_value(client, reg, v); 538 fscher_write_value(client, reg, v);
548 mutex_unlock(&data->update_lock); 539 mutex_unlock(&data->update_lock);
549 return count; 540 return count;
550 } 541 }
551 542
552 static ssize_t show_temp_status(struct fscher_data *data, char *buf, int nr) 543 static ssize_t show_temp_status(struct fscher_data *data, char *buf, int nr)
553 { 544 {
554 /* bits 2..7 reserved => mask with 0x03 */ 545 /* bits 2..7 reserved => mask with 0x03 */
555 return sprintf(buf, "%u\n", data->temp_status[TEMP_INDEX_FROM_NUM(nr)] & 0x03); 546 return sprintf(buf, "%u\n", data->temp_status[TEMP_INDEX_FROM_NUM(nr)] & 0x03);
556 } 547 }
557 548
558 #define TEMP_FROM_REG(val) (((val) - 128) * 1000) 549 #define TEMP_FROM_REG(val) (((val) - 128) * 1000)
559 550
560 static ssize_t show_temp_input(struct fscher_data *data, char *buf, int nr) 551 static ssize_t show_temp_input(struct fscher_data *data, char *buf, int nr)
561 { 552 {
562 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[TEMP_INDEX_FROM_NUM(nr)])); 553 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[TEMP_INDEX_FROM_NUM(nr)]));
563 } 554 }
564 555
565 /* 556 /*
566 * The final conversion is specified in sensors.conf, as it depends on 557 * The final conversion is specified in sensors.conf, as it depends on
567 * mainboard specific values. We export the registers contents as 558 * mainboard specific values. We export the registers contents as
568 * pseudo-hundredths-of-Volts (range 0V - 2.55V). Not that it makes much 559 * pseudo-hundredths-of-Volts (range 0V - 2.55V). Not that it makes much
569 * sense per se, but it minimizes the conversions count and keeps the 560 * sense per se, but it minimizes the conversions count and keeps the
570 * values within a usual range. 561 * values within a usual range.
571 */ 562 */
572 #define VOLT_FROM_REG(val) ((val) * 10) 563 #define VOLT_FROM_REG(val) ((val) * 10)
573 564
574 static ssize_t show_in_input(struct fscher_data *data, char *buf, int nr) 565 static ssize_t show_in_input(struct fscher_data *data, char *buf, int nr)
575 { 566 {
576 return sprintf(buf, "%u\n", VOLT_FROM_REG(data->volt[nr])); 567 return sprintf(buf, "%u\n", VOLT_FROM_REG(data->volt[nr]));
577 } 568 }
578 569
579 570
580 571
581 static ssize_t show_revision(struct fscher_data *data, char *buf, int nr) 572 static ssize_t show_revision(struct fscher_data *data, char *buf, int nr)
582 { 573 {
583 return sprintf(buf, "%u\n", data->revision); 574 return sprintf(buf, "%u\n", data->revision);
584 } 575 }
585 576
586 577
587 578
588 static ssize_t show_alarms(struct fscher_data *data, char *buf, int nr) 579 static ssize_t show_alarms(struct fscher_data *data, char *buf, int nr)
589 { 580 {
590 /* bits 2, 5..6 reserved => mask with 0x9b */ 581 /* bits 2, 5..6 reserved => mask with 0x9b */
591 return sprintf(buf, "%u\n", data->global_event & 0x9b); 582 return sprintf(buf, "%u\n", data->global_event & 0x9b);
592 } 583 }
593 584
594 585
595 586
596 static ssize_t set_control(struct i2c_client *client, struct fscher_data *data, 587 static ssize_t set_control(struct i2c_client *client, struct fscher_data *data,
597 const char *buf, size_t count, int nr, int reg) 588 const char *buf, size_t count, int nr, int reg)
598 { 589 {
599 /* bits 1..7 reserved => mask with 0x01 */ 590 /* bits 1..7 reserved => mask with 0x01 */
600 unsigned long v = simple_strtoul(buf, NULL, 10) & 0x01; 591 unsigned long v = simple_strtoul(buf, NULL, 10) & 0x01;
601 592
602 mutex_lock(&data->update_lock); 593 mutex_lock(&data->update_lock);
603 data->global_control = v; 594 data->global_control = v;
604 fscher_write_value(client, reg, v); 595 fscher_write_value(client, reg, v);
605 mutex_unlock(&data->update_lock); 596 mutex_unlock(&data->update_lock);
606 return count; 597 return count;
607 } 598 }
608 599
609 static ssize_t show_control(struct fscher_data *data, char *buf, int nr) 600 static ssize_t show_control(struct fscher_data *data, char *buf, int nr)
610 { 601 {
611 /* bits 1..7 reserved => mask with 0x01 */ 602 /* bits 1..7 reserved => mask with 0x01 */
612 return sprintf(buf, "%u\n", data->global_control & 0x01); 603 return sprintf(buf, "%u\n", data->global_control & 0x01);
613 } 604 }
614 605
615 606
616 607
617 static ssize_t set_watchdog_control(struct i2c_client *client, struct 608 static ssize_t set_watchdog_control(struct i2c_client *client, struct
618 fscher_data *data, const char *buf, size_t count, 609 fscher_data *data, const char *buf, size_t count,
619 int nr, int reg) 610 int nr, int reg)
620 { 611 {
621 /* bits 0..3 reserved => mask with 0xf0 */ 612 /* bits 0..3 reserved => mask with 0xf0 */
622 unsigned long v = simple_strtoul(buf, NULL, 10) & 0xf0; 613 unsigned long v = simple_strtoul(buf, NULL, 10) & 0xf0;
623 614
624 mutex_lock(&data->update_lock); 615 mutex_lock(&data->update_lock);
625 data->watchdog[2] &= ~0xf0; 616 data->watchdog[2] &= ~0xf0;
626 data->watchdog[2] |= v; 617 data->watchdog[2] |= v;
627 fscher_write_value(client, reg, data->watchdog[2]); 618 fscher_write_value(client, reg, data->watchdog[2]);
628 mutex_unlock(&data->update_lock); 619 mutex_unlock(&data->update_lock);
629 return count; 620 return count;
630 } 621 }
631 622
632 static ssize_t show_watchdog_control(struct fscher_data *data, char *buf, int nr) 623 static ssize_t show_watchdog_control(struct fscher_data *data, char *buf, int nr)
633 { 624 {
634 /* bits 0..3 reserved, bit 5 write only => mask with 0xd0 */ 625 /* bits 0..3 reserved, bit 5 write only => mask with 0xd0 */
635 return sprintf(buf, "%u\n", data->watchdog[2] & 0xd0); 626 return sprintf(buf, "%u\n", data->watchdog[2] & 0xd0);
636 } 627 }
637 628
638 static ssize_t set_watchdog_status(struct i2c_client *client, struct fscher_data *data, 629 static ssize_t set_watchdog_status(struct i2c_client *client, struct fscher_data *data,
639 const char *buf, size_t count, int nr, int reg) 630 const char *buf, size_t count, int nr, int reg)
640 { 631 {
641 /* bits 0, 2..7 reserved => mask with 0x02 */ 632 /* bits 0, 2..7 reserved => mask with 0x02 */
642 unsigned long v = simple_strtoul(buf, NULL, 10) & 0x02; 633 unsigned long v = simple_strtoul(buf, NULL, 10) & 0x02;
643 634
644 mutex_lock(&data->update_lock); 635 mutex_lock(&data->update_lock);
645 data->watchdog[1] &= ~v; 636 data->watchdog[1] &= ~v;
646 fscher_write_value(client, reg, v); 637 fscher_write_value(client, reg, v);
647 mutex_unlock(&data->update_lock); 638 mutex_unlock(&data->update_lock);
648 return count; 639 return count;
649 } 640 }
650 641
651 static ssize_t show_watchdog_status(struct fscher_data *data, char *buf, int nr) 642 static ssize_t show_watchdog_status(struct fscher_data *data, char *buf, int nr)
652 { 643 {
653 /* bits 0, 2..7 reserved => mask with 0x02 */ 644 /* bits 0, 2..7 reserved => mask with 0x02 */
654 return sprintf(buf, "%u\n", data->watchdog[1] & 0x02); 645 return sprintf(buf, "%u\n", data->watchdog[1] & 0x02);
655 } 646 }
656 647
657 static ssize_t set_watchdog_preset(struct i2c_client *client, struct fscher_data *data, 648 static ssize_t set_watchdog_preset(struct i2c_client *client, struct fscher_data *data,
658 const char *buf, size_t count, int nr, int reg) 649 const char *buf, size_t count, int nr, int reg)
659 { 650 {
660 unsigned long v = simple_strtoul(buf, NULL, 10) & 0xff; 651 unsigned long v = simple_strtoul(buf, NULL, 10) & 0xff;
661 652
662 mutex_lock(&data->update_lock); 653 mutex_lock(&data->update_lock);