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>
29 #include <linux/mutex.h>
30 #include <linux/sysfs.h>
31 #include <linux/slab.h>
33 MODULE_LICENSE("GPL");
34 MODULE_DESCRIPTION("System voltages control via Attansic ATXP1");
35 MODULE_VERSION("0.6.3");
36 MODULE_AUTHOR("Sebastian Witt <se.witt@gmx.net>");
38 #define ATXP1_VID 0x00
39 #define ATXP1_CVID 0x01
40 #define ATXP1_GPIO1 0x06
41 #define ATXP1_GPIO2 0x0a
42 #define ATXP1_VIDENA 0x20
43 #define ATXP1_VIDMASK 0x1f
44 #define ATXP1_GPIO1MASK 0x0f
46 static const unsigned short normal_i2c
[] = { 0x37, 0x4e, I2C_CLIENT_END
};
49 struct i2c_client
*client
;
50 struct mutex update_lock
;
51 unsigned long last_updated
;
54 u8 vid
; /* VID output register */
55 u8 cpu_vid
; /* VID input from CPU */
56 u8 gpio1
; /* General purpose I/O register 1 */
57 u8 gpio2
; /* General purpose I/O register 2 */
59 u8 vrm
; /* Detected CPU VRM */
62 static struct atxp1_data
*atxp1_update_device(struct device
*dev
)
64 struct atxp1_data
*data
= dev_get_drvdata(dev
);
65 struct i2c_client
*client
= data
->client
;
67 mutex_lock(&data
->update_lock
);
69 if (time_after(jiffies
, data
->last_updated
+ HZ
) || !data
->valid
) {
71 /* Update local register data */
72 data
->reg
.vid
= i2c_smbus_read_byte_data(client
, ATXP1_VID
);
73 data
->reg
.cpu_vid
= i2c_smbus_read_byte_data(client
,
75 data
->reg
.gpio1
= i2c_smbus_read_byte_data(client
, ATXP1_GPIO1
);
76 data
->reg
.gpio2
= i2c_smbus_read_byte_data(client
, ATXP1_GPIO2
);
81 mutex_unlock(&data
->update_lock
);
86 /* sys file functions for cpu0_vid */
87 static ssize_t
atxp1_showvcore(struct device
*dev
,
88 struct device_attribute
*attr
, char *buf
)
91 struct atxp1_data
*data
;
93 data
= atxp1_update_device(dev
);
95 size
= sprintf(buf
, "%d\n", vid_from_reg(data
->reg
.vid
& ATXP1_VIDMASK
,
101 static ssize_t
atxp1_storevcore(struct device
*dev
,
102 struct device_attribute
*attr
,
103 const char *buf
, size_t count
)
105 struct atxp1_data
*data
= atxp1_update_device(dev
);
106 struct i2c_client
*client
= data
->client
;
111 err
= kstrtoul(buf
, 10, &vcore
);
119 vid
= vid_to_reg(vcore
, data
->vrm
);
121 dev_err(dev
, "VID calculation failed.\n");
126 * If output enabled, use control register value.
127 * Otherwise original CPU VID
129 if (data
->reg
.vid
& ATXP1_VIDENA
)
130 cvid
= data
->reg
.vid
& ATXP1_VIDMASK
;
132 cvid
= data
->reg
.cpu_vid
;
134 /* Nothing changed, aborting */
138 dev_dbg(dev
, "Setting VCore to %d mV (0x%02x)\n", (int)vcore
, vid
);
140 /* Write every 25 mV step to increase stability */
142 for (; cvid
>= vid
; cvid
--)
143 i2c_smbus_write_byte_data(client
,
144 ATXP1_VID
, cvid
| ATXP1_VIDENA
);
146 for (; cvid
<= vid
; cvid
++)
147 i2c_smbus_write_byte_data(client
,
148 ATXP1_VID
, cvid
| ATXP1_VIDENA
);
157 * CPU core reference voltage
160 static DEVICE_ATTR(cpu0_vid
, S_IRUGO
| S_IWUSR
, atxp1_showvcore
,
163 /* sys file functions for GPIO1 */
164 static ssize_t
atxp1_showgpio1(struct device
*dev
,
165 struct device_attribute
*attr
, char *buf
)
168 struct atxp1_data
*data
;
170 data
= atxp1_update_device(dev
);
172 size
= sprintf(buf
, "0x%02x\n", data
->reg
.gpio1
& ATXP1_GPIO1MASK
);
177 static ssize_t
atxp1_storegpio1(struct device
*dev
,
178 struct device_attribute
*attr
, const char *buf
,
181 struct atxp1_data
*data
= atxp1_update_device(dev
);
182 struct i2c_client
*client
= data
->client
;
186 err
= kstrtoul(buf
, 16, &value
);
190 value
&= ATXP1_GPIO1MASK
;
192 if (value
!= (data
->reg
.gpio1
& ATXP1_GPIO1MASK
)) {
193 dev_info(dev
, "Writing 0x%x to GPIO1.\n", (unsigned int)value
);
195 i2c_smbus_write_byte_data(client
, ATXP1_GPIO1
, value
);
204 * GPIO1 data register
205 * unit: Four bit as hex (e.g. 0x0f)
207 static DEVICE_ATTR(gpio1
, S_IRUGO
| S_IWUSR
, atxp1_showgpio1
, atxp1_storegpio1
);
209 /* sys file functions for GPIO2 */
210 static ssize_t
atxp1_showgpio2(struct device
*dev
,
211 struct device_attribute
*attr
, char *buf
)
214 struct atxp1_data
*data
;
216 data
= atxp1_update_device(dev
);
218 size
= sprintf(buf
, "0x%02x\n", data
->reg
.gpio2
);
223 static ssize_t
atxp1_storegpio2(struct device
*dev
,
224 struct device_attribute
*attr
,
225 const char *buf
, size_t count
)
227 struct atxp1_data
*data
= atxp1_update_device(dev
);
228 struct i2c_client
*client
= data
->client
;
232 err
= kstrtoul(buf
, 16, &value
);
237 if (value
!= data
->reg
.gpio2
) {
238 dev_info(dev
, "Writing 0x%x to GPIO1.\n", (unsigned int)value
);
240 i2c_smbus_write_byte_data(client
, ATXP1_GPIO2
, value
);
249 * GPIO2 data register
250 * unit: Eight bit as hex (e.g. 0xff)
252 static DEVICE_ATTR(gpio2
, S_IRUGO
| S_IWUSR
, atxp1_showgpio2
, atxp1_storegpio2
);
254 static struct attribute
*atxp1_attrs
[] = {
255 &dev_attr_gpio1
.attr
,
256 &dev_attr_gpio2
.attr
,
257 &dev_attr_cpu0_vid
.attr
,
260 ATTRIBUTE_GROUPS(atxp1
);
262 /* Return 0 if detection is successful, -ENODEV otherwise */
263 static int atxp1_detect(struct i2c_client
*new_client
,
264 struct i2c_board_info
*info
)
266 struct i2c_adapter
*adapter
= new_client
->adapter
;
270 if (!i2c_check_functionality(adapter
, I2C_FUNC_SMBUS_BYTE_DATA
))
273 /* Detect ATXP1, checking if vendor ID registers are all zero */
274 if (!((i2c_smbus_read_byte_data(new_client
, 0x3e) == 0) &&
275 (i2c_smbus_read_byte_data(new_client
, 0x3f) == 0) &&
276 (i2c_smbus_read_byte_data(new_client
, 0xfe) == 0) &&
277 (i2c_smbus_read_byte_data(new_client
, 0xff) == 0)))
281 * No vendor ID, now checking if registers 0x10,0x11 (non-existent)
282 * showing the same as register 0x00
284 temp
= i2c_smbus_read_byte_data(new_client
, 0x00);
286 if (!((i2c_smbus_read_byte_data(new_client
, 0x10) == temp
) &&
287 (i2c_smbus_read_byte_data(new_client
, 0x11) == temp
)))
291 temp
= vid_which_vrm();
293 if ((temp
!= 90) && (temp
!= 91)) {
294 dev_err(&adapter
->dev
, "atxp1: Not supporting VRM %d.%d\n",
295 temp
/ 10, temp
% 10);
299 strlcpy(info
->type
, "atxp1", I2C_NAME_SIZE
);
304 static int atxp1_probe(struct i2c_client
*client
,
305 const struct i2c_device_id
*id
)
307 struct device
*dev
= &client
->dev
;
308 struct atxp1_data
*data
;
309 struct device
*hwmon_dev
;
311 data
= devm_kzalloc(dev
, sizeof(struct atxp1_data
), GFP_KERNEL
);
316 data
->vrm
= vid_which_vrm();
318 data
->client
= client
;
319 mutex_init(&data
->update_lock
);
321 hwmon_dev
= devm_hwmon_device_register_with_groups(dev
, client
->name
,
324 if (IS_ERR(hwmon_dev
))
325 return PTR_ERR(hwmon_dev
);
327 dev_info(dev
, "Using VRM: %d.%d\n", data
->vrm
/ 10, data
->vrm
% 10);
332 static const struct i2c_device_id atxp1_id
[] = {
336 MODULE_DEVICE_TABLE(i2c
, atxp1_id
);
338 static struct i2c_driver atxp1_driver
= {
339 .class = I2C_CLASS_HWMON
,
343 .probe
= atxp1_probe
,
344 .id_table
= atxp1_id
,
345 .detect
= atxp1_detect
,
346 .address_list
= normal_i2c
,
349 module_i2c_driver(atxp1_driver
);
This page took 0.038866 seconds and 5 git commands to generate.