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