drivers/powercap/intel_rapl_tpmi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * intel_rapl_tpmi: Intel RAPL driver via TPMI interface
   4  *
   5  * Copyright (c) 2023, Intel Corporation.
   6  * All Rights Reserved.
   7  *
   8  */
   9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11 #include <linux/auxiliary_bus.h>
  12 #include <linux/io.h>
  13 #include <linux/intel_tpmi.h>
  14 #include <linux/intel_rapl.h>
  15 #include <linux/module.h>
  16 #include <linux/slab.h>
  17
  18 #define TPMI_RAPL_VERSION 1
  19
  20 /* 1 header + 10 registers + 5 reserved. 8 bytes for each. */
  21 #define TPMI_RAPL_DOMAIN_SIZE 128
  22
  23 enum tpmi_rapl_domain_type {
  24         TPMI_RAPL_DOMAIN_INVALID,
  25         TPMI_RAPL_DOMAIN_SYSTEM,
  26         TPMI_RAPL_DOMAIN_PACKAGE,
  27         TPMI_RAPL_DOMAIN_RESERVED,
  28         TPMI_RAPL_DOMAIN_MEMORY,
  29         TPMI_RAPL_DOMAIN_MAX,
  30 };
  31
  32 enum tpmi_rapl_register {
  33         TPMI_RAPL_REG_HEADER,
  34         TPMI_RAPL_REG_UNIT,
  35         TPMI_RAPL_REG_PL1,
  36         TPMI_RAPL_REG_PL2,
  37         TPMI_RAPL_REG_PL3,
  38         TPMI_RAPL_REG_PL4,
  39         TPMI_RAPL_REG_RESERVED,
  40         TPMI_RAPL_REG_ENERGY_STATUS,
  41         TPMI_RAPL_REG_PERF_STATUS,
  42         TPMI_RAPL_REG_POWER_INFO,
  43         TPMI_RAPL_REG_DOMAIN_INFO,
  44         TPMI_RAPL_REG_INTERRUPT,
  45         TPMI_RAPL_REG_MAX = 15,
  46 };
  47
  48 struct tpmi_rapl_package {
  49         struct rapl_if_priv priv;
  50         struct intel_tpmi_plat_info *tpmi_info;
  51         struct rapl_package *rp;
  52         void __iomem *base;
  53         struct list_head node;
  54 };
  55
  56 static LIST_HEAD(tpmi_rapl_packages);
  57 static DEFINE_MUTEX(tpmi_rapl_lock);
  58
  59 static struct powercap_control_type *tpmi_control_type;
  60
  61 static int tpmi_rapl_read_raw(int id, struct reg_action *ra)
  62 {
  63         if (!ra->reg.mmio)
  64                 return -EINVAL;
  65
  66         ra->value = readq(ra->reg.mmio);
  67
  68         ra->value &= ra->mask;
  69         return 0;
  70 }
  71
  72 static int tpmi_rapl_write_raw(int id, struct reg_action *ra)
  73 {
  74         u64 val;
  75
  76         if (!ra->reg.mmio)
  77                 return -EINVAL;
  78
  79         val = readq(ra->reg.mmio);
  80
  81         val &= ~ra->mask;
  82         val |= ra->value;
  83
  84         writeq(val, ra->reg.mmio);
  85         return 0;
  86 }
  87
  88 static struct tpmi_rapl_package *trp_alloc(int pkg_id)
  89 {
  90         struct tpmi_rapl_package *trp;
  91         int ret;
  92
  93         mutex_lock(&tpmi_rapl_lock);
  94
  95         if (list_empty(&tpmi_rapl_packages)) {
  96                 tpmi_control_type = powercap_register_control_type(NULL, "intel-rapl", NULL);
  97                 if (IS_ERR(tpmi_control_type)) {
  98                         ret = PTR_ERR(tpmi_control_type);
  99                         goto err_unlock;
 100                 }
 101         }
 102
 103         trp = kzalloc(sizeof(*trp), GFP_KERNEL);
 104         if (!trp) {
 105                 ret = -ENOMEM;
 106                 goto err_del_powercap;
 107         }
 108
 109         list_add(&trp->node, &tpmi_rapl_packages);
 110
 111         mutex_unlock(&tpmi_rapl_lock);
 112         return trp;
 113
 114 err_del_powercap:
 115         if (list_empty(&tpmi_rapl_packages))
 116                 powercap_unregister_control_type(tpmi_control_type);
 117 err_unlock:
 118         mutex_unlock(&tpmi_rapl_lock);
 119         return ERR_PTR(ret);
 120 }
 121
 122 static void trp_release(struct tpmi_rapl_package *trp)
 123 {
 124         mutex_lock(&tpmi_rapl_lock);
 125         list_del(&trp->node);
 126
 127         if (list_empty(&tpmi_rapl_packages))
 128                 powercap_unregister_control_type(tpmi_control_type);
 129
 130         kfree(trp);
 131         mutex_unlock(&tpmi_rapl_lock);
 132 }
 133
 134 /*
 135  * Bit 0 of TPMI_RAPL_REG_DOMAIN_INFO indicates if the current package is a domain
 136  * root or not. Only domain root packages can enumerate System (Psys) Domain.
 137  */
 138 #define TPMI_RAPL_DOMAIN_ROOT   BIT(0)
 139
 140 static int parse_one_domain(struct tpmi_rapl_package *trp, u32 offset)
 141 {
 142         u8 tpmi_domain_version;
 143         enum rapl_domain_type domain_type;
 144         enum tpmi_rapl_domain_type tpmi_domain_type;
 145         enum tpmi_rapl_register reg_index;
 146         enum rapl_domain_reg_id reg_id;
 147         int tpmi_domain_size, tpmi_domain_flags;
 148         u64 tpmi_domain_header = readq(trp->base + offset);
 149         u64 tpmi_domain_info;
 150
 151         /* Domain Parent bits are ignored for now */
 152         tpmi_domain_version = tpmi_domain_header & 0xff;
 153         tpmi_domain_type = tpmi_domain_header >> 8 & 0xff;
 154         tpmi_domain_size = tpmi_domain_header >> 16 & 0xff;
 155         tpmi_domain_flags = tpmi_domain_header >> 32 & 0xffff;
 156
 157         if (tpmi_domain_version != TPMI_RAPL_VERSION) {
 158                 pr_warn(FW_BUG "Unsupported version:%d\n", tpmi_domain_version);
 159                 return -ENODEV;
 160         }
 161
 162         /* Domain size: in unit of 128 Bytes */
 163         if (tpmi_domain_size != 1) {
 164                 pr_warn(FW_BUG "Invalid Domain size %d\n", tpmi_domain_size);
 165                 return -EINVAL;
 166         }
 167
 168         /* Unit register and Energy Status register are mandatory for each domain */
 169         if (!(tpmi_domain_flags & BIT(TPMI_RAPL_REG_UNIT)) ||
 170             !(tpmi_domain_flags & BIT(TPMI_RAPL_REG_ENERGY_STATUS))) {
 171                 pr_warn(FW_BUG "Invalid Domain flag 0x%x\n", tpmi_domain_flags);
 172                 return -EINVAL;
 173         }
 174
 175         switch (tpmi_domain_type) {
 176         case TPMI_RAPL_DOMAIN_PACKAGE:
 177                 domain_type = RAPL_DOMAIN_PACKAGE;
 178                 break;
 179         case TPMI_RAPL_DOMAIN_SYSTEM:
 180                 if (!(tpmi_domain_flags & BIT(TPMI_RAPL_REG_DOMAIN_INFO))) {
 181                         pr_warn(FW_BUG "System domain must support Domain Info register\n");
 182                         return -ENODEV;
 183                 }
 184                 tpmi_domain_info = readq(trp->base + offset + TPMI_RAPL_REG_DOMAIN_INFO);
 185                 if (!(tpmi_domain_info & TPMI_RAPL_DOMAIN_ROOT))
 186                         return 0;
 187                 domain_type = RAPL_DOMAIN_PLATFORM;
 188                 break;
 189         case TPMI_RAPL_DOMAIN_MEMORY:
 190                 domain_type = RAPL_DOMAIN_DRAM;
 191                 break;
 192         default:
 193                 pr_warn(FW_BUG "Unsupported Domain type %d\n", tpmi_domain_type);
 194                 return -EINVAL;
 195         }
 196
 197         if (trp->priv.regs[domain_type][RAPL_DOMAIN_REG_UNIT].mmio) {
 198                 pr_warn(FW_BUG "Duplicate Domain type %d\n", tpmi_domain_type);
 199                 return -EINVAL;
 200         }
 201
 202         reg_index = TPMI_RAPL_REG_HEADER;
 203         while (++reg_index != TPMI_RAPL_REG_MAX) {
 204                 if (!(tpmi_domain_flags & BIT(reg_index)))
 205                         continue;
 206
 207                 switch (reg_index) {
 208                 case TPMI_RAPL_REG_UNIT:
 209                         reg_id = RAPL_DOMAIN_REG_UNIT;
 210                         break;
 211                 case TPMI_RAPL_REG_PL1:
 212                         reg_id = RAPL_DOMAIN_REG_LIMIT;
 213                         trp->priv.limits[domain_type] |= BIT(POWER_LIMIT1);
 214                         break;
 215                 case TPMI_RAPL_REG_PL2:
 216                         reg_id = RAPL_DOMAIN_REG_PL2;
 217                         trp->priv.limits[domain_type] |= BIT(POWER_LIMIT2);
 218                         break;
 219                 case TPMI_RAPL_REG_PL4:
 220                         reg_id = RAPL_DOMAIN_REG_PL4;
 221                         trp->priv.limits[domain_type] |= BIT(POWER_LIMIT4);
 222                         break;
 223                 case TPMI_RAPL_REG_ENERGY_STATUS:
 224                         reg_id = RAPL_DOMAIN_REG_STATUS;
 225                         break;
 226                 case TPMI_RAPL_REG_PERF_STATUS:
 227                         reg_id = RAPL_DOMAIN_REG_PERF;
 228                         break;
 229                 case TPMI_RAPL_REG_POWER_INFO:
 230                         reg_id = RAPL_DOMAIN_REG_INFO;
 231                         break;
 232                 default:
 233                         continue;
 234                 }
 235                 trp->priv.regs[domain_type][reg_id].mmio = trp->base + offset + reg_index * 8;
 236         }
 237
 238         return 0;
 239 }
 240
 241 static int intel_rapl_tpmi_probe(struct auxiliary_device *auxdev,
 242                                  const struct auxiliary_device_id *id)
 243 {
 244         struct tpmi_rapl_package *trp;
 245         struct intel_tpmi_plat_info *info;
 246         struct resource *res;
 247         u32 offset;
 248         int ret;
 249
 250         info = tpmi_get_platform_data(auxdev);
 251         if (!info)
 252                 return -ENODEV;
 253
 254         trp = trp_alloc(info->package_id);
 255         if (IS_ERR(trp))
 256                 return PTR_ERR(trp);
 257
 258         if (tpmi_get_resource_count(auxdev) > 1) {
 259                 dev_err(&auxdev->dev, "does not support multiple resources\n");
 260                 ret = -EINVAL;
 261                 goto err;
 262         }
 263
 264         res = tpmi_get_resource_at_index(auxdev, 0);
 265         if (!res) {
 266                 dev_err(&auxdev->dev, "can't fetch device resource info\n");
 267                 ret = -EIO;
 268                 goto err;
 269         }
 270
 271         trp->base = devm_ioremap_resource(&auxdev->dev, res);
 272         if (IS_ERR(trp->base)) {
 273                 ret = PTR_ERR(trp->base);
 274                 goto err;
 275         }
 276
 277         for (offset = 0; offset < resource_size(res); offset += TPMI_RAPL_DOMAIN_SIZE) {
 278                 ret = parse_one_domain(trp, offset);
 279                 if (ret)
 280                         goto err;
 281         }
 282
 283         trp->tpmi_info = info;
 284         trp->priv.type = RAPL_IF_TPMI;
 285         trp->priv.read_raw = tpmi_rapl_read_raw;
 286         trp->priv.write_raw = tpmi_rapl_write_raw;
 287         trp->priv.control_type = tpmi_control_type;
 288
 289         /* RAPL TPMI I/F is per physical package */
 290         trp->rp = rapl_find_package_domain(info->package_id, &trp->priv, false);
 291         if (trp->rp) {
 292                 dev_err(&auxdev->dev, "Domain for Package%d already exists\n", info->package_id);
 293                 ret = -EEXIST;
 294                 goto err;
 295         }
 296
 297         trp->rp = rapl_add_package(info->package_id, &trp->priv, false);
 298         if (IS_ERR(trp->rp)) {
 299                 dev_err(&auxdev->dev, "Failed to add RAPL Domain for Package%d, %ld\n",
 300                         info->package_id, PTR_ERR(trp->rp));
 301                 ret = PTR_ERR(trp->rp);
 302                 goto err;
 303         }
 304
 305         auxiliary_set_drvdata(auxdev, trp);
 306
 307         return 0;
 308 err:
 309         trp_release(trp);
 310         return ret;
 311 }
 312
 313 static void intel_rapl_tpmi_remove(struct auxiliary_device *auxdev)
 314 {
 315         struct tpmi_rapl_package *trp = auxiliary_get_drvdata(auxdev);
 316
 317         rapl_remove_package(trp->rp);
 318         trp_release(trp);
 319 }
 320
 321 static const struct auxiliary_device_id intel_rapl_tpmi_ids[] = {
 322         {.name = "intel_vsec.tpmi-rapl" },
 323         { }
 324 };
 325
 326 MODULE_DEVICE_TABLE(auxiliary, intel_rapl_tpmi_ids);
 327
 328 static struct auxiliary_driver intel_rapl_tpmi_driver = {
 329         .probe = intel_rapl_tpmi_probe,
 330         .remove = intel_rapl_tpmi_remove,
 331         .id_table = intel_rapl_tpmi_ids,
 332 };
 333
 334 module_auxiliary_driver(intel_rapl_tpmi_driver)
 335
 336 MODULE_IMPORT_NS(INTEL_TPMI);
 337
 338 MODULE_DESCRIPTION("Intel RAPL TPMI Driver");
 339 MODULE_LICENSE("GPL");