xref: /openbmc/linux/drivers/hwmon/atxp1.c (revision 9d56dd3b083a3bec56e9da35ce07baca81030b03)
1 /*
2     atxp1.c - kernel module for setting CPU VID and general purpose
3                      I/Os using the Attansic ATXP1 chip.
4 
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.
9 
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.
14 
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.
18 
19 */
20 
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 
32 MODULE_LICENSE("GPL");
33 MODULE_DESCRIPTION("System voltages control via Attansic ATXP1");
34 MODULE_VERSION("0.6.3");
35 MODULE_AUTHOR("Sebastian Witt <se.witt@gmx.net>");
36 
37 #define ATXP1_VID	0x00
38 #define ATXP1_CVID	0x01
39 #define ATXP1_GPIO1	0x06
40 #define ATXP1_GPIO2	0x0a
41 #define ATXP1_VIDENA	0x20
42 #define ATXP1_VIDMASK	0x1f
43 #define ATXP1_GPIO1MASK	0x0f
44 
45 static const unsigned short normal_i2c[] = { 0x37, 0x4e, I2C_CLIENT_END };
46 
47 static int atxp1_probe(struct i2c_client *client,
48 		       const struct i2c_device_id *id);
49 static int atxp1_remove(struct i2c_client *client);
50 static struct atxp1_data * atxp1_update_device(struct device *dev);
51 static int atxp1_detect(struct i2c_client *client, struct i2c_board_info *info);
52 
53 static const struct i2c_device_id atxp1_id[] = {
54 	{ "atxp1", 0 },
55 	{ }
56 };
57 MODULE_DEVICE_TABLE(i2c, atxp1_id);
58 
59 static struct i2c_driver atxp1_driver = {
60 	.class		= I2C_CLASS_HWMON,
61 	.driver = {
62 		.name	= "atxp1",
63 	},
64 	.probe		= atxp1_probe,
65 	.remove		= atxp1_remove,
66 	.id_table	= atxp1_id,
67 	.detect		= atxp1_detect,
68 	.address_list	= normal_i2c,
69 };
70 
71 struct atxp1_data {
72 	struct device *hwmon_dev;
73 	struct mutex update_lock;
74 	unsigned long last_updated;
75 	u8 valid;
76 	struct {
77 		u8 vid;		/* VID output register */
78 		u8 cpu_vid; /* VID input from CPU */
79 		u8 gpio1;   /* General purpose I/O register 1 */
80 		u8 gpio2;   /* General purpose I/O register 2 */
81 	} reg;
82 	u8 vrm;			/* Detected CPU VRM */
83 };
84 
85 static struct atxp1_data * atxp1_update_device(struct device *dev)
86 {
87 	struct i2c_client *client;
88 	struct atxp1_data *data;
89 
90 	client = to_i2c_client(dev);
91 	data = i2c_get_clientdata(client);
92 
93 	mutex_lock(&data->update_lock);
94 
95 	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
96 
97 		/* Update local register data */
98 		data->reg.vid = i2c_smbus_read_byte_data(client, ATXP1_VID);
99 		data->reg.cpu_vid = i2c_smbus_read_byte_data(client, ATXP1_CVID);
100 		data->reg.gpio1 = i2c_smbus_read_byte_data(client, ATXP1_GPIO1);
101 		data->reg.gpio2 = i2c_smbus_read_byte_data(client, ATXP1_GPIO2);
102 
103 		data->valid = 1;
104 	}
105 
106 	mutex_unlock(&data->update_lock);
107 
108 	return(data);
109 }
110 
111 /* sys file functions for cpu0_vid */
112 static ssize_t atxp1_showvcore(struct device *dev, struct device_attribute *attr, char *buf)
113 {
114 	int size;
115 	struct atxp1_data *data;
116 
117 	data = atxp1_update_device(dev);
118 
119 	size = sprintf(buf, "%d\n", vid_from_reg(data->reg.vid & ATXP1_VIDMASK, data->vrm));
120 
121 	return size;
122 }
123 
124 static ssize_t atxp1_storevcore(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
125 {
126 	struct atxp1_data *data;
127 	struct i2c_client *client;
128 	int vid, cvid;
129 	unsigned int vcore;
130 
131 	client = to_i2c_client(dev);
132 	data = atxp1_update_device(dev);
133 
134 	vcore = simple_strtoul(buf, NULL, 10);
135 	vcore /= 25;
136 	vcore *= 25;
137 
138 	/* Calculate VID */
139 	vid = vid_to_reg(vcore, data->vrm);
140 
141 	if (vid < 0) {
142 		dev_err(dev, "VID calculation failed.\n");
143 		return -1;
144 	}
145 
146 	/* If output enabled, use control register value. Otherwise original CPU VID */
147 	if (data->reg.vid & ATXP1_VIDENA)
148 		cvid = data->reg.vid & ATXP1_VIDMASK;
149 	else
150 		cvid = data->reg.cpu_vid;
151 
152 	/* Nothing changed, aborting */
153 	if (vid == cvid)
154 		return count;
155 
156 	dev_dbg(dev, "Setting VCore to %d mV (0x%02x)\n", vcore, vid);
157 
158 	/* Write every 25 mV step to increase stability */
159 	if (cvid > vid) {
160 		for (; cvid >= vid; cvid--) {
161         		i2c_smbus_write_byte_data(client, ATXP1_VID, cvid | ATXP1_VIDENA);
162 		}
163 	}
164 	else {
165 		for (; cvid <= vid; cvid++) {
166         		i2c_smbus_write_byte_data(client, ATXP1_VID, cvid | ATXP1_VIDENA);
167 		}
168 	}
169 
170 	data->valid = 0;
171 
172 	return count;
173 }
174 
175 /* CPU core reference voltage
176     unit: millivolt
177 */
178 static DEVICE_ATTR(cpu0_vid, S_IRUGO | S_IWUSR, atxp1_showvcore, atxp1_storevcore);
179 
180 /* sys file functions for GPIO1 */
181 static ssize_t atxp1_showgpio1(struct device *dev, struct device_attribute *attr, char *buf)
182 {
183 	int size;
184 	struct atxp1_data *data;
185 
186 	data = atxp1_update_device(dev);
187 
188 	size = sprintf(buf, "0x%02x\n", data->reg.gpio1 & ATXP1_GPIO1MASK);
189 
190 	return size;
191 }
192 
193 static ssize_t atxp1_storegpio1(struct device *dev, struct device_attribute *attr, const char*buf, size_t count)
194 {
195 	struct atxp1_data *data;
196 	struct i2c_client *client;
197 	unsigned int value;
198 
199 	client = to_i2c_client(dev);
200 	data = atxp1_update_device(dev);
201 
202 	value = simple_strtoul(buf, NULL, 16);
203 
204 	value &= ATXP1_GPIO1MASK;
205 
206 	if (value != (data->reg.gpio1 & ATXP1_GPIO1MASK)) {
207 		dev_info(dev, "Writing 0x%x to GPIO1.\n", value);
208 
209 		i2c_smbus_write_byte_data(client, ATXP1_GPIO1, value);
210 
211 		data->valid = 0;
212 	}
213 
214 	return count;
215 }
216 
217 /* GPIO1 data register
218     unit: Four bit as hex (e.g. 0x0f)
219 */
220 static DEVICE_ATTR(gpio1, S_IRUGO | S_IWUSR, atxp1_showgpio1, atxp1_storegpio1);
221 
222 /* sys file functions for GPIO2 */
223 static ssize_t atxp1_showgpio2(struct device *dev, struct device_attribute *attr, char *buf)
224 {
225 	int size;
226 	struct atxp1_data *data;
227 
228 	data = atxp1_update_device(dev);
229 
230 	size = sprintf(buf, "0x%02x\n", data->reg.gpio2);
231 
232 	return size;
233 }
234 
235 static ssize_t atxp1_storegpio2(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
236 {
237 	struct atxp1_data *data;
238 	struct i2c_client *client;
239 	unsigned int value;
240 
241 	client = to_i2c_client(dev);
242 	data = atxp1_update_device(dev);
243 
244 	value = simple_strtoul(buf, NULL, 16) & 0xff;
245 
246 	if (value != data->reg.gpio2) {
247 		dev_info(dev, "Writing 0x%x to GPIO1.\n", value);
248 
249 		i2c_smbus_write_byte_data(client, ATXP1_GPIO2, value);
250 
251 		data->valid = 0;
252 	}
253 
254 	return count;
255 }
256 
257 /* GPIO2 data register
258     unit: Eight bit as hex (e.g. 0xff)
259 */
260 static DEVICE_ATTR(gpio2, S_IRUGO | S_IWUSR, atxp1_showgpio2, atxp1_storegpio2);
261 
262 static struct attribute *atxp1_attributes[] = {
263 	&dev_attr_gpio1.attr,
264 	&dev_attr_gpio2.attr,
265 	&dev_attr_cpu0_vid.attr,
266 	NULL
267 };
268 
269 static const struct attribute_group atxp1_group = {
270 	.attrs = atxp1_attributes,
271 };
272 
273 
274 /* Return 0 if detection is successful, -ENODEV otherwise */
275 static int atxp1_detect(struct i2c_client *new_client,
276 			struct i2c_board_info *info)
277 {
278 	struct i2c_adapter *adapter = new_client->adapter;
279 
280 	u8 temp;
281 
282 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
283 		return -ENODEV;
284 
285 	/* Detect ATXP1, checking if vendor ID registers are all zero */
286 	if (!((i2c_smbus_read_byte_data(new_client, 0x3e) == 0) &&
287 	     (i2c_smbus_read_byte_data(new_client, 0x3f) == 0) &&
288 	     (i2c_smbus_read_byte_data(new_client, 0xfe) == 0) &&
289 	     (i2c_smbus_read_byte_data(new_client, 0xff) == 0)))
290 		return -ENODEV;
291 
292 	/* No vendor ID, now checking if registers 0x10,0x11 (non-existent)
293 	 * showing the same as register 0x00 */
294 	temp = i2c_smbus_read_byte_data(new_client, 0x00);
295 
296 	if (!((i2c_smbus_read_byte_data(new_client, 0x10) == temp) &&
297 	      (i2c_smbus_read_byte_data(new_client, 0x11) == temp)))
298 		return -ENODEV;
299 
300 	/* Get VRM */
301 	temp = vid_which_vrm();
302 
303 	if ((temp != 90) && (temp != 91)) {
304 		dev_err(&adapter->dev, "atxp1: Not supporting VRM %d.%d\n",
305 				temp / 10, temp % 10);
306 		return -ENODEV;
307 	}
308 
309 	strlcpy(info->type, "atxp1", I2C_NAME_SIZE);
310 
311 	return 0;
312 }
313 
314 static int atxp1_probe(struct i2c_client *new_client,
315 		       const struct i2c_device_id *id)
316 {
317 	struct atxp1_data *data;
318 	int err;
319 
320 	data = kzalloc(sizeof(struct atxp1_data), GFP_KERNEL);
321 	if (!data) {
322 		err = -ENOMEM;
323 		goto exit;
324 	}
325 
326 	/* Get VRM */
327 	data->vrm = vid_which_vrm();
328 
329 	i2c_set_clientdata(new_client, data);
330 	data->valid = 0;
331 
332 	mutex_init(&data->update_lock);
333 
334 	/* Register sysfs hooks */
335 	if ((err = sysfs_create_group(&new_client->dev.kobj, &atxp1_group)))
336 		goto exit_free;
337 
338 	data->hwmon_dev = hwmon_device_register(&new_client->dev);
339 	if (IS_ERR(data->hwmon_dev)) {
340 		err = PTR_ERR(data->hwmon_dev);
341 		goto exit_remove_files;
342 	}
343 
344 	dev_info(&new_client->dev, "Using VRM: %d.%d\n",
345 			 data->vrm / 10, data->vrm % 10);
346 
347 	return 0;
348 
349 exit_remove_files:
350 	sysfs_remove_group(&new_client->dev.kobj, &atxp1_group);
351 exit_free:
352 	kfree(data);
353 exit:
354 	return err;
355 };
356 
357 static int atxp1_remove(struct i2c_client *client)
358 {
359 	struct atxp1_data * data = i2c_get_clientdata(client);
360 
361 	hwmon_device_unregister(data->hwmon_dev);
362 	sysfs_remove_group(&client->dev.kobj, &atxp1_group);
363 
364 	kfree(data);
365 
366 	return 0;
367 };
368 
369 static int __init atxp1_init(void)
370 {
371 	return i2c_add_driver(&atxp1_driver);
372 };
373 
374 static void __exit atxp1_exit(void)
375 {
376 	i2c_del_driver(&atxp1_driver);
377 };
378 
379 module_init(atxp1_init);
380 module_exit(atxp1_exit);
381