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: "Alexander Duyck" <alexander.h.duyck@linux.intel.com> 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/intel_vsec.h> 13 #include <linux/io-64-nonatomic-lo-hi.h> 14 #include <linux/module.h> 15 #include <linux/mm.h> 16 #include <linux/pci.h> 17 18 #include "class.h" 19 20 #define PMT_XA_START 1 21 #define PMT_XA_MAX INT_MAX 22 #define PMT_XA_LIMIT XA_LIMIT(PMT_XA_START, PMT_XA_MAX) 23 #define GUID_SPR_PUNIT 0x9956f43f 24 25 bool intel_pmt_is_early_client_hw(struct device *dev) 26 { 27 struct intel_vsec_device *ivdev = dev_to_ivdev(dev); 28 29 /* 30 * Early implementations of PMT on client platforms have some 31 * differences from the server platforms (which use the Out Of Band 32 * Management Services Module OOBMSM). 33 */ 34 return !!(ivdev->quirks & VSEC_QUIRK_EARLY_HW); 35 } 36 EXPORT_SYMBOL_NS_GPL(intel_pmt_is_early_client_hw, INTEL_PMT); 37 38 static inline int 39 pmt_memcpy64_fromio(void *to, const u64 __iomem *from, size_t count) 40 { 41 int i, remain; 42 u64 *buf = to; 43 44 if (!IS_ALIGNED((unsigned long)from, 8)) 45 return -EFAULT; 46 47 for (i = 0; i < count/8; i++) 48 buf[i] = readq(&from[i]); 49 50 /* Copy any remaining bytes */ 51 remain = count % 8; 52 if (remain) { 53 u64 tmp = readq(&from[i]); 54 55 memcpy(&buf[i], &tmp, remain); 56 } 57 58 return count; 59 } 60 61 int pmt_telem_read_mmio(struct pci_dev *pdev, struct pmt_callbacks *cb, u32 guid, void *buf, 62 void __iomem *addr, loff_t off, u32 count) 63 { 64 if (cb && cb->read_telem) 65 return cb->read_telem(pdev, guid, buf, off, count); 66 67 addr += off; 68 69 if (guid == GUID_SPR_PUNIT) 70 /* PUNIT on SPR only supports aligned 64-bit read */ 71 return pmt_memcpy64_fromio(buf, addr, count); 72 73 memcpy_fromio(buf, addr, count); 74 75 return count; 76 } 77 EXPORT_SYMBOL_NS_GPL(pmt_telem_read_mmio, INTEL_PMT); 78 79 /* 80 * sysfs 81 */ 82 static ssize_t 83 intel_pmt_read(struct file *filp, struct kobject *kobj, 84 struct bin_attribute *attr, char *buf, loff_t off, 85 size_t count) 86 { 87 struct intel_pmt_entry *entry = container_of(attr, 88 struct intel_pmt_entry, 89 pmt_bin_attr); 90 91 if (off < 0) 92 return -EINVAL; 93 94 if (off >= entry->size) 95 return 0; 96 97 if (count > entry->size - off) 98 count = entry->size - off; 99 100 count = pmt_telem_read_mmio(entry->ep->pcidev, entry->cb, entry->header.guid, buf, 101 entry->base, off, count); 102 103 return count; 104 } 105 106 static int 107 intel_pmt_mmap(struct file *filp, struct kobject *kobj, 108 const struct bin_attribute *attr, struct vm_area_struct *vma) 109 { 110 struct intel_pmt_entry *entry = container_of(attr, 111 struct intel_pmt_entry, 112 pmt_bin_attr); 113 unsigned long vsize = vma->vm_end - vma->vm_start; 114 struct device *dev = kobj_to_dev(kobj); 115 unsigned long phys = entry->base_addr; 116 unsigned long pfn = PFN_DOWN(phys); 117 unsigned long psize; 118 119 if (vma->vm_flags & (VM_WRITE | VM_MAYWRITE)) 120 return -EROFS; 121 122 psize = (PFN_UP(entry->base_addr + entry->size) - pfn) * PAGE_SIZE; 123 if (vsize > psize) { 124 dev_err(dev, "Requested mmap size is too large\n"); 125 return -EINVAL; 126 } 127 128 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 129 if (io_remap_pfn_range(vma, vma->vm_start, pfn, 130 vsize, vma->vm_page_prot)) 131 return -EAGAIN; 132 133 return 0; 134 } 135 136 static ssize_t 137 guid_show(struct device *dev, struct device_attribute *attr, char *buf) 138 { 139 struct intel_pmt_entry *entry = dev_get_drvdata(dev); 140 141 return sprintf(buf, "0x%x\n", entry->guid); 142 } 143 static DEVICE_ATTR_RO(guid); 144 145 static ssize_t size_show(struct device *dev, struct device_attribute *attr, 146 char *buf) 147 { 148 struct intel_pmt_entry *entry = dev_get_drvdata(dev); 149 150 return sprintf(buf, "%zu\n", entry->size); 151 } 152 static DEVICE_ATTR_RO(size); 153 154 static ssize_t 155 offset_show(struct device *dev, struct device_attribute *attr, char *buf) 156 { 157 struct intel_pmt_entry *entry = dev_get_drvdata(dev); 158 159 return sprintf(buf, "%lu\n", offset_in_page(entry->base_addr)); 160 } 161 static DEVICE_ATTR_RO(offset); 162 163 static struct attribute *intel_pmt_attrs[] = { 164 &dev_attr_guid.attr, 165 &dev_attr_size.attr, 166 &dev_attr_offset.attr, 167 NULL 168 }; 169 ATTRIBUTE_GROUPS(intel_pmt); 170 171 static struct class intel_pmt_class = { 172 .name = "intel_pmt", 173 .dev_groups = intel_pmt_groups, 174 }; 175 176 static int intel_pmt_populate_entry(struct intel_pmt_entry *entry, 177 struct intel_vsec_device *ivdev, 178 struct resource *disc_res) 179 { 180 struct pci_dev *pci_dev = ivdev->pcidev; 181 struct device *dev = &ivdev->auxdev.dev; 182 struct intel_pmt_header *header = &entry->header; 183 u8 bir; 184 185 /* 186 * The base offset should always be 8 byte aligned. 187 * 188 * For non-local access types the lower 3 bits of base offset 189 * contains the index of the base address register where the 190 * telemetry can be found. 191 */ 192 bir = GET_BIR(header->base_offset); 193 194 /* Local access and BARID only for now */ 195 switch (header->access_type) { 196 case ACCESS_LOCAL: 197 if (bir) { 198 dev_err(dev, 199 "Unsupported BAR index %d for access type %d\n", 200 bir, header->access_type); 201 return -EINVAL; 202 } 203 /* 204 * For access_type LOCAL, the base address is as follows: 205 * base address = end of discovery region + base offset 206 */ 207 entry->base_addr = disc_res->end + 1 + header->base_offset; 208 209 /* 210 * Some hardware use a different calculation for the base address 211 * when access_type == ACCESS_LOCAL. On the these systems 212 * ACCESS_LOCAL refers to an address in the same BAR as the 213 * header but at a fixed offset. But as the header address was 214 * supplied to the driver, we don't know which BAR it was in. 215 * So search for the bar whose range includes the header address. 216 */ 217 if (intel_pmt_is_early_client_hw(dev)) { 218 int i; 219 220 entry->base_addr = 0; 221 for (i = 0; i < 6; i++) 222 if (disc_res->start >= pci_resource_start(pci_dev, i) && 223 (disc_res->start <= pci_resource_end(pci_dev, i))) { 224 entry->base_addr = pci_resource_start(pci_dev, i) + 225 header->base_offset; 226 break; 227 } 228 if (!entry->base_addr) 229 return -EINVAL; 230 } 231 232 break; 233 case ACCESS_BARID: 234 /* Use the provided base address if it exists */ 235 if (ivdev->base_addr) { 236 entry->base_addr = ivdev->base_addr + 237 GET_ADDRESS(header->base_offset); 238 break; 239 } 240 241 /* 242 * If another BAR was specified then the base offset 243 * represents the offset within that BAR. SO retrieve the 244 * address from the parent PCI device and add offset. 245 */ 246 entry->base_addr = pci_resource_start(pci_dev, bir) + 247 GET_ADDRESS(header->base_offset); 248 break; 249 default: 250 dev_err(dev, "Unsupported access type %d\n", 251 header->access_type); 252 return -EINVAL; 253 } 254 255 entry->guid = header->guid; 256 entry->size = header->size; 257 entry->cb = ivdev->priv_data; 258 259 return 0; 260 } 261 262 static int intel_pmt_dev_register(struct intel_pmt_entry *entry, 263 struct intel_pmt_namespace *ns, 264 struct device *parent) 265 { 266 struct intel_vsec_device *ivdev = dev_to_ivdev(parent); 267 struct resource res = {0}; 268 struct device *dev; 269 int ret; 270 271 ret = xa_alloc(ns->xa, &entry->devid, entry, PMT_XA_LIMIT, GFP_KERNEL); 272 if (ret) 273 return ret; 274 275 dev = device_create(&intel_pmt_class, parent, MKDEV(0, 0), entry, 276 "%s%d", ns->name, entry->devid); 277 278 if (IS_ERR(dev)) { 279 dev_err(parent, "Could not create %s%d device node\n", 280 ns->name, entry->devid); 281 ret = PTR_ERR(dev); 282 goto fail_dev_create; 283 } 284 285 entry->kobj = &dev->kobj; 286 287 if (ns->attr_grp) { 288 ret = sysfs_create_group(entry->kobj, ns->attr_grp); 289 if (ret) 290 goto fail_sysfs_create_group; 291 } 292 293 /* if size is 0 assume no data buffer, so no file needed */ 294 if (!entry->size) 295 return 0; 296 297 res.start = entry->base_addr; 298 res.end = res.start + entry->size - 1; 299 res.flags = IORESOURCE_MEM; 300 301 entry->base = devm_ioremap_resource(dev, &res); 302 if (IS_ERR(entry->base)) { 303 ret = PTR_ERR(entry->base); 304 goto fail_ioremap; 305 } 306 307 sysfs_bin_attr_init(&entry->pmt_bin_attr); 308 entry->pmt_bin_attr.attr.name = ns->name; 309 entry->pmt_bin_attr.attr.mode = 0440; 310 entry->pmt_bin_attr.mmap = intel_pmt_mmap; 311 entry->pmt_bin_attr.read = intel_pmt_read; 312 entry->pmt_bin_attr.size = entry->size; 313 314 ret = sysfs_create_bin_file(&dev->kobj, &entry->pmt_bin_attr); 315 if (ret) 316 goto fail_ioremap; 317 318 if (ns->pmt_add_endpoint) { 319 ret = ns->pmt_add_endpoint(ivdev, entry); 320 if (ret) 321 goto fail_add_endpoint; 322 } 323 324 return 0; 325 326 fail_add_endpoint: 327 sysfs_remove_bin_file(entry->kobj, &entry->pmt_bin_attr); 328 fail_ioremap: 329 if (ns->attr_grp) 330 sysfs_remove_group(entry->kobj, ns->attr_grp); 331 fail_sysfs_create_group: 332 device_unregister(dev); 333 fail_dev_create: 334 xa_erase(ns->xa, entry->devid); 335 336 return ret; 337 } 338 339 int intel_pmt_dev_create(struct intel_pmt_entry *entry, struct intel_pmt_namespace *ns, 340 struct intel_vsec_device *intel_vsec_dev, int idx) 341 { 342 struct device *dev = &intel_vsec_dev->auxdev.dev; 343 struct resource *disc_res; 344 int ret; 345 346 disc_res = &intel_vsec_dev->resource[idx]; 347 348 entry->disc_table = devm_ioremap_resource(dev, disc_res); 349 if (IS_ERR(entry->disc_table)) 350 return PTR_ERR(entry->disc_table); 351 352 ret = ns->pmt_header_decode(entry, dev); 353 if (ret) 354 return ret; 355 356 ret = intel_pmt_populate_entry(entry, intel_vsec_dev, disc_res); 357 if (ret) 358 return ret; 359 360 return intel_pmt_dev_register(entry, ns, dev); 361 } 362 EXPORT_SYMBOL_NS_GPL(intel_pmt_dev_create, INTEL_PMT); 363 364 void intel_pmt_dev_destroy(struct intel_pmt_entry *entry, 365 struct intel_pmt_namespace *ns) 366 { 367 struct device *dev = kobj_to_dev(entry->kobj); 368 369 if (entry->size) 370 sysfs_remove_bin_file(entry->kobj, &entry->pmt_bin_attr); 371 372 if (ns->attr_grp) 373 sysfs_remove_group(entry->kobj, ns->attr_grp); 374 375 device_unregister(dev); 376 xa_erase(ns->xa, entry->devid); 377 } 378 EXPORT_SYMBOL_NS_GPL(intel_pmt_dev_destroy, INTEL_PMT); 379 380 static int __init pmt_class_init(void) 381 { 382 return class_register(&intel_pmt_class); 383 } 384 385 static void __exit pmt_class_exit(void) 386 { 387 class_unregister(&intel_pmt_class); 388 } 389 390 module_init(pmt_class_init); 391 module_exit(pmt_class_exit); 392 393 MODULE_AUTHOR("Alexander Duyck <alexander.h.duyck@linux.intel.com>"); 394 MODULE_DESCRIPTION("Intel PMT Class driver"); 395 MODULE_LICENSE("GPL v2"); 396