Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

Linux/drivers/hwmon/sis5595.c

  1 /*
  2  * sis5595.c - Part of lm_sensors, Linux kernel modules
  3  *             for hardware monitoring
  4  *
  5  * Copyright (C) 1998 - 2001 Frodo Looijaard <frodol@dds.nl>,
  6  *                           Kyösti Mälkki <kmalkki@cc.hut.fi>, and
  7  *                           Mark D. Studebaker <mdsxyz123@yahoo.com>
  8  * Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with
  9  * the help of Jean Delvare <jdelvare@suse.de>
 10  *
 11  * This program is free software; you can redistribute it and/or modify
 12  * it under the terms of the GNU General Public License as published by
 13  * the Free Software Foundation; either version 2 of the License, or
 14  * (at your option) any later version.
 15  *
 16  * This program is distributed in the hope that it will be useful,
 17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19  * GNU General Public License for more details.
 20  *
 21  * You should have received a copy of the GNU General Public License
 22  * along with this program; if not, write to the Free Software
 23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 24  */
 25 
 26 /*
 27  * SiS southbridge has a LM78-like chip integrated on the same IC.
 28  * This driver is a customized copy of lm78.c
 29  *
 30  * Supports following revisions:
 31  *      Version         PCI ID          PCI Revision
 32  *      1               1039/0008       AF or less
 33  *      2               1039/0008       B0 or greater
 34  *
 35  *  Note: these chips contain a 0008 device which is incompatible with the
 36  *       5595. We recognize these by the presence of the listed
 37  *       "blacklist" PCI ID and refuse to load.
 38  *
 39  * NOT SUPPORTED        PCI ID          BLACKLIST PCI ID
 40  *       540            0008            0540
 41  *       550            0008            0550
 42  *      5513            0008            5511
 43  *      5581            0008            5597
 44  *      5582            0008            5597
 45  *      5597            0008            5597
 46  *      5598            0008            5597/5598
 47  *       630            0008            0630
 48  *       645            0008            0645
 49  *       730            0008            0730
 50  *       735            0008            0735
 51  */
 52 
 53 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 54 
 55 #include <linux/module.h>
 56 #include <linux/slab.h>
 57 #include <linux/ioport.h>
 58 #include <linux/pci.h>
 59 #include <linux/platform_device.h>
 60 #include <linux/hwmon.h>
 61 #include <linux/hwmon-sysfs.h>
 62 #include <linux/err.h>
 63 #include <linux/init.h>
 64 #include <linux/jiffies.h>
 65 #include <linux/mutex.h>
 66 #include <linux/sysfs.h>
 67 #include <linux/acpi.h>
 68 #include <linux/io.h>
 69 
 70 
 71 /*
 72  * If force_addr is set to anything different from 0, we forcibly enable
 73  * the device at the given address.
 74  */
 75 static u16 force_addr;
 76 module_param(force_addr, ushort, 0);
 77 MODULE_PARM_DESC(force_addr,
 78                  "Initialize the base address of the sensors");
 79 
 80 static struct platform_device *pdev;
 81 
 82 /* Many SIS5595 constants specified below */
 83 
 84 /* Length of ISA address segment */
 85 #define SIS5595_EXTENT 8
 86 /* PCI Config Registers */
 87 #define SIS5595_BASE_REG 0x68
 88 #define SIS5595_PIN_REG 0x7A
 89 #define SIS5595_ENABLE_REG 0x7B
 90 
 91 /* Where are the ISA address/data registers relative to the base address */
 92 #define SIS5595_ADDR_REG_OFFSET 5
 93 #define SIS5595_DATA_REG_OFFSET 6
 94 
 95 /* The SIS5595 registers */
 96 #define SIS5595_REG_IN_MAX(nr) (0x2b + (nr) * 2)
 97 #define SIS5595_REG_IN_MIN(nr) (0x2c + (nr) * 2)
 98 #define SIS5595_REG_IN(nr) (0x20 + (nr))
 99 
