1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * atxp1.c - kernel module for setting CPU VID and general purpose
4 * I/Os using the Attansic ATXP1 chip.
5 *
6 * The ATXP1 can reside on I2C addresses 0x37 or 0x4e. The chip is
7 * not auto-detected by the driver and must be instantiated explicitly.
8 * See Documentation/i2c/instantiating-devices.rst for more information.
9 */
10
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/jiffies.h>
15 #include <linux/i2c.h>
16 #include <linux/hwmon.h>
17 #include <linux/hwmon-vid.h>
18 #include <linux/err.h>
19 #include <linux/mutex.h>
20 #include <linux/sysfs.h>
21 #include <linux/slab.h>
22
23 MODULE_LICENSE("GPL");
24 MODULE_DESCRIPTION("System voltages control via Attansic ATXP1");
25 MODULE_VERSION("0.6.3");
26 MODULE_AUTHOR("Sebastian Witt <se.witt@gmx.net>");
27
28 #define ATXP1_VID 0x00
29 #define ATXP1_CVID 0x01
30 #define ATXP1_GPIO1 0x06
31 #define ATXP1_GPIO2 0x0a
32 #define ATXP1_VIDENA 0x20
33 #define ATXP1_VIDMASK 0x1f
34 #define ATXP1_GPIO1MASK 0x0f
35
36 struct atxp1_data {
37 struct i2c_client *client;
38 struct mutex update_lock;
39 unsigned long last_updated;
40 u8 valid;
41 struct {
42 u8 vid; /* VID output register */
43 u8 cpu_vid; /* VID input from CPU */
44 u8 gpio1; /* General purpose I/O register 1 */
45 u8 gpio2; /* General purpose I/O register 2 */
46 } reg;
47 u8 vrm; /* Detected CPU VRM */
48 };
49
atxp1_update_device(struct device * dev)50 static struct atxp1_data *atxp1_update_device(struct device *dev)
51 {
52 struct atxp1_data *data = dev_get_drvdata(dev);
53 struct i2c_client *client = data->client;
54
55 mutex_lock(&data->update_lock);
56
57 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
58
59 /* Update local register data */
60 data->reg.vid = i2c_smbus_read_byte_data(client, ATXP1_VID);
61 data->reg.cpu_vid = i2c_smbus_read_byte_data(client,
62 ATXP1_CVID);
63 data->reg.gpio1 = i2c_smbus_read_byte_data(client, ATXP1_GPIO1);
64 data->reg.gpio2 = i2c_smbus_read_byte_data(client, ATXP1_GPIO2);
65
66 data->valid = 1;
67 }
68
69 mutex_unlock(&data->update_lock);
70
71 return data;
72 }
73
74 /* sys file functions for cpu0_vid */
cpu0_vid_show(struct device * dev,struct device_attribute * attr,char * buf)75 static ssize_t cpu0_vid_show(struct device *dev,
76 struct device_attribute *attr, char *buf)
77 {
78 int size;
79 struct atxp1_data *data;
80
81 data = atxp1_update_device(dev);
82
83 size = sprintf(buf, "%d\n", vid_from_reg(data->reg.vid & ATXP1_VIDMASK,
84 data->vrm));
85
86 return size;
87 }
88
cpu0_vid_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)89 static ssize_t cpu0_vid_store(struct device *dev,
90 struct device_attribute *attr, const char *buf,
91 size_t count)
92 {
93 struct atxp1_data *data = atxp1_update_device(dev);
94 struct i2c_client *client = data->client;
95 int vid, cvid;
96 unsigned long vcore;
97 int err;
98
99 err = kstrtoul(buf, 10, &vcore);
100 if (err)
101 return err;
102
103 vcore /= 25;
104 vcore *= 25;
105
106 /* Calculate VID */
107 vid = vid_to_reg(vcore, data->vrm);
108 if (vid < 0) {
109 dev_err(dev, "VID calculation failed.\n");
110 return vid;
111 }
112
113 /*
114 * If output enabled, use control register value.
115 * Otherwise original CPU VID
116 */
117 if (data->reg.vid & ATXP1_VIDENA)
118 cvid = data->reg.vid & ATXP1_VIDMASK;
119 else
120 cvid = data->reg.cpu_vid;
121
122 /* Nothing changed, aborting */
123 if (vid == cvid)
124 return count;
125
126 dev_dbg(dev, "Setting VCore to %d mV (0x%02x)\n", (int)vcore, vid);
127
128 /* Write every 25 mV step to increase stability */
129 if (cvid > vid) {
130 for (; cvid >= vid; cvid--)
131 i2c_smbus_write_byte_data(client,
132 ATXP1_VID, cvid | ATXP1_VIDENA);
133 } else {
134 for (; cvid <= vid; cvid++)
135 i2c_smbus_write_byte_data(client,
136 ATXP1_VID, cvid | ATXP1_VIDENA);
137 }
138
139 data->valid = 0;
140
141 return count;
142 }
143
144 /*
145 * CPU core reference voltage
146 * unit: millivolt
147 */
148 static DEVICE_ATTR_RW(cpu0_vid);
149
150 /* sys file functions for GPIO1 */
gpio1_show(struct device * dev,struct device_attribute * attr,char * buf)151 static ssize_t gpio1_show(struct device *dev, struct device_attribute *attr,
152 char *buf)
153 {
154 int size;
155 struct atxp1_data *data;
156
157 data = atxp1_update_device(dev);
158
159 size = sprintf(buf, "0x%02x\n", data->reg.gpio1 & ATXP1_GPIO1MASK);
160
161 return size;
162 }
163
gpio1_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)164 static ssize_t gpio1_store(struct device *dev, struct device_attribute *attr,
165 const char *buf, size_t count)
166 {
167 struct atxp1_data *data = atxp1_update_device(dev);
168 struct i2c_client *client = data->client;
169 unsigned long value;
170 int err;
171
172 err = kstrtoul(buf, 16, &value);
173 if (err)
174 return err;
175
176 value &= ATXP1_GPIO1MASK;
177
178 if (value != (data->reg.gpio1 & ATXP1_GPIO1MASK)) {
179 dev_info(dev, "Writing 0x%x to GPIO1.\n", (unsigned int)value);
180
181 i2c_smbus_write_byte_data(client, ATXP1_GPIO1, value);
182
183 data->valid = 0;
184 }
185
186 return count;
187 }
188
189 /*
190 * GPIO1 data register
191 * unit: Four bit as hex (e.g. 0x0f)
192 */
193 static DEVICE_ATTR_RW(gpio1);
194
195 /* sys file functions for GPIO2 */
gpio2_show(struct device * dev,struct device_attribute * attr,char * buf)196 static ssize_t gpio2_show(struct device *dev, struct device_attribute *attr,
197 char *buf)
198 {
199 int size;
200 struct atxp1_data *data;
201
202 data = atxp1_update_device(dev);
203
204 size = sprintf(buf, "0x%02x\n", data->reg.gpio2);
205
206 return size;
207 }
208
gpio2_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)209 static ssize_t gpio2_store(struct device *dev, struct device_attribute *attr,
210 const char *buf, size_t count)
211 {
212 struct atxp1_data *data = atxp1_update_device(dev);
213 struct i2c_client *client = data->client;
214 unsigned long value;
215 int err;
216
217 err = kstrtoul(buf, 16, &value);
218 if (err)
219 return err;
220 value &= 0xff;
221
222 if (value != data->reg.gpio2) {
223 dev_info(dev, "Writing 0x%x to GPIO1.\n", (unsigned int)value);
224
225 i2c_smbus_write_byte_data(client, ATXP1_GPIO2, value);
226
227 data->valid = 0;
228 }
229
230 return count;
231 }
232
233 /*
234 * GPIO2 data register
235 * unit: Eight bit as hex (e.g. 0xff)
236 */
237 static DEVICE_ATTR_RW(gpio2);
238
239 static struct attribute *atxp1_attrs[] = {
240 &dev_attr_gpio1.attr,
241 &dev_attr_gpio2.attr,
242 &dev_attr_cpu0_vid.attr,
243 NULL
244 };
245 ATTRIBUTE_GROUPS(atxp1);
246
atxp1_probe(struct i2c_client * client)247 static int atxp1_probe(struct i2c_client *client)
248 {
249 struct device *dev = &client->dev;
250 struct atxp1_data *data;
251 struct device *hwmon_dev;
252
253 data = devm_kzalloc(dev, sizeof(struct atxp1_data), GFP_KERNEL);
254 if (!data)
255 return -ENOMEM;
256
257 /* Get VRM */
258 data->vrm = vid_which_vrm();
259 if (data->vrm != 90 && data->vrm != 91) {
260 dev_err(dev, "atxp1: Not supporting VRM %d.%d\n",
261 data->vrm / 10, data->vrm % 10);
262 return -ENODEV;
263 }
264
265 data->client = client;
266 mutex_init(&data->update_lock);
267
268 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
269 data,
270 atxp1_groups);
271 if (IS_ERR(hwmon_dev))
272 return PTR_ERR(hwmon_dev);
273
274 dev_info(dev, "Using VRM: %d.%d\n", data->vrm / 10, data->vrm % 10);
275
276 return 0;
277 };
278
279 static const struct i2c_device_id atxp1_id[] = {
280 { "atxp1", 0 },
281 { }
282 };
283 MODULE_DEVICE_TABLE(i2c, atxp1_id);
284
285 static struct i2c_driver atxp1_driver = {
286 .class = I2C_CLASS_HWMON,
287 .driver = {
288 .name = "atxp1",
289 },
290 .probe_new = atxp1_probe,
291 .id_table = atxp1_id,
292 };
293
294 module_i2c_driver(atxp1_driver);
295