1 /* 2 * A driver for the Integrated Circuits ICS932S401 3 * Copyright (C) 2008 IBM 4 * 5 * Author: Darrick J. Wong <darrick.wong@oracle.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21 22 #include <linux/module.h> 23 #include <linux/jiffies.h> 24 #include <linux/i2c.h> 25 #include <linux/err.h> 26 #include <linux/mutex.h> 27 #include <linux/delay.h> 28 #include <linux/log2.h> 29 #include <linux/slab.h> 30 31 /* Addresses to scan */ 32 static const unsigned short normal_i2c[] = { 0x69, I2C_CLIENT_END }; 33 34 /* ICS932S401 registers */ 35 #define ICS932S401_REG_CFG2 0x01 36 #define ICS932S401_CFG1_SPREAD 0x01 37 #define ICS932S401_REG_CFG7 0x06 38 #define ICS932S401_FS_MASK 0x07 39 #define ICS932S401_REG_VENDOR_REV 0x07 40 #define ICS932S401_VENDOR 1 41 #define ICS932S401_VENDOR_MASK 0x0F 42 #define ICS932S401_REV 4 43 #define ICS932S401_REV_SHIFT 4 44 #define ICS932S401_REG_DEVICE 0x09 45 #define ICS932S401_DEVICE 11 46 #define ICS932S401_REG_CTRL 0x0A 47 #define ICS932S401_MN_ENABLED 0x80 48 #define ICS932S401_CPU_ALT 0x04 49 #define ICS932S401_SRC_ALT 0x08 50 #define ICS932S401_REG_CPU_M_CTRL 0x0B 51 #define ICS932S401_M_MASK 0x3F 52 #define ICS932S401_REG_CPU_N_CTRL 0x0C 53 #define ICS932S401_REG_CPU_SPREAD1 0x0D 54 #define ICS932S401_REG_CPU_SPREAD2 0x0E 55 #define ICS932S401_SPREAD_MASK 0x7FFF 56 #define ICS932S401_REG_SRC_M_CTRL 0x0F 57 #define ICS932S401_REG_SRC_N_CTRL 0x10 58 #define ICS932S401_REG_SRC_SPREAD1 0x11 59 #define ICS932S401_REG_SRC_SPREAD2 0x12 60 #define ICS932S401_REG_CPU_DIVISOR 0x13 61 #define ICS932S401_CPU_DIVISOR_SHIFT 4 62 #define ICS932S401_REG_PCISRC_DIVISOR 0x14 63 #define ICS932S401_SRC_DIVISOR_MASK 0x0F 64 #define ICS932S401_PCI_DIVISOR_SHIFT 4 65 66 /* Base clock is 14.318MHz */ 67 #define BASE_CLOCK 14318 68 69 #define NUM_REGS 21 70 #define NUM_MIRRORED_REGS 15 71 72 static int regs_to_copy[NUM_MIRRORED_REGS] = { 73 ICS932S401_REG_CFG2, 74 ICS932S401_REG_CFG7, 75 ICS932S401_REG_VENDOR_REV, 76 ICS932S401_REG_DEVICE, 77 ICS932S401_REG_CTRL, 78 ICS932S401_REG_CPU_M_CTRL, 79 ICS932S401_REG_CPU_N_CTRL, 80 ICS932S401_REG_CPU_SPREAD1, 81 ICS932S401_REG_CPU_SPREAD2, 82 ICS932S401_REG_SRC_M_CTRL, 83 ICS932S401_REG_SRC_N_CTRL, 84 ICS932S401_REG_SRC_SPREAD1, 85 ICS932S401_REG_SRC_SPREAD2, 86 ICS932S401_REG_CPU_DIVISOR, 87 ICS932S401_REG_PCISRC_DIVISOR, 88 }; 89 90 /* How often do we reread sensors values? (In jiffies) */ 91 #define SENSOR_REFRESH_INTERVAL (2 * HZ) 92 93 /* How often do we reread sensor limit values? (In jiffies) */ 94 #define LIMIT_REFRESH_INTERVAL (60 * HZ) 95 96 struct ics932s401_data { 97 struct attribute_group attrs; 98 struct mutex lock; 99 char sensors_valid; 100 unsigned long sensors_last_updated; /* In jiffies */ 101 102 u8 regs[NUM_REGS]; 103 }; 104 105 static int ics932s401_probe(struct i2c_client *client, 106 const struct i2c_device_id *id); 107 static int ics932s401_detect(struct i2c_client *client, 108 struct i2c_board_info *info); 109 static int ics932s401_remove(struct i2c_client *client); 110 111 static const struct i2c_device_id ics932s401_id[] = { 112 { "ics932s401", 0 }, 113 { } 114 }; 115 MODULE_DEVICE_TABLE(i2c, ics932s401_id); 116 117 static struct i2c_driver ics932s401_driver = { 118 .class = I2C_CLASS_HWMON, 119 .driver = { 120 .name = "ics932s401", 121 }, 122 .probe = ics932s401_probe, 123 .remove = ics932s401_remove, 124 .id_table = ics932s401_id, 125 .detect = ics932s401_detect, 126 .address_list = normal_i2c, 127 }; 128 129 static struct ics932s401_data *ics932s401_update_device(struct device *dev) 130 { 131 struct i2c_client *client = to_i2c_client(dev); 132 struct ics932s401_data *data = i2c_get_clientdata(client); 133 unsigned long local_jiffies = jiffies; 134 int i, temp; 135 136 mutex_lock(&data->lock); 137 if (time_before(local_jiffies, data->sensors_last_updated + 138 SENSOR_REFRESH_INTERVAL) 139 && data->sensors_valid) 140 goto out; 141 142 /* 143 * Each register must be read as a word and then right shifted 8 bits. 144 * Not really sure why this is; setting the "byte count programming" 145 * register to 1 does not fix this problem. 146 */ 147 for (i = 0; i < NUM_MIRRORED_REGS; i++) { 148 temp = i2c_smbus_read_word_data(client, regs_to_copy[i]); 149 data->regs[regs_to_copy[i]] = temp >> 8; 150 } 151 152 data->sensors_last_updated = local_jiffies; 153 data->sensors_valid = 1; 154 155 out: 156 mutex_unlock(&data->lock); 157 return data; 158 } 159 160 static ssize_t show_spread_enabled(struct device *dev, 161 struct device_attribute *devattr, 162 char *buf) 163 { 164 struct ics932s401_data *data = ics932s401_update_device(dev); 165 166 if (data->regs[ICS932S401_REG_CFG2] & ICS932S401_CFG1_SPREAD) 167 return sprintf(buf, "1\n"); 168 169 return sprintf(buf, "0\n"); 170 } 171 172 /* bit to cpu khz map */ 173 static const int fs_speeds[] = { 174 266666, 175 133333, 176 200000, 177 166666, 178 333333, 179 100000, 180 400000, 181 0, 182 }; 183 184 /* clock divisor map */ 185 static const int divisors[] = {2, 3, 5, 15, 4, 6, 10, 30, 8, 12, 20, 60, 16, 186 24, 40, 120}; 187 188 /* Calculate CPU frequency from the M/N registers. */ 189 static int calculate_cpu_freq(struct ics932s401_data *data) 190 { 191 int m, n, freq; 192 193 m = data->regs[ICS932S401_REG_CPU_M_CTRL] & ICS932S401_M_MASK; 194 n = data->regs[ICS932S401_REG_CPU_N_CTRL]; 195 196 /* Pull in bits 8 & 9 from the M register */ 197 n |= ((int)data->regs[ICS932S401_REG_CPU_M_CTRL] & 0x80) << 1; 198 n |= ((int)data->regs[ICS932S401_REG_CPU_M_CTRL] & 0x40) << 3; 199 200 freq = BASE_CLOCK * (n + 8) / (m + 2); 201 freq /= divisors[data->regs[ICS932S401_REG_CPU_DIVISOR] >> 202 ICS932S401_CPU_DIVISOR_SHIFT]; 203 204 return freq; 205 } 206 207 static ssize_t show_cpu_clock(struct device *dev, 208 struct device_attribute *devattr, 209 char *buf) 210 { 211 struct ics932s401_data *data = ics932s401_update_device(dev); 212 213 return sprintf(buf, "%d\n", calculate_cpu_freq(data)); 214 } 215 216 static ssize_t show_cpu_clock_sel(struct device *dev, 217 struct device_attribute *devattr, 218 char *buf) 219 { 220 struct ics932s401_data *data = ics932s401_update_device(dev); 221 int freq; 222 223 if (data->regs[ICS932S401_REG_CTRL] & ICS932S401_MN_ENABLED) 224 freq = calculate_cpu_freq(data); 225 else { 226 /* Freq is neatly wrapped up for us */ 227 int fid = data->regs[ICS932S401_REG_CFG7] & ICS932S401_FS_MASK; 228 freq = fs_speeds[fid]; 229 if (data->regs[ICS932S401_REG_CTRL] & ICS932S401_CPU_ALT) { 230 switch (freq) { 231 case 166666: 232 freq = 160000; 233 break; 234 case 333333: 235 freq = 320000; 236 break; 237 } 238 } 239 } 240 241 return sprintf(buf, "%d\n", freq); 242 } 243 244 /* Calculate SRC frequency from the M/N registers. */ 245 static int calculate_src_freq(struct ics932s401_data *data) 246 { 247 int m, n, freq; 248 249 m = data->regs[ICS932S401_REG_SRC_M_CTRL] & ICS932S401_M_MASK; 250 n = data->regs[ICS932S401_REG_SRC_N_CTRL]; 251 252 /* Pull in bits 8 & 9 from the M register */ 253 n |= ((int)data->regs[ICS932S401_REG_SRC_M_CTRL] & 0x80) << 1; 254 n |= ((int)data->regs[ICS932S401_REG_SRC_M_CTRL] & 0x40) << 3; 255 256 freq = BASE_CLOCK * (n + 8) / (m + 2); 257 freq /= divisors[data->regs[ICS932S401_REG_PCISRC_DIVISOR] & 258 ICS932S401_SRC_DIVISOR_MASK]; 259 260 return freq; 261 } 262 263 static ssize_t show_src_clock(struct device *dev, 264 struct device_attribute *devattr, 265 char *buf) 266 { 267 struct ics932s401_data *data = ics932s401_update_device(dev); 268 269 return sprintf(buf, "%d\n", calculate_src_freq(data)); 270 } 271 272 static ssize_t show_src_clock_sel(struct device *dev, 273 struct device_attribute *devattr, 274 char *buf) 275 { 276 struct ics932s401_data *data = ics932s401_update_device(dev); 277 int freq; 278 279 if (data->regs[ICS932S401_REG_CTRL] & ICS932S401_MN_ENABLED) 280 freq = calculate_src_freq(data); 281 else 282 /* Freq is neatly wrapped up for us */ 283 if (data->regs[ICS932S401_REG_CTRL] & ICS932S401_CPU_ALT && 284 data->regs[ICS932S401_REG_CTRL] & ICS932S401_SRC_ALT) 285 freq = 96000; 286 else 287 freq = 100000; 288 289 return sprintf(buf, "%d\n", freq); 290 } 291 292 /* Calculate PCI frequency from the SRC M/N registers. */ 293 static int calculate_pci_freq(struct ics932s401_data *data) 294 { 295 int m, n, freq; 296 297 m = data->regs[ICS932S401_REG_SRC_M_CTRL] & ICS932S401_M_MASK; 298 n = data->regs[ICS932S401_REG_SRC_N_CTRL]; 299 300 /* Pull in bits 8 & 9 from the M register */ 301 n |= ((int)data->regs[ICS932S401_REG_SRC_M_CTRL] & 0x80) << 1; 302 n |= ((int)data->regs[ICS932S401_REG_SRC_M_CTRL] & 0x40) << 3; 303 304 freq = BASE_CLOCK * (n + 8) / (m + 2); 305 freq /= divisors[data->regs[ICS932S401_REG_PCISRC_DIVISOR] >> 306 ICS932S401_PCI_DIVISOR_SHIFT]; 307 308 return freq; 309 } 310 311 static ssize_t show_pci_clock(struct device *dev, 312 struct device_attribute *devattr, 313 char *buf) 314 { 315 struct ics932s401_data *data = ics932s401_update_device(dev); 316 317 return sprintf(buf, "%d\n", calculate_pci_freq(data)); 318 } 319 320 static ssize_t show_pci_clock_sel(struct device *dev, 321 struct device_attribute *devattr, 322 char *buf) 323 { 324 struct ics932s401_data *data = ics932s401_update_device(dev); 325 int freq; 326 327 if (data->regs[ICS932S401_REG_CTRL] & ICS932S401_MN_ENABLED) 328 freq = calculate_pci_freq(data); 329 else 330 freq = 33333; 331 332 return sprintf(buf, "%d\n", freq); 333 } 334 335 static ssize_t show_value(struct device *dev, 336 struct device_attribute *devattr, 337 char *buf); 338 339 static ssize_t show_spread(struct device *dev, 340 struct device_attribute *devattr, 341 char *buf); 342 343 static DEVICE_ATTR(spread_enabled, S_IRUGO, show_spread_enabled, NULL); 344 static DEVICE_ATTR(cpu_clock_selection, S_IRUGO, show_cpu_clock_sel, NULL); 345 static DEVICE_ATTR(cpu_clock, S_IRUGO, show_cpu_clock, NULL); 346 static DEVICE_ATTR(src_clock_selection, S_IRUGO, show_src_clock_sel, NULL); 347 static DEVICE_ATTR(src_clock, S_IRUGO, show_src_clock, NULL); 348 static DEVICE_ATTR(pci_clock_selection, S_IRUGO, show_pci_clock_sel, NULL); 349 static DEVICE_ATTR(pci_clock, S_IRUGO, show_pci_clock, NULL); 350 static DEVICE_ATTR(usb_clock, S_IRUGO, show_value, NULL); 351 static DEVICE_ATTR(ref_clock, S_IRUGO, show_value, NULL); 352 static DEVICE_ATTR(cpu_spread, S_IRUGO, show_spread, NULL); 353 static DEVICE_ATTR(src_spread, S_IRUGO, show_spread, NULL); 354 355 static struct attribute *ics932s401_attr[] = 356 { 357 &dev_attr_spread_enabled.attr, 358 &dev_attr_cpu_clock_selection.attr, 359 &dev_attr_cpu_clock.attr, 360 &dev_attr_src_clock_selection.attr, 361 &dev_attr_src_clock.attr, 362 &dev_attr_pci_clock_selection.attr, 363 &dev_attr_pci_clock.attr, 364 &dev_attr_usb_clock.attr, 365 &dev_attr_ref_clock.attr, 366 &dev_attr_cpu_spread.attr, 367 &dev_attr_src_spread.attr, 368 NULL 369 }; 370 371 static ssize_t show_value(struct device *dev, 372 struct device_attribute *devattr, 373 char *buf) 374 { 375 int x; 376 377 if (devattr == &dev_attr_usb_clock) 378 x = 48000; 379 else if (devattr == &dev_attr_ref_clock) 380 x = BASE_CLOCK; 381 else 382 BUG(); 383 384 return sprintf(buf, "%d\n", x); 385 } 386 387 static ssize_t show_spread(struct device *dev, 388 struct device_attribute *devattr, 389 char *buf) 390 { 391 struct ics932s401_data *data = ics932s401_update_device(dev); 392 int reg; 393 unsigned long val; 394 395 if (!(data->regs[ICS932S401_REG_CFG2] & ICS932S401_CFG1_SPREAD)) 396 return sprintf(buf, "0%%\n"); 397 398 if (devattr == &dev_attr_src_spread) 399 reg = ICS932S401_REG_SRC_SPREAD1; 400 else if (devattr == &dev_attr_cpu_spread) 401 reg = ICS932S401_REG_CPU_SPREAD1; 402 else 403 BUG(); 404 405 val = data->regs[reg] | (data->regs[reg + 1] << 8); 406 val &= ICS932S401_SPREAD_MASK; 407 408 /* Scale 0..2^14 to -0.5. */ 409 val = 500000 * val / 16384; 410 return sprintf(buf, "-0.%lu%%\n", val); 411 } 412 413 /* Return 0 if detection is successful, -ENODEV otherwise */ 414 static int ics932s401_detect(struct i2c_client *client, 415 struct i2c_board_info *info) 416 { 417 struct i2c_adapter *adapter = client->adapter; 418 int vendor, device, revision; 419 420 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 421 return -ENODEV; 422 423 vendor = i2c_smbus_read_word_data(client, ICS932S401_REG_VENDOR_REV); 424 vendor >>= 8; 425 revision = vendor >> ICS932S401_REV_SHIFT; 426 vendor &= ICS932S401_VENDOR_MASK; 427 if (vendor != ICS932S401_VENDOR) 428 return -ENODEV; 429 430 device = i2c_smbus_read_word_data(client, ICS932S401_REG_DEVICE); 431 device >>= 8; 432 if (device != ICS932S401_DEVICE) 433 return -ENODEV; 434 435 if (revision != ICS932S401_REV) 436 dev_info(&adapter->dev, "Unknown revision %d\n", revision); 437 438 strlcpy(info->type, "ics932s401", I2C_NAME_SIZE); 439 440 return 0; 441 } 442 443 static int ics932s401_probe(struct i2c_client *client, 444 const struct i2c_device_id *id) 445 { 446 struct ics932s401_data *data; 447 int err; 448 449 data = kzalloc(sizeof(struct ics932s401_data), GFP_KERNEL); 450 if (!data) { 451 err = -ENOMEM; 452 goto exit; 453 } 454 455 i2c_set_clientdata(client, data); 456 mutex_init(&data->lock); 457 458 dev_info(&client->dev, "%s chip found\n", client->name); 459 460 /* Register sysfs hooks */ 461 data->attrs.attrs = ics932s401_attr; 462 err = sysfs_create_group(&client->dev.kobj, &data->attrs); 463 if (err) 464 goto exit_free; 465 466 return 0; 467 468 exit_free: 469 kfree(data); 470 exit: 471 return err; 472 } 473 474 static int ics932s401_remove(struct i2c_client *client) 475 { 476 struct ics932s401_data *data = i2c_get_clientdata(client); 477 478 sysfs_remove_group(&client->dev.kobj, &data->attrs); 479 kfree(data); 480 return 0; 481 } 482 483 module_i2c_driver(ics932s401_driver); 484 485 MODULE_AUTHOR("Darrick J. Wong <darrick.wong@oracle.com>"); 486 MODULE_DESCRIPTION("ICS932S401 driver"); 487 MODULE_LICENSE("GPL"); 488 489 /* IBM IntelliStation Z30 */ 490 MODULE_ALIAS("dmi:bvnIBM:*:rn9228:*"); 491 MODULE_ALIAS("dmi:bvnIBM:*:rn9232:*"); 492 493 /* IBM x3650/x3550 */ 494 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3650*"); 495 MODULE_ALIAS("dmi:bvnIBM:*:pnIBMSystemx3550*"); 496