2 atxp1.c - kernel module for setting CPU VID and general purpose
3 I/Os using the Attansic ATXP1 chip.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include <linux/kernel.h>
22 #include <linux/init.h>
23 #include <linux/module.h>
24 #include <linux/jiffies.h>
25 #include <linux/i2c.h>
26 #include <linux/hwmon.h>
27 #include <linux/hwmon-vid.h>
28 #include <linux/err.h>
30 MODULE_LICENSE("GPL");
31 MODULE_DESCRIPTION("System voltages control via Attansic ATXP1");
32 MODULE_VERSION("0.6.2");
33 MODULE_AUTHOR("Sebastian Witt <se.witt@gmx.net>");
35 #define ATXP1_VID 0x00
36 #define ATXP1_CVID 0x01
37 #define ATXP1_GPIO1 0x06
38 #define ATXP1_GPIO2 0x0a
39 #define ATXP1_VIDENA 0x20
40 #define ATXP1_VIDMASK 0x1f
41 #define ATXP1_GPIO1MASK 0x0f
43 static unsigned short normal_i2c
[] = { 0x37, 0x4e, I2C_CLIENT_END
};
45 I2C_CLIENT_INSMOD_1(atxp1
);
47 static int atxp1_attach_adapter(struct i2c_adapter
* adapter
);
48 static int atxp1_detach_client(struct i2c_client
* client
);
49 static struct atxp1_data
* atxp1_update_device(struct device
*dev
);
50 static int atxp1_detect(struct i2c_adapter
*adapter
, int address
, int kind
);
52 static struct i2c_driver atxp1_driver
= {
56 .attach_adapter
= atxp1_attach_adapter
,
57 .detach_client
= atxp1_detach_client
,
61 struct i2c_client client
;
62 struct class_device
*class_dev
;
63 struct semaphore update_lock
;
64 unsigned long last_updated
;
67 u8 vid
; /* VID output register */
68 u8 cpu_vid
; /* VID input from CPU */
69 u8 gpio1
; /* General purpose I/O register 1 */
70 u8 gpio2
; /* General purpose I/O register 2 */
72 u8 vrm
; /* Detected CPU VRM */
75 static struct atxp1_data
* atxp1_update_device(struct device
*dev
)
77 struct i2c_client
*client
;
78 struct atxp1_data
*data
;
80 client
= to_i2c_client(dev
);
81 data
= i2c_get_clientdata(client
);
83 down(&data
->update_lock
);
85 if (time_after(jiffies
, data
->last_updated
+ HZ
) || !data
->valid
) {
87 /* Update local register data */
88 data
->reg
.vid
= i2c_smbus_read_byte_data(client
, ATXP1_VID
);
89 data
->reg
.cpu_vid
= i2c_smbus_read_byte_data(client
, ATXP1_CVID
);
90 data
->reg
.gpio1
= i2c_smbus_read_byte_data(client
, ATXP1_GPIO1
);
91 data
->reg
.gpio2
= i2c_smbus_read_byte_data(client
, ATXP1_GPIO2
);
96 up(&data
->update_lock
);
101 /* sys file functions for cpu0_vid */
102 static ssize_t
atxp1_showvcore(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
105 struct atxp1_data
*data
;
107 data
= atxp1_update_device(dev
);
109 size
= sprintf(buf
, "%d\n", vid_from_reg(data
->reg
.vid
& ATXP1_VIDMASK
, data
->vrm
));
114 static ssize_t
atxp1_storevcore(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
116 struct atxp1_data
*data
;
117 struct i2c_client
*client
;
122 client
= to_i2c_client(dev
);
123 data
= atxp1_update_device(dev
);
125 vcore
= simple_strtoul(buf
, NULL
, 10);
130 vid
= vid_to_reg(vcore
, data
->vrm
);
133 dev_err(dev
, "VID calculation failed.\n");
137 /* If output enabled, use control register value. Otherwise original CPU VID */
138 if (data
->reg
.vid
& ATXP1_VIDENA
)
139 cvid
= data
->reg
.vid
& ATXP1_VIDMASK
;
141 cvid
= data
->reg
.cpu_vid
;
143 /* Nothing changed, aborting */
147 dev_dbg(dev
, "Setting VCore to %d mV (0x%02x)\n", vcore
, vid
);
149 /* Write every 25 mV step to increase stability */
151 for (; cvid
>= vid
; cvid
--) {
152 i2c_smbus_write_byte_data(client
, ATXP1_VID
, cvid
| ATXP1_VIDENA
);
156 for (; cvid
<= vid
; cvid
++) {
157 i2c_smbus_write_byte_data(client
, ATXP1_VID
, cvid
| ATXP1_VIDENA
);
166 /* CPU core reference voltage
169 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
| S_IWUSR
, atxp1_showvcore
, atxp1_storevcore
);
171 /* sys file functions for GPIO1 */
172 static ssize_t
atxp1_showgpio1(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
175 struct atxp1_data
*data
;
177 data
= atxp1_update_device(dev
);
179 size
= sprintf(buf
, "0x%02x\n", data
->reg
.gpio1
& ATXP1_GPIO1MASK
);
184 static ssize_t
atxp1_storegpio1(struct device
*dev
, struct device_attribute
*attr
, const char*buf
, size_t count
)
186 struct atxp1_data
*data
;
187 struct i2c_client
*client
;
190 client
= to_i2c_client(dev
);
191 data
= atxp1_update_device(dev
);
193 value
= simple_strtoul(buf
, NULL
, 16);
195 value
&= ATXP1_GPIO1MASK
;
197 if (value
!= (data
->reg
.gpio1
& ATXP1_GPIO1MASK
)) {
198 dev_info(dev
, "Writing 0x%x to GPIO1.\n", value
);
200 i2c_smbus_write_byte_data(client
, ATXP1_GPIO1
, value
);
208 /* GPIO1 data register
209 unit: Four bit as hex (e.g. 0x0f)
211 static DEVICE_ATTR(gpio1
, S_IRUGO
| S_IWUSR
, atxp1_showgpio1
, atxp1_storegpio1
);
213 /* sys file functions for GPIO2 */
214 static ssize_t
atxp1_showgpio2(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
217 struct atxp1_data
*data
;
219 data
= atxp1_update_device(dev
);
221 size
= sprintf(buf
, "0x%02x\n", data
->reg
.gpio2
);
226 static ssize_t
atxp1_storegpio2(struct device
*dev
, struct device_attribute
*attr
, const char *buf
, size_t count
)
228 struct atxp1_data
*data
;
229 struct i2c_client
*client
;
232 client
= to_i2c_client(dev
);
233 data
= atxp1_update_device(dev
);
235 value
= simple_strtoul(buf
, NULL
, 16) & 0xff;
237 if (value
!= data
->reg
.gpio2
) {
238 dev_info(dev
, "Writing 0x%x to GPIO1.\n", value
);
240 i2c_smbus_write_byte_data(client
, ATXP1_GPIO2
, value
);
248 /* GPIO2 data register
249 unit: Eight bit as hex (e.g. 0xff)
251 static DEVICE_ATTR(gpio2
, S_IRUGO
| S_IWUSR
, atxp1_showgpio2
, atxp1_storegpio2
);
254 static int atxp1_attach_adapter(struct i2c_adapter
*adapter
)
256 if (!(adapter
->class & I2C_CLASS_HWMON
))
258 return i2c_probe(adapter
, &addr_data
, &atxp1_detect
);
261 static int atxp1_detect(struct i2c_adapter
*adapter
, int address
, int kind
)
263 struct i2c_client
* new_client
;
264 struct atxp1_data
* data
;
268 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
271 if (!(data
= kzalloc(sizeof(struct atxp1_data
), GFP_KERNEL
))) {
276 new_client
= &data
->client
;
277 i2c_set_clientdata(new_client
, data
);
279 new_client
->addr
= address
;
280 new_client
->adapter
= adapter
;
281 new_client
->driver
= &atxp1_driver
;
282 new_client
->flags
= 0;
284 /* Detect ATXP1, checking if vendor ID registers are all zero */
285 if (!((i2c_smbus_read_byte_data(new_client
, 0x3e) == 0) &&
286 (i2c_smbus_read_byte_data(new_client
, 0x3f) == 0) &&
287 (i2c_smbus_read_byte_data(new_client
, 0xfe) == 0) &&
288 (i2c_smbus_read_byte_data(new_client
, 0xff) == 0) )) {
290 /* No vendor ID, now checking if registers 0x10,0x11 (non-existent)
291 * showing the same as register 0x00 */
292 temp
= i2c_smbus_read_byte_data(new_client
, 0x00);
294 if (!((i2c_smbus_read_byte_data(new_client
, 0x10) == temp
) &&
295 (i2c_smbus_read_byte_data(new_client
, 0x11) == temp
) ))
300 data
->vrm
= vid_which_vrm();
302 if ((data
->vrm
!= 90) && (data
->vrm
!= 91)) {
303 dev_err(&new_client
->dev
, "Not supporting VRM %d.%d\n",
304 data
->vrm
/ 10, data
->vrm
% 10);
308 strncpy(new_client
->name
, "atxp1", I2C_NAME_SIZE
);
312 init_MUTEX(&data
->update_lock
);
314 err
= i2c_attach_client(new_client
);
318 dev_err(&new_client
->dev
, "Attach client error.\n");
322 data
->class_dev
= hwmon_device_register(&new_client
->dev
);
323 if (IS_ERR(data
->class_dev
)) {
324 err
= PTR_ERR(data
->class_dev
);
328 device_create_file(&new_client
->dev
, &dev_attr_gpio1
);
329 device_create_file(&new_client
->dev
, &dev_attr_gpio2
);
330 device_create_file(&new_client
->dev
, &dev_attr_cpu0_vid
);
332 dev_info(&new_client
->dev
, "Using VRM: %d.%d\n",
333 data
->vrm
/ 10, data
->vrm
% 10);
338 i2c_detach_client(new_client
);
345 static int atxp1_detach_client(struct i2c_client
* client
)
347 struct atxp1_data
* data
= i2c_get_clientdata(client
);
350 hwmon_device_unregister(data
->class_dev
);
352 err
= i2c_detach_client(client
);
355 dev_err(&client
->dev
, "Failed to detach client.\n");
362 static int __init
atxp1_init(void)
364 return i2c_add_driver(&atxp1_driver
);
367 static void __exit
atxp1_exit(void)
369 i2c_del_driver(&atxp1_driver
);
372 module_init(atxp1_init
);
373 module_exit(atxp1_exit
);