aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/hwmon
diff options
context:
space:
mode:
authorRoger Lucas <roger@planbit.co.uk>2007-06-12 15:04:08 -0400
committerMark M. Hoffman <mhoffman@lightlink.com>2007-07-19 14:22:14 -0400
commitec5e1a4b8faa6a3522171a185a5c6ac9609e14b4 (patch)
tree17ac93d11ece3808b3d78e9aa4c308a37ab9a8b4 /drivers/hwmon
parent2f6ae157905c393f7372607bc2954f7689838199 (diff)
hwmon: Convert vt8231 to a platform driver
Convert the vt8231 driver from the nonsensical i2c-isa hack to a regular platform driver. Signed-off-by: Roger Lucas <roger@planbit.co.uk> Signed-off-by: Jean Delvare <khali@linux-fr.org> Signed-off-by: Mark M. Hoffman <mhoffman@lightlink.com>
Diffstat (limited to 'drivers/hwmon')
-rw-r--r--drivers/hwmon/Kconfig3
-rw-r--r--drivers/hwmon/vt8231.c317
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
518config SENSORS_VT8231 518config 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;
42module_param(force_addr, int, 0); 41module_param(force_addr, int, 0);
43MODULE_PARM_DESC(force_addr, "Initialize the base address of the sensors"); 42MODULE_PARM_DESC(force_addr, "Initialize the base address of the sensors");
44 43
45/* Device address 44static struct platform_device *pdev;
46 Note that we can't determine the ISA address until we have initialized
47 our module */
48static 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
150struct vt8231_data { 146struct 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
170static struct pci_dev *s_bridge; 168static struct pci_dev *s_bridge;
171static int vt8231_detect(struct i2c_adapter *adapter); 169static int vt8231_probe(struct platform_device *pdev);
172static int vt8231_detach_client(struct i2c_client *client); 170static int vt8231_remove(struct platform_device *pdev);
173static struct vt8231_data *vt8231_update_device(struct device *dev); 171static struct vt8231_data *vt8231_update_device(struct device *dev);
174static void vt8231_init_client(struct i2c_client *client); 172static void vt8231_init_device(struct vt8231_data *data);
175 173
176static inline int vt8231_read_value(struct i2c_client *client, u8 reg) 174static 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
181static inline void vt8231_write_value(struct i2c_client *client, u8 reg, 179static 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,
278static ssize_t set_in5_min(struct device *dev, struct device_attribute *attr, 274static 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,
293static ssize_t set_in5_max(struct device *dev, struct device_attribute *attr, 288static 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,
348static ssize_t set_temp0_max(struct device *dev, struct device_attribute *attr, 342static 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}
361static ssize_t set_temp0_min(struct device *dev, struct device_attribute *attr, 354static 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,
500static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr, 489static 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
555static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 542static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
556 543
544static 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}
550static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
551
557static struct attribute *vt8231_attributes_temps[6][4] = { 552static 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
658static struct i2c_driver vt8231_driver = { 654static 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
667static struct pci_device_id vt8231_pci_ids[] = { 663static 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
683int vt8231_detect(struct i2c_adapter *adapter) 679int 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
772exit_remove_files: 736exit_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);
780exit_detach:
781 i2c_detach_client(client);
782exit_free: 745exit_free:
783 kfree(data); 746 kfree(data);
747
784exit_release: 748exit_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
789static int vt8231_detach_client(struct i2c_client *client) 753static 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
814static void vt8231_init_client(struct i2c_client *client) 774static 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
820static struct vt8231_data *vt8231_update_device(struct device *dev) 780static 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
850static 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
883exit_device_put:
884 platform_device_put(pdev);
885exit:
886 return err;
887}
888
891static int __devinit vt8231_pci_probe(struct pci_dev *dev, 889static 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
943exit_unregister:
944 platform_driver_unregister(&vt8231_driver);
945exit:
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 }