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