Login
[x]
Log in using an account from:
Fedora Account System
Red Hat Associate
Red Hat Customer
Or login using a Red Hat Bugzilla account
Forgot Password
Login:
Hide Forgot
Create an Account
Red Hat Bugzilla – Attachment 306344 Details for
Bug 446061
IT87 hwmon module does not support later chipset revisions.
[?]
New
Simple Search
Advanced Search
My Links
Browse
Requests
Reports
Current State
Search
Tabular reports
Graphical reports
Duplicates
Other Reports
User Changes
Plotly Reports
Bug Status
Bug Severity
Non-Defaults
|
Product Dashboard
Help
Page Help!
Bug Writing Guidelines
What's new
Browser Support Policy
5.0.4.rh83 Release notes
FAQ
Guides index
User guide
Web Services
Contact
Legal
This site requires JavaScript to be enabled to function correctly, please enable it.
[patch]
it87 driver update test patch
RHEL5-it87-update.patch (text/plain), 56.65 KB, created by
Brian Maly
on 2008-05-22 07:35:54 UTC
(
hide
)
Description:
it87 driver update test patch
Filename:
MIME Type:
Creator:
Brian Maly
Created:
2008-05-22 07:35:54 UTC
Size:
56.65 KB
patch
obsolete
>--- linux-2.6.18.noarch/drivers/hwmon/it87.c.orig 2008-05-22 02:10:18.000000000 -0400 >+++ linux-2.6.18.noarch/drivers/hwmon/it87.c 2008-05-22 02:16:58.000000000 -0400 >@@ -2,12 +2,23 @@ > it87.c - Part of lm_sensors, Linux kernel modules for hardware > monitoring. > >+ The IT8705F is an LPC-based Super I/O part that contains UARTs, a >+ parallel port, an IR port, a MIDI port, a floppy controller, etc., in >+ addition to an Environment Controller (Enhanced Hardware Monitor and >+ Fan Controller) >+ >+ This driver supports only the Environment Controller in the IT8705F and >+ similar parts. The other devices are supported by different drivers. >+ > Supports: IT8705F Super I/O chip w/LPC interface >- IT8712F Super I/O chip w/LPC interface & SMBus >+ IT8712F Super I/O chip w/LPC interface >+ IT8716F Super I/O chip w/LPC interface >+ IT8718F Super I/O chip w/LPC interface >+ IT8726F Super I/O chip w/LPC interface > Sis950 A clone of the IT8705F > >- Copyright (C) 2001 Chris Gauthron <chrisg@0-in.com> >- Largely inspired by lm78.c of the same package >+ Copyright (C) 2001 Chris Gauthron >+ Copyright (C) 2005-2007 Jean Delvare <khali@linux-fr.org> > > This program is free software; you can redistribute it and/or modify > it under the terms of the GNU General Public License as published by >@@ -24,38 +35,34 @@ > Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. > */ > >-/* >- djg@pdp8.net David Gesswein 7/18/01 >- Modified to fix bug with not all alarms enabled. >- Added ability to read battery voltage and select temperature sensor >- type at module load time. >-*/ >- > #include <linux/module.h> > #include <linux/init.h> > #include <linux/slab.h> > #include <linux/jiffies.h> >-#include <linux/i2c.h> >-#include <linux/i2c-isa.h> >+#include <linux/platform_device.h> > #include <linux/hwmon.h> > #include <linux/hwmon-sysfs.h> > #include <linux/hwmon-vid.h> > #include <linux/err.h> > #include <linux/mutex.h> >+#include <linux/sysfs.h> > #include <asm/io.h> > >+#define DRVNAME "it87" >+ >+enum chips { it87, it8712, it8716, it8718 }; > >-/* Addresses to scan */ >-static unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END }; >-static unsigned short isa_address; >+static unsigned short force_id; >+module_param(force_id, ushort, 0); >+MODULE_PARM_DESC(force_id, "Override the detected device ID"); > >-/* Insmod parameters */ >-I2C_CLIENT_INSMOD_2(it87, it8712); >+static struct platform_device *pdev; > > #define REG 0x2e /* The register to read/write */ > #define DEV 0x07 /* Register: Logical device select */ > #define VAL 0x2f /* The value to read/write */ > #define PME 0x04 /* The device with the fan registers in it */ >+#define GPIO 0x07 /* The device with the IT8718F VID value in it */ > #define DEVID 0x20 /* Register: Device ID */ > #define DEVREV 0x22 /* Register: Device Revision */ > >@@ -77,10 +84,10 @@ static int superio_inw(int reg) > } > > static inline void >-superio_select(void) >+superio_select(int ldn) > { > outb(DEV, REG); >- outb(PME, VAL); >+ outb(ldn, VAL); > } > > static inline void >@@ -99,29 +106,39 @@ superio_exit(void) > outb(0x02, VAL); > } > >+/* Logical device 4 registers */ > #define IT8712F_DEVID 0x8712 > #define IT8705F_DEVID 0x8705 >+#define IT8716F_DEVID 0x8716 >+#define IT8718F_DEVID 0x8718 >+#define IT8726F_DEVID 0x8726 > #define IT87_ACT_REG 0x30 > #define IT87_BASE_REG 0x60 > >+/* Logical device 7 registers (IT8712F and later) */ >+#define IT87_SIO_PINX2_REG 0x2c /* Pin selection */ >+#define IT87_SIO_VID_REG 0xfc /* VID value */ >+ > /* Update battery voltage after every reading if true */ > static int update_vbat; > > /* Not all BIOSes properly configure the PWM registers */ > static int fix_pwm_polarity; > >-/* Chip Type */ >- >-static u16 chip_type; >- > /* Many IT87 constants specified below */ > > /* Length of ISA address segment */ > #define IT87_EXTENT 8 > >-/* Where are the ISA address/data registers relative to the base address */ >-#define IT87_ADDR_REG_OFFSET 5 >-#define IT87_DATA_REG_OFFSET 6 >+/* Length of ISA address segment for Environmental Controller */ >+#define IT87_EC_EXTENT 2 >+ >+/* Offset of EC registers from ISA base address */ >+#define IT87_EC_OFFSET 5 >+ >+/* Where are the ISA address/data registers relative to the EC base address */ >+#define IT87_ADDR_REG_OFFSET 0 >+#define IT87_DATA_REG_OFFSET 1 > > /*----- The IT87 registers -----*/ > >@@ -131,13 +148,21 @@ static u16 chip_type; > #define IT87_REG_ALARM2 0x02 > #define IT87_REG_ALARM3 0x03 > >+/* The IT8718F has the VID value in a different register, in Super-I/O >+ configuration space. */ > #define IT87_REG_VID 0x0a >+/* Warning: register 0x0b is used for something completely different in >+ new chips/revisions. I suspect only 16-bit tachometer mode will work >+ for these. */ > #define IT87_REG_FAN_DIV 0x0b >+#define IT87_REG_FAN_16BIT 0x0c > > /* Monitors: 9 voltage (0 to 7, battery), 3 temp (1 to 3), 3 fan (1 to 3) */ > >-#define IT87_REG_FAN(nr) (0x0d + (nr)) >-#define IT87_REG_FAN_MIN(nr) (0x10 + (nr)) >+static const u8 IT87_REG_FAN[] = { 0x0d, 0x0e, 0x0f, 0x80, 0x82 }; >+static const u8 IT87_REG_FAN_MIN[] = { 0x10, 0x11, 0x12, 0x84, 0x86 }; >+static const u8 IT87_REG_FANX[] = { 0x18, 0x19, 0x1a, 0x81, 0x83 }; >+static const u8 IT87_REG_FANX_MIN[] = { 0x1b, 0x1c, 0x1d, 0x85, 0x87 }; > #define IT87_REG_FAN_MAIN_CTRL 0x13 > #define IT87_REG_FAN_CTL 0x14 > #define IT87_REG_PWM(nr) (0x15 + (nr)) >@@ -150,8 +175,6 @@ static u16 chip_type; > #define IT87_REG_TEMP_HIGH(nr) (0x40 + (nr) * 2) > #define IT87_REG_TEMP_LOW(nr) (0x41 + (nr) * 2) > >-#define IT87_REG_I2C_ADDR 0x48 >- > #define IT87_REG_VIN_ENABLE 0x50 > #define IT87_REG_TEMP_ENABLE 0x51 > >@@ -169,7 +192,16 @@ static inline u8 FAN_TO_REG(long rpm, in > 254); > } > >+static inline u16 FAN16_TO_REG(long rpm) >+{ >+ if (rpm == 0) >+ return 0xffff; >+ return SENSORS_LIMIT((1350000 + rpm) / (rpm * 2), 1, 0xfffe); >+} >+ > #define FAN_FROM_REG(val,div) ((val)==0?-1:(val)==255?0:1350000/((val)*(div))) >+/* The divider is fixed to 2 in 16-bit mode */ >+#define FAN16_FROM_REG(val) ((val)==0?-1:(val)==0xffff?0:1350000/((val)*2)) > > #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\ > ((val)+500)/1000),-128,127)) >@@ -181,32 +213,48 @@ static inline u8 FAN_TO_REG(long rpm, in > static int DIV_TO_REG(int val) > { > int answer = 0; >- while ((val >>= 1) != 0) >+ while (answer < 7 && (val >>= 1)) > answer++; > return answer; > } > #define DIV_FROM_REG(val) (1 << (val)) > >+static const unsigned int pwm_freq[8] = { >+ 48000000 / 128, >+ 24000000 / 128, >+ 12000000 / 128, >+ 8000000 / 128, >+ 6000000 / 128, >+ 3000000 / 128, >+ 1500000 / 128, >+ 750000 / 128, >+}; >+ > >-/* For each registered IT87, we need to keep some data in memory. That >- data is pointed to by it87_list[NR]->data. The structure itself is >- dynamically allocated, at the same time when a new it87 client is >- allocated. */ >+struct it87_sio_data { >+ enum chips type; >+ /* Values read from Super-I/O config space */ >+ u8 vid_value; >+}; >+ >+/* For each registered chip, we need to keep some data in memory. >+ The structure is dynamically allocated. */ > struct it87_data { >- struct i2c_client client; >- struct class_device *class_dev; >- struct mutex lock; >+ struct device *hwmon_dev; > enum chips type; > >+ unsigned short addr; >+ const char *name; > struct mutex update_lock; > char valid; /* !=0 if following fields are valid */ > unsigned long last_updated; /* In jiffies */ > > u8 in[9]; /* Register value */ >- u8 in_max[9]; /* Register value */ >- u8 in_min[9]; /* Register value */ >- u8 fan[3]; /* Register value */ >- u8 fan_min[3]; /* Register value */ >+ u8 in_max[8]; /* Register value */ >+ u8 in_min[8]; /* Register value */ >+ u8 has_fan; /* Bitfield, fans enabled */ >+ u16 fan[5]; /* Register values, possibly combined */ >+ u16 fan_min[5]; /* Register values, possibly combined */ > u8 temp[3]; /* Register value */ > u8 temp_high[3]; /* Register value */ > u8 temp_low[3]; /* Register value */ >@@ -216,40 +264,30 @@ struct it87_data { > u8 vrm; > u32 alarms; /* Register encoding, combined */ > u8 fan_main_ctrl; /* Register value */ >+ u8 fan_ctl; /* Register value */ > u8 manual_pwm_ctl[3]; /* manual PWM value set by user */ > }; > > >-static int it87_attach_adapter(struct i2c_adapter *adapter); >-static int it87_isa_attach_adapter(struct i2c_adapter *adapter); >-static int it87_detect(struct i2c_adapter *adapter, int address, int kind); >-static int it87_detach_client(struct i2c_client *client); >+static int it87_probe(struct platform_device *pdev); >+static int __devexit it87_remove(struct platform_device *pdev); > >-static int it87_read_value(struct i2c_client *client, u8 reg); >-static int it87_write_value(struct i2c_client *client, u8 reg, u8 value); >+static int it87_read_value(struct it87_data *data, u8 reg); >+static void it87_write_value(struct it87_data *data, u8 reg, u8 value); > static struct it87_data *it87_update_device(struct device *dev); >-static int it87_check_pwm(struct i2c_client *client); >-static void it87_init_client(struct i2c_client *client, struct it87_data *data); >- >+static int it87_check_pwm(struct device *dev); >+static void it87_init_device(struct platform_device *pdev); > >-static struct i2c_driver it87_driver = { >- .driver = { >- .name = "it87", >- }, >- .id = I2C_DRIVERID_IT87, >- .attach_adapter = it87_attach_adapter, >- .detach_client = it87_detach_client, >-}; > >-static struct i2c_driver it87_isa_driver = { >+static struct platform_driver it87_driver = { > .driver = { >- .name = "it87-isa", >+ .owner = THIS_MODULE, >+ .name = DRVNAME, > }, >- .attach_adapter = it87_isa_attach_adapter, >- .detach_client = it87_detach_client, >+ .probe = it87_probe, >+ .remove = __devexit_p(it87_remove), > }; > >- > static ssize_t show_in(struct device *dev, struct device_attribute *attr, > char *buf) > { >@@ -286,13 +324,12 @@ static ssize_t set_in_min(struct device > struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); > int nr = sensor_attr->index; > >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > unsigned long val = simple_strtoul(buf, NULL, 10); > > mutex_lock(&data->update_lock); > data->in_min[nr] = IN_TO_REG(val); >- it87_write_value(client, IT87_REG_VIN_MIN(nr), >+ it87_write_value(data, IT87_REG_VIN_MIN(nr), > data->in_min[nr]); > mutex_unlock(&data->update_lock); > return count; >@@ -303,13 +340,12 @@ static ssize_t set_in_max(struct device > struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); > int nr = sensor_attr->index; > >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > unsigned long val = simple_strtoul(buf, NULL, 10); > > mutex_lock(&data->update_lock); > data->in_max[nr] = IN_TO_REG(val); >- it87_write_value(client, IT87_REG_VIN_MAX(nr), >+ it87_write_value(data, IT87_REG_VIN_MAX(nr), > data->in_max[nr]); > mutex_unlock(&data->update_lock); > return count; >@@ -377,13 +413,12 @@ static ssize_t set_temp_max(struct devic > struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); > int nr = sensor_attr->index; > >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > int val = simple_strtol(buf, NULL, 10); > > mutex_lock(&data->update_lock); > data->temp_high[nr] = TEMP_TO_REG(val); >- it87_write_value(client, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]); >+ it87_write_value(data, IT87_REG_TEMP_HIGH(nr), data->temp_high[nr]); > mutex_unlock(&data->update_lock); > return count; > } >@@ -393,13 +428,12 @@ static ssize_t set_temp_min(struct devic > struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); > int nr = sensor_attr->index; > >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > int val = simple_strtol(buf, NULL, 10); > > mutex_lock(&data->update_lock); > data->temp_low[nr] = TEMP_TO_REG(val); >- it87_write_value(client, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]); >+ it87_write_value(data, IT87_REG_TEMP_LOW(nr), data->temp_low[nr]); > mutex_unlock(&data->update_lock); > return count; > } >@@ -436,8 +470,7 @@ static ssize_t set_sensor(struct device > struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); > int nr = sensor_attr->index; > >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > int val = simple_strtol(buf, NULL, 10); > > mutex_lock(&data->update_lock); >@@ -453,7 +486,7 @@ static ssize_t set_sensor(struct device > mutex_unlock(&data->update_lock); > return -EINVAL; > } >- it87_write_value(client, IT87_REG_TEMP_ENABLE, data->sensor); >+ it87_write_value(data, IT87_REG_TEMP_ENABLE, data->sensor); > mutex_unlock(&data->update_lock); > return count; > } >@@ -513,18 +546,26 @@ static ssize_t show_pwm(struct device *d > struct it87_data *data = it87_update_device(dev); > return sprintf(buf,"%d\n", data->manual_pwm_ctl[nr]); > } >+static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr, >+ char *buf) >+{ >+ struct it87_data *data = it87_update_device(dev); >+ int index = (data->fan_ctl >> 4) & 0x07; >+ >+ return sprintf(buf, "%u\n", pwm_freq[index]); >+} > static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr, > const char *buf, size_t count) > { > struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); > int nr = sensor_attr->index; > >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > int val = simple_strtol(buf, NULL, 10); >- u8 reg = it87_read_value(client, IT87_REG_FAN_DIV); >+ u8 reg; > > mutex_lock(&data->update_lock); >+ reg = it87_read_value(data, IT87_REG_FAN_DIV); > switch (nr) { > case 0: data->fan_div[nr] = reg & 0x07; break; > case 1: data->fan_div[nr] = (reg >> 3) & 0x07; break; >@@ -532,7 +573,7 @@ static ssize_t set_fan_min(struct device > } > > data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); >- it87_write_value(client, IT87_REG_FAN_MIN(nr), data->fan_min[nr]); >+ it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]); > mutex_unlock(&data->update_lock); > return count; > } >@@ -542,17 +583,16 @@ static ssize_t set_fan_div(struct device > struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); > int nr = sensor_attr->index; > >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >- int val = simple_strtol(buf, NULL, 10); >- int i, min[3]; >+ struct it87_data *data = dev_get_drvdata(dev); >+ unsigned long val = simple_strtoul(buf, NULL, 10); >+ int min; > u8 old; > > mutex_lock(&data->update_lock); >- old = it87_read_value(client, IT87_REG_FAN_DIV); >+ old = it87_read_value(data, IT87_REG_FAN_DIV); > >- for (i = 0; i < 3; i++) >- min[i] = FAN_FROM_REG(data->fan_min[i], DIV_FROM_REG(data->fan_div[i])); >+ /* Save fan min limit */ >+ min = FAN_FROM_REG(data->fan_min[nr], DIV_FROM_REG(data->fan_div[nr])); > > switch (nr) { > case 0: >@@ -570,12 +610,12 @@ static ssize_t set_fan_div(struct device > val |= (data->fan_div[1] & 0x07) << 3; > if (data->fan_div[2] == 3) > val |= 0x1 << 6; >- it87_write_value(client, IT87_REG_FAN_DIV, val); >+ it87_write_value(data, IT87_REG_FAN_DIV, val); >+ >+ /* Restore fan min limit */ >+ data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); >+ it87_write_value(data, IT87_REG_FAN_MIN[nr], data->fan_min[nr]); > >- for (i = 0; i < 3; i++) { >- data->fan_min[i]=FAN_TO_REG(min[i], DIV_FROM_REG(data->fan_div[i])); >- it87_write_value(client, IT87_REG_FAN_MIN(i), data->fan_min[i]); >- } > mutex_unlock(&data->update_lock); > return count; > } >@@ -585,8 +625,7 @@ static ssize_t set_pwm_enable(struct dev > struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); > int nr = sensor_attr->index; > >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > int val = simple_strtol(buf, NULL, 10); > > mutex_lock(&data->update_lock); >@@ -594,17 +633,17 @@ static ssize_t set_pwm_enable(struct dev > if (val == 0) { > int tmp; > /* make sure the fan is on when in on/off mode */ >- tmp = it87_read_value(client, IT87_REG_FAN_CTL); >- it87_write_value(client, IT87_REG_FAN_CTL, tmp | (1 << nr)); >+ tmp = it87_read_value(data, IT87_REG_FAN_CTL); >+ it87_write_value(data, IT87_REG_FAN_CTL, tmp | (1 << nr)); > /* set on/off mode */ > data->fan_main_ctrl &= ~(1 << nr); >- it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); >+ it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); > } else if (val == 1) { > /* set SmartGuardian mode */ > data->fan_main_ctrl |= (1 << nr); >- it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); >+ it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); > /* set saved pwm value, clear FAN_CTLX PWM mode bit */ >- it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr])); >+ it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr])); > } else { > mutex_unlock(&data->update_lock); > return -EINVAL; >@@ -619,8 +658,7 @@ static ssize_t set_pwm(struct device *de > struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); > int nr = sensor_attr->index; > >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > int val = simple_strtol(buf, NULL, 10); > > if (val < 0 || val > 255) >@@ -629,8 +667,29 @@ static ssize_t set_pwm(struct device *de > mutex_lock(&data->update_lock); > data->manual_pwm_ctl[nr] = val; > if (data->fan_main_ctrl & (1 << nr)) >- it87_write_value(client, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr])); >+ it87_write_value(data, IT87_REG_PWM(nr), PWM_TO_REG(data->manual_pwm_ctl[nr])); >+ mutex_unlock(&data->update_lock); >+ return count; >+} >+static ssize_t set_pwm_freq(struct device *dev, >+ struct device_attribute *attr, const char *buf, size_t count) >+{ >+ struct it87_data *data = dev_get_drvdata(dev); >+ unsigned long val = simple_strtoul(buf, NULL, 10); >+ int i; >+ >+ /* Search for the nearest available frequency */ >+ for (i = 0; i < 7; i++) { >+ if (val > (pwm_freq[i] + pwm_freq[i+1]) / 2) >+ break; >+ } >+ >+ mutex_lock(&data->update_lock); >+ data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL) & 0x8f; >+ data->fan_ctl |= i << 4; >+ it87_write_value(data, IT87_REG_FAN_CTL, data->fan_ctl); > mutex_unlock(&data->update_lock); >+ > return count; > } > >@@ -650,12 +709,69 @@ show_fan_offset(3); > static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \ > show_pwm_enable, set_pwm_enable, offset - 1); \ > static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \ >- show_pwm, set_pwm, offset - 1); >+ show_pwm, set_pwm, offset - 1); \ >+static DEVICE_ATTR(pwm##offset##_freq, \ >+ (offset == 1 ? S_IRUGO | S_IWUSR : S_IRUGO), \ >+ show_pwm_freq, (offset == 1 ? set_pwm_freq : NULL)); > > show_pwm_offset(1); > show_pwm_offset(2); > show_pwm_offset(3); > >+/* A different set of callbacks for 16-bit fans */ >+static ssize_t show_fan16(struct device *dev, struct device_attribute *attr, >+ char *buf) >+{ >+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); >+ int nr = sensor_attr->index; >+ struct it87_data *data = it87_update_device(dev); >+ return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan[nr])); >+} >+ >+static ssize_t show_fan16_min(struct device *dev, struct device_attribute *attr, >+ char *buf) >+{ >+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); >+ int nr = sensor_attr->index; >+ struct it87_data *data = it87_update_device(dev); >+ return sprintf(buf, "%d\n", FAN16_FROM_REG(data->fan_min[nr])); >+} >+ >+static ssize_t set_fan16_min(struct device *dev, struct device_attribute *attr, >+ const char *buf, size_t count) >+{ >+ struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); >+ int nr = sensor_attr->index; >+ struct it87_data *data = dev_get_drvdata(dev); >+ int val = simple_strtol(buf, NULL, 10); >+ >+ mutex_lock(&data->update_lock); >+ data->fan_min[nr] = FAN16_TO_REG(val); >+ it87_write_value(data, IT87_REG_FAN_MIN[nr], >+ data->fan_min[nr] & 0xff); >+ it87_write_value(data, IT87_REG_FANX_MIN[nr], >+ data->fan_min[nr] >> 8); >+ mutex_unlock(&data->update_lock); >+ return count; >+} >+ >+/* We want to use the same sysfs file names as 8-bit fans, but we need >+ different variable names, so we have to use SENSOR_ATTR instead of >+ SENSOR_DEVICE_ATTR. */ >+#define show_fan16_offset(offset) \ >+static struct sensor_device_attribute sensor_dev_attr_fan##offset##_input16 \ >+ = SENSOR_ATTR(fan##offset##_input, S_IRUGO, \ >+ show_fan16, NULL, offset - 1); \ >+static struct sensor_device_attribute sensor_dev_attr_fan##offset##_min16 \ >+ = SENSOR_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ >+ show_fan16_min, set_fan16_min, offset - 1) >+ >+show_fan16_offset(1); >+show_fan16_offset(2); >+show_fan16_offset(3); >+show_fan16_offset(4); >+show_fan16_offset(5); >+ > /* Alarms */ > static ssize_t show_alarms(struct device *dev, struct device_attribute *attr, char *buf) > { >@@ -664,17 +780,40 @@ static ssize_t show_alarms(struct device > } > static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); > >+static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, >+ char *buf) >+{ >+ int bitnr = to_sensor_dev_attr(attr)->index; >+ struct it87_data *data = it87_update_device(dev); >+ return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1); >+} >+static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 8); >+static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 9); >+static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 10); >+static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 11); >+static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 12); >+static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, show_alarm, NULL, 13); >+static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, show_alarm, NULL, 14); >+static SENSOR_DEVICE_ATTR(in7_alarm, S_IRUGO, show_alarm, NULL, 15); >+static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 0); >+static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 1); >+static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 2); >+static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO, show_alarm, NULL, 3); >+static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 6); >+static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 16); >+static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 17); >+static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 18); >+ > static ssize_t > show_vrm_reg(struct device *dev, struct device_attribute *attr, char *buf) > { >- struct it87_data *data = it87_update_device(dev); >+ struct it87_data *data = dev_get_drvdata(dev); > return sprintf(buf, "%u\n", data->vrm); > } > static ssize_t > store_vrm_reg(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) > { >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > u32 val; > > val = simple_strtoul(buf, NULL, 10); >@@ -683,8 +822,6 @@ store_vrm_reg(struct device *dev, struct > return count; > } > static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm_reg, store_vrm_reg); >-#define device_create_file_vrm(client) \ >-device_create_file(&client->dev, &dev_attr_vrm) > > static ssize_t > show_vid_reg(struct device *dev, struct device_attribute *attr, char *buf) >@@ -693,37 +830,155 @@ show_vid_reg(struct device *dev, struct > return sprintf(buf, "%ld\n", (long) vid_from_reg(data->vid, data->vrm)); > } > static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid_reg, NULL); >-#define device_create_file_vid(client) \ >-device_create_file(&client->dev, &dev_attr_cpu0_vid) > >-/* This function is called when: >- * it87_driver is inserted (when this module is loaded), for each >- available adapter >- * when a new adapter is inserted (and it87_driver is still present) */ >-static int it87_attach_adapter(struct i2c_adapter *adapter) >+static ssize_t show_name(struct device *dev, struct device_attribute >+ *devattr, char *buf) > { >- if (!(adapter->class & I2C_CLASS_HWMON)) >- return 0; >- return i2c_probe(adapter, &addr_data, it87_detect); >+ struct it87_data *data = dev_get_drvdata(dev); >+ return sprintf(buf, "%s\n", data->name); > } >+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL); > >-static int it87_isa_attach_adapter(struct i2c_adapter *adapter) >-{ >- return it87_detect(adapter, isa_address, -1); >-} >+static struct attribute *it87_attributes[] = { >+ &sensor_dev_attr_in0_input.dev_attr.attr, >+ &sensor_dev_attr_in1_input.dev_attr.attr, >+ &sensor_dev_attr_in2_input.dev_attr.attr, >+ &sensor_dev_attr_in3_input.dev_attr.attr, >+ &sensor_dev_attr_in4_input.dev_attr.attr, >+ &sensor_dev_attr_in5_input.dev_attr.attr, >+ &sensor_dev_attr_in6_input.dev_attr.attr, >+ &sensor_dev_attr_in7_input.dev_attr.attr, >+ &sensor_dev_attr_in8_input.dev_attr.attr, >+ &sensor_dev_attr_in0_min.dev_attr.attr, >+ &sensor_dev_attr_in1_min.dev_attr.attr, >+ &sensor_dev_attr_in2_min.dev_attr.attr, >+ &sensor_dev_attr_in3_min.dev_attr.attr, >+ &sensor_dev_attr_in4_min.dev_attr.attr, >+ &sensor_dev_attr_in5_min.dev_attr.attr, >+ &sensor_dev_attr_in6_min.dev_attr.attr, >+ &sensor_dev_attr_in7_min.dev_attr.attr, >+ &sensor_dev_attr_in0_max.dev_attr.attr, >+ &sensor_dev_attr_in1_max.dev_attr.attr, >+ &sensor_dev_attr_in2_max.dev_attr.attr, >+ &sensor_dev_attr_in3_max.dev_attr.attr, >+ &sensor_dev_attr_in4_max.dev_attr.attr, >+ &sensor_dev_attr_in5_max.dev_attr.attr, >+ &sensor_dev_attr_in6_max.dev_attr.attr, >+ &sensor_dev_attr_in7_max.dev_attr.attr, >+ &sensor_dev_attr_in0_alarm.dev_attr.attr, >+ &sensor_dev_attr_in1_alarm.dev_attr.attr, >+ &sensor_dev_attr_in2_alarm.dev_attr.attr, >+ &sensor_dev_attr_in3_alarm.dev_attr.attr, >+ &sensor_dev_attr_in4_alarm.dev_attr.attr, >+ &sensor_dev_attr_in5_alarm.dev_attr.attr, >+ &sensor_dev_attr_in6_alarm.dev_attr.attr, >+ &sensor_dev_attr_in7_alarm.dev_attr.attr, >+ >+ &sensor_dev_attr_temp1_input.dev_attr.attr, >+ &sensor_dev_attr_temp2_input.dev_attr.attr, >+ &sensor_dev_attr_temp3_input.dev_attr.attr, >+ &sensor_dev_attr_temp1_max.dev_attr.attr, >+ &sensor_dev_attr_temp2_max.dev_attr.attr, >+ &sensor_dev_attr_temp3_max.dev_attr.attr, >+ &sensor_dev_attr_temp1_min.dev_attr.attr, >+ &sensor_dev_attr_temp2_min.dev_attr.attr, >+ &sensor_dev_attr_temp3_min.dev_attr.attr, >+ &sensor_dev_attr_temp1_type.dev_attr.attr, >+ &sensor_dev_attr_temp2_type.dev_attr.attr, >+ &sensor_dev_attr_temp3_type.dev_attr.attr, >+ &sensor_dev_attr_temp1_alarm.dev_attr.attr, >+ &sensor_dev_attr_temp2_alarm.dev_attr.attr, >+ &sensor_dev_attr_temp3_alarm.dev_attr.attr, >+ >+ &dev_attr_alarms.attr, >+ &dev_attr_name.attr, >+ NULL >+}; >+ >+static const struct attribute_group it87_group = { >+ .attrs = it87_attributes, >+}; >+ >+static struct attribute *it87_attributes_opt[] = { >+ &sensor_dev_attr_fan1_input16.dev_attr.attr, >+ &sensor_dev_attr_fan1_min16.dev_attr.attr, >+ &sensor_dev_attr_fan2_input16.dev_attr.attr, >+ &sensor_dev_attr_fan2_min16.dev_attr.attr, >+ &sensor_dev_attr_fan3_input16.dev_attr.attr, >+ &sensor_dev_attr_fan3_min16.dev_attr.attr, >+ &sensor_dev_attr_fan4_input16.dev_attr.attr, >+ &sensor_dev_attr_fan4_min16.dev_attr.attr, >+ &sensor_dev_attr_fan5_input16.dev_attr.attr, >+ &sensor_dev_attr_fan5_min16.dev_attr.attr, >+ >+ &sensor_dev_attr_fan1_input.dev_attr.attr, >+ &sensor_dev_attr_fan1_min.dev_attr.attr, >+ &sensor_dev_attr_fan1_div.dev_attr.attr, >+ &sensor_dev_attr_fan2_input.dev_attr.attr, >+ &sensor_dev_attr_fan2_min.dev_attr.attr, >+ &sensor_dev_attr_fan2_div.dev_attr.attr, >+ &sensor_dev_attr_fan3_input.dev_attr.attr, >+ &sensor_dev_attr_fan3_min.dev_attr.attr, >+ &sensor_dev_attr_fan3_div.dev_attr.attr, >+ >+ &sensor_dev_attr_fan1_alarm.dev_attr.attr, >+ &sensor_dev_attr_fan2_alarm.dev_attr.attr, >+ &sensor_dev_attr_fan3_alarm.dev_attr.attr, >+ &sensor_dev_attr_fan4_alarm.dev_attr.attr, >+ &sensor_dev_attr_fan5_alarm.dev_attr.attr, >+ >+ &sensor_dev_attr_pwm1_enable.dev_attr.attr, >+ &sensor_dev_attr_pwm2_enable.dev_attr.attr, >+ &sensor_dev_attr_pwm3_enable.dev_attr.attr, >+ &sensor_dev_attr_pwm1.dev_attr.attr, >+ &sensor_dev_attr_pwm2.dev_attr.attr, >+ &sensor_dev_attr_pwm3.dev_attr.attr, >+ &dev_attr_pwm1_freq.attr, >+ &dev_attr_pwm2_freq.attr, >+ &dev_attr_pwm3_freq.attr, >+ >+ &dev_attr_vrm.attr, >+ &dev_attr_cpu0_vid.attr, >+ NULL >+}; >+ >+static const struct attribute_group it87_group_opt = { >+ .attrs = it87_attributes_opt, >+}; > > /* SuperIO detection - will change isa_address if a chip is found */ >-static int __init it87_find(unsigned short *address) >+static int __init it87_find(unsigned short *address, >+ struct it87_sio_data *sio_data) > { > int err = -ENODEV; >+ u16 chip_type; > > superio_enter(); >- chip_type = superio_inw(DEVID); >- if (chip_type != IT8712F_DEVID >- && chip_type != IT8705F_DEVID) >- goto exit; >+ chip_type = force_id ? force_id : superio_inw(DEVID); > >- superio_select(); >+ switch (chip_type) { >+ case IT8705F_DEVID: >+ sio_data->type = it87; >+ break; >+ case IT8712F_DEVID: >+ sio_data->type = it8712; >+ break; >+ case IT8716F_DEVID: >+ case IT8726F_DEVID: >+ sio_data->type = it8716; >+ break; >+ case IT8718F_DEVID: >+ sio_data->type = it8718; >+ break; >+ case 0xffff: /* No device at all */ >+ goto exit; >+ default: >+ pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n", >+ chip_type); >+ goto exit; >+ } >+ >+ superio_select(PME); > if (!(superio_inb(IT87_ACT_REG) & 0x01)) { > pr_info("it87: Device not activated, skipping\n"); > goto exit; >@@ -739,252 +994,260 @@ static int __init it87_find(unsigned sho > pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n", > chip_type, *address, superio_inb(DEVREV) & 0x0f); > >+ /* Read GPIO config and VID value from LDN 7 (GPIO) */ >+ if (chip_type != IT8705F_DEVID) { >+ int reg; >+ >+ superio_select(GPIO); >+ if (chip_type == it8718) >+ sio_data->vid_value = superio_inb(IT87_SIO_VID_REG); >+ >+ reg = superio_inb(IT87_SIO_PINX2_REG); >+ if (reg & (1 << 0)) >+ pr_info("it87: in3 is VCC (+5V)\n"); >+ if (reg & (1 << 1)) >+ pr_info("it87: in7 is VCCH (+5V Stand-By)\n"); >+ } >+ > exit: > superio_exit(); > return err; > } > >-/* This function is called by i2c_probe */ >-static int it87_detect(struct i2c_adapter *adapter, int address, int kind) >+static int __devinit it87_probe(struct platform_device *pdev) > { >- int i; >- struct i2c_client *new_client; > struct it87_data *data; >+ struct resource *res; >+ struct device *dev = &pdev->dev; >+ struct it87_sio_data *sio_data = dev->platform_data; > int err = 0; >- const char *name = ""; >- int is_isa = i2c_is_isa_adapter(adapter); > int enable_pwm_interface; >- >- if (!is_isa && >- !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) >+ static const char *names[] = { >+ "it87", >+ "it8712", >+ "it8716", >+ "it8718", >+ }; >+ >+ res = platform_get_resource(pdev, IORESOURCE_IO, 0); >+ if (!request_region(res->start, IT87_EC_EXTENT, DRVNAME)) { >+ dev_err(dev, "Failed to request region 0x%lx-0x%lx\n", >+ (unsigned long)res->start, >+ (unsigned long)(res->start + IT87_EC_EXTENT - 1)); >+ err = -EBUSY; > goto ERROR0; >- >- /* Reserve the ISA region */ >- if (is_isa) >- if (!request_region(address, IT87_EXTENT, >- it87_isa_driver.driver.name)) >- goto ERROR0; >- >- /* For now, we presume we have a valid client. We create the >- client structure, even though we cannot fill it completely yet. >- But it allows us to access it87_{read,write}_value. */ >+ } > > if (!(data = kzalloc(sizeof(struct it87_data), GFP_KERNEL))) { > err = -ENOMEM; > goto ERROR1; > } > >- new_client = &data->client; >- if (is_isa) >- mutex_init(&data->lock); >- i2c_set_clientdata(new_client, data); >- new_client->addr = address; >- new_client->adapter = adapter; >- new_client->driver = is_isa ? &it87_isa_driver : &it87_driver; >- new_client->flags = 0; >+ data->addr = res->start; >+ data->type = sio_data->type; >+ data->name = names[sio_data->type]; > > /* Now, we do the remaining detection. */ >- >- if (kind < 0) { >- if ((it87_read_value(new_client, IT87_REG_CONFIG) & 0x80) >- || (!is_isa >- && it87_read_value(new_client, IT87_REG_I2C_ADDR) != address)) { >- err = -ENODEV; >- goto ERROR2; >- } >- } >- >- /* Determine the chip type. */ >- if (kind <= 0) { >- i = it87_read_value(new_client, IT87_REG_CHIPID); >- if (i == 0x90) { >- kind = it87; >- if ((is_isa) && (chip_type == IT8712F_DEVID)) >- kind = it8712; >- } >- else { >- if (kind == 0) >- dev_info(&adapter->dev, >- "Ignoring 'force' parameter for unknown chip at " >- "adapter %d, address 0x%02x\n", >- i2c_adapter_id(adapter), address); >- err = -ENODEV; >- goto ERROR2; >- } >+ if ((it87_read_value(data, IT87_REG_CONFIG) & 0x80) >+ || it87_read_value(data, IT87_REG_CHIPID) != 0x90) { >+ err = -ENODEV; >+ goto ERROR2; > } > >- if (kind == it87) { >- name = "it87"; >- } else if (kind == it8712) { >- name = "it8712"; >- } >+ platform_set_drvdata(pdev, data); > >- /* Fill in the remaining client fields and put it into the global list */ >- strlcpy(new_client->name, name, I2C_NAME_SIZE); >- data->type = kind; >- data->valid = 0; > mutex_init(&data->update_lock); > >- /* Tell the I2C layer a new client has arrived */ >- if ((err = i2c_attach_client(new_client))) >- goto ERROR2; >- >- if (!is_isa) >- dev_info(&new_client->dev, "The I2C interface to IT87xxF " >- "hardware monitoring chips is deprecated. Please " >- "report if you still rely on it.\n"); >- > /* Check PWM configuration */ >- enable_pwm_interface = it87_check_pwm(new_client); >+ enable_pwm_interface = it87_check_pwm(dev); > > /* Initialize the IT87 chip */ >- it87_init_client(new_client, data); >+ it87_init_device(pdev); > > /* Register sysfs hooks */ >- data->class_dev = hwmon_device_register(&new_client->dev); >- if (IS_ERR(data->class_dev)) { >- err = PTR_ERR(data->class_dev); >- goto ERROR3; >- } >- >- device_create_file(&new_client->dev, &sensor_dev_attr_in0_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in1_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in2_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in3_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in4_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in5_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in6_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in7_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in8_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in0_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in1_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in2_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in3_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in4_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in5_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in6_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in7_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in0_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in1_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in2_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in3_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in4_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in5_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in6_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_in7_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp1_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp2_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp3_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp1_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp2_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp3_max.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp1_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp2_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp3_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp1_type.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp2_type.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_temp3_type.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_fan1_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_fan2_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_fan3_input.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_fan1_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_fan2_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_fan3_min.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_fan1_div.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_fan2_div.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_fan3_div.dev_attr); >- device_create_file(&new_client->dev, &dev_attr_alarms); >+ if ((err = sysfs_create_group(&dev->kobj, &it87_group))) >+ goto ERROR2; >+ >+ /* Do not create fan files for disabled fans */ >+ if (data->type == it8716 || data->type == it8718) { >+ /* 16-bit tachometers */ >+ if (data->has_fan & (1 << 0)) { >+ if ((err = device_create_file(dev, >+ &sensor_dev_attr_fan1_input16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan1_min16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan1_alarm.dev_attr))) >+ goto ERROR4; >+ } >+ if (data->has_fan & (1 << 1)) { >+ if ((err = device_create_file(dev, >+ &sensor_dev_attr_fan2_input16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan2_min16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan2_alarm.dev_attr))) >+ goto ERROR4; >+ } >+ if (data->has_fan & (1 << 2)) { >+ if ((err = device_create_file(dev, >+ &sensor_dev_attr_fan3_input16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan3_min16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan3_alarm.dev_attr))) >+ goto ERROR4; >+ } >+ if (data->has_fan & (1 << 3)) { >+ if ((err = device_create_file(dev, >+ &sensor_dev_attr_fan4_input16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan4_min16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan4_alarm.dev_attr))) >+ goto ERROR4; >+ } >+ if (data->has_fan & (1 << 4)) { >+ if ((err = device_create_file(dev, >+ &sensor_dev_attr_fan5_input16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan5_min16.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan5_alarm.dev_attr))) >+ goto ERROR4; >+ } >+ } else { >+ /* 8-bit tachometers with clock divider */ >+ if (data->has_fan & (1 << 0)) { >+ if ((err = device_create_file(dev, >+ &sensor_dev_attr_fan1_input.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan1_min.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan1_div.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan1_alarm.dev_attr))) >+ goto ERROR4; >+ } >+ if (data->has_fan & (1 << 1)) { >+ if ((err = device_create_file(dev, >+ &sensor_dev_attr_fan2_input.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan2_min.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan2_div.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan2_alarm.dev_attr))) >+ goto ERROR4; >+ } >+ if (data->has_fan & (1 << 2)) { >+ if ((err = device_create_file(dev, >+ &sensor_dev_attr_fan3_input.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan3_min.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan3_div.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_fan3_alarm.dev_attr))) >+ goto ERROR4; >+ } >+ } >+ > if (enable_pwm_interface) { >- device_create_file(&new_client->dev, &sensor_dev_attr_pwm1_enable.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_pwm2_enable.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_pwm3_enable.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_pwm1.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_pwm2.dev_attr); >- device_create_file(&new_client->dev, &sensor_dev_attr_pwm3.dev_attr); >+ if ((err = device_create_file(dev, >+ &sensor_dev_attr_pwm1_enable.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_pwm2_enable.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_pwm3_enable.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_pwm1.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_pwm2.dev_attr)) >+ || (err = device_create_file(dev, >+ &sensor_dev_attr_pwm3.dev_attr)) >+ || (err = device_create_file(dev, >+ &dev_attr_pwm1_freq)) >+ || (err = device_create_file(dev, >+ &dev_attr_pwm2_freq)) >+ || (err = device_create_file(dev, >+ &dev_attr_pwm3_freq))) >+ goto ERROR4; > } > >- if (data->type == it8712) { >+ if (data->type == it8712 || data->type == it8716 >+ || data->type == it8718) { > data->vrm = vid_which_vrm(); >- device_create_file_vrm(new_client); >- device_create_file_vid(new_client); >+ /* VID reading from Super-I/O config space if available */ >+ data->vid = sio_data->vid_value; >+ if ((err = device_create_file(dev, >+ &dev_attr_vrm)) >+ || (err = device_create_file(dev, >+ &dev_attr_cpu0_vid))) >+ goto ERROR4; >+ } >+ >+ data->hwmon_dev = hwmon_device_register(dev); >+ if (IS_ERR(data->hwmon_dev)) { >+ err = PTR_ERR(data->hwmon_dev); >+ goto ERROR4; > } > > return 0; > >-ERROR3: >- i2c_detach_client(new_client); >+ERROR4: >+ sysfs_remove_group(&dev->kobj, &it87_group); >+ sysfs_remove_group(&dev->kobj, &it87_group_opt); > ERROR2: >+ platform_set_drvdata(pdev, NULL); > kfree(data); > ERROR1: >- if (is_isa) >- release_region(address, IT87_EXTENT); >+ release_region(res->start, IT87_EC_EXTENT); > ERROR0: > return err; > } > >-static int it87_detach_client(struct i2c_client *client) >+static int __devexit it87_remove(struct platform_device *pdev) > { >- struct it87_data *data = i2c_get_clientdata(client); >- int err; >- >- hwmon_device_unregister(data->class_dev); >+ struct it87_data *data = platform_get_drvdata(pdev); > >- if ((err = i2c_detach_client(client))) >- return err; >+ hwmon_device_unregister(data->hwmon_dev); >+ sysfs_remove_group(&pdev->dev.kobj, &it87_group); >+ sysfs_remove_group(&pdev->dev.kobj, &it87_group_opt); > >- if(i2c_is_isa_client(client)) >- release_region(client->addr, IT87_EXTENT); >+ release_region(data->addr, IT87_EC_EXTENT); >+ platform_set_drvdata(pdev, NULL); > kfree(data); > > return 0; > } > >-/* The SMBus locks itself, but ISA access must be locked explicitly! >- We don't want to lock the whole ISA bus, so we lock each client >- separately. >+/* Must be called with data->update_lock held, except during initialization. > We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks, > would slow down the IT87 access and should not be necessary. */ >-static int it87_read_value(struct i2c_client *client, u8 reg) >+static int it87_read_value(struct it87_data *data, u8 reg) > { >- struct it87_data *data = i2c_get_clientdata(client); >+ outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET); >+ return inb_p(data->addr + IT87_DATA_REG_OFFSET); >+} > >- int res; >- if (i2c_is_isa_client(client)) { >- mutex_lock(&data->lock); >- outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET); >- res = inb_p(client->addr + IT87_DATA_REG_OFFSET); >- mutex_unlock(&data->lock); >- return res; >- } else >- return i2c_smbus_read_byte_data(client, reg); >-} >- >-/* The SMBus locks itself, but ISA access muse be locked explicitly! >- We don't want to lock the whole ISA bus, so we lock each client >- separately. >+/* Must be called with data->update_lock held, except during initialization. > We ignore the IT87 BUSY flag at this moment - it could lead to deadlocks, > would slow down the IT87 access and should not be necessary. */ >-static int it87_write_value(struct i2c_client *client, u8 reg, u8 value) >+static void it87_write_value(struct it87_data *data, u8 reg, u8 value) > { >- struct it87_data *data = i2c_get_clientdata(client); >- >- if (i2c_is_isa_client(client)) { >- mutex_lock(&data->lock); >- outb_p(reg, client->addr + IT87_ADDR_REG_OFFSET); >- outb_p(value, client->addr + IT87_DATA_REG_OFFSET); >- mutex_unlock(&data->lock); >- return 0; >- } else >- return i2c_smbus_write_byte_data(client, reg, value); >+ outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET); >+ outb_p(value, data->addr + IT87_DATA_REG_OFFSET); > } > > /* Return 1 if and only if the PWM interface is safe to use */ >-static int it87_check_pwm(struct i2c_client *client) >+static int __devinit it87_check_pwm(struct device *dev) > { >+ struct it87_data *data = dev_get_drvdata(dev); > /* Some BIOSes fail to correctly configure the IT87 fans. All fans off > * and polarity set to active low is sign that this is the case so we > * disable pwm control to protect the user. */ >- int tmp = it87_read_value(client, IT87_REG_FAN_CTL); >+ int tmp = it87_read_value(data, IT87_REG_FAN_CTL); > if ((tmp & 0x87) == 0) { > if (fix_pwm_polarity) { > /* The user asks us to attempt a chip reconfiguration. >@@ -994,7 +1257,7 @@ static int it87_check_pwm(struct i2c_cli > u8 pwm[3]; > > for (i = 0; i < 3; i++) >- pwm[i] = it87_read_value(client, >+ pwm[i] = it87_read_value(data, > IT87_REG_PWM(i)); > > /* If any fan is in automatic pwm mode, the polarity >@@ -1002,26 +1265,26 @@ static int it87_check_pwm(struct i2c_cli > * better don't change anything (but still disable the > * PWM interface). */ > if (!((pwm[0] | pwm[1] | pwm[2]) & 0x80)) { >- dev_info(&client->dev, "Reconfiguring PWM to " >+ dev_info(dev, "Reconfiguring PWM to " > "active high polarity\n"); >- it87_write_value(client, IT87_REG_FAN_CTL, >+ it87_write_value(data, IT87_REG_FAN_CTL, > tmp | 0x87); > for (i = 0; i < 3; i++) >- it87_write_value(client, >+ it87_write_value(data, > IT87_REG_PWM(i), > 0x7f & ~pwm[i]); > return 1; > } > >- dev_info(&client->dev, "PWM configuration is " >+ dev_info(dev, "PWM configuration is " > "too broken to be fixed\n"); > } > >- dev_info(&client->dev, "Detected broken BIOS " >+ dev_info(dev, "Detected broken BIOS " > "defaults, disabling PWM interface\n"); > return 0; > } else if (fix_pwm_polarity) { >- dev_info(&client->dev, "PWM configuration looks " >+ dev_info(dev, "PWM configuration looks " > "sane, won't touch\n"); > } > >@@ -1029,8 +1292,9 @@ static int it87_check_pwm(struct i2c_cli > } > > /* Called when we have found a new IT87. */ >-static void it87_init_client(struct i2c_client *client, struct it87_data *data) >+static void __devinit it87_init_device(struct platform_device *pdev) > { >+ struct it87_data *data = platform_get_drvdata(pdev); > int tmp, i; > > /* initialize to sane defaults: >@@ -1044,28 +1308,60 @@ static void it87_init_client(struct i2c_ > data->manual_pwm_ctl[i] = 0xff; > } > >+ /* Some chips seem to have default value 0xff for all limit >+ * registers. For low voltage limits it makes no sense and triggers >+ * alarms, so change to 0 instead. For high temperature limits, it >+ * means -1 degree C, which surprisingly doesn't trigger an alarm, >+ * but is still confusing, so change to 127 degrees C. */ >+ for (i = 0; i < 8; i++) { >+ tmp = it87_read_value(data, IT87_REG_VIN_MIN(i)); >+ if (tmp == 0xff) >+ it87_write_value(data, IT87_REG_VIN_MIN(i), 0); >+ } >+ for (i = 0; i < 3; i++) { >+ tmp = it87_read_value(data, IT87_REG_TEMP_HIGH(i)); >+ if (tmp == 0xff) >+ it87_write_value(data, IT87_REG_TEMP_HIGH(i), 127); >+ } >+ > /* Check if temperature channnels are reset manually or by some reason */ >- tmp = it87_read_value(client, IT87_REG_TEMP_ENABLE); >+ tmp = it87_read_value(data, IT87_REG_TEMP_ENABLE); > if ((tmp & 0x3f) == 0) { > /* Temp1,Temp3=thermistor; Temp2=thermal diode */ > tmp = (tmp & 0xc0) | 0x2a; >- it87_write_value(client, IT87_REG_TEMP_ENABLE, tmp); >+ it87_write_value(data, IT87_REG_TEMP_ENABLE, tmp); > } > data->sensor = tmp; > > /* Check if voltage monitors are reset manually or by some reason */ >- tmp = it87_read_value(client, IT87_REG_VIN_ENABLE); >+ tmp = it87_read_value(data, IT87_REG_VIN_ENABLE); > if ((tmp & 0xff) == 0) { > /* Enable all voltage monitors */ >- it87_write_value(client, IT87_REG_VIN_ENABLE, 0xff); >+ it87_write_value(data, IT87_REG_VIN_ENABLE, 0xff); > } > > /* Check if tachometers are reset manually or by some reason */ >- data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL); >+ data->fan_main_ctrl = it87_read_value(data, IT87_REG_FAN_MAIN_CTRL); > if ((data->fan_main_ctrl & 0x70) == 0) { > /* Enable all fan tachometers */ > data->fan_main_ctrl |= 0x70; >- it87_write_value(client, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); >+ it87_write_value(data, IT87_REG_FAN_MAIN_CTRL, data->fan_main_ctrl); >+ } >+ data->has_fan = (data->fan_main_ctrl >> 4) & 0x07; >+ >+ /* Set tachometers to 16-bit mode if needed */ >+ if (data->type == it8716 || data->type == it8718) { >+ tmp = it87_read_value(data, IT87_REG_FAN_16BIT); >+ if (~tmp & 0x07 & data->has_fan) { >+ dev_dbg(&pdev->dev, >+ "Setting fan1-3 to 16-bit mode\n"); >+ it87_write_value(data, IT87_REG_FAN_16BIT, >+ tmp | 0x07); >+ } >+ if (tmp & (1 << 4)) >+ data->has_fan |= (1 << 3); /* fan4 enabled */ >+ if (tmp & (1 << 5)) >+ data->has_fan |= (1 << 4); /* fan5 enabled */ > } > > /* Set current fan mode registers and the default settings for the >@@ -1073,7 +1369,7 @@ static void it87_init_client(struct i2c_ > for (i = 0; i < 3; i++) { > if (data->fan_main_ctrl & (1 << i)) { > /* pwm mode */ >- tmp = it87_read_value(client, IT87_REG_PWM(i)); >+ tmp = it87_read_value(data, IT87_REG_PWM(i)); > if (tmp & 0x80) { > /* automatic pwm - not yet implemented, but > * leave the settings made by the BIOS alone >@@ -1087,15 +1383,14 @@ static void it87_init_client(struct i2c_ > } > > /* Start monitoring */ >- it87_write_value(client, IT87_REG_CONFIG, >- (it87_read_value(client, IT87_REG_CONFIG) & 0x36) >+ it87_write_value(data, IT87_REG_CONFIG, >+ (it87_read_value(data, IT87_REG_CONFIG) & 0x36) > | (update_vbat ? 0x41 : 0x01)); > } > > static struct it87_data *it87_update_device(struct device *dev) > { >- struct i2c_client *client = to_i2c_client(dev); >- struct it87_data *data = i2c_get_clientdata(client); >+ struct it87_data *data = dev_get_drvdata(dev); > int i; > > mutex_lock(&data->update_lock); >@@ -1106,55 +1401,71 @@ static struct it87_data *it87_update_dev > if (update_vbat) { > /* Cleared after each update, so reenable. Value > returned by this read will be previous value */ >- it87_write_value(client, IT87_REG_CONFIG, >- it87_read_value(client, IT87_REG_CONFIG) | 0x40); >+ it87_write_value(data, IT87_REG_CONFIG, >+ it87_read_value(data, IT87_REG_CONFIG) | 0x40); > } > for (i = 0; i <= 7; i++) { > data->in[i] = >- it87_read_value(client, IT87_REG_VIN(i)); >+ it87_read_value(data, IT87_REG_VIN(i)); > data->in_min[i] = >- it87_read_value(client, IT87_REG_VIN_MIN(i)); >+ it87_read_value(data, IT87_REG_VIN_MIN(i)); > data->in_max[i] = >- it87_read_value(client, IT87_REG_VIN_MAX(i)); >+ it87_read_value(data, IT87_REG_VIN_MAX(i)); > } >+ /* in8 (battery) has no limit registers */ > data->in[8] = >- it87_read_value(client, IT87_REG_VIN(8)); >- /* Temperature sensor doesn't have limit registers, set >- to min and max value */ >- data->in_min[8] = 0; >- data->in_max[8] = 255; >+ it87_read_value(data, IT87_REG_VIN(8)); >+ >+ for (i = 0; i < 5; i++) { >+ /* Skip disabled fans */ >+ if (!(data->has_fan & (1 << i))) >+ continue; > >- for (i = 0; i < 3; i++) { >- data->fan[i] = >- it87_read_value(client, IT87_REG_FAN(i)); > data->fan_min[i] = >- it87_read_value(client, IT87_REG_FAN_MIN(i)); >+ it87_read_value(data, IT87_REG_FAN_MIN[i]); >+ data->fan[i] = it87_read_value(data, >+ IT87_REG_FAN[i]); >+ /* Add high byte if in 16-bit mode */ >+ if (data->type == it8716 || data->type == it8718) { >+ data->fan[i] |= it87_read_value(data, >+ IT87_REG_FANX[i]) << 8; >+ data->fan_min[i] |= it87_read_value(data, >+ IT87_REG_FANX_MIN[i]) << 8; >+ } > } > for (i = 0; i < 3; i++) { > data->temp[i] = >- it87_read_value(client, IT87_REG_TEMP(i)); >+ it87_read_value(data, IT87_REG_TEMP(i)); > data->temp_high[i] = >- it87_read_value(client, IT87_REG_TEMP_HIGH(i)); >+ it87_read_value(data, IT87_REG_TEMP_HIGH(i)); > data->temp_low[i] = >- it87_read_value(client, IT87_REG_TEMP_LOW(i)); >+ it87_read_value(data, IT87_REG_TEMP_LOW(i)); > } > >- i = it87_read_value(client, IT87_REG_FAN_DIV); >- data->fan_div[0] = i & 0x07; >- data->fan_div[1] = (i >> 3) & 0x07; >- data->fan_div[2] = (i & 0x40) ? 3 : 1; >+ /* Newer chips don't have clock dividers */ >+ if ((data->has_fan & 0x07) && data->type != it8716 >+ && data->type != it8718) { >+ i = it87_read_value(data, IT87_REG_FAN_DIV); >+ data->fan_div[0] = i & 0x07; >+ data->fan_div[1] = (i >> 3) & 0x07; >+ data->fan_div[2] = (i & 0x40) ? 3 : 1; >+ } > > data->alarms = >- it87_read_value(client, IT87_REG_ALARM1) | >- (it87_read_value(client, IT87_REG_ALARM2) << 8) | >- (it87_read_value(client, IT87_REG_ALARM3) << 16); >- data->fan_main_ctrl = it87_read_value(client, IT87_REG_FAN_MAIN_CTRL); >+ it87_read_value(data, IT87_REG_ALARM1) | >+ (it87_read_value(data, IT87_REG_ALARM2) << 8) | >+ (it87_read_value(data, IT87_REG_ALARM3) << 16); >+ data->fan_main_ctrl = it87_read_value(data, >+ IT87_REG_FAN_MAIN_CTRL); >+ data->fan_ctl = it87_read_value(data, IT87_REG_FAN_CTL); > >- data->sensor = it87_read_value(client, IT87_REG_TEMP_ENABLE); >+ data->sensor = it87_read_value(data, IT87_REG_TEMP_ENABLE); > /* The 8705 does not have VID capability */ >- if (data->type == it8712) { >- data->vid = it87_read_value(client, IT87_REG_VID); >- data->vid &= 0x1f; >+ if (data->type == it8712 || data->type == it8716) { >+ data->vid = it87_read_value(data, IT87_REG_VID); >+ /* The older IT8712F revisions had only 5 VID pins, >+ but we assume it is always safe to read 6 bits. */ >+ data->vid &= 0x3f; > } > data->last_updated = jiffies; > data->valid = 1; >@@ -1165,20 +1476,70 @@ static struct it87_data *it87_update_dev > return data; > } > >+static int __init it87_device_add(unsigned short address, >+ const struct it87_sio_data *sio_data) >+{ >+ struct resource res = { >+ .start = address + IT87_EC_OFFSET, >+ .end = address + IT87_EC_OFFSET + IT87_EC_EXTENT - 1, >+ .name = DRVNAME, >+ .flags = IORESOURCE_IO, >+ }; >+ int err; >+ >+ pdev = platform_device_alloc(DRVNAME, address); >+ if (!pdev) { >+ err = -ENOMEM; >+ printk(KERN_ERR DRVNAME ": Device allocation failed\n"); >+ goto exit; >+ } >+ >+ err = platform_device_add_resources(pdev, &res, 1); >+ if (err) { >+ printk(KERN_ERR DRVNAME ": Device resource addition failed " >+ "(%d)\n", err); >+ goto exit_device_put; >+ } >+ >+ err = platform_device_add_data(pdev, sio_data, >+ sizeof(struct it87_sio_data)); >+ if (err) { >+ printk(KERN_ERR DRVNAME ": Platform data allocation failed\n"); >+ goto exit_device_put; >+ } >+ >+ err = platform_device_add(pdev); >+ if (err) { >+ printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n", >+ err); >+ goto exit_device_put; >+ } >+ >+ return 0; >+ >+exit_device_put: >+ platform_device_put(pdev); >+exit: >+ return err; >+} >+ > static int __init sm_it87_init(void) > { >- int res; >+ int err; >+ unsigned short isa_address=0; >+ struct it87_sio_data sio_data; > >- res = i2c_add_driver(&it87_driver); >- if (res) >- return res; >- >- if (!it87_find(&isa_address)) { >- res = i2c_isa_add_driver(&it87_isa_driver); >- if (res) { >- i2c_del_driver(&it87_driver); >- return res; >- } >+ err = it87_find(&isa_address, &sio_data); >+ if (err) >+ return err; >+ err = platform_driver_register(&it87_driver); >+ if (err) >+ return err; >+ >+ err = it87_device_add(isa_address, &sio_data); >+ if (err){ >+ platform_driver_unregister(&it87_driver); >+ return err; > } > > return 0; >@@ -1186,14 +1547,14 @@ static int __init sm_it87_init(void) > > static void __exit sm_it87_exit(void) > { >- if (isa_address) >- i2c_isa_del_driver(&it87_isa_driver); >- i2c_del_driver(&it87_driver); >+ platform_device_unregister(pdev); >+ platform_driver_unregister(&it87_driver); > } > > >-MODULE_AUTHOR("Chris Gauthron <chrisg@0-in.com>"); >-MODULE_DESCRIPTION("IT8705F, IT8712F, Sis950 driver"); >+MODULE_AUTHOR("Chris Gauthron, " >+ "Jean Delvare <khali@linux-fr.org>"); >+MODULE_DESCRIPTION("IT8705F/8712F/8716F/8718F/8726F, SiS950 driver"); > module_param(update_vbat, bool, 0); > MODULE_PARM_DESC(update_vbat, "Update vbat if set else return powerup value"); > module_param(fix_pwm_polarity, bool, 0);
<b>You cannot view the attachment while viewing its details because your browser does not support IFRAMEs. <a href="attachment.cgi?id=306344">View the attachment on a separate page</a>.</b>
View Attachment As Diff
View Attachment As Raw
Actions:
View
|
Diff
Attachments on
bug 446061
: 306344