diff options
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/hwmon/Kconfig | 3 | ||||
-rw-r--r-- | drivers/hwmon/vt8231.c | 317 |
2 files changed, 174 insertions, 146 deletions
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index 398a52e163e4..aea2d57c6764 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig | |||
@@ -517,9 +517,8 @@ config SENSORS_VT1211 | |||
517 | 517 | ||
518 | config SENSORS_VT8231 | 518 | config SENSORS_VT8231 |
519 | tristate "VIA VT8231" | 519 | tristate "VIA VT8231" |
520 | depends on I2C && PCI && EXPERIMENTAL | 520 | depends on PCI |
521 | select HWMON_VID | 521 | select HWMON_VID |
522 | select I2C_ISA | ||
523 | help | 522 | help |
524 | If you say yes here then you get support for the integrated sensors | 523 | If you say yes here then you get support for the integrated sensors |
525 | in the VIA VT8231 device. | 524 | in the VIA VT8231 device. |
diff --git a/drivers/hwmon/vt8231.c b/drivers/hwmon/vt8231.c index a6a4aa0eee16..320d8141be78 100644 --- a/drivers/hwmon/vt8231.c +++ b/drivers/hwmon/vt8231.c | |||
@@ -29,8 +29,7 @@ | |||
29 | #include <linux/slab.h> | 29 | #include <linux/slab.h> |
30 | #include <linux/pci.h> | 30 | #include <linux/pci.h> |
31 | #include <linux/jiffies.h> | 31 | #include <linux/jiffies.h> |
32 | #include <linux/i2c.h> | 32 | #include <linux/platform_device.h> |
33 | #include <linux/i2c-isa.h> | ||
34 | #include <linux/hwmon.h> | 33 | #include <linux/hwmon.h> |
35 | #include <linux/hwmon-sysfs.h> | 34 | #include <linux/hwmon-sysfs.h> |
36 | #include <linux/hwmon-vid.h> | 35 | #include <linux/hwmon-vid.h> |
@@ -42,10 +41,7 @@ static int force_addr; | |||
42 | module_param(force_addr, int, 0); | 41 | module_param(force_addr, int, 0); |
43 | MODULE_PARM_DESC(force_addr, "Initialize the base address of the sensors"); | 42 | MODULE_PARM_DESC(force_addr, "Initialize the base address of the sensors"); |
44 | 43 | ||
45 | /* Device address | 44 | static struct platform_device *pdev; |
46 | Note that we can't determine the ISA address until we have initialized | ||
47 | our module */ | ||
48 | static unsigned short isa_address; | ||
49 | 45 | ||
50 | #define VT8231_EXTENT 0x80 | 46 | #define VT8231_EXTENT 0x80 |
51 | #define VT8231_BASE_REG 0x70 | 47 | #define VT8231_BASE_REG 0x70 |
@@ -148,7 +144,9 @@ static inline u8 FAN_TO_REG(long rpm, int div) | |||
148 | #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : 1310720 / ((val) * (div))) | 144 | #define FAN_FROM_REG(val, div) ((val) == 0 ? 0 : 1310720 / ((val) * (div))) |
149 | 145 | ||
150 | struct vt8231_data { | 146 | struct vt8231_data { |
151 | struct i2c_client client; | 147 | unsigned short addr; |
148 | const char *name; | ||
149 | |||
152 | struct mutex update_lock; | 150 | struct mutex update_lock; |
153 | struct class_device *class_dev; | 151 | struct class_device *class_dev; |
154 | char valid; /* !=0 if following fields are valid */ | 152 | char valid; /* !=0 if following fields are valid */ |
@@ -168,20 +166,20 @@ struct vt8231_data { | |||
168 | }; | 166 | }; |
169 | 167 | ||
170 | static struct pci_dev *s_bridge; | 168 | static struct pci_dev *s_bridge; |
171 | static int vt8231_detect(struct i2c_adapter *adapter); | 169 | static int vt8231_probe(struct platform_device *pdev); |
172 | static int vt8231_detach_client(struct i2c_client *client); | 170 | static int vt8231_remove(struct platform_device *pdev); |
173 | static struct vt8231_data *vt8231_update_device(struct device *dev); | 171 | static struct vt8231_data *vt8231_update_device(struct device *dev); |
174 | static void vt8231_init_client(struct i2c_client *client); | 172 | static void vt8231_init_device(struct vt8231_data *data); |
175 | 173 | ||
176 | static inline int vt8231_read_value(struct i2c_client *client, u8 reg) | 174 | static inline int vt8231_read_value(struct vt8231_data *data, u8 reg) |
177 | { | 175 | { |
178 | return inb_p(client->addr + reg); | 176 | return inb_p(data->addr + reg); |
179 | } | 177 | } |
180 | 178 | ||
181 | static inline void vt8231_write_value(struct i2c_client *client, u8 reg, | 179 | static inline void vt8231_write_value(struct vt8231_data *data, u8 reg, |
182 | u8 value) | 180 | u8 value) |
183 | { | 181 | { |
184 | outb_p(value, client->addr + reg); | 182 | outb_p(value, data->addr + reg); |
185 | } | 183 | } |
186 | 184 | ||
187 | /* following are the sysfs callback functions */ | 185 | /* following are the sysfs callback functions */ |
@@ -220,13 +218,12 @@ static ssize_t set_in_min(struct device *dev, struct device_attribute *attr, | |||
220 | { | 218 | { |
221 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); | 219 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); |
222 | int nr = sensor_attr->index; | 220 | int nr = sensor_attr->index; |
223 | struct i2c_client *client = to_i2c_client(dev); | 221 | struct vt8231_data *data = dev_get_drvdata(dev); |
224 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
225 | unsigned long val = simple_strtoul(buf, NULL, 10); | 222 | unsigned long val = simple_strtoul(buf, NULL, 10); |
226 | 223 | ||
227 | mutex_lock(&data->update_lock); | 224 | mutex_lock(&data->update_lock); |
228 | data->in_min[nr] = SENSORS_LIMIT(((val * 958) / 10000) + 3, 0, 255); | 225 | data->in_min[nr] = SENSORS_LIMIT(((val * 958) / 10000) + 3, 0, 255); |
229 | vt8231_write_value(client, regvoltmin[nr], data->in_min[nr]); | 226 | vt8231_write_value(data, regvoltmin[nr], data->in_min[nr]); |
230 | mutex_unlock(&data->update_lock); | 227 | mutex_unlock(&data->update_lock); |
231 | return count; | 228 | return count; |
232 | } | 229 | } |
@@ -236,13 +233,12 @@ static ssize_t set_in_max(struct device *dev, struct device_attribute *attr, | |||
236 | { | 233 | { |
237 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); | 234 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); |
238 | int nr = sensor_attr->index; | 235 | int nr = sensor_attr->index; |
239 | struct i2c_client *client = to_i2c_client(dev); | 236 | struct vt8231_data *data = dev_get_drvdata(dev); |
240 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
241 | unsigned long val = simple_strtoul(buf, NULL, 10); | 237 | unsigned long val = simple_strtoul(buf, NULL, 10); |
242 | 238 | ||
243 | mutex_lock(&data->update_lock); | 239 | mutex_lock(&data->update_lock); |
244 | data->in_max[nr] = SENSORS_LIMIT(((val * 958) / 10000) + 3, 0, 255); | 240 | data->in_max[nr] = SENSORS_LIMIT(((val * 958) / 10000) + 3, 0, 255); |
245 | vt8231_write_value(client, regvoltmax[nr], data->in_max[nr]); | 241 | vt8231_write_value(data, regvoltmax[nr], data->in_max[nr]); |
246 | mutex_unlock(&data->update_lock); | 242 | mutex_unlock(&data->update_lock); |
247 | return count; | 243 | return count; |
248 | } | 244 | } |
@@ -278,14 +274,13 @@ static ssize_t show_in5_max(struct device *dev, struct device_attribute *attr, | |||
278 | static ssize_t set_in5_min(struct device *dev, struct device_attribute *attr, | 274 | static ssize_t set_in5_min(struct device *dev, struct device_attribute *attr, |
279 | const char *buf, size_t count) | 275 | const char *buf, size_t count) |
280 | { | 276 | { |
281 | struct i2c_client *client = to_i2c_client(dev); | 277 | struct vt8231_data *data = dev_get_drvdata(dev); |
282 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
283 | unsigned long val = simple_strtoul(buf, NULL, 10); | 278 | unsigned long val = simple_strtoul(buf, NULL, 10); |
284 | 279 | ||
285 | mutex_lock(&data->update_lock); | 280 | mutex_lock(&data->update_lock); |
286 | data->in_min[5] = SENSORS_LIMIT(((val * 958 * 34) / (10000 * 54)) + 3, | 281 | data->in_min[5] = SENSORS_LIMIT(((val * 958 * 34) / (10000 * 54)) + 3, |
287 | 0, 255); | 282 | 0, 255); |
288 | vt8231_write_value(client, regvoltmin[5], data->in_min[5]); | 283 | vt8231_write_value(data, regvoltmin[5], data->in_min[5]); |
289 | mutex_unlock(&data->update_lock); | 284 | mutex_unlock(&data->update_lock); |
290 | return count; | 285 | return count; |
291 | } | 286 | } |
@@ -293,14 +288,13 @@ static ssize_t set_in5_min(struct device *dev, struct device_attribute *attr, | |||
293 | static ssize_t set_in5_max(struct device *dev, struct device_attribute *attr, | 288 | static ssize_t set_in5_max(struct device *dev, struct device_attribute *attr, |
294 | const char *buf, size_t count) | 289 | const char *buf, size_t count) |
295 | { | 290 | { |
296 | struct i2c_client *client = to_i2c_client(dev); | 291 | struct vt8231_data *data = dev_get_drvdata(dev); |
297 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
298 | unsigned long val = simple_strtoul(buf, NULL, 10); | 292 | unsigned long val = simple_strtoul(buf, NULL, 10); |
299 | 293 | ||
300 | mutex_lock(&data->update_lock); | 294 | mutex_lock(&data->update_lock); |
301 | data->in_max[5] = SENSORS_LIMIT(((val * 958 * 34) / (10000 * 54)) + 3, | 295 | data->in_max[5] = SENSORS_LIMIT(((val * 958 * 34) / (10000 * 54)) + 3, |
302 | 0, 255); | 296 | 0, 255); |
303 | vt8231_write_value(client, regvoltmax[5], data->in_max[5]); | 297 | vt8231_write_value(data, regvoltmax[5], data->in_max[5]); |
304 | mutex_unlock(&data->update_lock); | 298 | mutex_unlock(&data->update_lock); |
305 | return count; | 299 | return count; |
306 | } | 300 | } |
@@ -348,26 +342,24 @@ static ssize_t show_temp0_min(struct device *dev, struct device_attribute *attr, | |||
348 | static ssize_t set_temp0_max(struct device *dev, struct device_attribute *attr, | 342 | static ssize_t set_temp0_max(struct device *dev, struct device_attribute *attr, |
349 | const char *buf, size_t count) | 343 | const char *buf, size_t count) |
350 | { | 344 | { |
351 | struct i2c_client *client = to_i2c_client(dev); | 345 | struct vt8231_data *data = dev_get_drvdata(dev); |
352 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
353 | int val = simple_strtol(buf, NULL, 10); | 346 | int val = simple_strtol(buf, NULL, 10); |
354 | 347 | ||
355 | mutex_lock(&data->update_lock); | 348 | mutex_lock(&data->update_lock); |
356 | data->temp_max[0] = SENSORS_LIMIT((val + 500) / 1000, 0, 255); | 349 | data->temp_max[0] = SENSORS_LIMIT((val + 500) / 1000, 0, 255); |
357 | vt8231_write_value(client, regtempmax[0], data->temp_max[0]); | 350 | vt8231_write_value(data, regtempmax[0], data->temp_max[0]); |
358 | mutex_unlock(&data->update_lock); | 351 | mutex_unlock(&data->update_lock); |
359 | return count; | 352 | return count; |
360 | } | 353 | } |
361 | static ssize_t set_temp0_min(struct device *dev, struct device_attribute *attr, | 354 | static ssize_t set_temp0_min(struct device *dev, struct device_attribute *attr, |
362 | const char *buf, size_t count) | 355 | const char *buf, size_t count) |
363 | { | 356 | { |
364 | struct i2c_client *client = to_i2c_client(dev); | 357 | struct vt8231_data *data = dev_get_drvdata(dev); |
365 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
366 | int val = simple_strtol(buf, NULL, 10); | 358 | int val = simple_strtol(buf, NULL, 10); |
367 | 359 | ||
368 | mutex_lock(&data->update_lock); | 360 | mutex_lock(&data->update_lock); |
369 | data->temp_min[0] = SENSORS_LIMIT((val + 500) / 1000, 0, 255); | 361 | data->temp_min[0] = SENSORS_LIMIT((val + 500) / 1000, 0, 255); |
370 | vt8231_write_value(client, regtempmin[0], data->temp_min[0]); | 362 | vt8231_write_value(data, regtempmin[0], data->temp_min[0]); |
371 | mutex_unlock(&data->update_lock); | 363 | mutex_unlock(&data->update_lock); |
372 | return count; | 364 | return count; |
373 | } | 365 | } |
@@ -404,13 +396,12 @@ static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr, | |||
404 | { | 396 | { |
405 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); | 397 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); |
406 | int nr = sensor_attr->index; | 398 | int nr = sensor_attr->index; |
407 | struct i2c_client *client = to_i2c_client(dev); | 399 | struct vt8231_data *data = dev_get_drvdata(dev); |
408 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
409 | int val = simple_strtol(buf, NULL, 10); | 400 | int val = simple_strtol(buf, NULL, 10); |
410 | 401 | ||
411 | mutex_lock(&data->update_lock); | 402 | mutex_lock(&data->update_lock); |
412 | data->temp_max[nr] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val), 0, 255); | 403 | data->temp_max[nr] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val), 0, 255); |
413 | vt8231_write_value(client, regtempmax[nr], data->temp_max[nr]); | 404 | vt8231_write_value(data, regtempmax[nr], data->temp_max[nr]); |
414 | mutex_unlock(&data->update_lock); | 405 | mutex_unlock(&data->update_lock); |
415 | return count; | 406 | return count; |
416 | } | 407 | } |
@@ -419,13 +410,12 @@ static ssize_t set_temp_min(struct device *dev, struct device_attribute *attr, | |||
419 | { | 410 | { |
420 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); | 411 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); |
421 | int nr = sensor_attr->index; | 412 | int nr = sensor_attr->index; |
422 | struct i2c_client *client = to_i2c_client(dev); | 413 | struct vt8231_data *data = dev_get_drvdata(dev); |
423 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
424 | int val = simple_strtol(buf, NULL, 10); | 414 | int val = simple_strtol(buf, NULL, 10); |
425 | 415 | ||
426 | mutex_lock(&data->update_lock); | 416 | mutex_lock(&data->update_lock); |
427 | data->temp_min[nr] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val), 0, 255); | 417 | data->temp_min[nr] = SENSORS_LIMIT(TEMP_MAXMIN_TO_REG(val), 0, 255); |
428 | vt8231_write_value(client, regtempmin[nr], data->temp_min[nr]); | 418 | vt8231_write_value(data, regtempmin[nr], data->temp_min[nr]); |
429 | mutex_unlock(&data->update_lock); | 419 | mutex_unlock(&data->update_lock); |
430 | return count; | 420 | return count; |
431 | } | 421 | } |
@@ -486,13 +476,12 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, | |||
486 | { | 476 | { |
487 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); | 477 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); |
488 | int nr = sensor_attr->index; | 478 | int nr = sensor_attr->index; |
489 | struct i2c_client *client = to_i2c_client(dev); | 479 | struct vt8231_data *data = dev_get_drvdata(dev); |
490 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
491 | int val = simple_strtoul(buf, NULL, 10); | 480 | int val = simple_strtoul(buf, NULL, 10); |
492 | 481 | ||
493 | mutex_lock(&data->update_lock); | 482 | mutex_lock(&data->update_lock); |
494 | data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); | 483 | data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); |
495 | vt8231_write_value(client, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]); | 484 | vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]); |
496 | mutex_unlock(&data->update_lock); | 485 | mutex_unlock(&data->update_lock); |
497 | return count; | 486 | return count; |
498 | } | 487 | } |
@@ -500,12 +489,11 @@ static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, | |||
500 | static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, | 489 | static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, |
501 | const char *buf, size_t count) | 490 | const char *buf, size_t count) |
502 | { | 491 | { |
503 | struct i2c_client *client = to_i2c_client(dev); | 492 | struct vt8231_data *data = dev_get_drvdata(dev); |
504 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
505 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); | 493 | struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); |
506 | unsigned long val = simple_strtoul(buf, NULL, 10); | 494 | unsigned long val = simple_strtoul(buf, NULL, 10); |
507 | int nr = sensor_attr->index; | 495 | int nr = sensor_attr->index; |
508 | int old = vt8231_read_value(client, VT8231_REG_FANDIV); | 496 | int old = vt8231_read_value(data, VT8231_REG_FANDIV); |
509 | long min = FAN_FROM_REG(data->fan_min[nr], | 497 | long min = FAN_FROM_REG(data->fan_min[nr], |
510 | DIV_FROM_REG(data->fan_div[nr])); | 498 | DIV_FROM_REG(data->fan_div[nr])); |
511 | 499 | ||
@@ -516,7 +504,7 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, | |||
516 | case 4: data->fan_div[nr] = 2; break; | 504 | case 4: data->fan_div[nr] = 2; break; |
517 | case 8: data->fan_div[nr] = 3; break; | 505 | case 8: data->fan_div[nr] = 3; break; |
518 | default: | 506 | default: |
519 | dev_err(&client->dev, "fan_div value %ld not supported." | 507 | dev_err(dev, "fan_div value %ld not supported." |
520 | "Choose one of 1, 2, 4 or 8!\n", val); | 508 | "Choose one of 1, 2, 4 or 8!\n", val); |
521 | mutex_unlock(&data->update_lock); | 509 | mutex_unlock(&data->update_lock); |
522 | return -EINVAL; | 510 | return -EINVAL; |
@@ -524,10 +512,10 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, | |||
524 | 512 | ||
525 | /* Correct the fan minimum speed */ | 513 | /* Correct the fan minimum speed */ |
526 | data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); | 514 | data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); |
527 | vt8231_write_value(client, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]); | 515 | vt8231_write_value(data, VT8231_REG_FAN_MIN(nr), data->fan_min[nr]); |
528 | 516 | ||
529 | old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4); | 517 | old = (old & 0x0f) | (data->fan_div[1] << 6) | (data->fan_div[0] << 4); |
530 | vt8231_write_value(client, VT8231_REG_FANDIV, old); | 518 | vt8231_write_value(data, VT8231_REG_FANDIV, old); |
531 | mutex_unlock(&data->update_lock); | 519 | mutex_unlock(&data->update_lock); |
532 | return count; | 520 | return count; |
533 | } | 521 | } |
@@ -551,9 +539,16 @@ static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, | |||
551 | struct vt8231_data *data = vt8231_update_device(dev); | 539 | struct vt8231_data *data = vt8231_update_device(dev); |
552 | return sprintf(buf, "%d\n", data->alarms); | 540 | return sprintf(buf, "%d\n", data->alarms); |
553 | } | 541 | } |
554 | |||
555 | static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); | 542 | static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); |
556 | 543 | ||
544 | static ssize_t show_name(struct device *dev, struct device_attribute | ||
545 | *devattr, char *buf) | ||
546 | { | ||
547 | struct vt8231_data *data = dev_get_drvdata(dev); | ||
548 | return sprintf(buf, "%s\n", data->name); | ||
549 | } | ||
550 | static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); | ||
551 | |||
557 | static struct attribute *vt8231_attributes_temps[6][4] = { | 552 | static struct attribute *vt8231_attributes_temps[6][4] = { |
558 | { | 553 | { |
559 | &dev_attr_temp1_input.attr, | 554 | &dev_attr_temp1_input.attr, |
@@ -648,6 +643,7 @@ static struct attribute *vt8231_attributes[] = { | |||
648 | &sensor_dev_attr_fan1_div.dev_attr.attr, | 643 | &sensor_dev_attr_fan1_div.dev_attr.attr, |
649 | &sensor_dev_attr_fan2_div.dev_attr.attr, | 644 | &sensor_dev_attr_fan2_div.dev_attr.attr, |
650 | &dev_attr_alarms.attr, | 645 | &dev_attr_alarms.attr, |
646 | &dev_attr_name.attr, | ||
651 | NULL | 647 | NULL |
652 | }; | 648 | }; |
653 | 649 | ||
@@ -655,13 +651,13 @@ static const struct attribute_group vt8231_group = { | |||
655 | .attrs = vt8231_attributes, | 651 | .attrs = vt8231_attributes, |
656 | }; | 652 | }; |
657 | 653 | ||
658 | static struct i2c_driver vt8231_driver = { | 654 | static struct platform_driver vt8231_driver = { |
659 | .driver = { | 655 | .driver = { |
660 | .owner = THIS_MODULE, | 656 | .owner = THIS_MODULE, |
661 | .name = "vt8231", | 657 | .name = "vt8231", |
662 | }, | 658 | }, |
663 | .attach_adapter = vt8231_detect, | 659 | .probe = vt8231_probe, |
664 | .detach_client = vt8231_detach_client, | 660 | .remove = __devexit_p(vt8231_remove), |
665 | }; | 661 | }; |
666 | 662 | ||
667 | static struct pci_device_id vt8231_pci_ids[] = { | 663 | static struct pci_device_id vt8231_pci_ids[] = { |
@@ -680,40 +676,18 @@ static struct pci_driver vt8231_pci_driver = { | |||
680 | .probe = vt8231_pci_probe, | 676 | .probe = vt8231_pci_probe, |
681 | }; | 677 | }; |
682 | 678 | ||
683 | int vt8231_detect(struct i2c_adapter *adapter) | 679 | int vt8231_probe(struct platform_device *pdev) |
684 | { | 680 | { |
685 | struct i2c_client *client; | 681 | struct resource *res; |
686 | struct vt8231_data *data; | 682 | struct vt8231_data *data; |
687 | int err = 0, i; | 683 | int err = 0, i; |
688 | u16 val; | ||
689 | |||
690 | /* 8231 requires multiple of 256 */ | ||
691 | if (force_addr) { | ||
692 | isa_address = force_addr & 0xFF00; | ||
693 | dev_warn(&adapter->dev, "forcing ISA address 0x%04X\n", | ||
694 | isa_address); | ||
695 | if (PCIBIOS_SUCCESSFUL != pci_write_config_word(s_bridge, | ||
696 | VT8231_BASE_REG, isa_address)) | ||
697 | return -ENODEV; | ||
698 | } | ||
699 | |||
700 | if (PCIBIOS_SUCCESSFUL != | ||
701 | pci_read_config_word(s_bridge, VT8231_ENABLE_REG, &val)) | ||
702 | return -ENODEV; | ||
703 | |||
704 | if (!(val & 0x0001)) { | ||
705 | dev_warn(&adapter->dev, "enabling sensors\n"); | ||
706 | if (PCIBIOS_SUCCESSFUL != | ||
707 | pci_write_config_word(s_bridge, VT8231_ENABLE_REG, | ||
708 | val | 0x0001)) | ||
709 | return -ENODEV; | ||
710 | } | ||
711 | 684 | ||
712 | /* Reserve the ISA region */ | 685 | /* Reserve the ISA region */ |
713 | if (!request_region(isa_address, VT8231_EXTENT, | 686 | res = platform_get_resource(pdev, IORESOURCE_IO, 0); |
714 | vt8231_pci_driver.name)) { | 687 | if (!request_region(res->start, VT8231_EXTENT, |
715 | dev_err(&adapter->dev, "region 0x%x already in use!\n", | 688 | vt8231_driver.driver.name)) { |
716 | isa_address); | 689 | dev_err(&pdev->dev, "Region 0x%lx-0x%lx already in use!\n", |
690 | (unsigned long)res->start, (unsigned long)res->end); | ||
717 | return -ENODEV; | 691 | return -ENODEV; |
718 | } | 692 | } |
719 | 693 | ||
@@ -722,33 +696,23 @@ int vt8231_detect(struct i2c_adapter *adapter) | |||
722 | goto exit_release; | 696 | goto exit_release; |
723 | } | 697 | } |
724 | 698 | ||
725 | client = &data->client; | 699 | platform_set_drvdata(pdev, data); |
726 | i2c_set_clientdata(client, data); | 700 | data->addr = res->start; |
727 | client->addr = isa_address; | 701 | data->name = "vt8231"; |
728 | client->adapter = adapter; | ||
729 | client->driver = &vt8231_driver; | ||
730 | |||
731 | /* Fill in the remaining client fields and put into the global list */ | ||
732 | strlcpy(client->name, "vt8231", I2C_NAME_SIZE); | ||
733 | 702 | ||
734 | mutex_init(&data->update_lock); | 703 | mutex_init(&data->update_lock); |
735 | 704 | vt8231_init_device(data); | |
736 | /* Tell the I2C layer a new client has arrived */ | ||
737 | if ((err = i2c_attach_client(client))) | ||
738 | goto exit_free; | ||
739 | |||
740 | vt8231_init_client(client); | ||
741 | 705 | ||
742 | /* Register sysfs hooks */ | 706 | /* Register sysfs hooks */ |
743 | if ((err = sysfs_create_group(&client->dev.kobj, &vt8231_group))) | 707 | if ((err = sysfs_create_group(&pdev->dev.kobj, &vt8231_group))) |
744 | goto exit_detach; | 708 | goto exit_free; |
745 | 709 | ||
746 | /* Must update device information to find out the config field */ | 710 | /* Must update device information to find out the config field */ |
747 | data->uch_config = vt8231_read_value(client, VT8231_REG_UCH_CONFIG); | 711 | data->uch_config = vt8231_read_value(data, VT8231_REG_UCH_CONFIG); |
748 | 712 | ||
749 | for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) { | 713 | for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) { |
750 | if (ISTEMP(i, data->uch_config)) { | 714 | if (ISTEMP(i, data->uch_config)) { |
751 | if ((err = sysfs_create_group(&client->dev.kobj, | 715 | if ((err = sysfs_create_group(&pdev->dev.kobj, |
752 | &vt8231_group_temps[i]))) | 716 | &vt8231_group_temps[i]))) |
753 | goto exit_remove_files; | 717 | goto exit_remove_files; |
754 | } | 718 | } |
@@ -756,13 +720,13 @@ int vt8231_detect(struct i2c_adapter *adapter) | |||
756 | 720 | ||
757 | for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) { | 721 | for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) { |
758 | if (ISVOLT(i, data->uch_config)) { | 722 | if (ISVOLT(i, data->uch_config)) { |
759 | if ((err = sysfs_create_group(&client->dev.kobj, | 723 | if ((err = sysfs_create_group(&pdev->dev.kobj, |
760 | &vt8231_group_volts[i]))) | 724 | &vt8231_group_volts[i]))) |
761 | goto exit_remove_files; | 725 | goto exit_remove_files; |
762 | } | 726 | } |
763 | } | 727 | } |
764 | 728 | ||
765 | data->class_dev = hwmon_device_register(&client->dev); | 729 | data->class_dev = hwmon_device_register(&pdev->dev); |
766 | if (IS_ERR(data->class_dev)) { | 730 | if (IS_ERR(data->class_dev)) { |
767 | err = PTR_ERR(data->class_dev); | 731 | err = PTR_ERR(data->class_dev); |
768 | goto exit_remove_files; | 732 | goto exit_remove_files; |
@@ -771,56 +735,51 @@ int vt8231_detect(struct i2c_adapter *adapter) | |||
771 | 735 | ||
772 | exit_remove_files: | 736 | exit_remove_files: |
773 | for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) | 737 | for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) |
774 | sysfs_remove_group(&client->dev.kobj, &vt8231_group_volts[i]); | 738 | sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]); |
775 | 739 | ||
776 | for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) | 740 | for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) |
777 | sysfs_remove_group(&client->dev.kobj, &vt8231_group_temps[i]); | 741 | sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]); |
742 | |||
743 | sysfs_remove_group(&pdev->dev.kobj, &vt8231_group); | ||
778 | 744 | ||
779 | sysfs_remove_group(&client->dev.kobj, &vt8231_group); | ||
780 | exit_detach: | ||
781 | i2c_detach_client(client); | ||
782 | exit_free: | 745 | exit_free: |
783 | kfree(data); | 746 | kfree(data); |
747 | |||
784 | exit_release: | 748 | exit_release: |
785 | release_region(isa_address, VT8231_EXTENT); | 749 | release_region(res->start, VT8231_EXTENT); |
786 | return err; | 750 | return err; |
787 | } | 751 | } |
788 | 752 | ||
789 | static int vt8231_detach_client(struct i2c_client *client) | 753 | static int vt8231_remove(struct platform_device *pdev) |
790 | { | 754 | { |
791 | struct vt8231_data *data = i2c_get_clientdata(client); | 755 | struct vt8231_data *data = platform_get_drvdata(pdev); |
792 | int err, i; | 756 | int i; |
793 | 757 | ||
794 | hwmon_device_unregister(data->class_dev); | 758 | hwmon_device_unregister(data->class_dev); |
795 | 759 | ||
796 | for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) | 760 | for (i = 0; i < ARRAY_SIZE(vt8231_group_volts); i++) |
797 | sysfs_remove_group(&client->dev.kobj, &vt8231_group_volts[i]); | 761 | sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_volts[i]); |
798 | 762 | ||
799 | for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) | 763 | for (i = 0; i < ARRAY_SIZE(vt8231_group_temps); i++) |
800 | sysfs_remove_group(&client->dev.kobj, &vt8231_group_temps[i]); | 764 | sysfs_remove_group(&pdev->dev.kobj, &vt8231_group_temps[i]); |
801 | 765 | ||
802 | sysfs_remove_group(&client->dev.kobj, &vt8231_group); | 766 | sysfs_remove_group(&pdev->dev.kobj, &vt8231_group); |
803 | 767 | ||
804 | if ((err = i2c_detach_client(client))) { | 768 | release_region(data->addr, VT8231_EXTENT); |
805 | return err; | 769 | platform_set_drvdata(pdev, NULL); |
806 | } | ||
807 | |||
808 | release_region(client->addr, VT8231_EXTENT); | ||
809 | kfree(data); | 770 | kfree(data); |
810 | |||
811 | return 0; | 771 | return 0; |
812 | } | 772 | } |
813 | 773 | ||
814 | static void vt8231_init_client(struct i2c_client *client) | 774 | static void vt8231_init_device(struct vt8231_data *data) |
815 | { | 775 | { |
816 | vt8231_write_value(client, VT8231_REG_TEMP1_CONFIG, 0); | 776 | vt8231_write_value(data, VT8231_REG_TEMP1_CONFIG, 0); |
817 | vt8231_write_value(client, VT8231_REG_TEMP2_CONFIG, 0); | 777 | vt8231_write_value(data, VT8231_REG_TEMP2_CONFIG, 0); |
818 | } | 778 | } |
819 | 779 | ||
820 | static struct vt8231_data *vt8231_update_device(struct device *dev) | 780 | static struct vt8231_data *vt8231_update_device(struct device *dev) |
821 | { | 781 | { |
822 | struct i2c_client *client = to_i2c_client(dev); | 782 | struct vt8231_data *data = dev_get_drvdata(dev); |
823 | struct vt8231_data *data = i2c_get_clientdata(client); | ||
824 | int i; | 783 | int i; |
825 | u16 low; | 784 | u16 low; |
826 | 785 | ||
@@ -830,41 +789,41 @@ static struct vt8231_data *vt8231_update_device(struct device *dev) | |||
830 | || !data->valid) { | 789 | || !data->valid) { |
831 | for (i = 0; i < 6; i++) { | 790 | for (i = 0; i < 6; i++) { |
832 | if (ISVOLT(i, data->uch_config)) { | 791 | if (ISVOLT(i, data->uch_config)) { |
833 | data->in[i] = vt8231_read_value(client, | 792 | data->in[i] = vt8231_read_value(data, |
834 | regvolt[i]); | 793 | regvolt[i]); |
835 | data->in_min[i] = vt8231_read_value(client, | 794 | data->in_min[i] = vt8231_read_value(data, |
836 | regvoltmin[i]); | 795 | regvoltmin[i]); |
837 | data->in_max[i] = vt8231_read_value(client, | 796 | data->in_max[i] = vt8231_read_value(data, |
838 | regvoltmax[i]); | 797 | regvoltmax[i]); |
839 | } | 798 | } |
840 | } | 799 | } |
841 | for (i = 0; i < 2; i++) { | 800 | for (i = 0; i < 2; i++) { |
842 | data->fan[i] = vt8231_read_value(client, | 801 | data->fan[i] = vt8231_read_value(data, |
843 | VT8231_REG_FAN(i)); | 802 | VT8231_REG_FAN(i)); |
844 | data->fan_min[i] = vt8231_read_value(client, | 803 | data->fan_min[i] = vt8231_read_value(data, |
845 | VT8231_REG_FAN_MIN(i)); | 804 | VT8231_REG_FAN_MIN(i)); |
846 | } | 805 | } |
847 | 806 | ||
848 | low = vt8231_read_value(client, VT8231_REG_TEMP_LOW01); | 807 | low = vt8231_read_value(data, VT8231_REG_TEMP_LOW01); |
849 | low = (low >> 6) | ((low & 0x30) >> 2) | 808 | low = (low >> 6) | ((low & 0x30) >> 2) |
850 | | (vt8231_read_value(client, VT8231_REG_TEMP_LOW25) << 4); | 809 | | (vt8231_read_value(data, VT8231_REG_TEMP_LOW25) << 4); |
851 | for (i = 0; i < 6; i++) { | 810 | for (i = 0; i < 6; i++) { |
852 | if (ISTEMP(i, data->uch_config)) { | 811 | if (ISTEMP(i, data->uch_config)) { |
853 | data->temp[i] = (vt8231_read_value(client, | 812 | data->temp[i] = (vt8231_read_value(data, |
854 | regtemp[i]) << 2) | 813 | regtemp[i]) << 2) |
855 | | ((low >> (2 * i)) & 0x03); | 814 | | ((low >> (2 * i)) & 0x03); |
856 | data->temp_max[i] = vt8231_read_value(client, | 815 | data->temp_max[i] = vt8231_read_value(data, |
857 | regtempmax[i]); | 816 | regtempmax[i]); |
858 | data->temp_min[i] = vt8231_read_value(client, | 817 | data->temp_min[i] = vt8231_read_value(data, |
859 | regtempmin[i]); | 818 | regtempmin[i]); |
860 | } | 819 | } |
861 | } | 820 | } |
862 | 821 | ||
863 | i = vt8231_read_value(client, VT8231_REG_FANDIV); | 822 | i = vt8231_read_value(data, VT8231_REG_FANDIV); |
864 | data->fan_div[0] = (i >> 4) & 0x03; | 823 | data->fan_div[0] = (i >> 4) & 0x03; |
865 | data->fan_div[1] = i >> 6; | 824 | data->fan_div[1] = i >> 6; |
866 | data->alarms = vt8231_read_value(client, VT8231_REG_ALARM1) | | 825 | data->alarms = vt8231_read_value(data, VT8231_REG_ALARM1) | |
867 | (vt8231_read_value(client, VT8231_REG_ALARM2) << 8); | 826 | (vt8231_read_value(data, VT8231_REG_ALARM2) << 8); |
868 | 827 | ||
869 | /* Set alarm flags correctly */ | 828 | /* Set alarm flags correctly */ |
870 | if (!data->fan[0] && data->fan_min[0]) { | 829 | if (!data->fan[0] && data->fan_min[0]) { |
@@ -888,33 +847,102 @@ static struct vt8231_data *vt8231_update_device(struct device *dev) | |||
888 | return data; | 847 | return data; |
889 | } | 848 | } |
890 | 849 | ||
850 | static int __devinit vt8231_device_add(unsigned short address) | ||
851 | { | ||
852 | struct resource res = { | ||
853 | .start = address, | ||
854 | .end = address + VT8231_EXTENT - 1, | ||
855 | .name = "vt8231", | ||
856 | .flags = IORESOURCE_IO, | ||
857 | }; | ||
858 | int err; | ||
859 | |||
860 | pdev = platform_device_alloc("vt8231", address); | ||
861 | if (!pdev) { | ||
862 | err = -ENOMEM; | ||
863 | printk(KERN_ERR "vt8231: Device allocation failed\n"); | ||
864 | goto exit; | ||
865 | } | ||
866 | |||
867 | err = platform_device_add_resources(pdev, &res, 1); | ||
868 | if (err) { | ||
869 | printk(KERN_ERR "vt8231: Device resource addition failed " | ||
870 | "(%d)\n", err); | ||
871 | goto exit_device_put; | ||
872 | } | ||
873 | |||
874 | err = platform_device_add(pdev); | ||
875 | if (err) { | ||
876 | printk(KERN_ERR "vt8231: Device addition failed (%d)\n", | ||
877 | err); | ||
878 | goto exit_device_put; | ||
879 | } | ||
880 | |||
881 | return 0; | ||
882 | |||
883 | exit_device_put: | ||
884 | platform_device_put(pdev); | ||
885 | exit: | ||
886 | return err; | ||
887 | } | ||
888 | |||
891 | static int __devinit vt8231_pci_probe(struct pci_dev *dev, | 889 | static int __devinit vt8231_pci_probe(struct pci_dev *dev, |
892 | const struct pci_device_id *id) | 890 | const struct pci_device_id *id) |
893 | { | 891 | { |
894 | u16 val; | 892 | u16 address, val; |
893 | if (force_addr) { | ||
894 | address = force_addr & 0xff00; | ||
895 | dev_warn(&dev->dev, "Forcing ISA address 0x%x\n", | ||
896 | address); | ||
897 | |||
898 | if (PCIBIOS_SUCCESSFUL != | ||
899 | pci_write_config_word(dev, VT8231_BASE_REG, address | 1)) | ||
900 | return -ENODEV; | ||
901 | } | ||
895 | 902 | ||
896 | if (PCIBIOS_SUCCESSFUL != pci_read_config_word(dev, VT8231_BASE_REG, | 903 | if (PCIBIOS_SUCCESSFUL != pci_read_config_word(dev, VT8231_BASE_REG, |
897 | &val)) | 904 | &val)) |
898 | return -ENODEV; | 905 | return -ENODEV; |
899 | 906 | ||
900 | isa_address = val & ~(VT8231_EXTENT - 1); | 907 | address = val & ~(VT8231_EXTENT - 1); |
901 | if (isa_address == 0 && force_addr == 0) { | 908 | if (address == 0) { |
902 | dev_err(&dev->dev, "base address not set -\ | 909 | dev_err(&dev->dev, "base address not set -\ |
903 | upgrade BIOS or use force_addr=0xaddr\n"); | 910 | upgrade BIOS or use force_addr=0xaddr\n"); |
904 | return -ENODEV; | 911 | return -ENODEV; |
905 | } | 912 | } |
906 | 913 | ||
907 | s_bridge = pci_dev_get(dev); | 914 | if (PCIBIOS_SUCCESSFUL != pci_read_config_word(dev, VT8231_ENABLE_REG, |
915 | &val)) | ||
916 | return -ENODEV; | ||
908 | 917 | ||
909 | if (i2c_isa_add_driver(&vt8231_driver)) { | 918 | if (!(val & 0x0001)) { |
910 | pci_dev_put(s_bridge); | 919 | dev_warn(&dev->dev, "enabling sensors\n"); |
911 | s_bridge = NULL; | 920 | if (PCIBIOS_SUCCESSFUL != |
921 | pci_write_config_word(dev, VT8231_ENABLE_REG, | ||
922 | val | 0x0001)) | ||
923 | return -ENODEV; | ||
912 | } | 924 | } |
913 | 925 | ||
926 | if (platform_driver_register(&vt8231_driver)) | ||
927 | goto exit; | ||
928 | |||
929 | /* Sets global pdev as a side effect */ | ||
930 | if (vt8231_device_add(address)) | ||
931 | goto exit_unregister; | ||
932 | |||
914 | /* Always return failure here. This is to allow other drivers to bind | 933 | /* Always return failure here. This is to allow other drivers to bind |
915 | * to this pci device. We don't really want to have control over the | 934 | * to this pci device. We don't really want to have control over the |
916 | * pci device, we only wanted to read as few register values from it. | 935 | * pci device, we only wanted to read as few register values from it. |
917 | */ | 936 | */ |
937 | |||
938 | /* We do, however, mark ourselves as using the PCI device to stop it | ||
939 | getting unloaded. */ | ||
940 | s_bridge = pci_dev_get(dev); | ||
941 | return -ENODEV; | ||
942 | |||
943 | exit_unregister: | ||
944 | platform_driver_unregister(&vt8231_driver); | ||
945 | exit: | ||
918 | return -ENODEV; | 946 | return -ENODEV; |
919 | } | 947 | } |
920 | 948 | ||
@@ -927,7 +955,8 @@ static void __exit sm_vt8231_exit(void) | |||
927 | { | 955 | { |
928 | pci_unregister_driver(&vt8231_pci_driver); | 956 | pci_unregister_driver(&vt8231_pci_driver); |
929 | if (s_bridge != NULL) { | 957 | if (s_bridge != NULL) { |
930 | i2c_isa_del_driver(&vt8231_driver); | 958 | platform_device_unregister(pdev); |
959 | platform_driver_unregister(&vt8231_driver); | ||
931 | pci_dev_put(s_bridge); | 960 | pci_dev_put(s_bridge); |
932 | s_bridge = NULL; | 961 | s_bridge = NULL; |
933 | } | 962 | } |