projects / deliverable / linux.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
hwmon: (lm78) Prevent misdetection of Winbond chips
[deliverable/linux.git] / drivers / hwmon / lm78.c
... / ...
CommitLineData
1/*
2 lm78.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring
4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
5 Copyright (c) 2007 Jean Delvare <khali@linux-fr.org>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20*/
21
22#include <linux/module.h>
23#include <linux/init.h>
24#include <linux/slab.h>
25#include <linux/jiffies.h>
26#include <linux/i2c.h>
27#include <linux/platform_device.h>
28#include <linux/ioport.h>
29#include <linux/hwmon.h>
30#include <linux/hwmon-vid.h>
31#include <linux/hwmon-sysfs.h>
32#include <linux/err.h>
33#include <linux/mutex.h>
34#include <asm/io.h>
35
36/* ISA device, if found */
37static struct platform_device *pdev;
38
39/* Addresses to scan */
40static const unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
41 0x2e, 0x2f, I2C_CLIENT_END };
42static unsigned short isa_address = 0x290;
43
44/* Insmod parameters */
45I2C_CLIENT_INSMOD_2(lm78, lm79);
46
47/* Many LM78 constants specified below */
48
49/* Length of ISA address segment */
50#define LM78_EXTENT 8
51
52/* Where are the ISA address/data registers relative to the base address */
53#define LM78_ADDR_REG_OFFSET 5
54#define LM78_DATA_REG_OFFSET 6
55
56/* The LM78 registers */
57#define LM78_REG_IN_MAX(nr) (0x2b + (nr) * 2)
58#define LM78_REG_IN_MIN(nr) (0x2c + (nr) * 2)
59#define LM78_REG_IN(nr) (0x20 + (nr))
60
61#define LM78_REG_FAN_MIN(nr) (0x3b + (nr))
62#define LM78_REG_FAN(nr) (0x28 + (nr))
63
64#define LM78_REG_TEMP 0x27
65#define LM78_REG_TEMP_OVER 0x39
66#define LM78_REG_TEMP_HYST 0x3a
67
68#define LM78_REG_ALARM1 0x41
69#define LM78_REG_ALARM2 0x42
70
71#define LM78_REG_VID_FANDIV 0x47
72
73#define LM78_REG_CONFIG 0x40
74#define LM78_REG_CHIPID 0x49
75#define LM78_REG_I2C_ADDR 0x48
76
77
78/* Conversions. Rounding and limit checking is only done on the TO_REG
79 variants. */
80
81/* IN: mV, (0V to 4.08V)
82 REG: 16mV/bit */
83static inline u8 IN_TO_REG(unsigned long val)
84{
85 unsigned long nval = SENSORS_LIMIT(val, 0, 4080);
86 return (nval + 8) / 16;
87}
88#define IN_FROM_REG(val) ((val) * 16)
89
90static inline u8 FAN_TO_REG(long rpm, int div)
91{
92 if (rpm <= 0)
93 return 255;
94 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
95}
96
97static inline int FAN_FROM_REG(u8 val, int div)
98{
99 return val==0 ? -1 : val==255 ? 0 : 1350000/(val*div);
100}
101
102/* TEMP: mC (-128C to +127C)
103 REG: 1C/bit, two's complement */
104static inline s8 TEMP_TO_REG(int val)
105{
106 int nval = SENSORS_LIMIT(val, -128000, 127000) ;
107 return nval<0 ? (nval-500)/1000 : (nval+500)/1000;
108}
109
110static inline int TEMP_FROM_REG(s8 val)
111{
112 return val * 1000;
113}
114
115#define DIV_FROM_REG(val) (1 << (val))
116
117/* There are some complications in a module like this. First off, LM78 chips
118 may be both present on the SMBus and the ISA bus, and we have to handle
119 those cases separately at some places. Second, there might be several
120 LM78 chips available (well, actually, that is probably never done; but
121 it is a clean illustration of how to handle a case like that). Finally,
122 a specific chip may be attached to *both* ISA and SMBus, and we would
123 not like to detect it double. */
124
125/* For ISA chips, we abuse the i2c_client addr and name fields. We also use
126 the driver field to differentiate between I2C and ISA chips. */
127struct lm78_data {
128 struct i2c_client client;
129 struct device *hwmon_dev;
130 struct mutex lock;
131 enum chips type;
132
133 struct mutex update_lock;
134 char valid; /* !=0 if following fields are valid */
135 unsigned long last_updated; /* In jiffies */
136
137 u8 in[7]; /* Register value */
138 u8 in_max[7]; /* Register value */
139 u8 in_min[7]; /* Register value */
140 u8 fan[3]; /* Register value */
141 u8 fan_min[3]; /* Register value */
142 s8 temp; /* Register value */
143 s8 temp_over; /* Register value */
144 s8 temp_hyst; /* Register value */
145 u8 fan_div[3]; /* Register encoding, shifted right */
146 u8 vid; /* Register encoding, combined */
147 u16 alarms; /* Register encoding, combined */
148};
149
150
151static int lm78_attach_adapter(struct i2c_adapter *adapter);
152static int lm78_detect(struct i2c_adapter *adapter, int address, int kind);
153static int lm78_detach_client(struct i2c_client *client);
154
155static int __devinit lm78_isa_probe(struct platform_device *pdev);
156static int __devexit lm78_isa_remove(struct platform_device *pdev);
157
158static int lm78_read_value(struct lm78_data *data, u8 reg);
159static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value);
160static struct lm78_data *lm78_update_device(struct device *dev);
161static void lm78_init_device(struct lm78_data *data);
162
163
164static struct i2c_driver lm78_driver = {
165 .driver = {
166 .name = "lm78",
167 },
168 .attach_adapter = lm78_attach_adapter,
169 .detach_client = lm78_detach_client,
170};
171
172static struct platform_driver lm78_isa_driver = {
173 .driver = {
174 .owner = THIS_MODULE,
175 .name = "lm78",
176 },
177 .probe = lm78_isa_probe,
178 .remove = lm78_isa_remove,
179};
180
181
182/* 7 Voltages */
183static ssize_t show_in(struct device *dev, struct device_attribute *da,
184 char *buf)
185{
186 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
187 struct lm78_data *data = lm78_update_device(dev);
188 return sprintf(buf, "%d\n", IN_FROM_REG(data->in[attr->index]));
189}
190
191static ssize_t show_in_min(struct device *dev, struct device_attribute *da,
192 char *buf)
193{
194 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
195 struct lm78_data *data = lm78_update_device(dev);
196 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_min[attr->index]));
197}
198
199static ssize_t show_in_max(struct device *dev, struct device_attribute *da,
200 char *buf)
201{
202 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
203 struct lm78_data *data = lm78_update_device(dev);
204 return sprintf(buf, "%d\n", IN_FROM_REG(data->in_max[attr->index]));
205}
206
207static ssize_t set_in_min(struct device *dev, struct device_attribute *da,
208 const char *buf, size_t count)
209{
210 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
211 struct lm78_data *data = dev_get_drvdata(dev);
212 unsigned long val = simple_strtoul(buf, NULL, 10);
213 int nr = attr->index;
214
215 mutex_lock(&data->update_lock);
216 data->in_min[nr] = IN_TO_REG(val);
217 lm78_write_value(data, LM78_REG_IN_MIN(nr), data->in_min[nr]);
218 mutex_unlock(&data->update_lock);
219 return count;
220}
221
222static ssize_t set_in_max(struct device *dev, struct device_attribute *da,
223 const char *buf, size_t count)
224{
225 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
226 struct lm78_data *data = dev_get_drvdata(dev);
227 unsigned long val = simple_strtoul(buf, NULL, 10);
228 int nr = attr->index;
229
230 mutex_lock(&data->update_lock);
231 data->in_max[nr] = IN_TO_REG(val);
232 lm78_write_value(data, LM78_REG_IN_MAX(nr), data->in_max[nr]);
233 mutex_unlock(&data->update_lock);
234 return count;
235}
236
237#define show_in_offset(offset) \
238static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
239 show_in, NULL, offset); \
240static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
241 show_in_min, set_in_min, offset); \
242static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
243 show_in_max, set_in_max, offset);
244
245show_in_offset(0);
246show_in_offset(1);
247show_in_offset(2);
248show_in_offset(3);
249show_in_offset(4);
250show_in_offset(5);
251show_in_offset(6);
252
253/* Temperature */
254static ssize_t show_temp(struct device *dev, struct device_attribute *da,
255 char *buf)
256{
257 struct lm78_data *data = lm78_update_device(dev);
258 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp));
259}
260
261static ssize_t show_temp_over(struct device *dev, struct device_attribute *da,
262 char *buf)
263{
264 struct lm78_data *data = lm78_update_device(dev);
265 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_over));
266}
267
268static ssize_t set_temp_over(struct device *dev, struct device_attribute *da,
269 const char *buf, size_t count)
270{
271 struct lm78_data *data = dev_get_drvdata(dev);
272 long val = simple_strtol(buf, NULL, 10);
273
274 mutex_lock(&data->update_lock);
275 data->temp_over = TEMP_TO_REG(val);
276 lm78_write_value(data, LM78_REG_TEMP_OVER, data->temp_over);
277 mutex_unlock(&data->update_lock);
278 return count;
279}
280
281static ssize_t show_temp_hyst(struct device *dev, struct device_attribute *da,
282 char *buf)
283{
284 struct lm78_data *data = lm78_update_device(dev);
285 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_hyst));
286}
287
288static ssize_t set_temp_hyst(struct device *dev, struct device_attribute *da,
289 const char *buf, size_t count)
290{
291 struct lm78_data *data = dev_get_drvdata(dev);
292 long val = simple_strtol(buf, NULL, 10);
293
294 mutex_lock(&data->update_lock);
295 data->temp_hyst = TEMP_TO_REG(val);
296 lm78_write_value(data, LM78_REG_TEMP_HYST, data->temp_hyst);
297 mutex_unlock(&data->update_lock);
298 return count;
299}
300
301static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL);
302static DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR,
303 show_temp_over, set_temp_over);
304static DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR,
305 show_temp_hyst, set_temp_hyst);
306
307/* 3 Fans */
308static ssize_t show_fan(struct device *dev, struct device_attribute *da,
309 char *buf)
310{
311 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
312 struct lm78_data *data = lm78_update_device(dev);
313 int nr = attr->index;
314 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
315 DIV_FROM_REG(data->fan_div[nr])) );
316}
317
318static ssize_t show_fan_min(struct device *dev, struct device_attribute *da,
319 char *buf)
320{
321 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
322 struct lm78_data *data = lm78_update_device(dev);
323 int nr = attr->index;
324 return sprintf(buf,"%d\n", FAN_FROM_REG(data->fan_min[nr],
325 DIV_FROM_REG(data->fan_div[nr])) );
326}
327
328static ssize_t set_fan_min(struct device *dev, struct device_attribute *da,
329 const char *buf, size_t count)
330{
331 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
332 struct lm78_data *data = dev_get_drvdata(dev);
333 int nr = attr->index;
334 unsigned long val = simple_strtoul(buf, NULL, 10);
335
336 mutex_lock(&data->update_lock);
337 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
338 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
339 mutex_unlock(&data->update_lock);
340 return count;
341}
342
343static ssize_t show_fan_div(struct device *dev, struct device_attribute *da,
344 char *buf)
345{
346 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
347 struct lm78_data *data = lm78_update_device(dev);
348 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[attr->index]));
349}
350
351/* Note: we save and restore the fan minimum here, because its value is
352 determined in part by the fan divisor. This follows the principle of
353 least surprise; the user doesn't expect the fan minimum to change just
354 because the divisor changed. */
355static ssize_t set_fan_div(struct device *dev, struct device_attribute *da,
356 const char *buf, size_t count)
357{
358 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
359 struct lm78_data *data = dev_get_drvdata(dev);
360 int nr = attr->index;
361 unsigned long val = simple_strtoul(buf, NULL, 10);
362 unsigned long min;
363 u8 reg;
364
365 mutex_lock(&data->update_lock);
366 min = FAN_FROM_REG(data->fan_min[nr],
367 DIV_FROM_REG(data->fan_div[nr]));
368
369 switch (val) {
370 case 1: data->fan_div[nr] = 0; break;
371 case 2: data->fan_div[nr] = 1; break;
372 case 4: data->fan_div[nr] = 2; break;
373 case 8: data->fan_div[nr] = 3; break;
374 default:
375 dev_err(dev, "fan_div value %ld not "
376 "supported. Choose one of 1, 2, 4 or 8!\n", val);
377 mutex_unlock(&data->update_lock);
378 return -EINVAL;
379 }
380
381 reg = lm78_read_value(data, LM78_REG_VID_FANDIV);
382 switch (nr) {
383 case 0:
384 reg = (reg & 0xcf) | (data->fan_div[nr] << 4);
385 break;
386 case 1:
387 reg = (reg & 0x3f) | (data->fan_div[nr] << 6);
388 break;
389 }
390 lm78_write_value(data, LM78_REG_VID_FANDIV, reg);
391
392 data->fan_min[nr] =
393 FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
394 lm78_write_value(data, LM78_REG_FAN_MIN(nr), data->fan_min[nr]);
395 mutex_unlock(&data->update_lock);
396
397 return count;
398}
399
400#define show_fan_offset(offset) \
401static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
402 show_fan, NULL, offset - 1); \
403static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
404 show_fan_min, set_fan_min, offset - 1);
405
406show_fan_offset(1);
407show_fan_offset(2);
408show_fan_offset(3);
409
410/* Fan 3 divisor is locked in H/W */
411static SENSOR_DEVICE_ATTR(fan1_div, S_IRUGO | S_IWUSR,
412 show_fan_div, set_fan_div, 0);
413static SENSOR_DEVICE_ATTR(fan2_div, S_IRUGO | S_IWUSR,
414 show_fan_div, set_fan_div, 1);
415static SENSOR_DEVICE_ATTR(fan3_div, S_IRUGO, show_fan_div, NULL, 2);
416
417/* VID */
418static ssize_t show_vid(struct device *dev, struct device_attribute *da,
419 char *buf)
420{
421 struct lm78_data *data = lm78_update_device(dev);
422 return sprintf(buf, "%d\n", vid_from_reg(data->vid, 82));
423}
424static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
425
426/* Alarms */
427static ssize_t show_alarms(struct device *dev, struct device_attribute *da,
428 char *buf)
429{
430 struct lm78_data *data = lm78_update_device(dev);
431 return sprintf(buf, "%u\n", data->alarms);
432}
433static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
434
435static ssize_t show_alarm(struct device *dev, struct device_attribute *da,
436 char *buf)
437{
438 struct lm78_data *data = lm78_update_device(dev);
439 int nr = to_sensor_dev_attr(da)->index;
440 return sprintf(buf, "%u\n", (data->alarms >> nr) & 1);
441}
442static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
443static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
444static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
445static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
446static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
447static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 9);
448static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 10);
449static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
450static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
451static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
452static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
453
454/* This function is called when:
455 * lm78_driver is inserted (when this module is loaded), for each
456 available adapter
457 * when a new adapter is inserted (and lm78_driver is still present)
458 We block updates of the ISA device to minimize the risk of concurrent
459 access to the same LM78 chip through different interfaces. */
460static int lm78_attach_adapter(struct i2c_adapter *adapter)
461{
462 struct lm78_data *data;
463 int err;
464
465 if (!(adapter->class & I2C_CLASS_HWMON))
466 return 0;
467
468 data = pdev ? platform_get_drvdata(pdev) : NULL;
469 if (data)
470 mutex_lock(&data->update_lock);
471 err = i2c_probe(adapter, &addr_data, lm78_detect);
472 if (data)
473 mutex_unlock(&data->update_lock);
474 return err;
475}
476
477static struct attribute *lm78_attributes[] = {
478 &sensor_dev_attr_in0_input.dev_attr.attr,
479 &sensor_dev_attr_in0_min.dev_attr.attr,
480 &sensor_dev_attr_in0_max.dev_attr.attr,
481 &sensor_dev_attr_in0_alarm.dev_attr.attr,
482 &sensor_dev_attr_in1_input.dev_attr.attr,
483 &sensor_dev_attr_in1_min.dev_attr.attr,
484 &sensor_dev_attr_in1_max.dev_attr.attr,
485 &sensor_dev_attr_in1_alarm.dev_attr.attr,
486 &sensor_dev_attr_in2_input.dev_attr.attr,
487 &sensor_dev_attr_in2_min.dev_attr.attr,
488 &sensor_dev_attr_in2_max.dev_attr.attr,
489 &sensor_dev_attr_in2_alarm.dev_attr.attr,
490 &sensor_dev_attr_in3_input.dev_attr.attr,
491 &sensor_dev_attr_in3_min.dev_attr.attr,
492 &sensor_dev_attr_in3_max.dev_attr.attr,
493 &sensor_dev_attr_in3_alarm.dev_attr.attr,
494 &sensor_dev_attr_in4_input.dev_attr.attr,
495 &sensor_dev_attr_in4_min.dev_attr.attr,
496 &sensor_dev_attr_in4_max.dev_attr.attr,
497 &sensor_dev_attr_in4_alarm.dev_attr.attr,
498 &sensor_dev_attr_in5_input.dev_attr.attr,
499 &sensor_dev_attr_in5_min.dev_attr.attr,
500 &sensor_dev_attr_in5_max.dev_attr.attr,
501 &sensor_dev_attr_in5_alarm.dev_attr.attr,
502 &sensor_dev_attr_in6_input.dev_attr.attr,
503 &sensor_dev_attr_in6_min.dev_attr.attr,
504 &sensor_dev_attr_in6_max.dev_attr.attr,
505 &sensor_dev_attr_in6_alarm.dev_attr.attr,
506 &dev_attr_temp1_input.attr,
507 &dev_attr_temp1_max.attr,
508 &dev_attr_temp1_max_hyst.attr,
509 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
510 &sensor_dev_attr_fan1_input.dev_attr.attr,
511 &sensor_dev_attr_fan1_min.dev_attr.attr,
512 &sensor_dev_attr_fan1_div.dev_attr.attr,
513 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
514 &sensor_dev_attr_fan2_input.dev_attr.attr,
515 &sensor_dev_attr_fan2_min.dev_attr.attr,
516 &sensor_dev_attr_fan2_div.dev_attr.attr,
517 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
518 &sensor_dev_attr_fan3_input.dev_attr.attr,
519 &sensor_dev_attr_fan3_min.dev_attr.attr,
520 &sensor_dev_attr_fan3_div.dev_attr.attr,
521 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
522 &dev_attr_alarms.attr,
523 &dev_attr_cpu0_vid.attr,
524
525 NULL
526};
527
528static const struct attribute_group lm78_group = {
529 .attrs = lm78_attributes,
530};
531
532/* I2C devices get this name attribute automatically, but for ISA devices
533 we must create it by ourselves. */
534static ssize_t show_name(struct device *dev, struct device_attribute
535 *devattr, char *buf)
536{
537 struct lm78_data *data = dev_get_drvdata(dev);
538
539 return sprintf(buf, "%s\n", data->client.name);
540}
541static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
542
543/* Returns 1 if the I2C chip appears to be an alias of the ISA chip */
544static int lm78_alias_detect(struct i2c_client *client, u8 chipid)
545{
546 struct lm78_data *i2c, *isa;
547 int i;
548
549 if (!pdev) /* No ISA chip */
550 return 0;
551
552 i2c = i2c_get_clientdata(client);
553 isa = platform_get_drvdata(pdev);
554
555 if (lm78_read_value(isa, LM78_REG_I2C_ADDR) != client->addr)
556 return 0; /* Address doesn't match */
557 if ((lm78_read_value(isa, LM78_REG_CHIPID) & 0xfe) != (chipid & 0xfe))
558 return 0; /* Chip type doesn't match */
559
560 /* We compare all the limit registers, the config register and the
561 * interrupt mask registers */
562 for (i = 0x2b; i <= 0x3d; i++) {
563 if (lm78_read_value(isa, i) != lm78_read_value(i2c, i))
564 return 0;
565 }
566 if (lm78_read_value(isa, LM78_REG_CONFIG) !=
567 lm78_read_value(i2c, LM78_REG_CONFIG))
568 return 0;
569 for (i = 0x43; i <= 0x46; i++) {
570 if (lm78_read_value(isa, i) != lm78_read_value(i2c, i))
571 return 0;
572 }
573
574 return 1;
575}
576
577/* This function is called by i2c_probe */
578static int lm78_detect(struct i2c_adapter *adapter, int address, int kind)
579{
580 int i, err;
581 struct i2c_client *new_client;
582 struct lm78_data *data;
583 const char *client_name = "";
584
585 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
586 err = -ENODEV;
587 goto ERROR1;
588 }
589
590 /* OK. For now, we presume we have a valid client. We now create the
591 client structure, even though we cannot fill it completely yet.
592 But it allows us to access lm78_{read,write}_value. */
593
594 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
595 err = -ENOMEM;
596 goto ERROR1;
597 }
598
599 new_client = &data->client;
600 i2c_set_clientdata(new_client, data);
601 new_client->addr = address;
602 new_client->adapter = adapter;
603 new_client->driver = &lm78_driver;
604
605 /* Now, we do the remaining detection. */
606 if (kind < 0) {
607 if (lm78_read_value(data, LM78_REG_CONFIG) & 0x80) {
608 err = -ENODEV;
609 goto ERROR2;
610 }
611 if (lm78_read_value(data, LM78_REG_I2C_ADDR) !=
612 address) {
613 err = -ENODEV;
614 goto ERROR2;
615 }
616 /* Explicitly prevent the misdetection of Winbond chips */
617 i = lm78_read_value(data, 0x4f);
618 if (i == 0xa3 || i == 0x5c) {
619 err = -ENODEV;
620 goto ERROR2;
621 }
622 }
623
624 /* Determine the chip type. */
625 if (kind <= 0) {
626 i = lm78_read_value(data, LM78_REG_CHIPID);
627 if (i == 0x00 || i == 0x20 /* LM78 */
628 || i == 0x40) /* LM78-J */
629 kind = lm78;
630 else if ((i & 0xfe) == 0xc0)
631 kind = lm79;
632 else {
633 if (kind == 0)
634 dev_warn(&adapter->dev, "Ignoring 'force' "
635 "parameter for unknown chip at "
636 "adapter %d, address 0x%02x\n",
637 i2c_adapter_id(adapter), address);
638 err = -ENODEV;
639 goto ERROR2;
640 }
641
642 if (lm78_alias_detect(new_client, i)) {
643 dev_dbg(&adapter->dev, "Device at 0x%02x appears to "
644 "be the same as ISA device\n", address);
645 err = -ENODEV;
646 goto ERROR2;
647 }
648 }
649
650 if (kind == lm78) {
651 client_name = "lm78";
652 } else if (kind == lm79) {
653 client_name = "lm79";
654 }
655
656 /* Fill in the remaining client fields and put into the global list */
657 strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
658 data->type = kind;
659
660 /* Tell the I2C layer a new client has arrived */
661 if ((err = i2c_attach_client(new_client)))
662 goto ERROR2;
663
664 /* Initialize the LM78 chip */
665 lm78_init_device(data);
666
667 /* Register sysfs hooks */
668 if ((err = sysfs_create_group(&new_client->dev.kobj, &lm78_group)))
669 goto ERROR3;
670
671 data->hwmon_dev = hwmon_device_register(&new_client->dev);
672 if (IS_ERR(data->hwmon_dev)) {
673 err = PTR_ERR(data->hwmon_dev);
674 goto ERROR4;
675 }
676
677 return 0;
678
679ERROR4:
680 sysfs_remove_group(&new_client->dev.kobj, &lm78_group);
681ERROR3:
682 i2c_detach_client(new_client);
683ERROR2:
684 kfree(data);
685ERROR1:
686 return err;
687}
688
689static int lm78_detach_client(struct i2c_client *client)
690{
691 struct lm78_data *data = i2c_get_clientdata(client);
692 int err;
693
694 hwmon_device_unregister(data->hwmon_dev);
695 sysfs_remove_group(&client->dev.kobj, &lm78_group);
696
697 if ((err = i2c_detach_client(client)))
698 return err;
699
700 kfree(data);
701
702 return 0;
703}
704
705static int __devinit lm78_isa_probe(struct platform_device *pdev)
706{
707 int err;
708 struct lm78_data *data;
709 struct resource *res;
710 const char *name;
711
712 /* Reserve the ISA region */
713 res = platform_get_resource(pdev, IORESOURCE_IO, 0);
714 if (!request_region(res->start + LM78_ADDR_REG_OFFSET, 2, "lm78")) {
715 err = -EBUSY;
716 goto exit;
717 }
718
719 if (!(data = kzalloc(sizeof(struct lm78_data), GFP_KERNEL))) {
720 err = -ENOMEM;
721 goto exit_release_region;
722 }
723 mutex_init(&data->lock);
724 data->client.addr = res->start;
725 i2c_set_clientdata(&data->client, data);
726 platform_set_drvdata(pdev, data);
727
728 if (lm78_read_value(data, LM78_REG_CHIPID) & 0x80) {
729 data->type = lm79;
730 name = "lm79";
731 } else {
732 data->type = lm78;
733 name = "lm78";
734 }
735 strlcpy(data->client.name, name, I2C_NAME_SIZE);
736
737 /* Initialize the LM78 chip */
738 lm78_init_device(data);
739
740 /* Register sysfs hooks */
741 if ((err = sysfs_create_group(&pdev->dev.kobj, &lm78_group))
742 || (err = device_create_file(&pdev->dev, &dev_attr_name)))
743 goto exit_remove_files;
744
745 data->hwmon_dev = hwmon_device_register(&pdev->dev);
746 if (IS_ERR(data->hwmon_dev)) {
747 err = PTR_ERR(data->hwmon_dev);
748 goto exit_remove_files;
749 }
750
751 return 0;
752
753 exit_remove_files:
754 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
755 device_remove_file(&pdev->dev, &dev_attr_name);
756 kfree(data);
757 exit_release_region:
758 release_region(res->start + LM78_ADDR_REG_OFFSET, 2);
759 exit:
760 return err;
761}
762
763static int __devexit lm78_isa_remove(struct platform_device *pdev)
764{
765 struct lm78_data *data = platform_get_drvdata(pdev);
766
767 hwmon_device_unregister(data->hwmon_dev);
768 sysfs_remove_group(&pdev->dev.kobj, &lm78_group);
769 device_remove_file(&pdev->dev, &dev_attr_name);
770 release_region(data->client.addr + LM78_ADDR_REG_OFFSET, 2);
771 kfree(data);
772
773 return 0;
774}
775
776/* The SMBus locks itself, but ISA access must be locked explicitly!
777 We don't want to lock the whole ISA bus, so we lock each client
778 separately.
779 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
780 would slow down the LM78 access and should not be necessary. */
781static int lm78_read_value(struct lm78_data *data, u8 reg)
782{
783 struct i2c_client *client = &data->client;
784
785 if (!client->driver) { /* ISA device */
786 int res;
787 mutex_lock(&data->lock);
788 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
789 res = inb_p(client->addr + LM78_DATA_REG_OFFSET);
790 mutex_unlock(&data->lock);
791 return res;
792 } else
793 return i2c_smbus_read_byte_data(client, reg);
794}
795
796/* The SMBus locks itself, but ISA access muse be locked explicitly!
797 We don't want to lock the whole ISA bus, so we lock each client
798 separately.
799 We ignore the LM78 BUSY flag at this moment - it could lead to deadlocks,
800 would slow down the LM78 access and should not be necessary.
801 There are some ugly typecasts here, but the good new is - they should
802 nowhere else be necessary! */
803static int lm78_write_value(struct lm78_data *data, u8 reg, u8 value)
804{
805 struct i2c_client *client = &data->client;
806
807 if (!client->driver) { /* ISA device */
808 mutex_lock(&data->lock);
809 outb_p(reg, client->addr + LM78_ADDR_REG_OFFSET);
810 outb_p(value, client->addr + LM78_DATA_REG_OFFSET);
811 mutex_unlock(&data->lock);
812 return 0;
813 } else
814 return i2c_smbus_write_byte_data(client, reg, value);
815}
816
817static void lm78_init_device(struct lm78_data *data)
818{
819 u8 config;
820 int i;
821
822 /* Start monitoring */
823 config = lm78_read_value(data, LM78_REG_CONFIG);
824 if ((config & 0x09) != 0x01)
825 lm78_write_value(data, LM78_REG_CONFIG,
826 (config & 0xf7) | 0x01);
827
828 /* A few vars need to be filled upon startup */
829 for (i = 0; i < 3; i++) {
830 data->fan_min[i] = lm78_read_value(data,
831 LM78_REG_FAN_MIN(i));
832 }
833
834 mutex_init(&data->update_lock);
835}
836
837static struct lm78_data *lm78_update_device(struct device *dev)
838{
839 struct lm78_data *data = dev_get_drvdata(dev);
840 int i;
841
842 mutex_lock(&data->update_lock);
843
844 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
845 || !data->valid) {
846
847 dev_dbg(dev, "Starting lm78 update\n");
848
849 for (i = 0; i <= 6; i++) {
850 data->in[i] =
851 lm78_read_value(data, LM78_REG_IN(i));
852 data->in_min[i] =
853 lm78_read_value(data, LM78_REG_IN_MIN(i));
854 data->in_max[i] =
855 lm78_read_value(data, LM78_REG_IN_MAX(i));
856 }
857 for (i = 0; i < 3; i++) {
858 data->fan[i] =
859 lm78_read_value(data, LM78_REG_FAN(i));
860 data->fan_min[i] =
861 lm78_read_value(data, LM78_REG_FAN_MIN(i));
862 }
863 data->temp = lm78_read_value(data, LM78_REG_TEMP);
864 data->temp_over =
865 lm78_read_value(data, LM78_REG_TEMP_OVER);
866 data->temp_hyst =
867 lm78_read_value(data, LM78_REG_TEMP_HYST);
868 i = lm78_read_value(data, LM78_REG_VID_FANDIV);
869 data->vid = i & 0x0f;
870 if (data->type == lm79)
871 data->vid |=
872 (lm78_read_value(data, LM78_REG_CHIPID) &
873 0x01) << 4;
874 else
875 data->vid |= 0x10;
876 data->fan_div[0] = (i >> 4) & 0x03;
877 data->fan_div[1] = i >> 6;
878 data->alarms = lm78_read_value(data, LM78_REG_ALARM1) +
879 (lm78_read_value(data, LM78_REG_ALARM2) << 8);
880 data->last_updated = jiffies;
881 data->valid = 1;
882
883 data->fan_div[2] = 1;
884 }
885
886 mutex_unlock(&data->update_lock);
887
888 return data;
889}
890
891/* return 1 if a supported chip is found, 0 otherwise */
892static int __init lm78_isa_found(unsigned short address)
893{
894 int val, save, found = 0;
895
896 /* We have to request the region in two parts because some
897 boards declare base+4 to base+7 as a PNP device */
898 if (!request_region(address, 4, "lm78")) {
899 pr_debug("lm78: Failed to request low part of region\n");
900 return 0;
901 }
902 if (!request_region(address + 4, 4, "lm78")) {
903 pr_debug("lm78: Failed to request high part of region\n");
904 release_region(address, 4);
905 return 0;
906 }
907
908#define REALLY_SLOW_IO
909 /* We need the timeouts for at least some LM78-like
910 chips. But only if we read 'undefined' registers. */
911 val = inb_p(address + 1);
912 if (inb_p(address + 2) != val
913 || inb_p(address + 3) != val
914 || inb_p(address + 7) != val)
915 goto release;
916#undef REALLY_SLOW_IO
917
918 /* We should be able to change the 7 LSB of the address port. The
919 MSB (busy flag) should be clear initially, set after the write. */
920 save = inb_p(address + LM78_ADDR_REG_OFFSET);
921 if (save & 0x80)
922 goto release;
923 val = ~save & 0x7f;
924 outb_p(val, address + LM78_ADDR_REG_OFFSET);
925 if (inb_p(address + LM78_ADDR_REG_OFFSET) != (val | 0x80)) {
926 outb_p(save, address + LM78_ADDR_REG_OFFSET);
927 goto release;
928 }
929
930 /* We found a device, now see if it could be an LM78 */
931 outb_p(LM78_REG_CONFIG, address + LM78_ADDR_REG_OFFSET);
932 val = inb_p(address + LM78_DATA_REG_OFFSET);
933 if (val & 0x80)
934 goto release;
935 outb_p(LM78_REG_I2C_ADDR, address + LM78_ADDR_REG_OFFSET);
936 val = inb_p(address + LM78_DATA_REG_OFFSET);
937 if (val < 0x03 || val > 0x77) /* Not a valid I2C address */
938 goto release;
939
940 /* The busy flag should be clear again */
941 if (inb_p(address + LM78_ADDR_REG_OFFSET) & 0x80)
942 goto release;
943
944 /* Explicitly prevent the misdetection of Winbond chips */
945 outb_p(0x4f, address + LM78_ADDR_REG_OFFSET);
946 val = inb_p(address + LM78_DATA_REG_OFFSET);
947 if (val == 0xa3 || val == 0x5c)
948 goto release;
949
950 /* Explicitly prevent the misdetection of ITE chips */
951 outb_p(0x58, address + LM78_ADDR_REG_OFFSET);
952 val = inb_p(address + LM78_DATA_REG_OFFSET);
953 if (val == 0x90)
954 goto release;
955
956 /* Determine the chip type */
957 outb_p(LM78_REG_CHIPID, address + LM78_ADDR_REG_OFFSET);
958 val = inb_p(address + LM78_DATA_REG_OFFSET);
959 if (val == 0x00 || val == 0x20 /* LM78 */
960 || val == 0x40 /* LM78-J */
961 || (val & 0xfe) == 0xc0) /* LM79 */
962 found = 1;
963
964 if (found)
965 pr_info("lm78: Found an %s chip at %#x\n",
966 val & 0x80 ? "LM79" : "LM78", (int)address);
967
968 release:
969 release_region(address + 4, 4);
970 release_region(address, 4);
971 return found;
972}
973
974static int __init lm78_isa_device_add(unsigned short address)
975{
976 struct resource res = {
977 .start = address,
978 .end = address + LM78_EXTENT - 1,
979 .name = "lm78",
980 .flags = IORESOURCE_IO,
981 };
982 int err;
983
984 pdev = platform_device_alloc("lm78", address);
985 if (!pdev) {
986 err = -ENOMEM;
987 printk(KERN_ERR "lm78: Device allocation failed\n");
988 goto exit;
989 }
990
991 err = platform_device_add_resources(pdev, &res, 1);
992 if (err) {
993 printk(KERN_ERR "lm78: Device resource addition failed "
994 "(%d)\n", err);
995 goto exit_device_put;
996 }
997
998 err = platform_device_add(pdev);
999 if (err) {
1000 printk(KERN_ERR "lm78: Device addition failed (%d)\n",
1001 err);
1002 goto exit_device_put;
1003 }
1004
1005 return 0;
1006
1007 exit_device_put:
1008 platform_device_put(pdev);
1009 exit:
1010 pdev = NULL;
1011 return err;
1012}
1013
1014static int __init sm_lm78_init(void)
1015{
1016 int res;
1017
1018 /* We register the ISA device first, so that we can skip the
1019 * registration of an I2C interface to the same device. */
1020 if (lm78_isa_found(isa_address)) {
1021 res = platform_driver_register(&lm78_isa_driver);
1022 if (res)
1023 goto exit;
1024
1025 /* Sets global pdev as a side effect */
1026 res = lm78_isa_device_add(isa_address);
1027 if (res)
1028 goto exit_unreg_isa_driver;
1029 }
1030
1031 res = i2c_add_driver(&lm78_driver);
1032 if (res)
1033 goto exit_unreg_isa_device;
1034
1035 return 0;
1036
1037 exit_unreg_isa_device:
1038 platform_device_unregister(pdev);
1039 exit_unreg_isa_driver:
1040 platform_driver_unregister(&lm78_isa_driver);
1041 exit:
1042 return res;
1043}
1044
1045static void __exit sm_lm78_exit(void)
1046{
1047 if (pdev) {
1048 platform_device_unregister(pdev);
1049 platform_driver_unregister(&lm78_isa_driver);
1050 }
1051 i2c_del_driver(&lm78_driver);
1052}
1053
1054
1055
1056MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
1057MODULE_DESCRIPTION("LM78/LM79 driver");
1058MODULE_LICENSE("GPL");
1059
1060module_init(sm_lm78_init);
1061module_exit(sm_lm78_exit);
Linux kernel - Deliverables
This page took 0.037312 seconds and 5 git commands to generate.