drivers/platform/x86/intel/vsec_tpmi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver to enumerate TPMI features and create devices
   4  *
   5  * Copyright (c) 2023, Intel Corporation.
   6  * All Rights Reserved.
   7  *
   8  * The TPMI (Topology Aware Register and PM Capsule Interface) provides a
   9  * flexible, extendable and PCIe enumerable MMIO interface for PM features.
  10  *
  11  * For example Intel RAPL (Running Average Power Limit) provides a MMIO
  12  * interface using TPMI. This has advantage over traditional MSR
  13  * (Model Specific Register) interface, where a thread needs to be scheduled
  14  * on the target CPU to read or write. Also the RAPL features vary between
  15  * CPU models, and hence lot of model specific code. Here TPMI provides an
  16  * architectural interface by providing hierarchical tables and fields,
  17  * which will not need any model specific implementation.
  18  *
  19  * The TPMI interface uses a PCI VSEC structure to expose the location of
  20  * MMIO region.
  21  *
  22  * This VSEC structure is present in the PCI configuration space of the
  23  * Intel Out-of-Band (OOB) device, which  is handled by the Intel VSEC
  24  * driver. The Intel VSEC driver parses VSEC structures present in the PCI
  25  * configuration space of the given device and creates an auxiliary device
  26  * object for each of them. In particular, it creates an auxiliary device
  27  * object representing TPMI that can be bound by an auxiliary driver.
  28  *
  29  * This TPMI driver will bind to the TPMI auxiliary device object created
  30  * by the Intel VSEC driver.
  31  *
  32  * The TPMI specification defines a PFS (PM Feature Structure) table.
  33  * This table is present in the TPMI MMIO region. The starting address
  34  * of PFS is derived from the tBIR (Bar Indicator Register) and "Address"
  35  * field from the VSEC header.
  36  *
  37  * Each TPMI PM feature has one entry in the PFS with a unique TPMI
  38  * ID and its access details. The TPMI driver creates device nodes
  39  * for the supported PM features.
  40  *
  41  * The names of the devices created by the TPMI driver start with the
  42  * "intel_vsec.tpmi-" prefix which is followed by a specific name of the
  43  * given PM feature (for example, "intel_vsec.tpmi-rapl.0").
  44  *
  45  * The device nodes are create by using interface "intel_vsec_add_aux()"
  46  * provided by the Intel VSEC driver.
  47  */
  48
  49 #include <linux/auxiliary_bus.h>
  50 #include <linux/bitfield.h>
  51 #include <linux/debugfs.h>
  52 #include <linux/delay.h>
  53 #include <linux/intel_tpmi.h>
  54 #include <linux/intel_vsec.h>
  55 #include <linux/io.h>
  56 #include <linux/iopoll.h>
  57 #include <linux/module.h>
  58 #include <linux/pci.h>
  59 #include <linux/security.h>
  60 #include <linux/sizes.h>
  61 #include <linux/string_helpers.h>
  62
  63 /**
  64  * struct intel_tpmi_pfs_entry - TPMI PM Feature Structure (PFS) entry
  65  * @tpmi_id:    TPMI feature identifier (what the feature is and its data format).
  66  * @num_entries: Number of feature interface instances present in the PFS.
  67  *               This represents the maximum number of Power domains in the SoC.
  68  * @entry_size: Interface instance entry size in 32-bit words.
  69  * @cap_offset: Offset from the PM_Features base address to the base of the PM VSEC
  70  *              register bank in KB.
  71  * @attribute:  Feature attribute: 0=BIOS. 1=OS. 2-3=Reserved.
  72  * @reserved:   Bits for use in the future.
  73  *
  74  * Represents one TPMI feature entry data in the PFS retrieved as is
  75  * from the hardware.
  76  */
  77 struct intel_tpmi_pfs_entry {
  78         u64 tpmi_id:8;
  79         u64 num_entries:8;
  80         u64 entry_size:16;
  81         u64 cap_offset:16;
  82         u64 attribute:2;
  83         u64 reserved:14;
  84 } __packed;
  85
  86 /**
  87  * struct intel_tpmi_pm_feature - TPMI PM Feature information for a TPMI ID
  88  * @pfs_header: PFS header retireved from the hardware.
  89  * @vsec_offset: Starting MMIO address for this feature in bytes. Essentially
  90  *               this offset = "Address" from VSEC header + PFS Capability
  91  *               offset for this feature entry.
  92  * @vsec_dev:   Pointer to intel_vsec_device structure for this TPMI device
  93  *
  94  * Represents TPMI instance information for one TPMI ID.
  95  */
  96 struct intel_tpmi_pm_feature {
  97         struct intel_tpmi_pfs_entry pfs_header;
  98         u64 vsec_offset;
  99         struct intel_vsec_device *vsec_dev;
 100 };
 101
 102 /**
 103  * struct intel_tpmi_info - TPMI information for all IDs in an instance
 104  * @tpmi_features:      Pointer to a list of TPMI feature instances
 105  * @vsec_dev:           Pointer to intel_vsec_device structure for this TPMI device
 106  * @feature_count:      Number of TPMI of TPMI instances pointed by tpmi_features
 107  * @pfs_start:          Start of PFS offset for the TPMI instances in this device
 108  * @plat_info:          Stores platform info which can be used by the client drivers
 109  * @tpmi_control_mem:   Memory mapped IO for getting control information
 110  * @dbgfs_dir:          debugfs entry pointer
 111  *
 112  * Stores the information for all TPMI devices enumerated from a single PCI device.
 113  */
 114 struct intel_tpmi_info {
 115         struct intel_tpmi_pm_feature *tpmi_features;
 116         struct intel_vsec_device *vsec_dev;
 117         int feature_count;
 118         u64 pfs_start;
 119         struct intel_tpmi_plat_info plat_info;
 120         void __iomem *tpmi_control_mem;
 121         struct dentry *dbgfs_dir;
 122 };
 123
 124 /**
 125  * struct tpmi_info_header - CPU package ID to PCI device mapping information
 126  * @fn:         PCI function number
 127  * @dev:        PCI device number
 128  * @bus:        PCI bus number
 129  * @pkg:        CPU Package id
 130  * @segment:    PCI segment id
 131  * @partition:  Package Partition id
 132  * @cdie_mask:  Bitmap of compute dies in the current partition
 133  * @reserved:   Reserved for future use
 134  * @lock:       When set to 1 the register is locked and becomes read-only
 135  *              until next reset. Not for use by the OS driver.
 136  *
 137  * The structure to read hardware provided mapping information.
 138  */
 139 struct tpmi_info_header {
 140         u64 fn:3;
 141         u64 dev:5;
 142         u64 bus:8;
 143         u64 pkg:8;
 144         u64 segment:8;
 145         u64 partition:2;
 146         u64 cdie_mask:16;
 147         u64 reserved:13;
 148         u64 lock:1;
 149 } __packed;
 150
 151 /**
 152  * struct tpmi_feature_state - Structure to read hardware state of a feature
 153  * @enabled:    Enable state of a feature, 1: enabled, 0: disabled
 154  * @reserved_1: Reserved for future use
 155  * @write_blocked: Writes are blocked means all write operations are ignored
 156  * @read_blocked: Reads are blocked means will read 0xFFs
 157  * @pcs_select: Interface used by out of band software, not used in OS
 158  * @reserved_2: Reserved for future use
 159  * @id:         TPMI ID of the feature
 160  * @reserved_3: Reserved for future use
 161  * @locked:     When set to 1, OS can't change this register.
 162  *
 163  * The structure is used to read hardware state of a TPMI feature. This
 164  * information is used for debug and restricting operations for this feature.
 165  */
 166 struct tpmi_feature_state {
 167         u32 enabled:1;
 168         u32 reserved_1:3;
 169         u32 write_blocked:1;
 170         u32 read_blocked:1;
 171         u32 pcs_select:1;
 172         u32 reserved_2:1;
 173         u32 id:8;
 174         u32 reserved_3:15;
 175         u32 locked:1;
 176 } __packed;
 177
 178 /*
 179  * The size from hardware is in u32 units. This size is from a trusted hardware,
 180  * but better to verify for pre silicon platforms. Set size to 0, when invalid.
 181  */
 182 #define TPMI_GET_SINGLE_ENTRY_SIZE(pfs)                                                 \
 183 ({                                                                                      \
 184         pfs->pfs_header.entry_size > SZ_1K ? 0 : pfs->pfs_header.entry_size << 2;       \
 185 })
 186
 187 /* Used during auxbus device creation */
 188 static DEFINE_IDA(intel_vsec_tpmi_ida);
 189
 190 struct intel_tpmi_plat_info *tpmi_get_platform_data(struct auxiliary_device *auxdev)
 191 {
 192         struct intel_vsec_device *vsec_dev = auxdev_to_ivdev(auxdev);
 193
 194         return vsec_dev->priv_data;
 195 }
 196 EXPORT_SYMBOL_NS_GPL(tpmi_get_platform_data, "INTEL_TPMI");
 197
 198 int tpmi_get_resource_count(struct auxiliary_device *auxdev)
 199 {
 200         struct intel_vsec_device *vsec_dev = auxdev_to_ivdev(auxdev);
 201
 202         if (vsec_dev)
 203                 return vsec_dev->num_resources;
 204
 205         return 0;
 206 }
 207 EXPORT_SYMBOL_NS_GPL(tpmi_get_resource_count, "INTEL_TPMI");
 208
 209 struct resource *tpmi_get_resource_at_index(struct auxiliary_device *auxdev, int index)
 210 {
 211         struct intel_vsec_device *vsec_dev = auxdev_to_ivdev(auxdev);
 212
 213         if (vsec_dev && index < vsec_dev->num_resources)
 214                 return &vsec_dev->resource[index];
 215
 216         return NULL;
 217 }
 218 EXPORT_SYMBOL_NS_GPL(tpmi_get_resource_at_index, "INTEL_TPMI");
 219
 220 /* TPMI Control Interface */
 221
 222 #define TPMI_CONTROL_STATUS_OFFSET      0x00
 223 #define TPMI_COMMAND_OFFSET             0x08
 224 #define TMPI_CONTROL_DATA_VAL_OFFSET    0x0c
 225
 226 /*
 227  * Spec is calling for max 1 seconds to get ownership at the worst
 228  * case. Read at 10 ms timeouts and repeat up to 1 second.
 229  */
 230 #define TPMI_CONTROL_TIMEOUT_US         (10 * USEC_PER_MSEC)
 231 #define TPMI_CONTROL_TIMEOUT_MAX_US     (1 * USEC_PER_SEC)
 232
 233 #define TPMI_RB_TIMEOUT_US              (10 * USEC_PER_MSEC)
 234 #define TPMI_RB_TIMEOUT_MAX_US          USEC_PER_SEC
 235
 236 /* TPMI Control status register defines */
 237
 238 #define TPMI_CONTROL_STATUS_RB          BIT_ULL(0)
 239
 240 #define TPMI_CONTROL_STATUS_OWNER       GENMASK_ULL(5, 4)
 241 #define TPMI_OWNER_NONE                 0
 242 #define TPMI_OWNER_IN_BAND              1
 243
 244 #define TPMI_CONTROL_STATUS_CPL         BIT_ULL(6)
 245 #define TPMI_CONTROL_STATUS_RESULT      GENMASK_ULL(15, 8)
 246 #define TPMI_CONTROL_STATUS_LEN         GENMASK_ULL(31, 16)
 247
 248 #define TPMI_CMD_PKT_LEN                2
 249 #define TPMI_CMD_STATUS_SUCCESS         0x40
 250
 251 /* TPMI command data registers */
 252 #define TMPI_CONTROL_DATA_CMD           GENMASK_ULL(7, 0)
 253 #define TPMI_CONTROL_DATA_VAL_FEATURE   GENMASK_ULL(48, 40)
 254
 255 /* Command to send via control interface */
 256 #define TPMI_CONTROL_GET_STATE_CMD      0x10
 257
 258 #define TPMI_CONTROL_CMD_MASK           GENMASK_ULL(48, 40)
 259
 260 #define TPMI_CMD_LEN_MASK               GENMASK_ULL(18, 16)
 261
 262 /* Mutex to complete get feature status without interruption */
 263 static DEFINE_MUTEX(tpmi_dev_lock);
 264
 265 static int tpmi_wait_for_owner(struct intel_tpmi_info *tpmi_info, u8 owner)
 266 {
 267         u64 control;
 268
 269         return readq_poll_timeout(tpmi_info->tpmi_control_mem + TPMI_CONTROL_STATUS_OFFSET,
 270                                   control, owner == FIELD_GET(TPMI_CONTROL_STATUS_OWNER, control),
 271                                   TPMI_CONTROL_TIMEOUT_US, TPMI_CONTROL_TIMEOUT_MAX_US);
 272 }
 273
 274 static int tpmi_read_feature_status(struct intel_tpmi_info *tpmi_info, int feature_id,
 275                                     struct tpmi_feature_state *feature_state)
 276 {
 277         u64 control, data;
 278         int ret;
 279
 280         if (!tpmi_info->tpmi_control_mem)
 281                 return -EFAULT;
 282
 283         mutex_lock(&tpmi_dev_lock);
 284
 285         /* Wait for owner bit set to 0 (none) */
 286         ret = tpmi_wait_for_owner(tpmi_info, TPMI_OWNER_NONE);
 287         if (ret)
 288                 goto err_unlock;
 289
 290         /* set command id to 0x10 for TPMI_GET_STATE */
 291         data = FIELD_PREP(TMPI_CONTROL_DATA_CMD, TPMI_CONTROL_GET_STATE_CMD);
 292
 293         /* 32 bits for DATA offset and +8 for feature_id field */
 294         data |= FIELD_PREP(TPMI_CONTROL_DATA_VAL_FEATURE, feature_id);
 295
 296         /* Write at command offset for qword access */
 297         writeq(data, tpmi_info->tpmi_control_mem + TPMI_COMMAND_OFFSET);
 298
 299         /* Wait for owner bit set to in-band */
 300         ret = tpmi_wait_for_owner(tpmi_info, TPMI_OWNER_IN_BAND);
 301         if (ret)
 302                 goto err_unlock;
 303
 304         /* Set Run Busy and packet length of 2 dwords */
 305         control = TPMI_CONTROL_STATUS_RB;
 306         control |= FIELD_PREP(TPMI_CONTROL_STATUS_LEN, TPMI_CMD_PKT_LEN);
 307
 308         /* Write at status offset for qword access */
 309         writeq(control, tpmi_info->tpmi_control_mem + TPMI_CONTROL_STATUS_OFFSET);
 310
 311         /* Wait for Run Busy clear */
 312         ret = readq_poll_timeout(tpmi_info->tpmi_control_mem + TPMI_CONTROL_STATUS_OFFSET,
 313                                  control, !(control & TPMI_CONTROL_STATUS_RB),
 314                                  TPMI_RB_TIMEOUT_US, TPMI_RB_TIMEOUT_MAX_US);
 315         if (ret)
 316                 goto done_proc;
 317
 318         control = FIELD_GET(TPMI_CONTROL_STATUS_RESULT, control);
 319         if (control != TPMI_CMD_STATUS_SUCCESS) {
 320                 ret = -EBUSY;
 321                 goto done_proc;
 322         }
 323
 324         /* Response is ready */
 325         memcpy_fromio(feature_state, tpmi_info->tpmi_control_mem + TMPI_CONTROL_DATA_VAL_OFFSET,
 326                       sizeof(*feature_state));
 327
 328         ret = 0;
 329
 330 done_proc:
 331         /* Set CPL "completion" bit */
 332         writeq(TPMI_CONTROL_STATUS_CPL, tpmi_info->tpmi_control_mem + TPMI_CONTROL_STATUS_OFFSET);
 333
 334 err_unlock:
 335         mutex_unlock(&tpmi_dev_lock);
 336
 337         return ret;
 338 }
 339
 340 int tpmi_get_feature_status(struct auxiliary_device *auxdev,
 341                             int feature_id, bool *read_blocked, bool *write_blocked)
 342 {
 343         struct intel_vsec_device *intel_vsec_dev = dev_to_ivdev(auxdev->dev.parent);
 344         struct intel_tpmi_info *tpmi_info = auxiliary_get_drvdata(&intel_vsec_dev->auxdev);
 345         struct tpmi_feature_state feature_state;
 346         int ret;
 347
 348         ret = tpmi_read_feature_status(tpmi_info, feature_id, &feature_state);
 349         if (ret)
 350                 return ret;
 351
 352         *read_blocked = feature_state.read_blocked;
 353         *write_blocked = feature_state.write_blocked;
 354
 355         return 0;
 356 }
 357 EXPORT_SYMBOL_NS_GPL(tpmi_get_feature_status, "INTEL_TPMI");
 358
 359 struct dentry *tpmi_get_debugfs_dir(struct auxiliary_device *auxdev)
 360 {
 361         struct intel_vsec_device *intel_vsec_dev = dev_to_ivdev(auxdev->dev.parent);
 362         struct intel_tpmi_info *tpmi_info = auxiliary_get_drvdata(&intel_vsec_dev->auxdev);
 363
 364         return tpmi_info->dbgfs_dir;
 365 }
 366 EXPORT_SYMBOL_NS_GPL(tpmi_get_debugfs_dir, "INTEL_TPMI");
 367
 368 static int tpmi_pfs_dbg_show(struct seq_file *s, void *unused)
 369 {
 370         struct intel_tpmi_info *tpmi_info = s->private;
 371         int locked, disabled, read_blocked, write_blocked;
 372         struct tpmi_feature_state feature_state;
 373         struct intel_tpmi_pm_feature *pfs;
 374         int ret, i;
 375
 376
 377         seq_printf(s, "tpmi PFS start offset 0x:%llx\n", tpmi_info->pfs_start);
 378         seq_puts(s, "tpmi_id\t\tentries\t\tsize\t\tcap_offset\tattribute\tvsec_offset\tlocked\tdisabled\tread_blocked\twrite_blocked\n");
 379         for (i = 0; i < tpmi_info->feature_count; ++i) {
 380                 pfs = &tpmi_info->tpmi_features[i];
 381                 ret = tpmi_read_feature_status(tpmi_info, pfs->pfs_header.tpmi_id, &feature_state);
 382                 if (ret) {
 383                         locked = 'U';
 384                         disabled = 'U';
 385                         read_blocked = 'U';
 386                         write_blocked = 'U';
 387                 } else {
 388                         disabled = feature_state.enabled ? 'N' : 'Y';
 389                         locked = feature_state.locked ? 'Y' : 'N';
 390                         read_blocked = feature_state.read_blocked ? 'Y' : 'N';
 391                         write_blocked = feature_state.write_blocked ? 'Y' : 'N';
 392                 }
 393                 seq_printf(s, "0x%02x\t\t0x%02x\t\t0x%04x\t\t0x%04x\t\t0x%02x\t\t0x%016llx\t%c\t%c\t\t%c\t\t%c\n",
 394                            pfs->pfs_header.tpmi_id, pfs->pfs_header.num_entries,
 395                            pfs->pfs_header.entry_size, pfs->pfs_header.cap_offset,
 396                            pfs->pfs_header.attribute, pfs->vsec_offset, locked, disabled,
 397                            read_blocked, write_blocked);
 398         }
 399
 400         return 0;
 401 }
 402 DEFINE_SHOW_ATTRIBUTE(tpmi_pfs_dbg);
 403
 404 #define MEM_DUMP_COLUMN_COUNT   8
 405
 406 static int tpmi_mem_dump_show(struct seq_file *s, void *unused)
 407 {
 408         size_t row_size = MEM_DUMP_COLUMN_COUNT * sizeof(u32);
 409         struct intel_tpmi_pm_feature *pfs = s->private;
 410         int count, ret = 0;
 411         void __iomem *mem;
 412         u32 size;
 413         u64 off;
 414         u8 *buffer;
 415
 416         size = TPMI_GET_SINGLE_ENTRY_SIZE(pfs);
 417         if (!size)
 418                 return -EIO;
 419
 420         buffer = kmalloc(size, GFP_KERNEL);
 421         if (!buffer)
 422                 return -ENOMEM;
 423
 424         off = pfs->vsec_offset;
 425
 426         mutex_lock(&tpmi_dev_lock);
 427
 428         for (count = 0; count < pfs->pfs_header.num_entries; ++count) {
 429                 seq_printf(s, "TPMI Instance:%d offset:0x%llx\n", count, off);
 430
 431                 mem = ioremap(off, size);
 432                 if (!mem) {
 433                         ret = -ENOMEM;
 434                         break;
 435                 }
 436
 437                 memcpy_fromio(buffer, mem, size);
 438
 439                 seq_hex_dump(s, " ", DUMP_PREFIX_OFFSET, row_size, sizeof(u32), buffer, size,
 440                              false);
 441
 442                 iounmap(mem);
 443
 444                 off += size;
 445         }
 446
 447         mutex_unlock(&tpmi_dev_lock);
 448
 449         kfree(buffer);
 450
 451         return ret;
 452 }
 453 DEFINE_SHOW_ATTRIBUTE(tpmi_mem_dump);
 454
 455 static ssize_t mem_write(struct file *file, const char __user *userbuf, size_t len, loff_t *ppos)
 456 {
 457         struct seq_file *m = file->private_data;
 458         struct intel_tpmi_pm_feature *pfs = m->private;
 459         u32 addr, value, punit, size;
 460         u32 num_elems, *array;
 461         void __iomem *mem;
 462         int ret;
 463
 464         size = TPMI_GET_SINGLE_ENTRY_SIZE(pfs);
 465         if (!size)
 466                 return -EIO;
 467
 468         ret = parse_int_array_user(userbuf, len, (int **)&array);
 469         if (ret < 0)
 470                 return ret;
 471
 472         num_elems = *array;
 473         if (num_elems != 3) {
 474                 ret = -EINVAL;
 475                 goto exit_write;
 476         }
 477
 478         punit = array[1];
 479         addr = array[2];
 480         value = array[3];
 481
 482         if (punit >= pfs->pfs_header.num_entries) {
 483                 ret = -EINVAL;
 484                 goto exit_write;
 485         }
 486
 487         if (addr >= size) {
 488                 ret = -EINVAL;
 489                 goto exit_write;
 490         }
 491
 492         mutex_lock(&tpmi_dev_lock);
 493
 494         mem = ioremap(pfs->vsec_offset + punit * size, size);
 495         if (!mem) {
 496                 ret = -ENOMEM;
 497                 goto unlock_mem_write;
 498         }
 499
 500         writel(value, mem + addr);
 501
 502         iounmap(mem);
 503
 504         ret = len;
 505
 506 unlock_mem_write:
 507         mutex_unlock(&tpmi_dev_lock);
 508
 509 exit_write:
 510         kfree(array);
 511
 512         return ret;
 513 }
 514
 515 static int mem_write_show(struct seq_file *s, void *unused)
 516 {
 517         return 0;
 518 }
 519
 520 static int mem_write_open(struct inode *inode, struct file *file)
 521 {
 522         return single_open(file, mem_write_show, inode->i_private);
 523 }
 524
 525 static const struct file_operations mem_write_ops = {
 526         .open           = mem_write_open,
 527         .read           = seq_read,
 528         .write          = mem_write,
 529         .llseek         = seq_lseek,
 530         .release        = single_release,
 531 };
 532
 533 #define tpmi_to_dev(info)       (&info->vsec_dev->pcidev->dev)
 534
 535 static void tpmi_dbgfs_register(struct intel_tpmi_info *tpmi_info)
 536 {
 537         char name[64];
 538         int i;
 539
 540         snprintf(name, sizeof(name), "tpmi-%s", dev_name(tpmi_to_dev(tpmi_info)));
 541         tpmi_info->dbgfs_dir = debugfs_create_dir(name, NULL);
 542
 543         debugfs_create_file("pfs_dump", 0444, tpmi_info->dbgfs_dir, tpmi_info, &tpmi_pfs_dbg_fops);
 544
 545         for (i = 0; i < tpmi_info->feature_count; ++i) {
 546                 struct intel_tpmi_pm_feature *pfs;
 547                 struct dentry *dir;
 548
 549                 pfs = &tpmi_info->tpmi_features[i];
 550                 snprintf(name, sizeof(name), "tpmi-id-%02x", pfs->pfs_header.tpmi_id);
 551                 dir = debugfs_create_dir(name, tpmi_info->dbgfs_dir);
 552
 553                 debugfs_create_file("mem_dump", 0444, dir, pfs, &tpmi_mem_dump_fops);
 554                 debugfs_create_file("mem_write", 0644, dir, pfs, &mem_write_ops);
 555         }
 556 }
 557
 558 static void tpmi_set_control_base(struct auxiliary_device *auxdev,
 559                                   struct intel_tpmi_info *tpmi_info,
 560                                   struct intel_tpmi_pm_feature *pfs)
 561 {
 562         void __iomem *mem;
 563         u32 size;
 564
 565         size = TPMI_GET_SINGLE_ENTRY_SIZE(pfs);
 566         if (!size)
 567                 return;
 568
 569         mem = devm_ioremap(&auxdev->dev, pfs->vsec_offset, size);
 570         if (!mem)
 571                 return;
 572
 573         /* mem is pointing to TPMI CONTROL base */
 574         tpmi_info->tpmi_control_mem = mem;
 575 }
 576
 577 static const char *intel_tpmi_name(enum intel_tpmi_id id)
 578 {
 579         switch (id) {
 580         case TPMI_ID_RAPL:
 581                 return "rapl";
 582         case TPMI_ID_PEM:
 583                 return "pem";
 584         case TPMI_ID_UNCORE:
 585                 return "uncore";
 586         case TPMI_ID_SST:
 587                 return "sst";
 588         case TPMI_ID_PLR:
 589                 return "plr";
 590         default:
 591                 return NULL;
 592         }
 593 }
 594
 595 /* String Length for tpmi-"feature_name(upto 8 bytes)" */
 596 #define TPMI_FEATURE_NAME_LEN   14
 597
 598 static int tpmi_create_device(struct intel_tpmi_info *tpmi_info,
 599                               struct intel_tpmi_pm_feature *pfs,
 600                               u64 pfs_start)
 601 {
 602         struct intel_vsec_device *vsec_dev = tpmi_info->vsec_dev;
 603         char feature_id_name[TPMI_FEATURE_NAME_LEN];
 604         struct intel_vsec_device *feature_vsec_dev;
 605         struct tpmi_feature_state feature_state;
 606         struct resource *res, *tmp;
 607         const char *name;
 608         int i, ret;
 609
 610         ret = tpmi_read_feature_status(tpmi_info, pfs->pfs_header.tpmi_id, &feature_state);
 611         if (ret)
 612                 return ret;
 613
 614         /*
 615          * If not enabled, continue to look at other features in the PFS, so return -EOPNOTSUPP.
 616          * This will not cause failure of loading of this driver.
 617          */
 618         if (!feature_state.enabled)
 619                 return -EOPNOTSUPP;
 620
 621         name = intel_tpmi_name(pfs->pfs_header.tpmi_id);
 622         if (!name)
 623                 return -EOPNOTSUPP;
 624
 625         res = kcalloc(pfs->pfs_header.num_entries, sizeof(*res), GFP_KERNEL);
 626         if (!res)
 627                 return -ENOMEM;
 628
 629         feature_vsec_dev = kzalloc(sizeof(*feature_vsec_dev), GFP_KERNEL);
 630         if (!feature_vsec_dev) {
 631                 kfree(res);
 632                 return -ENOMEM;
 633         }
 634
 635         snprintf(feature_id_name, sizeof(feature_id_name), "tpmi-%s", name);
 636
 637         for (i = 0, tmp = res; i < pfs->pfs_header.num_entries; i++, tmp++) {
 638                 u64 entry_size_bytes = pfs->pfs_header.entry_size * sizeof(u32);
 639
 640                 tmp->start = pfs->vsec_offset + entry_size_bytes * i;
 641                 tmp->end = tmp->start + entry_size_bytes - 1;
 642                 tmp->flags = IORESOURCE_MEM;
 643         }
 644
 645         feature_vsec_dev->pcidev = vsec_dev->pcidev;
 646         feature_vsec_dev->resource = res;
 647         feature_vsec_dev->num_resources = pfs->pfs_header.num_entries;
 648         feature_vsec_dev->priv_data = &tpmi_info->plat_info;
 649         feature_vsec_dev->priv_data_size = sizeof(tpmi_info->plat_info);
 650         feature_vsec_dev->ida = &intel_vsec_tpmi_ida;
 651
 652         /*
 653          * intel_vsec_add_aux() is resource managed, no explicit
 654          * delete is required on error or on module unload.
 655          * feature_vsec_dev and res memory are also freed as part of
 656          * device deletion.
 657          */
 658         return intel_vsec_add_aux(vsec_dev->pcidev, &vsec_dev->auxdev.dev,
 659                                   feature_vsec_dev, feature_id_name);
 660 }
 661
 662 static int tpmi_create_devices(struct intel_tpmi_info *tpmi_info)
 663 {
 664         struct intel_vsec_device *vsec_dev = tpmi_info->vsec_dev;
 665         int ret, i;
 666
 667         for (i = 0; i < vsec_dev->num_resources; i++) {
 668                 ret = tpmi_create_device(tpmi_info, &tpmi_info->tpmi_features[i],
 669                                          tpmi_info->pfs_start);
 670                 /*
 671                  * Fail, if the supported features fails to create device,
 672                  * otherwise, continue. Even if one device failed to create,
 673                  * fail the loading of driver. Since intel_vsec_add_aux()
 674                  * is resource managed, no clean up is required for the
 675                  * successfully created devices.
 676                  */
 677                 if (ret && ret != -EOPNOTSUPP)
 678                         return ret;
 679         }
 680
 681         return 0;
 682 }
 683
 684 #define TPMI_INFO_BUS_INFO_OFFSET       0x08
 685 #define TPMI_INFO_MAJOR_VERSION         0x00
 686 #define TPMI_INFO_MINOR_VERSION         0x02
 687
 688 static int tpmi_process_info(struct intel_tpmi_info *tpmi_info,
 689                              struct intel_tpmi_pm_feature *pfs)
 690 {
 691         struct tpmi_info_header header;
 692         void __iomem *info_mem;
 693         u64 feature_header;
 694         int ret = 0;
 695
 696         info_mem = ioremap(pfs->vsec_offset, pfs->pfs_header.entry_size * sizeof(u32));
 697         if (!info_mem)
 698                 return -ENOMEM;
 699
 700         feature_header = readq(info_mem);
 701         if (TPMI_MAJOR_VERSION(feature_header) != TPMI_INFO_MAJOR_VERSION) {
 702                 ret = -ENODEV;
 703                 goto error_info_header;
 704         }
 705
 706         memcpy_fromio(&header, info_mem + TPMI_INFO_BUS_INFO_OFFSET, sizeof(header));
 707
 708         tpmi_info->plat_info.package_id = header.pkg;
 709         tpmi_info->plat_info.bus_number = header.bus;
 710         tpmi_info->plat_info.device_number = header.dev;
 711         tpmi_info->plat_info.function_number = header.fn;
 712
 713         if (TPMI_MINOR_VERSION(feature_header) >= TPMI_INFO_MINOR_VERSION) {
 714                 tpmi_info->plat_info.cdie_mask = header.cdie_mask;
 715                 tpmi_info->plat_info.partition = header.partition;
 716                 tpmi_info->plat_info.segment = header.segment;
 717         }
 718
 719 error_info_header:
 720         iounmap(info_mem);
 721
 722         return ret;
 723 }
 724
 725 static int tpmi_fetch_pfs_header(struct intel_tpmi_pm_feature *pfs, u64 start, int size)
 726 {
 727         void __iomem *pfs_mem;
 728
 729         pfs_mem = ioremap(start, size);
 730         if (!pfs_mem)
 731                 return -ENOMEM;
 732
 733         memcpy_fromio(&pfs->pfs_header, pfs_mem, sizeof(pfs->pfs_header));
 734
 735         iounmap(pfs_mem);
 736
 737         return 0;
 738 }
 739
 740 #define TPMI_CAP_OFFSET_UNIT    1024
 741
 742 static int intel_vsec_tpmi_init(struct auxiliary_device *auxdev)
 743 {
 744         struct intel_vsec_device *vsec_dev = auxdev_to_ivdev(auxdev);
 745         struct pci_dev *pci_dev = vsec_dev->pcidev;
 746         struct intel_tpmi_info *tpmi_info;
 747         u64 pfs_start = 0;
 748         int ret, i;
 749
 750         tpmi_info = devm_kzalloc(&auxdev->dev, sizeof(*tpmi_info), GFP_KERNEL);
 751         if (!tpmi_info)
 752                 return -ENOMEM;
 753
 754         tpmi_info->vsec_dev = vsec_dev;
 755         tpmi_info->feature_count = vsec_dev->num_resources;
 756         tpmi_info->plat_info.bus_number = pci_dev->bus->number;
 757
 758         tpmi_info->tpmi_features = devm_kcalloc(&auxdev->dev, vsec_dev->num_resources,
 759                                                 sizeof(*tpmi_info->tpmi_features),
 760                                                 GFP_KERNEL);
 761         if (!tpmi_info->tpmi_features)
 762                 return -ENOMEM;
 763
 764         for (i = 0; i < vsec_dev->num_resources; i++) {
 765                 struct intel_tpmi_pm_feature *pfs;
 766                 struct resource *res;
 767                 u64 res_start;
 768                 int size, ret;
 769
 770                 pfs = &tpmi_info->tpmi_features[i];
 771                 pfs->vsec_dev = vsec_dev;
 772
 773                 res = &vsec_dev->resource[i];
 774                 if (!res)
 775                         continue;
 776
 777                 res_start = res->start;
 778                 size = resource_size(res);
 779                 if (size < 0)
 780                         continue;
 781
 782                 ret = tpmi_fetch_pfs_header(pfs, res_start, size);
 783                 if (ret)
 784                         continue;
 785
 786                 if (!pfs_start)
 787                         pfs_start = res_start;
 788
 789                 pfs->vsec_offset = pfs_start + pfs->pfs_header.cap_offset * TPMI_CAP_OFFSET_UNIT;
 790
 791                 /*
 792                  * Process TPMI_INFO to get PCI device to CPU package ID.
 793                  * Device nodes for TPMI features are not created in this
 794                  * for loop. So, the mapping information will be available
 795                  * when actual device nodes created outside this
 796                  * loop via tpmi_create_devices().
 797                  */
 798                 if (pfs->pfs_header.tpmi_id == TPMI_INFO_ID) {
 799                         ret = tpmi_process_info(tpmi_info, pfs);
 800                         if (ret)
 801                                 return ret;
 802                 }
 803
 804                 if (pfs->pfs_header.tpmi_id == TPMI_CONTROL_ID)
 805                         tpmi_set_control_base(auxdev, tpmi_info, pfs);
 806         }
 807
 808         tpmi_info->pfs_start = pfs_start;
 809
 810         auxiliary_set_drvdata(auxdev, tpmi_info);
 811
 812         ret = tpmi_create_devices(tpmi_info);
 813         if (ret)
 814                 return ret;
 815
 816         /*
 817          * Allow debugfs when security policy allows. Everything this debugfs
 818          * interface provides, can also be done via /dev/mem access. If
 819          * /dev/mem interface is locked, don't allow debugfs to present any
 820          * information. Also check for CAP_SYS_RAWIO as /dev/mem interface.
 821          */
 822         if (!security_locked_down(LOCKDOWN_DEV_MEM) && capable(CAP_SYS_RAWIO))
 823                 tpmi_dbgfs_register(tpmi_info);
 824
 825         return 0;
 826 }
 827
 828 static int tpmi_probe(struct auxiliary_device *auxdev,
 829                       const struct auxiliary_device_id *id)
 830 {
 831         return intel_vsec_tpmi_init(auxdev);
 832 }
 833
 834 static void tpmi_remove(struct auxiliary_device *auxdev)
 835 {
 836         struct intel_tpmi_info *tpmi_info = auxiliary_get_drvdata(auxdev);
 837
 838         debugfs_remove_recursive(tpmi_info->dbgfs_dir);
 839 }
 840
 841 static const struct auxiliary_device_id tpmi_id_table[] = {
 842         { .name = "intel_vsec.tpmi" },
 843         {}
 844 };
 845 MODULE_DEVICE_TABLE(auxiliary, tpmi_id_table);
 846
 847 static struct auxiliary_driver tpmi_aux_driver = {
 848         .id_table       = tpmi_id_table,
 849         .probe          = tpmi_probe,
 850         .remove         = tpmi_remove,
 851 };
 852
 853 module_auxiliary_driver(tpmi_aux_driver);
 854
 855 MODULE_IMPORT_NS("INTEL_VSEC");
 856 MODULE_DESCRIPTION("Intel TPMI enumeration module");
 857 MODULE_LICENSE("GPL");