100 #define SIS5595_REG_FAN_MIN(nr) (0x3b + (nr))
101 #define SIS5595_REG_FAN(nr) (0x28 + (nr))
102 
103 /*
104  * On the first version of the chip, the temp registers are separate.
105  * On the second version,
106  * TEMP pin is shared with IN4, configured in PCI register 0x7A.
107  * The registers are the same as well.
108  * OVER and HYST are really MAX and MIN.
109  */
110 
111 #define REV2MIN 0xb0
112 #define SIS5595_REG_TEMP        (((data->revision) >= REV2MIN) ? \
113                                         SIS5595_REG_IN(4) : 0x27)
114 #define SIS5595_REG_TEMP_OVER   (((data->revision) >= REV2MIN) ? \
115                                         SIS5595_REG_IN_MAX(4) : 0x39)
116 #define SIS5595_REG_TEMP_HYST   (((data->revision) >= REV2MIN) ? \
117                                         SIS5595_REG_IN_MIN(4) : 0x3a)
118 
119 #define SIS5595_REG_CONFIG 0x40
120 #define SIS5595_REG_ALARM1 0x41
121 #define SIS5595_REG_ALARM2 0x42
122 #define SIS5595_REG_FANDIV 0x47
123 
124 /*
125  * Conversions. Limit checking is only done on the TO_REG
126  * variants.
127  */
128 
129 /*
130  * IN: mV, (0V to 4.08V)
131  * REG: 16mV/bit
132  */
133 static inline u8 IN_TO_REG(unsigned long val)
134 {
135         unsigned long nval = clamp_val(val, 0, 4080);
136         return (nval + 8) / 16;
137 }
138 #define IN_FROM_REG(val) ((val) *  16)
139 
140 static inline u8 FAN_TO_REG(long rpm, int div)
141 {
142         if (rpm <= 0)
143                 return 255;
144         if (rpm > 1350000)
145                 return 1;
146         return clamp_val((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
147 }
148 
149 static inline int FAN_FROM_REG(u8 val, int div)
150 {
151         return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
152 }
153 
154 /*
155  * TEMP: mC (-54.12C to +157.53C)
156  * REG: 0.83C/bit + 52.12, two's complement
157  */
158 static inline int TEMP_FROM_REG(s8 val)
159 {
160         return val * 830 + 52120;
161 }
162 static inline s8 TEMP_TO_REG(long val)
163 {
164         int nval = clamp_val(val, -54120, 157530) ;
165         return nval < 0 ? (nval - 5212 - 415) / 830 : (nval - 5212 + 415) / 830;
166 }
167 
168 /*
169  * FAN DIV: 1, 2, 4, or 8 (defaults to 2)
170  * REG: 0, 1, 2, or 3 (respectively) (defaults to 1)
171  */
172 static inline u8 DIV_TO_REG(int val)
173 {
174         return val == 8 ? 3 : val == 4 ? 2 : val == 1 ? 0 : 1;
175 }
176 #define DIV_FROM_REG(val) (1 << (val))
177 
178 /*
179  * For each registered chip, we need to keep some data in memory.
180  * The structure is dynamically allocated.
181  */
182 struct sis5595_data {
183         unsigned short addr;
184         const char *name;
185         struct device *hwmon_dev;
186         struct mutex lock;
187 
188         struct mutex update_lock;
189         char valid;             /* !=0 if following fields are valid */
190         unsigned long last_updated;     /* In jiffies */
191         char maxins;            /* == 3 if temp enabled, otherwise == 4 */
192         u8 revision;            /* Reg. value */
193 
194         u8 in[5];               /* Register value */
195         u8 in_max[5];           /* Register value */
196         u8 in_min[5];           /* Register value */
197         u8 fan[2];              /* Register value */
198         u8 fan_min[2];          /* Register value */
199         s8 temp;                /* Register value */
200         s8 temp_over;           /* Register value */
201         s8 temp_hyst;           /* Register value */
202         u8 fan_div[2];          /* Register encoding, shifted right */
203         u16 alarms;             /* Register encoding, combined */
204 };
205 
206 static struct pci_dev *s_bridge;        /* pointer to the (only) sis5595 */
207 
208 static int sis5595_probe(struct platform_device *pdev);
209 static int sis5595_remove(struct platform_device *pdev);
210 
211 static int sis5595_read_value(struct sis5595_data *data, u8 reg);
212 static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value);
213 static struct sis5595_data *sis5595_update_device(struct device *dev);
214 static void sis5595_init_device(struct sis5595_data *data);
215 
216 static struct platform_driver sis5595_driver = {
217         .driver = {
218                 .name   = "sis5595",
219         },
220         .probe          = sis5595_probe,
221         .remove         = sis5595_remove,
222 };
223 
224 /* 4 Voltages */
225 static ssize_t show_in(struct device *dev, struct device_attribute *da,
226                        char *buf)
227 {
228         struct sis5595_data *data = sis5595_update_device(dev);
229         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
230         int nr = attr->index;
231         return sprintf(buf, "%d\n", IN_FROM_REG(data->in[nr]));
232 }
233 
234 static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
235                            char *buf)
236 {
237         struct sis5595_data *data = sis5595_update_device(dev);
238         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
239         int nr = attr->index;
240         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[nr]));
241 }
242 
243 static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
244                            char *buf)
245 {
246         struct sis5595_data *data = sis5595_update_device(dev);
247         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
248         int nr = attr->index;
249         return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[nr]));
250 }
251 
252 static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
253                           const char *buf, size_t count)
254 {
255         struct sis5595_data *data = dev_get_drvdata(dev);
256         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
257         int nr = attr->index;
258         unsigned long val;
259         int err;
260 
261         err = kstrtoul(buf, 10, &val);
262         if (err)
263                 return err;
264 
265         mutex_lock(&data->update_lock);
266         data->in_min[nr] = IN_TO_REG(val);
267         sis5595_write_value(data, SIS5595_REG_IN_MIN(nr), data->in_min[nr]);
268         mutex_unlock(&data->update_lock);
269         return count;
270 }
271 
272 static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
273                           const char *buf, size_t count)
274 {
275         struct sis5595_data *data = dev_get_drvdata(dev);
276         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
277         int nr = attr->index;
278         unsigned long val;
279         int err;
280 
281         err = kstrtoul(buf, 10, &val);
282         if (err)
283                 return err;
284 
285         mutex_lock(&data->update_lock);
286         data->in_max[nr] = IN_TO_REG(val);
287         sis5595_write_value(data, SIS5595_REG_IN_MAX(nr), data->in_max[nr]);
288         mutex_unlock(&data->update_lock);
289         return count;
290 }
291 
292 #define show_in_offset(offset)                                  \
293 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
294                 show_in, NULL, offset);                         \
295 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
296                 show_in_min, set_in_min, offset);               \
297 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
298                 show_in_max, set_in_max, offset);
299 
300 show_in_offset(0);
301 show_in_offset(1);
302 show_in_offset(2);
303 show_in_offset(3);
304 show_in_offset(4);
305 
306 /* Temperature */
307 static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
308                          char *buf)
309 {
310         struct sis5595_data *data = sis5595_update_device(dev);
311         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
312 }
313 
314 static ssize_t show_temp_over(struct device *dev, struct device_attribute *attr,
315                               char *buf)
316 {
317         struct sis5595_data *data = sis5595_update_device(dev);
318         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
319 }
320 
321 static ssize_t set_temp_over(struct device *dev, struct device_attribute *attr,
322                              const char *buf, size_t count)
323 {
324         struct sis5595_data *data = dev_get_drvdata(dev);
325         long val;
326         int err;
327 
328         err = kstrtol(buf, 10, &val);
329         if (err)
330                 return err;
331 
332         mutex_lock(&data->update_lock);
333         data->temp_over = TEMP_TO_REG(val);
334         sis5595_write_value(data, SIS5595_REG_TEMP_OVER, data->temp_over);
335         mutex_unlock(&data->update_lock);
336         return count;
337 }
338 
339 static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *attr,
340                               char *buf)
341 {
342         struct sis5595_data *data = sis5595_update_device(dev);
343         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
344 }
345 
346 static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *attr,
347                              const char *buf, size_t count)
348 {
349         struct sis5595_data *data = dev_get_drvdata(dev);
350         long val;
351         int err;
352 
353         err = kstrtol(buf, 10, &val);
354         if (err)
355                 return err;
356 
357         mutex_lock(&data->update_lock);
358         data->temp_hyst = TEMP_TO_REG(val);
359         sis5595_write_value(data, SIS5595_REG_TEMP_HYST, data->temp_hyst);
360         mutex_unlock(&data->update_lock);
361         return count;
362 }
363 
364 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
365 static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
366                 show_temp_over, set_temp_over);
367 static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
368                 show_temp_hyst, set_temp_hyst);
369 
370 /* 2 Fans */
371 static ssize_t show_fan(struct device *dev, struct device_attribute *da,
372                         char *buf)
373 {
374         struct sis5595_data *data = sis5595_update_device(dev);
375         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
376         int nr = attr->index;
377         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
378                 DIV_FROM_REG(data->fan_div[nr])));
379 }
380 
381 static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
382                             char *buf)
383 {
384         struct sis5595_data *data = sis5595_update_device(dev);
385         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
386         int nr = attr->index;
387         return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
388                 DIV_FROM_REG(data->fan_div[nr])));
389 }
390 
391 static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
392                            const char *buf, size_t count)
393 {
394         struct sis5595_data *data = dev_get_drvdata(dev);
395         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
396         int nr = attr->index;
397         unsigned long val;
398         int err;
399 
400         err = kstrtoul(buf, 10, &val);
401         if (err)
402                 return err;
403 
404         mutex_lock(&data->update_lock);
405         data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
406         sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
407         mutex_unlock(&data->update_lock);
408         return count;
409 }
410 
411 static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
412                             char *buf)
413 {
414         struct sis5595_data *data = sis5595_update_device(dev);
415         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
416         int nr = attr->index;
417         return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
418 }
419 
420 /*
421  * Note: we save and restore the fan minimum here, because its value is
422  * determined in part by the fan divisor.  This follows the principle of
423  * least surprise; the user doesn't expect the fan minimum to change just
424  * because the divisor changed.
425  */
426 static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
427                            const char *buf, size_t count)
428 {
429         struct sis5595_data *data = dev_get_drvdata(dev);
430         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
431         int nr = attr->index;
432         unsigned long min;
433         int reg;
434         unsigned long val;
435         int err;
436 
437         err = kstrtoul(buf, 10, &val);
438         if (err)
439                 return err;
440 
441         mutex_lock(&data->update_lock);
442         min = FAN_FROM_REG(data->fan_min[nr],
443                         DIV_FROM_REG(data->fan_div[nr]));
444         reg = sis5595_read_value(data, SIS5595_REG_FANDIV);
445 
446         switch (val) {
447         case 1:
448                 data->fan_div[nr] = 0;
449                 break;
450         case 2:
451                 data->fan_div[nr] = 1;
452                 break;
453         case 4:
454                 data->fan_div[nr] = 2;
455                 break;
456         case 8:
457                 data->fan_div[nr] = 3;
458                 break;
459         default:
460                 dev_err(dev,
461                         "fan_div value %ld not supported. Choose one of 1, 2, 4 or 8!\n",
462                         val);
463                 mutex_unlock(&data->update_lock);
464                 return -EINVAL;
465         }
466 
467         switch (nr) {
468         case 0:
469                 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
470                 break;
471         case 1:
472                 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
473                 break;
474         }
475         sis5595_write_value(data, SIS5595_REG_FANDIV, reg);
476         data->fan_min[nr] =
477                 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
478         sis5595_write_value(data, SIS5595_REG_FAN_MIN(nr), data->fan_min[nr]);
479         mutex_unlock(&data->update_lock);
480         return count;
481 }
482 
483 #define show_fan_offset(offset)                                         \
484 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,                 \
485                 show_fan, NULL, offset - 1);                            \
486 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR,         \
487                 show_fan_min, set_fan_min, offset - 1);                 \
488 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR,         \
489                 show_fan_div, set_fan_div, offset - 1);
490 
491 show_fan_offset(1);
492 show_fan_offset(2);
493 
494 /* Alarms */
495 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
496                            char *buf)
497 {
498         struct sis5595_data *data = sis5595_update_device(dev);
499         return sprintf(buf, "%d\n", data->alarms);
500 }
501 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
502 
503 static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
504                           char *buf)
505 {
506         struct sis5595_data *data = sis5595_update_device(dev);
507         int nr = to_sensor_dev_attr(da)->index;
508         return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
509 }
510 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
511 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
512 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
513 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
514 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 15);
515 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
516 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
517 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 15);
518 
519 static ssize_t show_name(struct device *dev, struct device_attribute *attr,
520                          char *buf)
521 {
522         struct sis5595_data *data = dev_get_drvdata(dev);
523         return sprintf(buf, "%s\n", data->name);
524 }
525 static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
526 
527 static struct attribute *sis5595_attributes[] = {
528         &sensor_dev_attr_in0_input.dev_attr.attr,
529         &sensor_dev_attr_in0_min.dev_attr.attr,
530         &sensor_dev_attr_in0_max.dev_attr.attr,
531         &sensor_dev_attr_in0_alarm.dev_attr.attr,
532         &sensor_dev_attr_in1_input.dev_attr.attr,
533         &sensor_dev_attr_in1_min.dev_attr.attr,
534         &sensor_dev_attr_in1_max.dev_attr.attr,
535         &sensor_dev_attr_in1_alarm.dev_attr.attr,
536         &sensor_dev_attr_in2_input.dev_attr.attr,
537         &sensor_dev_attr_in2_min.dev_attr.attr,
538         &sensor_dev_attr_in2_max.dev_attr.attr,
539         &sensor_dev_attr_in2_alarm.dev_attr.attr,
540         &sensor_dev_attr_in3_input.dev_attr.attr,
541         &sensor_dev_attr_in3_min.dev_attr.attr,
542         &sensor_dev_attr_in3_max.dev_attr.attr,
543         &sensor_dev_attr_in3_alarm.dev_attr.attr,
544 
545         &sensor_dev_attr_fan1_input.dev_attr.attr,
546         &sensor_dev_attr_fan1_min.dev_attr.attr,
547         &sensor_dev_attr_fan1_div.dev_attr.attr,
548         &sensor_dev_attr_fan1_alarm.dev_attr.attr,
549         &sensor_dev_attr_fan2_input.dev_attr.attr,
550         &sensor_dev_attr_fan2_min.dev_attr.attr,
551         &sensor_dev_attr_fan2_div.dev_attr.attr,
552         &sensor_dev_attr_fan2_alarm.dev_attr.attr,
553 
554         &dev_attr_alarms.attr,
555         &dev_attr_name.attr,
556         NULL
557 };
558 
559 static const struct attribute_group sis5595_group = {
560         .attrs = sis5595_attributes,
561 };
562 
563 static struct attribute *sis5595_attributes_in4[] = {
564         &sensor_dev_attr_in4_input.dev_attr.attr,
565         &sensor_dev_attr_in4_min.dev_attr.attr,
566         &sensor_dev_attr_in4_max.dev_attr.attr,
567         &sensor_dev_attr_in4_alarm.dev_attr.attr,
568         NULL
569 };
570 
571 static const struct attribute_group sis5595_group_in4 = {
572         .attrs = sis5595_attributes_in4,
573 };
574 
575 static struct attribute *sis5595_attributes_temp1[] = {
576         &dev_attr_temp1_input.attr,
577         &dev_attr_temp1_max.attr,
578         &dev_attr_temp1_max_hyst.attr,
579         &sensor_dev_attr_temp1_alarm.dev_attr.attr,
580         NULL
581 };
582 
583 static const struct attribute_group sis5595_group_temp1 = {
584         .attrs = sis5595_attributes_temp1,
585 };
586 
587 /* This is called when the module is loaded */
588 static int sis5595_probe(struct platform_device *pdev)
589 {
590         int err = 0;
591         int i;
592         struct sis5595_data *data;
593         struct resource *res;
594         char val;
595 
596         /* Reserve the ISA region */
597         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
598         if (!devm_request_region(&pdev->dev, res->start, SIS5595_EXTENT,
599                                  sis5595_driver.driver.name))
600                 return -EBUSY;
601 
602         data = devm_kzalloc(&pdev->dev, sizeof(struct sis5595_data),
603                             GFP_KERNEL);
604         if (!data)
605                 return -ENOMEM;
606 
607         mutex_init(&data->lock);
608         mutex_init(&data->update_lock);
609         data->addr = res->start;
610         data->name = "sis5595";
611         platform_set_drvdata(pdev, data);
612 
613         /*
614          * Check revision and pin registers to determine whether 4 or 5 voltages
615          */
616         data->revision = s_bridge->revision;
617         /* 4 voltages, 1 temp */
618         data->maxins = 3;
619         if (data->revision >= REV2MIN) {
620                 pci_read_config_byte(s_bridge, SIS5595_PIN_REG, &val);
621                 if (!(val & 0x80))
622                         /* 5 voltages, no temps */
623                         data->maxins = 4;
624         }
625 
626         /* Initialize the SIS5595 chip */
627         sis5595_init_device(data);
628 
629         /* A few vars need to be filled upon startup */
630         for (i = 0; i < 2; i++) {
631                 data->fan_min[i] = sis5595_read_value(data,
632                                         SIS5595_REG_FAN_MIN(i));
633         }
634 
635         /* Register sysfs hooks */
636         err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group);
637         if (err)
638                 return err;
639         if (data->maxins == 4) {
640                 err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group_in4);
641                 if (err)
642                         goto exit_remove_files;
643         } else {
644                 err = sysfs_create_group(&pdev->dev.kobj, &sis5595_group_temp1);
645                 if (err)
646                         goto exit_remove_files;
647         }
648 
649         data->hwmon_dev = hwmon_device_register(&pdev->dev);
650         if (IS_ERR(data->hwmon_dev)) {
651                 err = PTR_ERR(data->hwmon_dev);
652                 goto exit_remove_files;
653         }
654 
655         return 0;
656 
657 exit_remove_files:
658         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
659         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
660         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
661         return err;
662 }
663 
664 static int sis5595_remove(struct platform_device *pdev)
665 {
666         struct sis5595_data *data = platform_get_drvdata(pdev);
667 
668         hwmon_device_unregister(data->hwmon_dev);
669         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group);
670         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_in4);
671         sysfs_remove_group(&pdev->dev.kobj, &sis5595_group_temp1);
672 
673         return 0;
674 }
675 
676 
677 /* ISA access must be locked explicitly. */
678 static int sis5595_read_value(struct sis5595_data *data, u8 reg)
679 {
680         int res;
681 
682         mutex_lock(&data->lock);
683         outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
684         res = inb_p(data->addr + SIS5595_DATA_REG_OFFSET);
685         mutex_unlock(&data->lock);
686         return res;
687 }
688 
689 static void sis5595_write_value(struct sis5595_data *data, u8 reg, u8 value)
690 {
691         mutex_lock(&data->lock);
692         outb_p(reg, data->addr + SIS5595_ADDR_REG_OFFSET);
693         outb_p(value, data->addr + SIS5595_DATA_REG_OFFSET);
694         mutex_unlock(&data->lock);
695 }
696 
697 /* Called when we have found a new SIS5595. */
698 static void sis5595_init_device(struct sis5595_data *data)
699 {
700         u8 config = sis5595_read_value(data, SIS5595_REG_CONFIG);
701         if (!(config & 0x01))
702                 sis5595_write_value(data, SIS5595_REG_CONFIG,
703                                 (config & 0xf7) | 0x01);
704 }
705 
706 static struct sis5595_data *sis5595_update_device(struct device *dev)
707 {
708         struct sis5595_data *data = dev_get_drvdata(dev);
709         int i;
710 
711         mutex_lock(&data->update_lock);
712 
713         if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
714             || !data->valid) {
715 
716                 for (i = 0; i <= data->maxins; i++) {
717                         data->in[i] =
718                             sis5595_read_value(data, SIS5595_REG_IN(i));
719                         data->in_min[i] =
720                             sis5595_read_value(data,
721                                                SIS5595_REG_IN_MIN(i));
722                         data->in_max[i] =
723                             sis5595_read_value(data,
724                                                SIS5595_REG_IN_MAX(i));
725                 }
726                 for (i = 0; i < 2; i++) {
727                         data->fan[i] =
728                             sis5595_read_value(data, SIS5595_REG_FAN(i));
729                         data->fan_min[i] =
730                             sis5595_read_value(data,
731                                                SIS5595_REG_FAN_MIN(i));
732                 }
733                 if (data->maxins == 3) {
734                         data->temp =
735                             sis5595_read_value(data, SIS5595_REG_TEMP);
736                         data->temp_over =
737                             sis5595_read_value(data, SIS5595_REG_TEMP_OVER);
738                         data->temp_hyst =
739                             sis5595_read_value(data, SIS5595_REG_TEMP_HYST);
740                 }
741                 i = sis5595_read_value(data, SIS5595_REG_FANDIV);
742                 data->fan_div[0] = (i >> 4) & 0x03;
743                 data->fan_div[1] = i >> 6;
744                 data->alarms =
745                     sis5595_read_value(data, SIS5595_REG_ALARM1) |
746                     (sis5595_read_value(data, SIS5595_REG_ALARM2) << 8);
747                 data->last_updated = jiffies;
748                 data->valid = 1;
749         }
750 
751         mutex_unlock(&data->update_lock);
752 
753         return data;
754 }
755 
756 static const struct pci_device_id sis5595_pci_ids[] = {
757         { PCI_DEVICE(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_503) },
758         { 0, }
759 };
760 
761 MODULE_DEVICE_TABLE(pci, sis5595_pci_ids);
762 
763 static int blacklist[] = {
764         PCI_DEVICE_ID_SI_540,
765         PCI_DEVICE_ID_SI_550,
766         PCI_DEVICE_ID_SI_630,
767         PCI_DEVICE_ID_SI_645,
768         PCI_DEVICE_ID_SI_730,
769         PCI_DEVICE_ID_SI_735,
770         PCI_DEVICE_ID_SI_5511, /*
771                                 * 5513 chip has the 0008 device but
772                                 * that ID shows up in other chips so we
773                                 * use the 5511 ID for recognition
774                                 */
775         PCI_DEVICE_ID_SI_5597,
776         PCI_DEVICE_ID_SI_5598,
777         0 };
778 
779 static int sis5595_device_add(unsigned short address)
780 {
781         struct resource res = {
782                 .start  = address,
783                 .end    = address + SIS5595_EXTENT - 1,
784                 .name   = "sis5595",
785                 .flags  = IORESOURCE_IO,
786         };
787         int err;
788 
789         err = acpi_check_resource_conflict(&res);
790         if (err)
791                 goto exit;
792 
793         pdev = platform_device_alloc("sis5595", address);
794         if (!pdev) {
795                 err = -ENOMEM;
796                 pr_err("Device allocation failed\n");
797                 goto exit;
798         }
799 
800         err = platform_device_add_resources(pdev, &res, 1);
801         if (err) {
802                 pr_err("Device resource addition failed (%d)\n", err);
803                 goto exit_device_put;
804         }
805 
806         err = platform_device_add(pdev);
807         if (err) {
808                 pr_err("Device addition failed (%d)\n", err);
809                 goto exit_device_put;
810         }
811 
812         return 0;
813 
814 exit_device_put:
815         platform_device_put(pdev);
816 exit:
817         return err;
818 }
819 
820 static int sis5595_pci_probe(struct pci_dev *dev,
821                                        const struct pci_device_id *id)
822 {
823         u16 address;
824         u8 enable;
825         int *i;
826 
827         for (i = blacklist; *i != 0; i++) {
828                 struct pci_dev *d;
829                 d = pci_get_device(PCI_VENDOR_ID_SI, *i, NULL);
830                 if (d) {
831                         dev_err(&d->dev,
832                                 "Looked for SIS5595 but found unsupported device %.4x\n",
833                                 *i);
834                         pci_dev_put(d);
835                         return -ENODEV;
836                 }
837         }
838 
839         force_addr &= ~(SIS5595_EXTENT - 1);
840         if (force_addr) {
841                 dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", force_addr);
842                 pci_write_config_word(dev, SIS5595_BASE_REG, force_addr);
843         }
844 
845         if (PCIBIOS_SUCCESSFUL !=
846             pci_read_config_word(dev, SIS5595_BASE_REG, &address)) {
847                 dev_err(&dev->dev, "Failed to read ISA address\n");
848                 return -ENODEV;
849         }
850 
851         address &= ~(SIS5595_EXTENT - 1);
852         if (!address) {
853                 dev_err(&dev->dev,
854                         "Base address not set - upgrade BIOS or use force_addr=0xaddr\n");
855                 return -ENODEV;
856         }
857         if (force_addr && address != force_addr) {
858                 /* doesn't work for some chips? */
859                 dev_err(&dev->dev, "Failed to force ISA address\n");
860                 return -ENODEV;
861         }
862 
863         if (PCIBIOS_SUCCESSFUL !=
864             pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable)) {
865                 dev_err(&dev->dev, "Failed to read enable register\n");
866                 return -ENODEV;
867         }
868         if (!(enable & 0x80)) {
869                 if ((PCIBIOS_SUCCESSFUL !=
870                      pci_write_config_byte(dev, SIS5595_ENABLE_REG,
871                                            enable | 0x80))
872                  || (PCIBIOS_SUCCESSFUL !=
873                      pci_read_config_byte(dev, SIS5595_ENABLE_REG, &enable))
874                  || (!(enable & 0x80))) {
875                         /* doesn't work for some chips! */
876                         dev_err(&dev->dev, "Failed to enable HWM device\n");
877                         return -ENODEV;
878                 }
879         }
880 
881         if (platform_driver_register(&sis5595_driver)) {
882                 dev_dbg(&dev->dev, "Failed to register sis5595 driver\n");
883                 goto exit;
884         }
885 
886         s_bridge = pci_dev_get(dev);
887         /* Sets global pdev as a side effect */
888         if (sis5595_device_add(address))
889                 goto exit_unregister;
890 
891         /*
892          * Always return failure here.  This is to allow other drivers to bind
893          * to this pci device.  We don't really want to have control over the
894          * pci device, we only wanted to read as few register values from it.
895          */
896         return -ENODEV;
897 
898 exit_unregister:
899         pci_dev_put(dev);
900         platform_driver_unregister(&sis5595_driver);
901 exit:
902         return -ENODEV;
903 }
904 
905 static struct pci_driver sis5595_pci_driver = {
906         .name            = "sis5595",
907         .id_table        = sis5595_pci_ids,
908         .probe           = sis5595_pci_probe,
909 };
910 
911 static int __init sm_sis5595_init(void)
912 {
913         return pci_register_driver(&sis5595_pci_driver);
914 }
915 
916 static void __exit sm_sis5595_exit(void)
917 {
918         pci_unregister_driver(&sis5595_pci_driver);
919         if (s_bridge != NULL) {
920                 platform_device_unregister(pdev);
921                 platform_driver_unregister(&sis5595_driver);
922                 pci_dev_put(s_bridge);
923                 s_bridge = NULL;
924         }
925 }
926 
927 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
928 MODULE_DESCRIPTION("SiS 5595 Sensor device");
929 MODULE_LICENSE("GPL");
930 
931 module_init(sm_sis5595_init);
932 module_exit(sm_sis5595_exit);
933 

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