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
 25bool 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}
 36EXPORT_SYMBOL_NS_GPL(intel_pmt_is_early_client_hw, "INTEL_PMT");
 37
 38static inline int
 39pmt_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
 61int 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}
 77EXPORT_SYMBOL_NS_GPL(pmt_telem_read_mmio, "INTEL_PMT");
 78
 79/*
 80 * sysfs
 81 */
 82static ssize_t
 83intel_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
106static int
107intel_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
136static ssize_t
137guid_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}
143static DEVICE_ATTR_RO(guid);
144
145static 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}
152static DEVICE_ATTR_RO(size);
153
154static ssize_t
155offset_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}
161static DEVICE_ATTR_RO(offset);
162
163static struct attribute *intel_pmt_attrs[] = {
164	&dev_attr_guid.attr,
165	&dev_attr_size.attr,
166	&dev_attr_offset.attr,
167	NULL
168};
169ATTRIBUTE_GROUPS(intel_pmt);
170
171static struct class intel_pmt_class = {
172	.name = "intel_pmt",
173	.dev_groups = intel_pmt_groups,
174};
175
176static 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
262static 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
326fail_add_endpoint:
327	sysfs_remove_bin_file(entry->kobj, &entry->pmt_bin_attr);
328fail_ioremap:
329	if (ns->attr_grp)
330		sysfs_remove_group(entry->kobj, ns->attr_grp);
331fail_sysfs_create_group:
332	device_unregister(dev);
333fail_dev_create:
334	xa_erase(ns->xa, entry->devid);
335
336	return ret;
337}
338
339int 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}
362EXPORT_SYMBOL_NS_GPL(intel_pmt_dev_create, "INTEL_PMT");
363
364void 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}
378EXPORT_SYMBOL_NS_GPL(intel_pmt_dev_destroy, "INTEL_PMT");
379
380static int __init pmt_class_init(void)
381{
382	return class_register(&intel_pmt_class);
383}
384
385static void __exit pmt_class_exit(void)
386{
387	class_unregister(&intel_pmt_class);
388}
389
390module_init(pmt_class_init);
391module_exit(pmt_class_exit);
392
393MODULE_AUTHOR("Alexander Duyck <alexander.h.duyck@linux.intel.com>");
394MODULE_DESCRIPTION("Intel PMT Class driver");
395MODULE_LICENSE("GPL v2");