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