Diff markup
1 /* 1 /*
2 gl520sm.c - Part of lm_sensors, Linux kern 2 gl520sm.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring 3 monitoring
4 Copyright (c) 1998, 1999 Frodo Looijaard 4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>,
5 Kyösti Mälkki 5 Kyösti Mälkki <kmalkki@cc.hut.fi>
6 Copyright (c) 2005 Maarten Deprez < 6 Copyright (c) 2005 Maarten Deprez <maartendeprez@users.sourceforge.net>
7 7
8 This program is free software; you can red 8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Publ 9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either versi 10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version. 11 (at your option) any later version.
12 12
13 This program is distributed in the hope th 13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the 14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULA 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more detail 16 GNU General Public License for more details.
17 17
18 You should have received a copy of the GNU 18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to 19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 21
22 */ 22 */
23 23
24 #include <linux/module.h> 24 #include <linux/module.h>
25 #include <linux/init.h> 25 #include <linux/init.h>
26 #include <linux/slab.h> 26 #include <linux/slab.h>
27 #include <linux/jiffies.h> 27 #include <linux/jiffies.h>
28 #include <linux/i2c.h> 28 #include <linux/i2c.h>
29 #include <linux/hwmon.h> 29 #include <linux/hwmon.h>
30 #include <linux/hwmon-sysfs.h> 30 #include <linux/hwmon-sysfs.h>
31 #include <linux/hwmon-vid.h> 31 #include <linux/hwmon-vid.h>
32 #include <linux/err.h> 32 #include <linux/err.h>
33 #include <linux/mutex.h> 33 #include <linux/mutex.h>
34 #include <linux/sysfs.h> 34 #include <linux/sysfs.h>
35 35
36 /* Type of the extra sensor */ 36 /* Type of the extra sensor */
37 static unsigned short extra_sensor_type; 37 static unsigned short extra_sensor_type;
38 module_param(extra_sensor_type, ushort, 0); 38 module_param(extra_sensor_type, ushort, 0);
39 MODULE_PARM_DESC(extra_sensor_type, "Type of e 39 MODULE_PARM_DESC(extra_sensor_type, "Type of extra sensor (0=autodetect, 1=temperature, 2=voltage)");
40 40
41 /* Addresses to scan */ 41 /* Addresses to scan */
42 static const unsigned short normal_i2c[] = { 0 42 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
43 43
44 /* Insmod parameters */ 44 /* Insmod parameters */
45 I2C_CLIENT_INSMOD_1(gl520sm); 45 I2C_CLIENT_INSMOD_1(gl520sm);
46 46
47 /* Many GL520 constants specified below 47 /* Many GL520 constants specified below
48 One of the inputs can be configured as either 48 One of the inputs can be configured as either temp or voltage.
49 That's why _TEMP2 and _IN4 access the same reg 49 That's why _TEMP2 and _IN4 access the same register
50 */ 50 */
51 51
52 /* The GL520 registers */ 52 /* The GL520 registers */
53 #define GL520_REG_CHIP_ID 0x00 53 #define GL520_REG_CHIP_ID 0x00
54 #define GL520_REG_REVISION 0x01 54 #define GL520_REG_REVISION 0x01
55 #define GL520_REG_CONF 0x03 55 #define GL520_REG_CONF 0x03
56 #define GL520_REG_MASK 0x11 56 #define GL520_REG_MASK 0x11
57 57
58 #define GL520_REG_VID_INPUT 0x02 58 #define GL520_REG_VID_INPUT 0x02
59 59
60 static const u8 GL520_REG_IN_INPUT[] = { 0x 60 static const u8 GL520_REG_IN_INPUT[] = { 0x15, 0x14, 0x13, 0x0d, 0x0e };
61 static const u8 GL520_REG_IN_LIMIT[] = { 0x 61 static const u8 GL520_REG_IN_LIMIT[] = { 0x0c, 0x09, 0x0a, 0x0b };
62 static const u8 GL520_REG_IN_MIN[] = { 0x 62 static const u8 GL520_REG_IN_MIN[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x18 };
63 static const u8 GL520_REG_IN_MAX[] = { 0x 63 static const u8 GL520_REG_IN_MAX[] = { 0x0c, 0x09, 0x0a, 0x0b, 0x17 };
64 64
65 static const u8 GL520_REG_TEMP_INPUT[] 65 static const u8 GL520_REG_TEMP_INPUT[] = { 0x04, 0x0e };
66 static const u8 GL520_REG_TEMP_MAX[] 66 static const u8 GL520_REG_TEMP_MAX[] = { 0x05, 0x17 };
67 static const u8 GL520_REG_TEMP_MAX_HYST[] 67 static const u8 GL520_REG_TEMP_MAX_HYST[] = { 0x06, 0x18 };
68 68
69 #define GL520_REG_FAN_INPUT 0x07 69 #define GL520_REG_FAN_INPUT 0x07
70 #define GL520_REG_FAN_MIN 0x08 70 #define GL520_REG_FAN_MIN 0x08
71 #define GL520_REG_FAN_DIV 0x0f 71 #define GL520_REG_FAN_DIV 0x0f
72 #define GL520_REG_FAN_OFF GL520_ 72 #define GL520_REG_FAN_OFF GL520_REG_FAN_DIV
73 73
74 #define GL520_REG_ALARMS 0x12 74 #define GL520_REG_ALARMS 0x12
75 #define GL520_REG_BEEP_MASK 0x10 75 #define GL520_REG_BEEP_MASK 0x10
76 #define GL520_REG_BEEP_ENABLE GL520_ 76 #define GL520_REG_BEEP_ENABLE GL520_REG_CONF
77 77
78 /* 78 /*
79 * Function declarations 79 * Function declarations
80 */ 80 */
81 81
82 static int gl520_probe(struct i2c_client *clie !! 82 static int gl520_attach_adapter(struct i2c_adapter *adapter);
83 const struct i2c_device !! 83 static int gl520_detect(struct i2c_adapter *adapter, int address, int kind);
84 static int gl520_detect(struct i2c_client *cli <<
85 struct i2c_board_info <<
86 static void gl520_init_client(struct i2c_clien 84 static void gl520_init_client(struct i2c_client *client);
87 static int gl520_remove(struct i2c_client *cli !! 85 static int gl520_detach_client(struct i2c_client *client);
88 static int gl520_read_value(struct i2c_client 86 static int gl520_read_value(struct i2c_client *client, u8 reg);
89 static int gl520_write_value(struct i2c_client 87 static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value);
90 static struct gl520_data *gl520_update_device( 88 static struct gl520_data *gl520_update_device(struct device *dev);
91 89
92 /* Driver data */ 90 /* Driver data */
93 static const struct i2c_device_id gl520_id[] = <<
94 { "gl520sm", gl520sm }, <<
95 { } <<
96 }; <<
97 MODULE_DEVICE_TABLE(i2c, gl520_id); <<
98 <<
99 static struct i2c_driver gl520_driver = { 91 static struct i2c_driver gl520_driver = {
100 .class = I2C_CLASS_HWMON, <<
101 .driver = { 92 .driver = {
102 .name = "gl520sm", 93 .name = "gl520sm",
103 }, 94 },
104 .probe = gl520_probe, !! 95 .attach_adapter = gl520_attach_adapter,
105 .remove = gl520_remove, !! 96 .detach_client = gl520_detach_client,
106 .id_table = gl520_id, <<
107 .detect = gl520_detect, <<
108 .address_data = &addr_data, <<
109 }; 97 };
110 98
111 /* Client data */ 99 /* Client data */
112 struct gl520_data { 100 struct gl520_data {
>> 101 struct i2c_client client;
113 struct device *hwmon_dev; 102 struct device *hwmon_dev;
114 struct mutex update_lock; 103 struct mutex update_lock;
115 char valid; /* zero until 104 char valid; /* zero until the following fields are valid */
116 unsigned long last_updated; /* in 105 unsigned long last_updated; /* in jiffies */
117 106
118 u8 vid; 107 u8 vid;
119 u8 vrm; 108 u8 vrm;
120 u8 in_input[5]; /* [0] = VVD * 109 u8 in_input[5]; /* [0] = VVD */
121 u8 in_min[5]; /* [0] = VDD * 110 u8 in_min[5]; /* [0] = VDD */
122 u8 in_max[5]; /* [0] = VDD * 111 u8 in_max[5]; /* [0] = VDD */
123 u8 fan_input[2]; 112 u8 fan_input[2];
124 u8 fan_min[2]; 113 u8 fan_min[2];
125 u8 fan_div[2]; 114 u8 fan_div[2];
126 u8 fan_off; 115 u8 fan_off;
127 u8 temp_input[2]; 116 u8 temp_input[2];
128 u8 temp_max[2]; 117 u8 temp_max[2];
129 u8 temp_max_hyst[2]; 118 u8 temp_max_hyst[2];
130 u8 alarms; 119 u8 alarms;
131 u8 beep_enable; 120 u8 beep_enable;
132 u8 beep_mask; 121 u8 beep_mask;
133 u8 alarm_mask; 122 u8 alarm_mask;
134 u8 two_temps; 123 u8 two_temps;
135 }; 124 };
136 125
137 /* 126 /*
138 * Sysfs stuff 127 * Sysfs stuff
139 */ 128 */
140 129
141 static ssize_t get_cpu_vid(struct device *dev, 130 static ssize_t get_cpu_vid(struct device *dev, struct device_attribute *attr,
142 char *buf) 131 char *buf)
143 { 132 {
144 struct gl520_data *data = gl520_update 133 struct gl520_data *data = gl520_update_device(dev);
145 return sprintf(buf, "%u\n", vid_from_r 134 return sprintf(buf, "%u\n", vid_from_reg(data->vid, data->vrm));
146 } 135 }
147 static DEVICE_ATTR(cpu0_vid, S_IRUGO, get_cpu_ 136 static DEVICE_ATTR(cpu0_vid, S_IRUGO, get_cpu_vid, NULL);
148 137
149 #define VDD_FROM_REG(val) (((val)*95+2)/4) 138 #define VDD_FROM_REG(val) (((val)*95+2)/4)
150 #define VDD_TO_REG(val) (SENSORS_LIMIT((((val) 139 #define VDD_TO_REG(val) (SENSORS_LIMIT((((val)*4+47)/95),0,255))
151 140
152 #define IN_FROM_REG(val) ((val)*19) 141 #define IN_FROM_REG(val) ((val)*19)
153 #define IN_TO_REG(val) (SENSORS_LIMIT((((val)+ 142 #define IN_TO_REG(val) (SENSORS_LIMIT((((val)+9)/19),0,255))
154 143
155 static ssize_t get_in_input(struct device *dev 144 static ssize_t get_in_input(struct device *dev, struct device_attribute *attr,
156 char *buf) 145 char *buf)
157 { 146 {
158 int n = to_sensor_dev_attr(attr)->inde 147 int n = to_sensor_dev_attr(attr)->index;
159 struct gl520_data *data = gl520_update 148 struct gl520_data *data = gl520_update_device(dev);
160 u8 r = data->in_input[n]; 149 u8 r = data->in_input[n];
161 150
162 if (n == 0) 151 if (n == 0)
163 return sprintf(buf, "%d\n", VD 152 return sprintf(buf, "%d\n", VDD_FROM_REG(r));
164 else 153 else
165 return sprintf(buf, "%d\n", IN 154 return sprintf(buf, "%d\n", IN_FROM_REG(r));
166 } 155 }
167 156
168 static ssize_t get_in_min(struct device *dev, 157 static ssize_t get_in_min(struct device *dev, struct device_attribute *attr,
169 char *buf) 158 char *buf)
170 { 159 {
171 int n = to_sensor_dev_attr(attr)->inde 160 int n = to_sensor_dev_attr(attr)->index;
172 struct gl520_data *data = gl520_update 161 struct gl520_data *data = gl520_update_device(dev);
173 u8 r = data->in_min[n]; 162 u8 r = data->in_min[n];
174 163
175 if (n == 0) 164 if (n == 0)
176 return sprintf(buf, "%d\n", VD 165 return sprintf(buf, "%d\n", VDD_FROM_REG(r));
177 else 166 else
178 return sprintf(buf, "%d\n", IN 167 return sprintf(buf, "%d\n", IN_FROM_REG(r));
179 } 168 }
180 169
181 static ssize_t get_in_max(struct device *dev, 170 static ssize_t get_in_max(struct device *dev, struct device_attribute *attr,
182 char *buf) 171 char *buf)
183 { 172 {
184 int n = to_sensor_dev_attr(attr)->inde 173 int n = to_sensor_dev_attr(attr)->index;
185 struct gl520_data *data = gl520_update 174 struct gl520_data *data = gl520_update_device(dev);
186 u8 r = data->in_max[n]; 175 u8 r = data->in_max[n];
187 176
188 if (n == 0) 177 if (n == 0)
189 return sprintf(buf, "%d\n", VD 178 return sprintf(buf, "%d\n", VDD_FROM_REG(r));
190 else 179 else
191 return sprintf(buf, "%d\n", IN 180 return sprintf(buf, "%d\n", IN_FROM_REG(r));
192 } 181 }
193 182
194 static ssize_t set_in_min(struct device *dev, 183 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
195 const char *buf, siz 184 const char *buf, size_t count)
196 { 185 {
197 struct i2c_client *client = to_i2c_cli 186 struct i2c_client *client = to_i2c_client(dev);
198 struct gl520_data *data = i2c_get_clie 187 struct gl520_data *data = i2c_get_clientdata(client);
199 int n = to_sensor_dev_attr(attr)->inde 188 int n = to_sensor_dev_attr(attr)->index;
200 long v = simple_strtol(buf, NULL, 10); 189 long v = simple_strtol(buf, NULL, 10);
201 u8 r; 190 u8 r;
202 191
203 mutex_lock(&data->update_lock); 192 mutex_lock(&data->update_lock);
204 193
205 if (n == 0) 194 if (n == 0)
206 r = VDD_TO_REG(v); 195 r = VDD_TO_REG(v);
207 else 196 else
208 r = IN_TO_REG(v); 197 r = IN_TO_REG(v);
209 198
210 data->in_min[n] = r; 199 data->in_min[n] = r;
211 200
212 if (n < 4) 201 if (n < 4)
213 gl520_write_value(client, GL52 202 gl520_write_value(client, GL520_REG_IN_MIN[n],
214 (gl520_read_ 203 (gl520_read_value(client, GL520_REG_IN_MIN[n])
215 & ~0xff) | 204 & ~0xff) | r);
216 else 205 else
217 gl520_write_value(client, GL52 206 gl520_write_value(client, GL520_REG_IN_MIN[n], r);
218 207
219 mutex_unlock(&data->update_lock); 208 mutex_unlock(&data->update_lock);
220 return count; 209 return count;
221 } 210 }
222 211
223 static ssize_t set_in_max(struct device *dev, 212 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
224 const char *buf, siz 213 const char *buf, size_t count)
225 { 214 {
226 struct i2c_client *client = to_i2c_cli 215 struct i2c_client *client = to_i2c_client(dev);
227 struct gl520_data *data = i2c_get_clie 216 struct gl520_data *data = i2c_get_clientdata(client);
228 int n = to_sensor_dev_attr(attr)->inde 217 int n = to_sensor_dev_attr(attr)->index;
229 long v = simple_strtol(buf, NULL, 10); 218 long v = simple_strtol(buf, NULL, 10);
230 u8 r; 219 u8 r;
231 220
232 if (n == 0) 221 if (n == 0)
233 r = VDD_TO_REG(v); 222 r = VDD_TO_REG(v);
234 else 223 else
235 r = IN_TO_REG(v); 224 r = IN_TO_REG(v);
236 225
237 mutex_lock(&data->update_lock); 226 mutex_lock(&data->update_lock);
238 227
239 data->in_max[n] = r; 228 data->in_max[n] = r;
240 229
241 if (n < 4) 230 if (n < 4)
242 gl520_write_value(client, GL52 231 gl520_write_value(client, GL520_REG_IN_MAX[n],
243 (gl520_read_ 232 (gl520_read_value(client, GL520_REG_IN_MAX[n])
244 & ~0xff00) 233 & ~0xff00) | (r << 8));
245 else 234 else
246 gl520_write_value(client, GL52 235 gl520_write_value(client, GL520_REG_IN_MAX[n], r);
247 236
248 mutex_unlock(&data->update_lock); 237 mutex_unlock(&data->update_lock);
249 return count; 238 return count;
250 } 239 }
251 240
252 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, 241 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, get_in_input, NULL, 0);
253 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, 242 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, get_in_input, NULL, 1);
254 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, 243 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, get_in_input, NULL, 2);
255 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, 244 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, get_in_input, NULL, 3);
256 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, 245 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, get_in_input, NULL, 4);
257 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S 246 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO | S_IWUSR,
258 get_in_min, set_in_min, 0); 247 get_in_min, set_in_min, 0);
259 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S 248 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO | S_IWUSR,
260 get_in_min, set_in_min, 1); 249 get_in_min, set_in_min, 1);
261 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S 250 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO | S_IWUSR,
262 get_in_min, set_in_min, 2); 251 get_in_min, set_in_min, 2);
263 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S 252 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO | S_IWUSR,
264 get_in_min, set_in_min, 3); 253 get_in_min, set_in_min, 3);
265 static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S 254 static SENSOR_DEVICE_ATTR(in4_min, S_IRUGO | S_IWUSR,
266 get_in_min, set_in_min, 4); 255 get_in_min, set_in_min, 4);
267 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S 256 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO | S_IWUSR,
268 get_in_max, set_in_max, 0); 257 get_in_max, set_in_max, 0);
269 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S 258 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO | S_IWUSR,
270 get_in_max, set_in_max, 1); 259 get_in_max, set_in_max, 1);
271 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S 260 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO | S_IWUSR,
272 get_in_max, set_in_max, 2); 261 get_in_max, set_in_max, 2);
273 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S 262 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO | S_IWUSR,
274 get_in_max, set_in_max, 3); 263 get_in_max, set_in_max, 3);
275 static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S 264 static SENSOR_DEVICE_ATTR(in4_max, S_IRUGO | S_IWUSR,
276 get_in_max, set_in_max, 4); 265 get_in_max, set_in_max, 4);
277 266
278 #define DIV_FROM_REG(val) (1 << (val)) 267 #define DIV_FROM_REG(val) (1 << (val))
279 #define FAN_FROM_REG(val,div) ((val)==0 ? 0 : 268 #define FAN_FROM_REG(val,div) ((val)==0 ? 0 : (480000/((val) << (div))))
280 #define FAN_TO_REG(val,div) ((val)<=0?0:SENSOR 269 #define FAN_TO_REG(val,div) ((val)<=0?0:SENSORS_LIMIT((480000 + ((val) << ((div)-1))) / ((val) << (div)), 1, 255));
281 270
282 static ssize_t get_fan_input(struct device *de 271 static ssize_t get_fan_input(struct device *dev, struct device_attribute *attr,
283 char *buf) 272 char *buf)
284 { 273 {
285 int n = to_sensor_dev_attr(attr)->inde 274 int n = to_sensor_dev_attr(attr)->index;
286 struct gl520_data *data = gl520_update 275 struct gl520_data *data = gl520_update_device(dev);
287 276
288 return sprintf(buf, "%d\n", FAN_FROM_R 277 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_input[n],
289 278 data->fan_div[n]));
290 } 279 }
291 280
292 static ssize_t get_fan_min(struct device *dev, 281 static ssize_t get_fan_min(struct device *dev, struct device_attribute *attr,
293 char *buf) 282 char *buf)
294 { 283 {
295 int n = to_sensor_dev_attr(attr)->inde 284 int n = to_sensor_dev_attr(attr)->index;
296 struct gl520_data *data = gl520_update 285 struct gl520_data *data = gl520_update_device(dev);
297 286
298 return sprintf(buf, "%d\n", FAN_FROM_R 287 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[n],
299 288 data->fan_div[n]));
300 } 289 }
301 290
302 static ssize_t get_fan_div(struct device *dev, 291 static ssize_t get_fan_div(struct device *dev, struct device_attribute *attr,
303 char *buf) 292 char *buf)
304 { 293 {
305 int n = to_sensor_dev_attr(attr)->inde 294 int n = to_sensor_dev_attr(attr)->index;
306 struct gl520_data *data = gl520_update 295 struct gl520_data *data = gl520_update_device(dev);
307 296
308 return sprintf(buf, "%d\n", DIV_FROM_R 297 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[n]));
309 } 298 }
310 299
311 static ssize_t get_fan_off(struct device *dev, 300 static ssize_t get_fan_off(struct device *dev, struct device_attribute *attr,
312 char *buf) 301 char *buf)
313 { 302 {
314 struct gl520_data *data = gl520_update 303 struct gl520_data *data = gl520_update_device(dev);
315 return sprintf(buf, "%d\n", data->fan_ 304 return sprintf(buf, "%d\n", data->fan_off);
316 } 305 }
317 306
318 static ssize_t set_fan_min(struct device *dev, 307 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
319 const char *buf, si 308 const char *buf, size_t count)
320 { 309 {
321 struct i2c_client *client = to_i2c_cli 310 struct i2c_client *client = to_i2c_client(dev);
322 struct gl520_data *data = i2c_get_clie 311 struct gl520_data *data = i2c_get_clientdata(client);
323 int n = to_sensor_dev_attr(attr)->inde 312 int n = to_sensor_dev_attr(attr)->index;
324 unsigned long v = simple_strtoul(buf, 313 unsigned long v = simple_strtoul(buf, NULL, 10);
325 u8 r; 314 u8 r;
326 315
327 mutex_lock(&data->update_lock); 316 mutex_lock(&data->update_lock);
328 r = FAN_TO_REG(v, data->fan_div[n]); 317 r = FAN_TO_REG(v, data->fan_div[n]);
329 data->fan_min[n] = r; 318 data->fan_min[n] = r;
330 319
331 if (n == 0) 320 if (n == 0)
332 gl520_write_value(client, GL52 321 gl520_write_value(client, GL520_REG_FAN_MIN,
333 (gl520_read_ 322 (gl520_read_value(client, GL520_REG_FAN_MIN)
334 & ~0xff00) 323 & ~0xff00) | (r << 8));
335 else 324 else
336 gl520_write_value(client, GL52 325 gl520_write_value(client, GL520_REG_FAN_MIN,
337 (gl520_read_ 326 (gl520_read_value(client, GL520_REG_FAN_MIN)
338 & ~0xff) | 327 & ~0xff) | r);
339 328
340 data->beep_mask = gl520_read_value(cli 329 data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
341 if (data->fan_min[n] == 0) 330 if (data->fan_min[n] == 0)
342 data->alarm_mask &= (n == 0) ? 331 data->alarm_mask &= (n == 0) ? ~0x20 : ~0x40;
343 else 332 else
344 data->alarm_mask |= (n == 0) ? 333 data->alarm_mask |= (n == 0) ? 0x20 : 0x40;
345 data->beep_mask &= data->alarm_mask; 334 data->beep_mask &= data->alarm_mask;
346 gl520_write_value(client, GL520_REG_BE 335 gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
347 336
348 mutex_unlock(&data->update_lock); 337 mutex_unlock(&data->update_lock);
349 return count; 338 return count;
350 } 339 }
351 340
352 static ssize_t set_fan_div(struct device *dev, 341 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
353 const char *buf, si 342 const char *buf, size_t count)
354 { 343 {
355 struct i2c_client *client = to_i2c_cli 344 struct i2c_client *client = to_i2c_client(dev);
356 struct gl520_data *data = i2c_get_clie 345 struct gl520_data *data = i2c_get_clientdata(client);
357 int n = to_sensor_dev_attr(attr)->inde 346 int n = to_sensor_dev_attr(attr)->index;
358 unsigned long v = simple_strtoul(buf, 347 unsigned long v = simple_strtoul(buf, NULL, 10);
359 u8 r; 348 u8 r;
360 349
361 switch (v) { 350 switch (v) {
362 case 1: r = 0; break; 351 case 1: r = 0; break;
363 case 2: r = 1; break; 352 case 2: r = 1; break;
364 case 4: r = 2; break; 353 case 4: r = 2; break;
365 case 8: r = 3; break; 354 case 8: r = 3; break;
366 default: 355 default:
367 dev_err(&client->dev, "fan_div 356 dev_err(&client->dev, "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n", v);
368 return -EINVAL; 357 return -EINVAL;
369 } 358 }
370 359
371 mutex_lock(&data->update_lock); 360 mutex_lock(&data->update_lock);
372 data->fan_div[n] = r; 361 data->fan_div[n] = r;
373 362
374 if (n == 0) 363 if (n == 0)
375 gl520_write_value(client, GL52 364 gl520_write_value(client, GL520_REG_FAN_DIV,
376 (gl520_read_ 365 (gl520_read_value(client, GL520_REG_FAN_DIV)
377 & ~0xc0) | 366 & ~0xc0) | (r << 6));
378 else 367 else
379 gl520_write_value(client, GL52 368 gl520_write_value(client, GL520_REG_FAN_DIV,
380 (gl520_read_ 369 (gl520_read_value(client, GL520_REG_FAN_DIV)
381 & ~0x30) | 370 & ~0x30) | (r << 4));
382 371
383 mutex_unlock(&data->update_lock); 372 mutex_unlock(&data->update_lock);
384 return count; 373 return count;
385 } 374 }
386 375
387 static ssize_t set_fan_off(struct device *dev, 376 static ssize_t set_fan_off(struct device *dev, struct device_attribute *attr,
388 const char *buf, si 377 const char *buf, size_t count)
389 { 378 {
390 struct i2c_client *client = to_i2c_cli 379 struct i2c_client *client = to_i2c_client(dev);
391 struct gl520_data *data = i2c_get_clie 380 struct gl520_data *data = i2c_get_clientdata(client);
392 u8 r = simple_strtoul(buf, NULL, 10)?1 381 u8 r = simple_strtoul(buf, NULL, 10)?1:0;
393 382
394 mutex_lock(&data->update_lock); 383 mutex_lock(&data->update_lock);
395 data->fan_off = r; 384 data->fan_off = r;
396 gl520_write_value(client, GL520_REG_FA 385 gl520_write_value(client, GL520_REG_FAN_OFF,
397 (gl520_read_value(cl 386 (gl520_read_value(client, GL520_REG_FAN_OFF)
398 & ~0x0c) | (r << 2) 387 & ~0x0c) | (r << 2));
399 mutex_unlock(&data->update_lock); 388 mutex_unlock(&data->update_lock);
400 return count; 389 return count;
401 } 390 }
402 391
403 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, 392 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, get_fan_input, NULL, 0);
404 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, 393 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, get_fan_input, NULL, 1);
405 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | 394 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO | S_IWUSR,
406 get_fan_min, set_fan_min, 0); 395 get_fan_min, set_fan_min, 0);
407 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | 396 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO | S_IWUSR,
408 get_fan_min, set_fan_min, 1); 397 get_fan_min, set_fan_min, 1);
409 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | 398 static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
410 get_fan_div, set_fan_div, 0); 399 get_fan_div, set_fan_div, 0);
411 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | 400 static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
412 get_fan_div, set_fan_div, 1); 401 get_fan_div, set_fan_div, 1);
413 static DEVICE_ATTR(fan1_off, S_IRUGO | S_IWUSR 402 static DEVICE_ATTR(fan1_off, S_IRUGO | S_IWUSR,
414 get_fan_off, set_fan_off); 403 get_fan_off, set_fan_off);
415 404
416 #define TEMP_FROM_REG(val) (((val) - 130) * 10 405 #define TEMP_FROM_REG(val) (((val) - 130) * 1000)
417 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((((va 406 #define TEMP_TO_REG(val) (SENSORS_LIMIT(((((val)<0?(val)-500:(val)+500) / 1000)+130),0,255))
418 407
419 static ssize_t get_temp_input(struct device *d 408 static ssize_t get_temp_input(struct device *dev, struct device_attribute *attr,
420 char *buf) 409 char *buf)
421 { 410 {
422 int n = to_sensor_dev_attr(attr)->inde 411 int n = to_sensor_dev_attr(attr)->index;
423 struct gl520_data *data = gl520_update 412 struct gl520_data *data = gl520_update_device(dev);
424 413
425 return sprintf(buf, "%d\n", TEMP_FROM_ 414 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_input[n]));
426 } 415 }
427 416
428 static ssize_t get_temp_max(struct device *dev 417 static ssize_t get_temp_max(struct device *dev, struct device_attribute *attr,
429 char *buf) 418 char *buf)
430 { 419 {
431 int n = to_sensor_dev_attr(attr)->inde 420 int n = to_sensor_dev_attr(attr)->index;
432 struct gl520_data *data = gl520_update 421 struct gl520_data *data = gl520_update_device(dev);
433 422
434 return sprintf(buf, "%d\n", TEMP_FROM_ 423 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[n]));
435 } 424 }
436 425
437 static ssize_t get_temp_max_hyst(struct device 426 static ssize_t get_temp_max_hyst(struct device *dev, struct device_attribute
438 *attr, char * 427 *attr, char *buf)
439 { 428 {
440 int n = to_sensor_dev_attr(attr)->inde 429 int n = to_sensor_dev_attr(attr)->index;
441 struct gl520_data *data = gl520_update 430 struct gl520_data *data = gl520_update_device(dev);
442 431
443 return sprintf(buf, "%d\n", TEMP_FROM_ 432 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[n]));
444 } 433 }
445 434
446 static ssize_t set_temp_max(struct device *dev 435 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
447 const char *buf, s 436 const char *buf, size_t count)
448 { 437 {
449 struct i2c_client *client = to_i2c_cli 438 struct i2c_client *client = to_i2c_client(dev);
450 struct gl520_data *data = i2c_get_clie 439 struct gl520_data *data = i2c_get_clientdata(client);
451 int n = to_sensor_dev_attr(attr)->inde 440 int n = to_sensor_dev_attr(attr)->index;
452 long v = simple_strtol(buf, NULL, 10); 441 long v = simple_strtol(buf, NULL, 10);
453 442
454 mutex_lock(&data->update_lock); 443 mutex_lock(&data->update_lock);
455 data->temp_max[n] = TEMP_TO_REG(v); 444 data->temp_max[n] = TEMP_TO_REG(v);
456 gl520_write_value(client, GL520_REG_TE 445 gl520_write_value(client, GL520_REG_TEMP_MAX[n], data->temp_max[n]);
457 mutex_unlock(&data->update_lock); 446 mutex_unlock(&data->update_lock);
458 return count; 447 return count;
459 } 448 }
460 449
461 static ssize_t set_temp_max_hyst(struct device 450 static ssize_t set_temp_max_hyst(struct device *dev, struct device_attribute
462 *attr, const 451 *attr, const char *buf, size_t count)
463 { 452 {
464 struct i2c_client *client = to_i2c_cli 453 struct i2c_client *client = to_i2c_client(dev);
465 struct gl520_data *data = i2c_get_clie 454 struct gl520_data *data = i2c_get_clientdata(client);
466 int n = to_sensor_dev_attr(attr)->inde 455 int n = to_sensor_dev_attr(attr)->index;
467 long v = simple_strtol(buf, NULL, 10); 456 long v = simple_strtol(buf, NULL, 10);
468 457
469 mutex_lock(&data->update_lock); 458 mutex_lock(&data->update_lock);
470 data->temp_max_hyst[n] = TEMP_TO_REG(v 459 data->temp_max_hyst[n] = TEMP_TO_REG(v);
471 gl520_write_value(client, GL520_REG_TE 460 gl520_write_value(client, GL520_REG_TEMP_MAX_HYST[n],
472 data->temp_max_hyst[ 461 data->temp_max_hyst[n]);
473 mutex_unlock(&data->update_lock); 462 mutex_unlock(&data->update_lock);
474 return count; 463 return count;
475 } 464 }
476 465
477 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO 466 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, get_temp_input, NULL, 0);
478 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO 467 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, get_temp_input, NULL, 1);
479 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | 468 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
480 get_temp_max, set_temp_max, 0) 469 get_temp_max, set_temp_max, 0);
481 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | 470 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR,
482 get_temp_max, set_temp_max, 1) 471 get_temp_max, set_temp_max, 1);
483 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IR 472 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
484 get_temp_max_hyst, set_temp_ma 473 get_temp_max_hyst, set_temp_max_hyst, 0);
485 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IR 474 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO | S_IWUSR,
486 get_temp_max_hyst, set_temp_ma 475 get_temp_max_hyst, set_temp_max_hyst, 1);
487 476
488 static ssize_t get_alarms(struct device *dev, 477 static ssize_t get_alarms(struct device *dev, struct device_attribute *attr,
489 char *buf) 478 char *buf)
490 { 479 {
491 struct gl520_data *data = gl520_update 480 struct gl520_data *data = gl520_update_device(dev);
492 return sprintf(buf, "%d\n", data->alar 481 return sprintf(buf, "%d\n", data->alarms);
493 } 482 }
494 483
495 static ssize_t get_beep_enable(struct device * 484 static ssize_t get_beep_enable(struct device *dev, struct device_attribute
496 *attr, char *bu 485 *attr, char *buf)
497 { 486 {
498 struct gl520_data *data = gl520_update 487 struct gl520_data *data = gl520_update_device(dev);
499 return sprintf(buf, "%d\n", data->beep 488 return sprintf(buf, "%d\n", data->beep_enable);
500 } 489 }
501 490
502 static ssize_t get_beep_mask(struct device *de 491 static ssize_t get_beep_mask(struct device *dev, struct device_attribute *attr,
503 char *buf) 492 char *buf)
504 { 493 {
505 struct gl520_data *data = gl520_update 494 struct gl520_data *data = gl520_update_device(dev);
506 return sprintf(buf, "%d\n", data->beep 495 return sprintf(buf, "%d\n", data->beep_mask);
507 } 496 }
508 497
509 static ssize_t set_beep_enable(struct device * 498 static ssize_t set_beep_enable(struct device *dev, struct device_attribute
510 *attr, const ch 499 *attr, const char *buf, size_t count)
511 { 500 {
512 struct i2c_client *client = to_i2c_cli 501 struct i2c_client *client = to_i2c_client(dev);
513 struct gl520_data *data = i2c_get_clie 502 struct gl520_data *data = i2c_get_clientdata(client);
514 u8 r = simple_strtoul(buf, NULL, 10)?0 503 u8 r = simple_strtoul(buf, NULL, 10)?0:1;
515 504
516 mutex_lock(&data->update_lock); 505 mutex_lock(&data->update_lock);
517 data->beep_enable = !r; 506 data->beep_enable = !r;
518 gl520_write_value(client, GL520_REG_BE 507 gl520_write_value(client, GL520_REG_BEEP_ENABLE,
519 (gl520_read_value(cl 508 (gl520_read_value(client, GL520_REG_BEEP_ENABLE)
520 & ~0x04) | (r << 2) 509 & ~0x04) | (r << 2));
521 mutex_unlock(&data->update_lock); 510 mutex_unlock(&data->update_lock);
522 return count; 511 return count;
523 } 512 }
524 513
525 static ssize_t set_beep_mask(struct device *de 514 static ssize_t set_beep_mask(struct device *dev, struct device_attribute *attr,
526 const char *buf, 515 const char *buf, size_t count)
527 { 516 {
528 struct i2c_client *client = to_i2c_cli 517 struct i2c_client *client = to_i2c_client(dev);
529 struct gl520_data *data = i2c_get_clie 518 struct gl520_data *data = i2c_get_clientdata(client);
530 u8 r = simple_strtoul(buf, NULL, 10); 519 u8 r = simple_strtoul(buf, NULL, 10);
531 520
532 mutex_lock(&data->update_lock); 521 mutex_lock(&data->update_lock);
533 r &= data->alarm_mask; 522 r &= data->alarm_mask;
534 data->beep_mask = r; 523 data->beep_mask = r;
535 gl520_write_value(client, GL520_REG_BE 524 gl520_write_value(client, GL520_REG_BEEP_MASK, r);
536 mutex_unlock(&data->update_lock); 525 mutex_unlock(&data->update_lock);
537 return count; 526 return count;
538 } 527 }
539 528
540 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms 529 static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
541 static DEVICE_ATTR(beep_enable, S_IRUGO | S_IW 530 static DEVICE_ATTR(beep_enable, S_IRUGO | S_IWUSR,
542 get_beep_enable, set_beep_enab 531 get_beep_enable, set_beep_enable);
543 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUS 532 static DEVICE_ATTR(beep_mask, S_IRUGO | S_IWUSR,
544 get_beep_mask, set_beep_mask); 533 get_beep_mask, set_beep_mask);
545 534
546 static ssize_t get_alarm(struct device *dev, s 535 static ssize_t get_alarm(struct device *dev, struct device_attribute *attr,
547 char *buf) 536 char *buf)
548 { 537 {
549 int bit_nr = to_sensor_dev_attr(attr)- 538 int bit_nr = to_sensor_dev_attr(attr)->index;
550 struct gl520_data *data = gl520_update 539 struct gl520_data *data = gl520_update_device(dev);
551 540
552 return sprintf(buf, "%d\n", (data->ala 541 return sprintf(buf, "%d\n", (data->alarms >> bit_nr) & 1);
553 } 542 }
554 543
555 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, 544 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, get_alarm, NULL, 0);
556 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, 545 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, get_alarm, NULL, 1);
557 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, 546 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, get_alarm, NULL, 2);
558 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, 547 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, get_alarm, NULL, 3);
559 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO 548 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, get_alarm, NULL, 4);
560 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, 549 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, get_alarm, NULL, 5);
561 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, 550 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, get_alarm, NULL, 6);
562 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO 551 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, get_alarm, NULL, 7);
563 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, 552 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, get_alarm, NULL, 7);
564 553
565 static ssize_t get_beep(struct device *dev, st 554 static ssize_t get_beep(struct device *dev, struct device_attribute *attr,
566 char *buf) 555 char *buf)
567 { 556 {
568 int bitnr = to_sensor_dev_attr(attr)-> 557 int bitnr = to_sensor_dev_attr(attr)->index;
569 struct gl520_data *data = gl520_update 558 struct gl520_data *data = gl520_update_device(dev);
570 559
571 return sprintf(buf, "%d\n", (data->bee 560 return sprintf(buf, "%d\n", (data->beep_mask >> bitnr) & 1);
572 } 561 }
573 562
574 static ssize_t set_beep(struct device *dev, st 563 static ssize_t set_beep(struct device *dev, struct device_attribute *attr,
575 const char *buf, size_ 564 const char *buf, size_t count)
576 { 565 {
577 struct i2c_client *client = to_i2c_cli 566 struct i2c_client *client = to_i2c_client(dev);
578 struct gl520_data *data = i2c_get_clie 567 struct gl520_data *data = i2c_get_clientdata(client);
579 int bitnr = to_sensor_dev_attr(attr)-> 568 int bitnr = to_sensor_dev_attr(attr)->index;
580 unsigned long bit; 569 unsigned long bit;
581 570
582 bit = simple_strtoul(buf, NULL, 10); 571 bit = simple_strtoul(buf, NULL, 10);
583 if (bit & ~1) 572 if (bit & ~1)
584 return -EINVAL; 573 return -EINVAL;
585 574
586 mutex_lock(&data->update_lock); 575 mutex_lock(&data->update_lock);
587 data->beep_mask = gl520_read_value(cli 576 data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
588 if (bit) 577 if (bit)
589 data->beep_mask |= (1 << bitnr 578 data->beep_mask |= (1 << bitnr);
590 else 579 else
591 data->beep_mask &= ~(1 << bitn 580 data->beep_mask &= ~(1 << bitnr);
592 gl520_write_value(client, GL520_REG_BE 581 gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
593 mutex_unlock(&data->update_lock); 582 mutex_unlock(&data->update_lock);
594 return count; 583 return count;
595 } 584 }
596 585
597 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | 586 static SENSOR_DEVICE_ATTR(in0_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 0);
598 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | 587 static SENSOR_DEVICE_ATTR(in1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 1);
599 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | 588 static SENSOR_DEVICE_ATTR(in2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 2);
600 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | 589 static SENSOR_DEVICE_ATTR(in3_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 3);
601 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO 590 static SENSOR_DEVICE_ATTR(temp1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 4);
602 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | 591 static SENSOR_DEVICE_ATTR(fan1_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 5);
603 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | 592 static SENSOR_DEVICE_ATTR(fan2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 6);
604 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO 593 static SENSOR_DEVICE_ATTR(temp2_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
605 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | 594 static SENSOR_DEVICE_ATTR(in4_beep, S_IRUGO | S_IWUSR, get_beep, set_beep, 7);
606 595
607 static struct attribute *gl520_attributes[] = 596 static struct attribute *gl520_attributes[] = {
608 &dev_attr_cpu0_vid.attr, 597 &dev_attr_cpu0_vid.attr,
609 598
610 &sensor_dev_attr_in0_input.dev_attr.at 599 &sensor_dev_attr_in0_input.dev_attr.attr,
611 &sensor_dev_attr_in0_min.dev_attr.attr 600 &sensor_dev_attr_in0_min.dev_attr.attr,
612 &sensor_dev_attr_in0_max.dev_attr.attr 601 &sensor_dev_attr_in0_max.dev_attr.attr,
613 &sensor_dev_attr_in0_alarm.dev_attr.at 602 &sensor_dev_attr_in0_alarm.dev_attr.attr,
614 &sensor_dev_attr_in0_beep.dev_attr.att 603 &sensor_dev_attr_in0_beep.dev_attr.attr,
615 &sensor_dev_attr_in1_input.dev_attr.at 604 &sensor_dev_attr_in1_input.dev_attr.attr,
616 &sensor_dev_attr_in1_min.dev_attr.attr 605 &sensor_dev_attr_in1_min.dev_attr.attr,
617 &sensor_dev_attr_in1_max.dev_attr.attr 606 &sensor_dev_attr_in1_max.dev_attr.attr,
618 &sensor_dev_attr_in1_alarm.dev_attr.at 607 &sensor_dev_attr_in1_alarm.dev_attr.attr,
619 &sensor_dev_attr_in1_beep.dev_attr.att 608 &sensor_dev_attr_in1_beep.dev_attr.attr,
620 &sensor_dev_attr_in2_input.dev_attr.at 609 &sensor_dev_attr_in2_input.dev_attr.attr,
621 &sensor_dev_attr_in2_min.dev_attr.attr 610 &sensor_dev_attr_in2_min.dev_attr.attr,
622 &sensor_dev_attr_in2_max.dev_attr.attr 611 &sensor_dev_attr_in2_max.dev_attr.attr,
623 &sensor_dev_attr_in2_alarm.dev_attr.at 612 &sensor_dev_attr_in2_alarm.dev_attr.attr,
624 &sensor_dev_attr_in2_beep.dev_attr.att 613 &sensor_dev_attr_in2_beep.dev_attr.attr,
625 &sensor_dev_attr_in3_input.dev_attr.at 614 &sensor_dev_attr_in3_input.dev_attr.attr,
626 &sensor_dev_attr_in3_min.dev_attr.attr 615 &sensor_dev_attr_in3_min.dev_attr.attr,
627 &sensor_dev_attr_in3_max.dev_attr.attr 616 &sensor_dev_attr_in3_max.dev_attr.attr,
628 &sensor_dev_attr_in3_alarm.dev_attr.at 617 &sensor_dev_attr_in3_alarm.dev_attr.attr,
629 &sensor_dev_attr_in3_beep.dev_attr.att 618 &sensor_dev_attr_in3_beep.dev_attr.attr,
630 619
631 &sensor_dev_attr_fan1_input.dev_attr.a 620 &sensor_dev_attr_fan1_input.dev_attr.attr,
632 &sensor_dev_attr_fan1_min.dev_attr.att 621 &sensor_dev_attr_fan1_min.dev_attr.attr,
633 &sensor_dev_attr_fan1_div.dev_attr.att 622 &sensor_dev_attr_fan1_div.dev_attr.attr,
634 &sensor_dev_attr_fan1_alarm.dev_attr.a 623 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
635 &sensor_dev_attr_fan1_beep.dev_attr.at 624 &sensor_dev_attr_fan1_beep.dev_attr.attr,
636 &dev_attr_fan1_off.attr, 625 &dev_attr_fan1_off.attr,
637 &sensor_dev_attr_fan2_input.dev_attr.a 626 &sensor_dev_attr_fan2_input.dev_attr.attr,
638 &sensor_dev_attr_fan2_min.dev_attr.att 627 &sensor_dev_attr_fan2_min.dev_attr.attr,
639 &sensor_dev_attr_fan2_div.dev_attr.att 628 &sensor_dev_attr_fan2_div.dev_attr.attr,
640 &sensor_dev_attr_fan2_alarm.dev_attr.a 629 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
641 &sensor_dev_attr_fan2_beep.dev_attr.at 630 &sensor_dev_attr_fan2_beep.dev_attr.attr,
642 631
643 &sensor_dev_attr_temp1_input.dev_attr. 632 &sensor_dev_attr_temp1_input.dev_attr.attr,
644 &sensor_dev_attr_temp1_max.dev_attr.at 633 &sensor_dev_attr_temp1_max.dev_attr.attr,
645 &sensor_dev_attr_temp1_max_hyst.dev_at 634 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
646 &sensor_dev_attr_temp1_alarm.dev_attr. 635 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
647 &sensor_dev_attr_temp1_beep.dev_attr.a 636 &sensor_dev_attr_temp1_beep.dev_attr.attr,
648 637
649 &dev_attr_alarms.attr, 638 &dev_attr_alarms.attr,
650 &dev_attr_beep_enable.attr, 639 &dev_attr_beep_enable.attr,
651 &dev_attr_beep_mask.attr, 640 &dev_attr_beep_mask.attr,
652 NULL 641 NULL
653 }; 642 };
654 643
655 static const struct attribute_group gl520_grou 644 static const struct attribute_group gl520_group = {
656 .attrs = gl520_attributes, 645 .attrs = gl520_attributes,
657 }; 646 };
658 647
659 static struct attribute *gl520_attributes_opt[ 648 static struct attribute *gl520_attributes_opt[] = {
660 &sensor_dev_attr_in4_input.dev_attr.at 649 &sensor_dev_attr_in4_input.dev_attr.attr,
661 &sensor_dev_attr_in4_min.dev_attr.attr 650 &sensor_dev_attr_in4_min.dev_attr.attr,
662 &sensor_dev_attr_in4_max.dev_attr.attr 651 &sensor_dev_attr_in4_max.dev_attr.attr,
663 &sensor_dev_attr_in4_alarm.dev_attr.at 652 &sensor_dev_attr_in4_alarm.dev_attr.attr,
664 &sensor_dev_attr_in4_beep.dev_attr.att 653 &sensor_dev_attr_in4_beep.dev_attr.attr,
665 654
666 &sensor_dev_attr_temp2_input.dev_attr. 655 &sensor_dev_attr_temp2_input.dev_attr.attr,
667 &sensor_dev_attr_temp2_max.dev_attr.at 656 &sensor_dev_attr_temp2_max.dev_attr.attr,
668 &sensor_dev_attr_temp2_max_hyst.dev_at 657 &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
669 &sensor_dev_attr_temp2_alarm.dev_attr. 658 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
670 &sensor_dev_attr_temp2_beep.dev_attr.a 659 &sensor_dev_attr_temp2_beep.dev_attr.attr,
671 NULL 660 NULL
672 }; 661 };
673 662
674 static const struct attribute_group gl520_grou 663 static const struct attribute_group gl520_group_opt = {
675 .attrs = gl520_attributes_opt, 664 .attrs = gl520_attributes_opt,
676 }; 665 };
677 666
678 667
679 /* 668 /*
680 * Real code 669 * Real code
681 */ 670 */
682 671
683 /* Return 0 if detection is successful, -ENODE !! 672 static int gl520_attach_adapter(struct i2c_adapter *adapter)
684 static int gl520_detect(struct i2c_client *cli !! 673 {
685 struct i2c_board_info !! 674 if (!(adapter->class & I2C_CLASS_HWMON))
>> 675 return 0;
>> 676 return i2c_probe(adapter, &addr_data, gl520_detect);
>> 677 }
>> 678
>> 679 static int gl520_detect(struct i2c_adapter *adapter, int address, int kind)
686 { 680 {
687 struct i2c_adapter *adapter = client-> !! 681 struct i2c_client *client;
>> 682 struct gl520_data *data;
>> 683 int err = 0;
688 684
689 if (!i2c_check_functionality(adapter, 685 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
690 I2C_FUNC_ 686 I2C_FUNC_SMBUS_WORD_DATA))
691 return -ENODEV; !! 687 goto exit;
>> 688
>> 689 /* OK. For now, we presume we have a valid client. We now create the
>> 690 client structure, even though we cannot fill it completely yet.
>> 691 But it allows us to access gl520_{read,write}_value. */
>> 692
>> 693 if (!(data = kzalloc(sizeof(struct gl520_data), GFP_KERNEL))) {
>> 694 err = -ENOMEM;
>> 695 goto exit;
>> 696 }
>> 697
>> 698 client = &data->client;
>> 699 i2c_set_clientdata(client, data);
>> 700 client->addr = address;
>> 701 client->adapter = adapter;
>> 702 client->driver = &gl520_driver;
692 703
693 /* Determine the chip type. */ 704 /* Determine the chip type. */
694 if (kind < 0) { 705 if (kind < 0) {
695 if ((gl520_read_value(client, 706 if ((gl520_read_value(client, GL520_REG_CHIP_ID) != 0x20) ||
696 ((gl520_read_value(client, 707 ((gl520_read_value(client, GL520_REG_REVISION) & 0x7f) != 0x00) ||
697 ((gl520_read_value(client, 708 ((gl520_read_value(client, GL520_REG_CONF) & 0x80) != 0x00)) {
698 dev_dbg(&client->dev, 709 dev_dbg(&client->dev, "Unknown chip type, skipping\n");
699 return -ENODEV; !! 710 goto exit_free;
700 } 711 }
701 } 712 }
702 713
703 strlcpy(info->type, "gl520sm", I2C_NAM !! 714 /* Fill in the remaining client fields */
704 !! 715 strlcpy(client->name, "gl520sm", I2C_NAME_SIZE);
705 return 0; <<
706 } <<
707 <<
708 static int gl520_probe(struct i2c_client *clie <<
709 const struct i2c_device <<
710 { <<
711 struct gl520_data *data; <<
712 int err; <<
713 <<
714 data = kzalloc(sizeof(struct gl520_dat <<
715 if (!data) { <<
716 err = -ENOMEM; <<
717 goto exit; <<
718 } <<
719 <<
720 i2c_set_clientdata(client, data); <<
721 mutex_init(&data->update_lock); 716 mutex_init(&data->update_lock);
722 717
>> 718 /* Tell the I2C layer a new client has arrived */
>> 719 if ((err = i2c_attach_client(client)))
>> 720 goto exit_free;
>> 721
723 /* Initialize the GL520SM chip */ 722 /* Initialize the GL520SM chip */
724 gl520_init_client(client); 723 gl520_init_client(client);
725 724
726 /* Register sysfs hooks */ 725 /* Register sysfs hooks */
727 if ((err = sysfs_create_group(&client- 726 if ((err = sysfs_create_group(&client->dev.kobj, &gl520_group)))
728 goto exit_free; !! 727 goto exit_detach;
729 728
730 if (data->two_temps) { 729 if (data->two_temps) {
731 if ((err = device_create_file( 730 if ((err = device_create_file(&client->dev,
732 &sensor_dev_at 731 &sensor_dev_attr_temp2_input.dev_attr))
733 || (err = device_create_file( 732 || (err = device_create_file(&client->dev,
734 &sensor_dev_at 733 &sensor_dev_attr_temp2_max.dev_attr))
735 || (err = device_create_file( 734 || (err = device_create_file(&client->dev,
736 &sensor_dev_at 735 &sensor_dev_attr_temp2_max_hyst.dev_attr))
737 || (err = device_create_file( 736 || (err = device_create_file(&client->dev,
738 &sensor_dev_at 737 &sensor_dev_attr_temp2_alarm.dev_attr))
739 || (err = device_create_file( 738 || (err = device_create_file(&client->dev,
740 &sensor_dev_at 739 &sensor_dev_attr_temp2_beep.dev_attr)))
741 goto exit_remove_files 740 goto exit_remove_files;
742 } else { 741 } else {
743 if ((err = device_create_file( 742 if ((err = device_create_file(&client->dev,
744 &sensor_dev_at 743 &sensor_dev_attr_in4_input.dev_attr))
745 || (err = device_create_file( 744 || (err = device_create_file(&client->dev,
746 &sensor_dev_at 745 &sensor_dev_attr_in4_min.dev_attr))
747 || (err = device_create_file( 746 || (err = device_create_file(&client->dev,
748 &sensor_dev_at 747 &sensor_dev_attr_in4_max.dev_attr))
749 || (err = device_create_file( 748 || (err = device_create_file(&client->dev,
750 &sensor_dev_at 749 &sensor_dev_attr_in4_alarm.dev_attr))
751 || (err = device_create_file( 750 || (err = device_create_file(&client->dev,
752 &sensor_dev_at 751 &sensor_dev_attr_in4_beep.dev_attr)))
753 goto exit_remove_files 752 goto exit_remove_files;
754 } 753 }
755 754
756 755
757 data->hwmon_dev = hwmon_device_registe 756 data->hwmon_dev = hwmon_device_register(&client->dev);
758 if (IS_ERR(data->hwmon_dev)) { 757 if (IS_ERR(data->hwmon_dev)) {
759 err = PTR_ERR(data->hwmon_dev) 758 err = PTR_ERR(data->hwmon_dev);
760 goto exit_remove_files; 759 goto exit_remove_files;
761 } 760 }
762 761
763 return 0; 762 return 0;
764 763
765 exit_remove_files: 764 exit_remove_files:
766 sysfs_remove_group(&client->dev.kobj, 765 sysfs_remove_group(&client->dev.kobj, &gl520_group);
767 sysfs_remove_group(&client->dev.kobj, 766 sysfs_remove_group(&client->dev.kobj, &gl520_group_opt);
>> 767 exit_detach:
>> 768 i2c_detach_client(client);
768 exit_free: 769 exit_free:
769 kfree(data); 770 kfree(data);
770 exit: 771 exit:
771 return err; 772 return err;
772 } 773 }
773 774
774 775
775 /* Called when we have found a new GL520SM. */ 776 /* Called when we have found a new GL520SM. */
776 static void gl520_init_client(struct i2c_clien 777 static void gl520_init_client(struct i2c_client *client)
777 { 778 {
778 struct gl520_data *data = i2c_get_clie 779 struct gl520_data *data = i2c_get_clientdata(client);
779 u8 oldconf, conf; 780 u8 oldconf, conf;
780 781
781 conf = oldconf = gl520_read_value(clie 782 conf = oldconf = gl520_read_value(client, GL520_REG_CONF);
782 783
783 data->alarm_mask = 0xff; 784 data->alarm_mask = 0xff;
784 data->vrm = vid_which_vrm(); 785 data->vrm = vid_which_vrm();
785 786
786 if (extra_sensor_type == 1) 787 if (extra_sensor_type == 1)
787 conf &= ~0x10; 788 conf &= ~0x10;
788 else if (extra_sensor_type == 2) 789 else if (extra_sensor_type == 2)
789 conf |= 0x10; 790 conf |= 0x10;
790 data->two_temps = !(conf & 0x10); 791 data->two_temps = !(conf & 0x10);
791 792
792 /* If IRQ# is disabled, we can safely 793 /* If IRQ# is disabled, we can safely force comparator mode */
793 if (!(conf & 0x20)) 794 if (!(conf & 0x20))
794 conf &= 0xf7; 795 conf &= 0xf7;
795 796
796 /* Enable monitoring if needed */ 797 /* Enable monitoring if needed */
797 conf |= 0x40; 798 conf |= 0x40;
798 799
799 if (conf != oldconf) 800 if (conf != oldconf)
800 gl520_write_value(client, GL52 801 gl520_write_value(client, GL520_REG_CONF, conf);
801 802
802 gl520_update_device(&(client->dev)); 803 gl520_update_device(&(client->dev));
803 804
804 if (data->fan_min[0] == 0) 805 if (data->fan_min[0] == 0)
805 data->alarm_mask &= ~0x20; 806 data->alarm_mask &= ~0x20;
806 if (data->fan_min[1] == 0) 807 if (data->fan_min[1] == 0)
807 data->alarm_mask &= ~0x40; 808 data->alarm_mask &= ~0x40;
808 809
809 data->beep_mask &= data->alarm_mask; 810 data->beep_mask &= data->alarm_mask;
810 gl520_write_value(client, GL520_REG_BE 811 gl520_write_value(client, GL520_REG_BEEP_MASK, data->beep_mask);
811 } 812 }
812 813
813 static int gl520_remove(struct i2c_client *cli !! 814 static int gl520_detach_client(struct i2c_client *client)
814 { 815 {
815 struct gl520_data *data = i2c_get_clie 816 struct gl520_data *data = i2c_get_clientdata(client);
>> 817 int err;
816 818
817 hwmon_device_unregister(data->hwmon_de 819 hwmon_device_unregister(data->hwmon_dev);
818 sysfs_remove_group(&client->dev.kobj, 820 sysfs_remove_group(&client->dev.kobj, &gl520_group);
819 sysfs_remove_group(&client->dev.kobj, 821 sysfs_remove_group(&client->dev.kobj, &gl520_group_opt);
820 822
>> 823 if ((err = i2c_detach_client(client)))
>> 824 return err;
>> 825
821 kfree(data); 826 kfree(data);
822 return 0; 827 return 0;
823 } 828 }
824 829
825 830
826 /* Registers 0x07 to 0x0c are word-sized, othe 831 /* Registers 0x07 to 0x0c are word-sized, others are byte-sized
827 GL520 uses a high-byte first convention */ 832 GL520 uses a high-byte first convention */
828 static int gl520_read_value(struct i2c_client 833 static int gl520_read_value(struct i2c_client *client, u8 reg)
829 { 834 {
830 if ((reg >= 0x07) && (reg <= 0x0c)) 835 if ((reg >= 0x07) && (reg <= 0x0c))
831 return swab16(i2c_smbus_read_w 836 return swab16(i2c_smbus_read_word_data(client, reg));
832 else 837 else
833 return i2c_smbus_read_byte_dat 838 return i2c_smbus_read_byte_data(client, reg);
834 } 839 }
835 840
836 static int gl520_write_value(struct i2c_client 841 static int gl520_write_value(struct i2c_client *client, u8 reg, u16 value)
837 { 842 {
838 if ((reg >= 0x07) && (reg <= 0x0c)) 843 if ((reg >= 0x07) && (reg <= 0x0c))
839 return i2c_smbus_write_word_da 844 return i2c_smbus_write_word_data(client, reg, swab16(value));
840 else 845 else
841 return i2c_smbus_write_byte_da 846 return i2c_smbus_write_byte_data(client, reg, value);
842 } 847 }
843 848
844 849
845 static struct gl520_data *gl520_update_device( 850 static struct gl520_data *gl520_update_device(struct device *dev)
846 { 851 {
847 struct i2c_client *client = to_i2c_cli 852 struct i2c_client *client = to_i2c_client(dev);
848 struct gl520_data *data = i2c_get_clie 853 struct gl520_data *data = i2c_get_clientdata(client);
849 int val, i; 854 int val, i;
850 855
851 mutex_lock(&data->update_lock); 856 mutex_lock(&data->update_lock);
852 857
853 if (time_after(jiffies, data->last_upd 858 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
854 859
855 dev_dbg(&client->dev, "Startin 860 dev_dbg(&client->dev, "Starting gl520sm update\n");
856 861
857 data->alarms = gl520_read_valu 862 data->alarms = gl520_read_value(client, GL520_REG_ALARMS);
858 data->beep_mask = gl520_read_v 863 data->beep_mask = gl520_read_value(client, GL520_REG_BEEP_MASK);
859 data->vid = gl520_read_value(c 864 data->vid = gl520_read_value(client, GL520_REG_VID_INPUT) & 0x1f;
860 865
861 for (i = 0; i < 4; i++) { 866 for (i = 0; i < 4; i++) {
862 data->in_input[i] = gl 867 data->in_input[i] = gl520_read_value(client,
863 868 GL520_REG_IN_INPUT[i]);
864 val = gl520_read_value 869 val = gl520_read_value(client, GL520_REG_IN_LIMIT[i]);
865 data->in_min[i] = val 870 data->in_min[i] = val & 0xff;
866 data->in_max[i] = (val 871 data->in_max[i] = (val >> 8) & 0xff;
867 } 872 }
868 873
869 val = gl520_read_value(client, 874 val = gl520_read_value(client, GL520_REG_FAN_INPUT);
870 data->fan_input[0] = (val >> 8 875 data->fan_input[0] = (val >> 8) & 0xff;
871 data->fan_input[1] = val & 0xf 876 data->fan_input[1] = val & 0xff;
872 877
873 val = gl520_read_value(client, 878 val = gl520_read_value(client, GL520_REG_FAN_MIN);
874 data->fan_min[0] = (val >> 8) 879 data->fan_min[0] = (val >> 8) & 0xff;
875 data->fan_min[1] = val & 0xff; 880 data->fan_min[1] = val & 0xff;
876 881
877 data->temp_input[0] = gl520_re 882 data->temp_input[0] = gl520_read_value(client,
878 883 GL520_REG_TEMP_INPUT[0]);
879 data->temp_max[0] = gl520_read 884 data->temp_max[0] = gl520_read_value(client,
880 885 GL520_REG_TEMP_MAX[0]);
881 data->temp_max_hyst[0] = gl520 886 data->temp_max_hyst[0] = gl520_read_value(client,
882 887 GL520_REG_TEMP_MAX_HYST[0]);
883 888
884 val = gl520_read_value(client, 889 val = gl520_read_value(client, GL520_REG_FAN_DIV);
885 data->fan_div[0] = (val >> 6) 890 data->fan_div[0] = (val >> 6) & 0x03;
886 data->fan_div[1] = (val >> 4) 891 data->fan_div[1] = (val >> 4) & 0x03;
887 data->fan_off = (val >> 2) & 0 892 data->fan_off = (val >> 2) & 0x01;
888 893
889 data->alarms &= data->alarm_ma 894 data->alarms &= data->alarm_mask;
890 895
891 val = gl520_read_value(client, 896 val = gl520_read_value(client, GL520_REG_CONF);
892 data->beep_enable = !((val >> 897 data->beep_enable = !((val >> 2) & 1);
893 898
894 /* Temp1 and Vin4 are the same 899 /* Temp1 and Vin4 are the same input */
895 if (data->two_temps) { 900 if (data->two_temps) {
896 data->temp_input[1] = 901 data->temp_input[1] = gl520_read_value(client,
897 902 GL520_REG_TEMP_INPUT[1]);
898 data->temp_max[1] = gl 903 data->temp_max[1] = gl520_read_value(client,
899 904 GL520_REG_TEMP_MAX[1]);
900 data->temp_max_hyst[1] 905 data->temp_max_hyst[1] = gl520_read_value(client,
901 906 GL520_REG_TEMP_MAX_HYST[1]);
902 } else { 907 } else {
903 data->in_input[4] = gl 908 data->in_input[4] = gl520_read_value(client,
904 909 GL520_REG_IN_INPUT[4]);
905 data->in_min[4] = gl52 910 data->in_min[4] = gl520_read_value(client,
906 911 GL520_REG_IN_MIN[4]);
907 data->in_max[4] = gl52 912 data->in_max[4] = gl520_read_value(client,
908 913 GL520_REG_IN_MAX[4]);
909 } 914 }
910 915
911 data->last_updated = jiffies; 916 data->last_updated = jiffies;
912 data->valid = 1; 917 data->valid = 1;
913 } 918 }
914 919
915 mutex_unlock(&data->update_lock); 920 mutex_unlock(&data->update_lock);
916 921
917 return data; 922 return data;
918 } 923 }
919 924
920 925
921 static int __init sensors_gl520sm_init(void) 926 static int __init sensors_gl520sm_init(void)
922 { 927 {
923 return i2c_add_driver(&gl520_driver); 928 return i2c_add_driver(&gl520_driver);
924 } 929 }
925 930
926 static void __exit sensors_gl520sm_exit(void) 931 static void __exit sensors_gl520sm_exit(void)
927 { 932 {
928 i2c_del_driver(&gl520_driver); 933 i2c_del_driver(&gl520_driver);
929 } 934 }
930 935
931 936
932 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> 937 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>, "
933 "Kyösti Mälkki <kmalkki@cc.hut.fi>, 938 "Kyösti Mälkki <kmalkki@cc.hut.fi>, "
934 "Maarten Deprez <maartendeprez@users.s 939 "Maarten Deprez <maartendeprez@users.sourceforge.net>");
935 MODULE_DESCRIPTION("GL520SM driver"); 940 MODULE_DESCRIPTION("GL520SM driver");
936 MODULE_LICENSE("GPL"); 941 MODULE_LICENSE("GPL");
937 942
938 module_init(sensors_gl520sm_init); 943 module_init(sensors_gl520sm_init);
939 module_exit(sensors_gl520sm_exit); 944 module_exit(sensors_gl520sm_exit);
940 945
|
This page was automatically generated by the
LXR engine.
|