drivers/platform/x86/intel_pmt_telemetry.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Intel Platform Monitory Technology Telemetry driver
   4  *
   5  * Copyright (c) 2020, Intel Corporation.
   6  * All Rights Reserved.
   7  *
   8  * Author: "David E. Box" <david.e.box@linux.intel.com>
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/pci.h>
  14 #include <linux/slab.h>
  15 #include <linux/uaccess.h>
  16 #include <linux/overflow.h>
  17
  18 #include "intel_pmt_class.h"
  19
  20 #define TELEM_DEV_NAME          "pmt_telemetry"
  21
  22 #define TELEM_SIZE_OFFSET       0x0
  23 #define TELEM_GUID_OFFSET       0x4
  24 #define TELEM_BASE_OFFSET       0x8
  25 #define TELEM_ACCESS(v)         ((v) & GENMASK(3, 0))
  26 /* size is in bytes */
  27 #define TELEM_SIZE(v)           (((v) & GENMASK(27, 12)) >> 10)
  28
  29 /* Used by client hardware to identify a fixed telemetry entry*/
  30 #define TELEM_CLIENT_FIXED_BLOCK_GUID   0x10000000
  31
  32 struct pmt_telem_priv {
  33         int                             num_entries;
  34         struct intel_pmt_entry          entry[];
  35 };
  36
  37 /*
  38  * Early implementations of PMT on client platforms have some
  39  * differences from the server platforms (which use the Out Of Band
  40  * Management Services Module OOBMSM). This list tracks those
  41  * platforms as needed to handle those differences. Newer client
  42  * platforms are expected to be fully compatible with server.
  43  */
  44 static const struct pci_device_id pmt_telem_early_client_pci_ids[] = {
  45         { PCI_VDEVICE(INTEL, 0x9a0d) }, /* TGL */
  46         { PCI_VDEVICE(INTEL, 0x467d) }, /* ADL */
  47         { }
  48 };
  49
  50 static bool intel_pmt_is_early_client_hw(struct device *dev)
  51 {
  52         struct pci_dev *parent = to_pci_dev(dev->parent);
  53
  54         return !!pci_match_id(pmt_telem_early_client_pci_ids, parent);
  55 }
  56
  57 static bool pmt_telem_region_overlaps(struct intel_pmt_entry *entry,
  58                                       struct device *dev)
  59 {
  60         u32 guid = readl(entry->disc_table + TELEM_GUID_OFFSET);
  61
  62         if (guid != TELEM_CLIENT_FIXED_BLOCK_GUID)
  63                 return false;
  64
  65         return intel_pmt_is_early_client_hw(dev);
  66 }
  67
  68 static int pmt_telem_header_decode(struct intel_pmt_entry *entry,
  69                                    struct intel_pmt_header *header,
  70                                    struct device *dev)
  71 {
  72         void __iomem *disc_table = entry->disc_table;
  73
  74         if (pmt_telem_region_overlaps(entry, dev))
  75                 return 1;
  76
  77         header->access_type = TELEM_ACCESS(readl(disc_table));
  78         header->guid = readl(disc_table + TELEM_GUID_OFFSET);
  79         header->base_offset = readl(disc_table + TELEM_BASE_OFFSET);
  80
  81         /* Size is measured in DWORDS, but accessor returns bytes */
  82         header->size = TELEM_SIZE(readl(disc_table));
  83
  84         return 0;
  85 }
  86
  87 static DEFINE_XARRAY_ALLOC(telem_array);
  88 static struct intel_pmt_namespace pmt_telem_ns = {
  89         .name = "telem",
  90         .xa = &telem_array,
  91         .pmt_header_decode = pmt_telem_header_decode,
  92 };
  93
  94 static int pmt_telem_remove(struct platform_device *pdev)
  95 {
  96         struct pmt_telem_priv *priv = platform_get_drvdata(pdev);
  97         int i;
  98
  99         for (i = 0; i < priv->num_entries; i++)
 100                 intel_pmt_dev_destroy(&priv->entry[i], &pmt_telem_ns);
 101
 102         return 0;
 103 }
 104
 105 static int pmt_telem_probe(struct platform_device *pdev)
 106 {
 107         struct pmt_telem_priv *priv;
 108         size_t size;
 109         int i, ret;
 110
 111         size = struct_size(priv, entry, pdev->num_resources);
 112         priv = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
 113         if (!priv)
 114                 return -ENOMEM;
 115
 116         platform_set_drvdata(pdev, priv);
 117
 118         for (i = 0; i < pdev->num_resources; i++) {
 119                 struct intel_pmt_entry *entry = &priv->entry[i];
 120
 121                 ret = intel_pmt_dev_create(entry, &pmt_telem_ns, pdev, i);
 122                 if (ret < 0)
 123                         goto abort_probe;
 124                 if (ret)
 125                         continue;
 126
 127                 priv->num_entries++;
 128         }
 129
 130         return 0;
 131 abort_probe:
 132         pmt_telem_remove(pdev);
 133         return ret;
 134 }
 135
 136 static struct platform_driver pmt_telem_driver = {
 137         .driver = {
 138                 .name   = TELEM_DEV_NAME,
 139         },
 140         .remove = pmt_telem_remove,
 141         .probe  = pmt_telem_probe,
 142 };
 143
 144 static int __init pmt_telem_init(void)
 145 {
 146         return platform_driver_register(&pmt_telem_driver);
 147 }
 148 module_init(pmt_telem_init);
 149
 150 static void __exit pmt_telem_exit(void)
 151 {
 152         platform_driver_unregister(&pmt_telem_driver);
 153         xa_destroy(&telem_array);
 154 }
 155 module_exit(pmt_telem_exit);
 156
 157 MODULE_AUTHOR("David E. Box <david.e.box@linux.intel.com>");
 158 MODULE_DESCRIPTION("Intel PMT Telemetry driver");
 159 MODULE_ALIAS("platform:" TELEM_DEV_NAME);
 160 MODULE_LICENSE("GPL v2");