drivers/hwmon/atxp1.c

   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
  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 */
  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
  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 */
 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
 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 */
 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
 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
 247 static int atxp1_probe(struct i2c_client *client,
 248                        const struct i2c_device_id *id)
 249 {
 250         struct device *dev = &client->dev;
 251         struct atxp1_data *data;
 252         struct device *hwmon_dev;
 253
 254         data = devm_kzalloc(dev, sizeof(struct atxp1_data), GFP_KERNEL);
 255         if (!data)
 256                 return -ENOMEM;
 257
 258         /* Get VRM */
 259         data->vrm = vid_which_vrm();
 260         if (data->vrm != 90 && data->vrm != 91) {
 261                 dev_err(dev, "atxp1: Not supporting VRM %d.%d\n",
 262                         data->vrm / 10, data->vrm % 10);
 263                 return -ENODEV;
 264         }
 265
 266         data->client = client;
 267         mutex_init(&data->update_lock);
 268
 269         hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
 270                                                            data,
 271                                                            atxp1_groups);
 272         if (IS_ERR(hwmon_dev))
 273                 return PTR_ERR(hwmon_dev);
 274
 275         dev_info(dev, "Using VRM: %d.%d\n", data->vrm / 10, data->vrm % 10);
 276
 277         return 0;
 278 };
 279
 280 static const struct i2c_device_id atxp1_id[] = {
 281         { "atxp1", 0 },
 282         { }
 283 };
 284 MODULE_DEVICE_TABLE(i2c, atxp1_id);
 285
 286 static struct i2c_driver atxp1_driver = {
 287         .class          = I2C_CLASS_HWMON,
 288         .driver = {
 289                 .name   = "atxp1",
 290         },
 291         .probe          = atxp1_probe,
 292         .id_table       = atxp1_id,
 293 };
 294
 295 module_i2c_driver(atxp1_driver);