Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/hwmon/sch5636.c

  1 /***************************************************************************
  2  *   Copyright (C) 2011-2012 Hans de Goede <hdegoede@redhat.com>           *
  3  *                                                                         *
  4  *   This program is free software; you can redistribute it and/or modify  *
  5  *   it under the terms of the GNU General Public License as published by  *
  6  *   the Free Software Foundation; either version 2 of the License, or     *
  7  *   (at your option) any later version.                                   *
  8  *                                                                         *
  9  *   This program is distributed in the hope that it will be useful,       *
 10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 12  *   GNU General Public License for more details.                          *
 13  *                                                                         *
 14  *   You should have received a copy of the GNU General Public License     *
 15  *   along with this program; if not, write to the                         *
 16  *   Free Software Foundation, Inc.,                                       *
 17  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 18  ***************************************************************************/
 19 
 20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 21 
 22 #include <linux/module.h>
 23 #include <linux/init.h>
 24 #include <linux/slab.h>
 25 #include <linux/jiffies.h>
 26 #include <linux/platform_device.h>
 27 #include <linux/hwmon.h>
 28 #include <linux/hwmon-sysfs.h>
 29 #include <linux/err.h>
 30 #include <linux/mutex.h>
 31 #include "sch56xx-common.h"
 32 
 33 #define DRVNAME "sch5636"
 34 #define DEVNAME "theseus" /* We only support one model for now */
 35 
 36 #define SCH5636_REG_FUJITSU_ID          0x780
 37 #define SCH5636_REG_FUJITSU_REV         0x783
 38 
 39 #define SCH5636_NO_INS                  5
 40 #define SCH5636_NO_TEMPS                16
 41 #define SCH5636_NO_FANS                 8
 42 
 43 static const u16 SCH5636_REG_IN_VAL[SCH5636_NO_INS] = {
 44         0x22, 0x23, 0x24, 0x25, 0x189 };
 45 static const u16 SCH5636_REG_IN_FACTORS[SCH5636_NO_INS] = {
 46         4400, 1500, 4000, 4400, 16000 };
 47 static const char * const SCH5636_IN_LABELS[SCH5636_NO_INS] = {
 48         "3.3V", "VREF", "VBAT", "3.3AUX", "12V" };
 49 
 50 static const u16 SCH5636_REG_TEMP_VAL[SCH5636_NO_TEMPS] = {
 51         0x2B, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x180, 0x181,
 52         0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C };
 53 #define SCH5636_REG_TEMP_CTRL(i)        (0x790 + (i))
 54 #define SCH5636_TEMP_WORKING            0x01
 55 #define SCH5636_TEMP_ALARM              0x02
 56 #define SCH5636_TEMP_DEACTIVATED        0x80
 57 
 58 static const u16 SCH5636_REG_FAN_VAL[SCH5636_NO_FANS] = {
 59         0x2C, 0x2E, 0x30, 0x32, 0x62, 0x64, 0x66, 0x68 };
 60 #define SCH5636_REG_FAN_CTRL(i)         (0x880 + (i))
 61 /* FAULT in datasheet, but acts as an alarm */
 62 #define SCH5636_FAN_ALARM               0x04
 63 #define SCH5636_FAN_NOT_PRESENT         0x08
 64 #define SCH5636_FAN_DEACTIVATED         0x80
 65 
 66 
 67 struct sch5636_data {
 68         unsigned short addr;
 69         struct device *hwmon_dev;
 70         struct sch56xx_watchdog_data *watchdog;
 71 
 72         struct mutex update_lock;
 73         char valid;                     /* !=0 if following fields are valid */
 74         unsigned long last_updated;     /* In jiffies */
 75         u8 in[SCH5636_NO_INS];
 76         u8 temp_val[SCH5636_NO_TEMPS];
 77         u8 temp_ctrl[SCH5636_NO_TEMPS];
 78         u16 fan_val[SCH5636_NO_FANS];
 79         u8 fan_ctrl[SCH5636_NO_FANS];
 80 };
 81 
 82 static struct sch5636_data *sch5636_update_device(struct device *dev)
 83 {
 84         struct sch5636_data *data = dev_get_drvdata(dev);
 85         struct sch5636_data *ret = data;
 86         int i, val;
 87 
 88         mutex_lock(&data->update_lock);
 89 
 90         /* Cache the values for 1 second */
 91         if (data->valid && !time_after(jiffies, data->last_updated + HZ))
 92                 goto abort;
 93 
 94         for (i = 0; i < SCH5636_NO_INS; i++) {
 95                 val = sch56xx_read_virtual_reg(data->addr,
 96                                                SCH5636_REG_IN_VAL[i]);
 97                 if (unlikely(val < 0)) {
 98                         ret = ERR_PTR(val);
 99                         goto abort;
100                 }
101                 data->in[i] = val;
102         }
103 
104         for (i = 0; i < SCH5636_NO_TEMPS; i++) {
105                 if (data->temp_ctrl[i] & SCH5636_TEMP_DEACTIVATED)
106                         continue;
107 
108                 val = sch56xx_read_virtual_reg(data->addr,
109                                                SCH5636_REG_TEMP_VAL[i]);
110                 if (unlikely(val < 0)) {
111                         ret = ERR_PTR(val);
112                         goto abort;
113                 }
114                 data->temp_val[i] = val;
115 
116                 val = sch56xx_read_virtual_reg(data->addr,
117                                                SCH5636_REG_TEMP_CTRL(i));
118                 if (unlikely(val < 0)) {
119                         ret = ERR_PTR(val);
120                         goto abort;
121                 }
122                 data->temp_ctrl[i] = val;
123                 /* Alarms need to be explicitly write-cleared */
124                 if (val & SCH5636_TEMP_ALARM) {
125                         sch56xx_write_virtual_reg(data->addr,
126                                                 SCH5636_REG_TEMP_CTRL(i), val);
127                 }
128         }
129 
130         for (i = 0; i < SCH5636_NO_FANS; i++) {
131                 if (data->fan_ctrl[i] & SCH5636_FAN_DEACTIVATED)
132                         continue;
133 
134                 val = sch56xx_read_virtual_reg16(data->addr,
135                                                  SCH5636_REG_FAN_VAL[i]);
136                 if (unlikely(val < 0)) {
137                         ret = ERR_PTR(val);
138                         goto abort;
139                 }
140                 data->fan_val[i] = val;
141 
142                 val = sch56xx_read_virtual_reg(data->addr,
143                                                SCH5636_REG_FAN_CTRL(i));
144                 if (unlikely(val < 0)) {
145                         ret = ERR_PTR(val);
146                         goto abort;
147                 }
148                 data->fan_ctrl[i] = val;
149                 /* Alarms need to be explicitly write-cleared */
150                 if (val & SCH5636_FAN_ALARM) {
151                         sch56xx_write_virtual_reg(data->addr,
152                                                 SCH5636_REG_FAN_CTRL(i), val);
153                 }
154         }
155 
156         data->last_updated = jiffies;
157         data->valid = 1;
158 abort:
159         mutex_unlock(&data->update_lock);
160         return ret;
161 }
162 
163 static int reg_to_rpm(u16 reg)
164 {
165         if (reg == 0)
166                 return -EIO;
167         if (reg == 0xffff)
168                 return 0;
169 
170         return 5400540 / reg;
171 }
172 
173 static ssize_t show_name(struct device *dev, struct device_attribute *devattr,
174         char *buf)
175 {
176         return snprintf(buf, PAGE_SIZE, "%s\n", DEVNAME);
177 }
178 
179 static ssize_t show_in_value(struct device *dev, struct device_attribute
180         *devattr, char *buf)
181 {
182         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
183         struct sch5636_data *data = sch5636_update_device(dev);
184         int val;
185 
186         if (IS_ERR(data))
187                 return PTR_ERR(data);
188 
189         val = DIV_ROUND_CLOSEST(
190                 data->in[attr->index] * SCH5636_REG_IN_FACTORS[attr->index],
191                 255);
192         return snprintf(buf, PAGE_SIZE, "%d\n", val);
193 }
194 
195 static ssize_t show_in_label(struct device *dev, struct device_attribute
196         *devattr, char *buf)
197 {
198         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
199 
200         return snprintf(buf, PAGE_SIZE, "%s\n",
201                         SCH5636_IN_LABELS[attr->index]);
202 }
203 
204 static ssize_t show_temp_value(struct device *dev, struct device_attribute
205         *devattr, char *buf)
206 {
207         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
208         struct sch5636_data *data = sch5636_update_device(dev);
209         int val;
210 
211         if (IS_ERR(data))
212                 return PTR_ERR(data);
213 
214         val = (data->temp_val[attr->index] - 64) * 1000;
215         return snprintf(buf, PAGE_SIZE, "%d\n", val);
216 }
217 
218 static ssize_t show_temp_fault(struct device *dev, struct device_attribute
219         *devattr, char *buf)
220 {
221         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
222         struct sch5636_data *data = sch5636_update_device(dev);
223         int val;
224 
225         if (IS_ERR(data))
226                 return PTR_ERR(data);
227 
228         val = (data->temp_ctrl[attr->index] & SCH5636_TEMP_WORKING) ? 0 : 1;
229         return snprintf(buf, PAGE_SIZE, "%d\n", val);
230 }
231 
232 static ssize_t show_temp_alarm(struct device *dev, struct device_attribute
233         *devattr, char *buf)
234 {
235         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
236         struct sch5636_data *data = sch5636_update_device(dev);
237         int val;
238 
239         if (IS_ERR(data))
240                 return PTR_ERR(data);
241 
242         val = (data->temp_ctrl[attr->index] & SCH5636_TEMP_ALARM) ? 1 : 0;
243         return snprintf(buf, PAGE_SIZE, "%d\n", val);
244 }
245 
246 static ssize_t show_fan_value(struct device *dev, struct device_attribute
247         *devattr, char *buf)
248 {
249         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
250         struct sch5636_data *data = sch5636_update_device(dev);
251         int val;
252 
253         if (IS_ERR(data))
254                 return PTR_ERR(data);
255 
256         val = reg_to_rpm(data->fan_val[attr->index]);
257         if (val < 0)
258                 return val;
259 
260         return snprintf(buf, PAGE_SIZE, "%d\n", val);
261 }
262 
263 static ssize_t show_fan_fault(struct device *dev, struct device_attribute
264         *devattr, char *buf)
265 {
266         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
267         struct sch5636_data *data = sch5636_update_device(dev);
268         int val;
269 
270         if (IS_ERR(data))
271                 return PTR_ERR(data);
272 
273         val = (data->fan_ctrl[attr->index] & SCH5636_FAN_NOT_PRESENT) ? 1 : 0;
274         return snprintf(buf, PAGE_SIZE, "%d\n", val);
275 }
276 
277 static ssize_t show_fan_alarm(struct device *dev, struct device_attribute
278         *devattr, char *buf)
279 {
280         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
281         struct sch5636_data *data = sch5636_update_device(dev);
282         int val;
283 
284         if (IS_ERR(data))
285                 return PTR_ERR(data);
286 
287         val = (data->fan_ctrl[attr->index] & SCH5636_FAN_ALARM) ? 1 : 0;
288         return snprintf(buf, PAGE_SIZE, "%d\n", val);
289 }
290 
291 static struct sensor_device_attribute sch5636_attr[] = {
292         SENSOR_ATTR(name, 0444, show_name, NULL, 0),
293         SENSOR_ATTR(in0_input, 0444, show_in_value, NULL, 0),
294         SENSOR_ATTR(in0_label, 0444, show_in_label, NULL, 0),
295         SENSOR_ATTR(in1_input, 0444, show_in_value, NULL, 1),
296         SENSOR_ATTR(in1_label, 0444, show_in_label, NULL, 1),
297         SENSOR_ATTR(in2_input, 0444, show_in_value, NULL, 2),
298         SENSOR_ATTR(in2_label, 0444, show_in_label, NULL, 2),
299         SENSOR_ATTR(in3_input, 0444, show_in_value, NULL, 3),
300         SENSOR_ATTR(in3_label, 0444, show_in_label, NULL, 3),
301         SENSOR_ATTR(in4_input, 0444, show_in_value, NULL, 4),
302         SENSOR_ATTR(in4_label, 0444, show_in_label, NULL, 4),
303 };
304 
305 static struct sensor_device_attribute sch5636_temp_attr[] = {
306         SENSOR_ATTR(temp1_input, 0444, show_temp_value, NULL, 0),
307         SENSOR_ATTR(temp1_fault, 0444, show_temp_fault, NULL, 0),
308         SENSOR_ATTR(temp1_alarm, 0444, show_temp_alarm, NULL, 0),
309         SENSOR_ATTR(temp2_input, 0444, show_temp_value, NULL, 1),
310         SENSOR_ATTR(temp2_fault, 0444, show_temp_fault, NULL, 1),
311         SENSOR_ATTR(temp2_alarm, 0444, show_temp_alarm, NULL, 1),
312         SENSOR_ATTR(temp3_input, 0444, show_temp_value, NULL, 2),
313         SENSOR_ATTR(temp3_fault, 0444, show_temp_fault, NULL, 2),
314         SENSOR_ATTR(temp3_alarm, 0444, show_temp_alarm, NULL, 2),
315         SENSOR_ATTR(temp4_input, 0444, show_temp_value, NULL, 3),
316         SENSOR_ATTR(temp4_fault, 0444, show_temp_fault, NULL, 3),
317         SENSOR_ATTR(temp4_alarm, 0444, show_temp_alarm, NULL, 3),
318         SENSOR_ATTR(temp5_input, 0444, show_temp_value, NULL, 4),
319         SENSOR_ATTR(temp5_fault, 0444, show_temp_fault, NULL, 4),
320         SENSOR_ATTR(temp5_alarm, 0444, show_temp_alarm, NULL, 4),
321         SENSOR_ATTR(temp6_input, 0444, show_temp_value, NULL, 5),
322         SENSOR_ATTR(temp6_fault, 0444, show_temp_fault, NULL, 5),
323         SENSOR_ATTR(temp6_alarm, 0444, show_temp_alarm, NULL, 5),
324         SENSOR_ATTR(temp7_input, 0444, show_temp_value, NULL, 6),
325         SENSOR_ATTR(temp7_fault, 0444, show_temp_fault, NULL, 6),
326         SENSOR_ATTR(temp7_alarm, 0444, show_temp_alarm, NULL, 6),
327         SENSOR_ATTR(temp8_input, 0444, show_temp_value, NULL, 7),
328         SENSOR_ATTR(temp8_fault, 0444, show_temp_fault, NULL, 7),
329         SENSOR_ATTR(temp8_alarm, 0444, show_temp_alarm, NULL, 7),
330         SENSOR_ATTR(temp9_input, 0444, show_temp_value, NULL, 8),
331         SENSOR_ATTR(temp9_fault, 0444, show_temp_fault, NULL, 8),
332         SENSOR_ATTR(temp9_alarm, 0444, show_temp_alarm, NULL, 8),
333         SENSOR_ATTR(temp10_input, 0444, show_temp_value, NULL, 9),
334         SENSOR_ATTR(temp10_fault, 0444, show_temp_fault, NULL, 9),
335         SENSOR_ATTR(temp10_alarm, 0444, show_temp_alarm, NULL, 9),
336         SENSOR_ATTR(temp11_input, 0444, show_temp_value, NULL, 10),
337         SENSOR_ATTR(temp11_fault, 0444, show_temp_fault, NULL, 10),
338         SENSOR_ATTR(temp11_alarm, 0444, show_temp_alarm, NULL, 10),
339         SENSOR_ATTR(temp12_input, 0444, show_temp_value, NULL, 11),
340         SENSOR_ATTR(temp12_fault, 0444, show_temp_fault, NULL, 11),
341         SENSOR_ATTR(temp12_alarm, 0444, show_temp_alarm, NULL, 11),
342         SENSOR_ATTR(temp13_input, 0444, show_temp_value, NULL, 12),
343         SENSOR_ATTR(temp13_fault, 0444, show_temp_fault, NULL, 12),
344         SENSOR_ATTR(temp13_alarm, 0444, show_temp_alarm, NULL, 12),
345         SENSOR_ATTR(temp14_input, 0444, show_temp_value, NULL, 13),
346         SENSOR_ATTR(temp14_fault, 0444, show_temp_fault, NULL, 13),
347         SENSOR_ATTR(temp14_alarm, 0444, show_temp_alarm, NULL, 13),
348         SENSOR_ATTR(temp15_input, 0444, show_temp_value, NULL, 14),
349         SENSOR_ATTR(temp15_fault, 0444, show_temp_fault, NULL, 14),
350         SENSOR_ATTR(temp15_alarm, 0444, show_temp_alarm, NULL, 14),
351         SENSOR_ATTR(temp16_input, 0444, show_temp_value, NULL, 15),
352         SENSOR_ATTR(temp16_fault, 0444, show_temp_fault, NULL, 15),
353         SENSOR_ATTR(temp16_alarm, 0444, show_temp_alarm, NULL, 15),
354 };
355 
356 static struct sensor_device_attribute sch5636_fan_attr[] = {
357         SENSOR_ATTR(fan1_input, 0444, show_fan_value, NULL, 0),
358         SENSOR_ATTR(fan1_fault, 0444, show_fan_fault, NULL, 0),
359         SENSOR_ATTR(fan1_alarm, 0444, show_fan_alarm, NULL, 0),
360         SENSOR_ATTR(fan2_input, 0444, show_fan_value, NULL, 1),
361         SENSOR_ATTR(fan2_fault, 0444, show_fan_fault, NULL, 1),
362         SENSOR_ATTR(fan2_alarm, 0444, show_fan_alarm, NULL, 1),
363         SENSOR_ATTR(fan3_input, 0444, show_fan_value, NULL, 2),
364         SENSOR_ATTR(fan3_fault, 0444, show_fan_fault, NULL, 2),
365         SENSOR_ATTR(fan3_alarm, 0444, show_fan_alarm, NULL, 2),
366         SENSOR_ATTR(fan4_input, 0444, show_fan_value, NULL, 3),
367         SENSOR_ATTR(fan4_fault, 0444, show_fan_fault, NULL, 3),
368         SENSOR_ATTR(fan4_alarm, 0444, show_fan_alarm, NULL, 3),
369         SENSOR_ATTR(fan5_input, 0444, show_fan_value, NULL, 4),
370         SENSOR_ATTR(fan5_fault, 0444, show_fan_fault, NULL, 4),
371         SENSOR_ATTR(fan5_alarm, 0444, show_fan_alarm, NULL, 4),
372         SENSOR_ATTR(fan6_input, 0444, show_fan_value, NULL, 5),
373         SENSOR_ATTR(fan6_fault, 0444, show_fan_fault, NULL, 5),
374         SENSOR_ATTR(fan6_alarm, 0444, show_fan_alarm, NULL, 5),
375         SENSOR_ATTR(fan7_input, 0444, show_fan_value, NULL, 6),
376         SENSOR_ATTR(fan7_fault, 0444, show_fan_fault, NULL, 6),
377         SENSOR_ATTR(fan7_alarm, 0444, show_fan_alarm, NULL, 6),
378         SENSOR_ATTR(fan8_input, 0444, show_fan_value, NULL, 7),
379         SENSOR_ATTR(fan8_fault, 0444, show_fan_fault, NULL, 7),
380         SENSOR_ATTR(fan8_alarm, 0444, show_fan_alarm, NULL, 7),
381 };
382 
383 static int sch5636_remove(struct platform_device *pdev)
384 {
385         struct sch5636_data *data = platform_get_drvdata(pdev);
386         int i;
387 
388         if (data->watchdog)
389                 sch56xx_watchdog_unregister(data->watchdog);
390 
391         if (data->hwmon_dev)
392                 hwmon_device_unregister(data->hwmon_dev);
393 
394         for (i = 0; i < ARRAY_SIZE(sch5636_attr); i++)
395                 device_remove_file(&pdev->dev, &sch5636_attr[i].dev_attr);
396 
397         for (i = 0; i < SCH5636_NO_TEMPS * 3; i++)
398                 device_remove_file(&pdev->dev,
399                                    &sch5636_temp_attr[i].dev_attr);
400 
401         for (i = 0; i < SCH5636_NO_FANS * 3; i++)
402                 device_remove_file(&pdev->dev,
403                                    &sch5636_fan_attr[i].dev_attr);
404 
405         return 0;
406 }
407 
408 static int sch5636_probe(struct platform_device *pdev)
409 {
410         struct sch5636_data *data;
411         int i, err, val, revision[2];
412         char id[4];
413 
414         data = devm_kzalloc(&pdev->dev, sizeof(struct sch5636_data),
415                             GFP_KERNEL);
416         if (!data)
417                 return -ENOMEM;
418 
419         data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
420         mutex_init(&data->update_lock);
421         platform_set_drvdata(pdev, data);
422 
423         for (i = 0; i < 3; i++) {
424                 val = sch56xx_read_virtual_reg(data->addr,
425                                                SCH5636_REG_FUJITSU_ID + i);
426                 if (val < 0) {
427                         pr_err("Could not read Fujitsu id byte at %#x\n",
428                                 SCH5636_REG_FUJITSU_ID + i);
429                         err = val;
430                         goto error;
431                 }
432                 id[i] = val;
433         }
434         id[i] = '\0';
435 
436         if (strcmp(id, "THS")) {
437                 pr_err("Unknown Fujitsu id: %02x%02x%02x\n",
438                        id[0], id[1], id[2]);
439                 err = -ENODEV;
440                 goto error;
441         }
442 
443         for (i = 0; i < 2; i++) {
444                 val = sch56xx_read_virtual_reg(data->addr,
445                                                SCH5636_REG_FUJITSU_REV + i);
446                 if (val < 0) {
447                         err = val;
448                         goto error;
449                 }
450                 revision[i] = val;
451         }
452         pr_info("Found %s chip at %#hx, revison: %d.%02d\n", DEVNAME,
453                 data->addr, revision[0], revision[1]);
454 
455         /* Read all temp + fan ctrl registers to determine which are active */
456         for (i = 0; i < SCH5636_NO_TEMPS; i++) {
457                 val = sch56xx_read_virtual_reg(data->addr,
458                                                SCH5636_REG_TEMP_CTRL(i));
459                 if (unlikely(val < 0)) {
460                         err = val;
461                         goto error;
462                 }
463                 data->temp_ctrl[i] = val;
464         }
465 
466         for (i = 0; i < SCH5636_NO_FANS; i++) {
467                 val = sch56xx_read_virtual_reg(data->addr,
468                                                SCH5636_REG_FAN_CTRL(i));
469                 if (unlikely(val < 0)) {
470                         err = val;
471                         goto error;
472                 }
473                 data->fan_ctrl[i] = val;
474         }
475 
476         for (i = 0; i < ARRAY_SIZE(sch5636_attr); i++) {
477                 err = device_create_file(&pdev->dev,
478                                          &sch5636_attr[i].dev_attr);
479                 if (err)
480                         goto error;
481         }
482 
483         for (i = 0; i < (SCH5636_NO_TEMPS * 3); i++) {
484                 if (data->temp_ctrl[i/3] & SCH5636_TEMP_DEACTIVATED)
485                         continue;
486 
487                 err = device_create_file(&pdev->dev,
488                                         &sch5636_temp_attr[i].dev_attr);
489                 if (err)
490                         goto error;
491         }
492 
493         for (i = 0; i < (SCH5636_NO_FANS * 3); i++) {
494                 if (data->fan_ctrl[i/3] & SCH5636_FAN_DEACTIVATED)
495                         continue;
496 
497                 err = device_create_file(&pdev->dev,
498                                         &sch5636_fan_attr[i].dev_attr);
499                 if (err)
500                         goto error;
501         }
502 
503         data->hwmon_dev = hwmon_device_register(&pdev->dev);
504         if (IS_ERR(data->hwmon_dev)) {
505                 err = PTR_ERR(data->hwmon_dev);
506                 data->hwmon_dev = NULL;
507                 goto error;
508         }
509 
510         /* Note failing to register the watchdog is not a fatal error */
511         data->watchdog = sch56xx_watchdog_register(&pdev->dev, data->addr,
512                                         (revision[0] << 8) | revision[1],
513                                         &data->update_lock, 0);
514 
515         return 0;
516 
517 error:
518         sch5636_remove(pdev);
519         return err;
520 }
521 
522 static struct platform_driver sch5636_driver = {
523         .driver = {
524                 .owner  = THIS_MODULE,
525                 .name   = DRVNAME,
526         },
527         .probe          = sch5636_probe,
528         .remove         = sch5636_remove,
529 };
530 
531 module_platform_driver(sch5636_driver);
532 
533 MODULE_DESCRIPTION("SMSC SCH5636 Hardware Monitoring Driver");
534 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
535 MODULE_LICENSE("GPL");
536 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us