drivers/misc/ics932s401.c

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