Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * configfs to configure the PCI endpoint
4 *
5 * Copyright (C) 2017 Texas Instruments
6 * Author: Kishon Vijay Abraham I <kishon@ti.com>
7 */
8
9#include <linux/module.h>
10#include <linux/idr.h>
11#include <linux/slab.h>
12
13#include <linux/pci-epc.h>
14#include <linux/pci-epf.h>
15#include <linux/pci-ep-cfs.h>
16
17static DEFINE_IDR(functions_idr);
18static DEFINE_MUTEX(functions_mutex);
19static struct config_group *functions_group;
20static struct config_group *controllers_group;
21
22struct pci_epf_group {
23 struct config_group group;
24 struct config_group primary_epc_group;
25 struct config_group secondary_epc_group;
26 struct config_group *type_group;
27 struct delayed_work cfs_work;
28 struct pci_epf *epf;
29 int index;
30};
31
32struct pci_epc_group {
33 struct config_group group;
34 struct pci_epc *epc;
35 bool start;
36};
37
38static inline struct pci_epf_group *to_pci_epf_group(struct config_item *item)
39{
40 return container_of(to_config_group(item), struct pci_epf_group, group);
41}
42
43static inline struct pci_epc_group *to_pci_epc_group(struct config_item *item)
44{
45 return container_of(to_config_group(item), struct pci_epc_group, group);
46}
47
48static int pci_secondary_epc_epf_link(struct config_item *epf_item,
49 struct config_item *epc_item)
50{
51 int ret;
52 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item->ci_parent);
53 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
54 struct pci_epc *epc = epc_group->epc;
55 struct pci_epf *epf = epf_group->epf;
56
57 ret = pci_epc_add_epf(epc, epf, SECONDARY_INTERFACE);
58 if (ret)
59 return ret;
60
61 ret = pci_epf_bind(epf);
62 if (ret) {
63 pci_epc_remove_epf(epc, epf, SECONDARY_INTERFACE);
64 return ret;
65 }
66
67 return 0;
68}
69
70static void pci_secondary_epc_epf_unlink(struct config_item *epc_item,
71 struct config_item *epf_item)
72{
73 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item->ci_parent);
74 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
75 struct pci_epc *epc;
76 struct pci_epf *epf;
77
78 WARN_ON_ONCE(epc_group->start);
79
80 epc = epc_group->epc;
81 epf = epf_group->epf;
82 pci_epf_unbind(epf);
83 pci_epc_remove_epf(epc, epf, SECONDARY_INTERFACE);
84}
85
86static struct configfs_item_operations pci_secondary_epc_item_ops = {
87 .allow_link = pci_secondary_epc_epf_link,
88 .drop_link = pci_secondary_epc_epf_unlink,
89};
90
91static const struct config_item_type pci_secondary_epc_type = {
92 .ct_item_ops = &pci_secondary_epc_item_ops,
93 .ct_owner = THIS_MODULE,
94};
95
96static struct config_group
97*pci_ep_cfs_add_secondary_group(struct pci_epf_group *epf_group)
98{
99 struct config_group *secondary_epc_group;
100
101 secondary_epc_group = &epf_group->secondary_epc_group;
102 config_group_init_type_name(secondary_epc_group, "secondary",
103 &pci_secondary_epc_type);
104 configfs_register_group(&epf_group->group, secondary_epc_group);
105
106 return secondary_epc_group;
107}
108
109static int pci_primary_epc_epf_link(struct config_item *epf_item,
110 struct config_item *epc_item)
111{
112 int ret;
113 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item->ci_parent);
114 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
115 struct pci_epc *epc = epc_group->epc;
116 struct pci_epf *epf = epf_group->epf;
117
118 ret = pci_epc_add_epf(epc, epf, PRIMARY_INTERFACE);
119 if (ret)
120 return ret;
121
122 ret = pci_epf_bind(epf);
123 if (ret) {
124 pci_epc_remove_epf(epc, epf, PRIMARY_INTERFACE);
125 return ret;
126 }
127
128 return 0;
129}
130
131static void pci_primary_epc_epf_unlink(struct config_item *epc_item,
132 struct config_item *epf_item)
133{
134 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item->ci_parent);
135 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
136 struct pci_epc *epc;
137 struct pci_epf *epf;
138
139 WARN_ON_ONCE(epc_group->start);
140
141 epc = epc_group->epc;
142 epf = epf_group->epf;
143 pci_epf_unbind(epf);
144 pci_epc_remove_epf(epc, epf, PRIMARY_INTERFACE);
145}
146
147static struct configfs_item_operations pci_primary_epc_item_ops = {
148 .allow_link = pci_primary_epc_epf_link,
149 .drop_link = pci_primary_epc_epf_unlink,
150};
151
152static const struct config_item_type pci_primary_epc_type = {
153 .ct_item_ops = &pci_primary_epc_item_ops,
154 .ct_owner = THIS_MODULE,
155};
156
157static struct config_group
158*pci_ep_cfs_add_primary_group(struct pci_epf_group *epf_group)
159{
160 struct config_group *primary_epc_group = &epf_group->primary_epc_group;
161
162 config_group_init_type_name(primary_epc_group, "primary",
163 &pci_primary_epc_type);
164 configfs_register_group(&epf_group->group, primary_epc_group);
165
166 return primary_epc_group;
167}
168
169static ssize_t pci_epc_start_store(struct config_item *item, const char *page,
170 size_t len)
171{
172 int ret;
173 bool start;
174 struct pci_epc *epc;
175 struct pci_epc_group *epc_group = to_pci_epc_group(item);
176
177 epc = epc_group->epc;
178
179 if (kstrtobool(page, &start) < 0)
180 return -EINVAL;
181
182 if (start == epc_group->start)
183 return -EALREADY;
184
185 if (!start) {
186 pci_epc_stop(epc);
187 epc_group->start = 0;
188 return len;
189 }
190
191 ret = pci_epc_start(epc);
192 if (ret) {
193 dev_err(&epc->dev, "failed to start endpoint controller\n");
194 return -EINVAL;
195 }
196
197 epc_group->start = start;
198
199 return len;
200}
201
202static ssize_t pci_epc_start_show(struct config_item *item, char *page)
203{
204 return sysfs_emit(page, "%d\n", to_pci_epc_group(item)->start);
205}
206
207CONFIGFS_ATTR(pci_epc_, start);
208
209static struct configfs_attribute *pci_epc_attrs[] = {
210 &pci_epc_attr_start,
211 NULL,
212};
213
214static int pci_epc_epf_link(struct config_item *epc_item,
215 struct config_item *epf_item)
216{
217 int ret;
218 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item);
219 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
220 struct pci_epc *epc = epc_group->epc;
221 struct pci_epf *epf = epf_group->epf;
222
223 ret = pci_epc_add_epf(epc, epf, PRIMARY_INTERFACE);
224 if (ret)
225 return ret;
226
227 ret = pci_epf_bind(epf);
228 if (ret) {
229 pci_epc_remove_epf(epc, epf, PRIMARY_INTERFACE);
230 return ret;
231 }
232
233 return 0;
234}
235
236static void pci_epc_epf_unlink(struct config_item *epc_item,
237 struct config_item *epf_item)
238{
239 struct pci_epc *epc;
240 struct pci_epf *epf;
241 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item);
242 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
243
244 WARN_ON_ONCE(epc_group->start);
245
246 epc = epc_group->epc;
247 epf = epf_group->epf;
248 pci_epf_unbind(epf);
249 pci_epc_remove_epf(epc, epf, PRIMARY_INTERFACE);
250}
251
252static struct configfs_item_operations pci_epc_item_ops = {
253 .allow_link = pci_epc_epf_link,
254 .drop_link = pci_epc_epf_unlink,
255};
256
257static const struct config_item_type pci_epc_type = {
258 .ct_item_ops = &pci_epc_item_ops,
259 .ct_attrs = pci_epc_attrs,
260 .ct_owner = THIS_MODULE,
261};
262
263struct config_group *pci_ep_cfs_add_epc_group(const char *name)
264{
265 int ret;
266 struct pci_epc *epc;
267 struct config_group *group;
268 struct pci_epc_group *epc_group;
269
270 epc_group = kzalloc(sizeof(*epc_group), GFP_KERNEL);
271 if (!epc_group) {
272 ret = -ENOMEM;
273 goto err;
274 }
275
276 group = &epc_group->group;
277
278 config_group_init_type_name(group, name, &pci_epc_type);
279 ret = configfs_register_group(controllers_group, group);
280 if (ret) {
281 pr_err("failed to register configfs group for %s\n", name);
282 goto err_register_group;
283 }
284
285 epc = pci_epc_get(name);
286 if (IS_ERR(epc)) {
287 ret = PTR_ERR(epc);
288 goto err_epc_get;
289 }
290
291 epc_group->epc = epc;
292
293 return group;
294
295err_epc_get:
296 configfs_unregister_group(group);
297
298err_register_group:
299 kfree(epc_group);
300
301err:
302 return ERR_PTR(ret);
303}
304EXPORT_SYMBOL(pci_ep_cfs_add_epc_group);
305
306void pci_ep_cfs_remove_epc_group(struct config_group *group)
307{
308 struct pci_epc_group *epc_group;
309
310 if (!group)
311 return;
312
313 epc_group = container_of(group, struct pci_epc_group, group);
314 pci_epc_put(epc_group->epc);
315 configfs_unregister_group(&epc_group->group);
316 kfree(epc_group);
317}
318EXPORT_SYMBOL(pci_ep_cfs_remove_epc_group);
319
320#define PCI_EPF_HEADER_R(_name) \
321static ssize_t pci_epf_##_name##_show(struct config_item *item, char *page) \
322{ \
323 struct pci_epf *epf = to_pci_epf_group(item)->epf; \
324 if (WARN_ON_ONCE(!epf->header)) \
325 return -EINVAL; \
326 return sysfs_emit(page, "0x%04x\n", epf->header->_name); \
327}
328
329#define PCI_EPF_HEADER_W_u32(_name) \
330static ssize_t pci_epf_##_name##_store(struct config_item *item, \
331 const char *page, size_t len) \
332{ \
333 u32 val; \
334 struct pci_epf *epf = to_pci_epf_group(item)->epf; \
335 if (WARN_ON_ONCE(!epf->header)) \
336 return -EINVAL; \
337 if (kstrtou32(page, 0, &val) < 0) \
338 return -EINVAL; \
339 epf->header->_name = val; \
340 return len; \
341}
342
343#define PCI_EPF_HEADER_W_u16(_name) \
344static ssize_t pci_epf_##_name##_store(struct config_item *item, \
345 const char *page, size_t len) \
346{ \
347 u16 val; \
348 struct pci_epf *epf = to_pci_epf_group(item)->epf; \
349 if (WARN_ON_ONCE(!epf->header)) \
350 return -EINVAL; \
351 if (kstrtou16(page, 0, &val) < 0) \
352 return -EINVAL; \
353 epf->header->_name = val; \
354 return len; \
355}
356
357#define PCI_EPF_HEADER_W_u8(_name) \
358static ssize_t pci_epf_##_name##_store(struct config_item *item, \
359 const char *page, size_t len) \
360{ \
361 u8 val; \
362 struct pci_epf *epf = to_pci_epf_group(item)->epf; \
363 if (WARN_ON_ONCE(!epf->header)) \
364 return -EINVAL; \
365 if (kstrtou8(page, 0, &val) < 0) \
366 return -EINVAL; \
367 epf->header->_name = val; \
368 return len; \
369}
370
371static ssize_t pci_epf_msi_interrupts_store(struct config_item *item,
372 const char *page, size_t len)
373{
374 u8 val;
375
376 if (kstrtou8(page, 0, &val) < 0)
377 return -EINVAL;
378
379 to_pci_epf_group(item)->epf->msi_interrupts = val;
380
381 return len;
382}
383
384static ssize_t pci_epf_msi_interrupts_show(struct config_item *item,
385 char *page)
386{
387 return sysfs_emit(page, "%d\n",
388 to_pci_epf_group(item)->epf->msi_interrupts);
389}
390
391static ssize_t pci_epf_msix_interrupts_store(struct config_item *item,
392 const char *page, size_t len)
393{
394 u16 val;
395
396 if (kstrtou16(page, 0, &val) < 0)
397 return -EINVAL;
398
399 to_pci_epf_group(item)->epf->msix_interrupts = val;
400
401 return len;
402}
403
404static ssize_t pci_epf_msix_interrupts_show(struct config_item *item,
405 char *page)
406{
407 return sysfs_emit(page, "%d\n",
408 to_pci_epf_group(item)->epf->msix_interrupts);
409}
410
411PCI_EPF_HEADER_R(vendorid)
412PCI_EPF_HEADER_W_u16(vendorid)
413
414PCI_EPF_HEADER_R(deviceid)
415PCI_EPF_HEADER_W_u16(deviceid)
416
417PCI_EPF_HEADER_R(revid)
418PCI_EPF_HEADER_W_u8(revid)
419
420PCI_EPF_HEADER_R(progif_code)
421PCI_EPF_HEADER_W_u8(progif_code)
422
423PCI_EPF_HEADER_R(subclass_code)
424PCI_EPF_HEADER_W_u8(subclass_code)
425
426PCI_EPF_HEADER_R(baseclass_code)
427PCI_EPF_HEADER_W_u8(baseclass_code)
428
429PCI_EPF_HEADER_R(cache_line_size)
430PCI_EPF_HEADER_W_u8(cache_line_size)
431
432PCI_EPF_HEADER_R(subsys_vendor_id)
433PCI_EPF_HEADER_W_u16(subsys_vendor_id)
434
435PCI_EPF_HEADER_R(subsys_id)
436PCI_EPF_HEADER_W_u16(subsys_id)
437
438PCI_EPF_HEADER_R(interrupt_pin)
439PCI_EPF_HEADER_W_u8(interrupt_pin)
440
441CONFIGFS_ATTR(pci_epf_, vendorid);
442CONFIGFS_ATTR(pci_epf_, deviceid);
443CONFIGFS_ATTR(pci_epf_, revid);
444CONFIGFS_ATTR(pci_epf_, progif_code);
445CONFIGFS_ATTR(pci_epf_, subclass_code);
446CONFIGFS_ATTR(pci_epf_, baseclass_code);
447CONFIGFS_ATTR(pci_epf_, cache_line_size);
448CONFIGFS_ATTR(pci_epf_, subsys_vendor_id);
449CONFIGFS_ATTR(pci_epf_, subsys_id);
450CONFIGFS_ATTR(pci_epf_, interrupt_pin);
451CONFIGFS_ATTR(pci_epf_, msi_interrupts);
452CONFIGFS_ATTR(pci_epf_, msix_interrupts);
453
454static struct configfs_attribute *pci_epf_attrs[] = {
455 &pci_epf_attr_vendorid,
456 &pci_epf_attr_deviceid,
457 &pci_epf_attr_revid,
458 &pci_epf_attr_progif_code,
459 &pci_epf_attr_subclass_code,
460 &pci_epf_attr_baseclass_code,
461 &pci_epf_attr_cache_line_size,
462 &pci_epf_attr_subsys_vendor_id,
463 &pci_epf_attr_subsys_id,
464 &pci_epf_attr_interrupt_pin,
465 &pci_epf_attr_msi_interrupts,
466 &pci_epf_attr_msix_interrupts,
467 NULL,
468};
469
470static int pci_epf_vepf_link(struct config_item *epf_pf_item,
471 struct config_item *epf_vf_item)
472{
473 struct pci_epf_group *epf_vf_group = to_pci_epf_group(epf_vf_item);
474 struct pci_epf_group *epf_pf_group = to_pci_epf_group(epf_pf_item);
475 struct pci_epf *epf_pf = epf_pf_group->epf;
476 struct pci_epf *epf_vf = epf_vf_group->epf;
477
478 return pci_epf_add_vepf(epf_pf, epf_vf);
479}
480
481static void pci_epf_vepf_unlink(struct config_item *epf_pf_item,
482 struct config_item *epf_vf_item)
483{
484 struct pci_epf_group *epf_vf_group = to_pci_epf_group(epf_vf_item);
485 struct pci_epf_group *epf_pf_group = to_pci_epf_group(epf_pf_item);
486 struct pci_epf *epf_pf = epf_pf_group->epf;
487 struct pci_epf *epf_vf = epf_vf_group->epf;
488
489 pci_epf_remove_vepf(epf_pf, epf_vf);
490}
491
492static void pci_epf_release(struct config_item *item)
493{
494 struct pci_epf_group *epf_group = to_pci_epf_group(item);
495
496 mutex_lock(&functions_mutex);
497 idr_remove(&functions_idr, epf_group->index);
498 mutex_unlock(&functions_mutex);
499 pci_epf_destroy(epf_group->epf);
500 kfree(epf_group);
501}
502
503static struct configfs_item_operations pci_epf_ops = {
504 .allow_link = pci_epf_vepf_link,
505 .drop_link = pci_epf_vepf_unlink,
506 .release = pci_epf_release,
507};
508
509static const struct config_item_type pci_epf_type = {
510 .ct_item_ops = &pci_epf_ops,
511 .ct_attrs = pci_epf_attrs,
512 .ct_owner = THIS_MODULE,
513};
514
515/**
516 * pci_epf_type_add_cfs() - Help function drivers to expose function specific
517 * attributes in configfs
518 * @epf: the EPF device that has to be configured using configfs
519 * @group: the parent configfs group (corresponding to entries in
520 * pci_epf_device_id)
521 *
522 * Invoke to expose function specific attributes in configfs.
523 *
524 * Return: A pointer to a config_group structure or NULL if the function driver
525 * does not have anything to expose (attributes configured by user) or if
526 * the function driver does not implement the add_cfs() method.
527 *
528 * Returns an error pointer if this function is called for an unbound EPF device
529 * or if the EPF driver add_cfs() method fails.
530 */
531static struct config_group *pci_epf_type_add_cfs(struct pci_epf *epf,
532 struct config_group *group)
533{
534 struct config_group *epf_type_group;
535
536 if (!epf->driver) {
537 dev_err(&epf->dev, "epf device not bound to driver\n");
538 return ERR_PTR(-ENODEV);
539 }
540
541 if (!epf->driver->ops->add_cfs)
542 return NULL;
543
544 mutex_lock(&epf->lock);
545 epf_type_group = epf->driver->ops->add_cfs(epf, group);
546 mutex_unlock(&epf->lock);
547
548 return epf_type_group;
549}
550
551static void pci_ep_cfs_add_type_group(struct pci_epf_group *epf_group)
552{
553 struct config_group *group;
554
555 group = pci_epf_type_add_cfs(epf_group->epf, &epf_group->group);
556 if (!group)
557 return;
558
559 if (IS_ERR(group)) {
560 dev_err(&epf_group->epf->dev,
561 "failed to create epf type specific attributes\n");
562 return;
563 }
564
565 configfs_register_group(&epf_group->group, group);
566}
567
568static void pci_epf_cfs_work(struct work_struct *work)
569{
570 struct pci_epf_group *epf_group;
571 struct config_group *group;
572
573 epf_group = container_of(work, struct pci_epf_group, cfs_work.work);
574 group = pci_ep_cfs_add_primary_group(epf_group);
575 if (IS_ERR(group)) {
576 pr_err("failed to create 'primary' EPC interface\n");
577 return;
578 }
579
580 group = pci_ep_cfs_add_secondary_group(epf_group);
581 if (IS_ERR(group)) {
582 pr_err("failed to create 'secondary' EPC interface\n");
583 return;
584 }
585
586 pci_ep_cfs_add_type_group(epf_group);
587}
588
589static struct config_group *pci_epf_make(struct config_group *group,
590 const char *name)
591{
592 struct pci_epf_group *epf_group;
593 struct pci_epf *epf;
594 char *epf_name;
595 int index, err;
596
597 epf_group = kzalloc(sizeof(*epf_group), GFP_KERNEL);
598 if (!epf_group)
599 return ERR_PTR(-ENOMEM);
600
601 mutex_lock(&functions_mutex);
602 index = idr_alloc(&functions_idr, epf_group, 0, 0, GFP_KERNEL);
603 mutex_unlock(&functions_mutex);
604 if (index < 0) {
605 err = index;
606 goto free_group;
607 }
608
609 epf_group->index = index;
610
611 config_group_init_type_name(&epf_group->group, name, &pci_epf_type);
612
613 epf_name = kasprintf(GFP_KERNEL, "%s.%d",
614 group->cg_item.ci_name, epf_group->index);
615 if (!epf_name) {
616 err = -ENOMEM;
617 goto remove_idr;
618 }
619
620 epf = pci_epf_create(epf_name);
621 if (IS_ERR(epf)) {
622 pr_err("failed to create endpoint function device\n");
623 err = -EINVAL;
624 goto free_name;
625 }
626
627 epf->group = &epf_group->group;
628 epf_group->epf = epf;
629
630 kfree(epf_name);
631
632 INIT_DELAYED_WORK(&epf_group->cfs_work, pci_epf_cfs_work);
633 queue_delayed_work(system_wq, &epf_group->cfs_work,
634 msecs_to_jiffies(1));
635
636 return &epf_group->group;
637
638free_name:
639 kfree(epf_name);
640
641remove_idr:
642 mutex_lock(&functions_mutex);
643 idr_remove(&functions_idr, epf_group->index);
644 mutex_unlock(&functions_mutex);
645
646free_group:
647 kfree(epf_group);
648
649 return ERR_PTR(err);
650}
651
652static void pci_epf_drop(struct config_group *group, struct config_item *item)
653{
654 config_item_put(item);
655}
656
657static struct configfs_group_operations pci_epf_group_ops = {
658 .make_group = &pci_epf_make,
659 .drop_item = &pci_epf_drop,
660};
661
662static const struct config_item_type pci_epf_group_type = {
663 .ct_group_ops = &pci_epf_group_ops,
664 .ct_owner = THIS_MODULE,
665};
666
667struct config_group *pci_ep_cfs_add_epf_group(const char *name)
668{
669 struct config_group *group;
670
671 group = configfs_register_default_group(functions_group, name,
672 &pci_epf_group_type);
673 if (IS_ERR(group))
674 pr_err("failed to register configfs group for %s function\n",
675 name);
676
677 return group;
678}
679EXPORT_SYMBOL(pci_ep_cfs_add_epf_group);
680
681void pci_ep_cfs_remove_epf_group(struct config_group *group)
682{
683 if (IS_ERR_OR_NULL(group))
684 return;
685
686 configfs_unregister_default_group(group);
687}
688EXPORT_SYMBOL(pci_ep_cfs_remove_epf_group);
689
690static const struct config_item_type pci_functions_type = {
691 .ct_owner = THIS_MODULE,
692};
693
694static const struct config_item_type pci_controllers_type = {
695 .ct_owner = THIS_MODULE,
696};
697
698static const struct config_item_type pci_ep_type = {
699 .ct_owner = THIS_MODULE,
700};
701
702static struct configfs_subsystem pci_ep_cfs_subsys = {
703 .su_group = {
704 .cg_item = {
705 .ci_namebuf = "pci_ep",
706 .ci_type = &pci_ep_type,
707 },
708 },
709 .su_mutex = __MUTEX_INITIALIZER(pci_ep_cfs_subsys.su_mutex),
710};
711
712static int __init pci_ep_cfs_init(void)
713{
714 int ret;
715 struct config_group *root = &pci_ep_cfs_subsys.su_group;
716
717 config_group_init(root);
718
719 ret = configfs_register_subsystem(&pci_ep_cfs_subsys);
720 if (ret) {
721 pr_err("Error %d while registering subsystem %s\n",
722 ret, root->cg_item.ci_namebuf);
723 goto err;
724 }
725
726 functions_group = configfs_register_default_group(root, "functions",
727 &pci_functions_type);
728 if (IS_ERR(functions_group)) {
729 ret = PTR_ERR(functions_group);
730 pr_err("Error %d while registering functions group\n",
731 ret);
732 goto err_functions_group;
733 }
734
735 controllers_group =
736 configfs_register_default_group(root, "controllers",
737 &pci_controllers_type);
738 if (IS_ERR(controllers_group)) {
739 ret = PTR_ERR(controllers_group);
740 pr_err("Error %d while registering controllers group\n",
741 ret);
742 goto err_controllers_group;
743 }
744
745 return 0;
746
747err_controllers_group:
748 configfs_unregister_default_group(functions_group);
749
750err_functions_group:
751 configfs_unregister_subsystem(&pci_ep_cfs_subsys);
752
753err:
754 return ret;
755}
756module_init(pci_ep_cfs_init);
757
758static void __exit pci_ep_cfs_exit(void)
759{
760 configfs_unregister_default_group(controllers_group);
761 configfs_unregister_default_group(functions_group);
762 configfs_unregister_subsystem(&pci_ep_cfs_subsys);
763}
764module_exit(pci_ep_cfs_exit);
765
766MODULE_DESCRIPTION("PCI EP CONFIGFS");
767MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * configfs to configure the PCI endpoint
4 *
5 * Copyright (C) 2017 Texas Instruments
6 * Author: Kishon Vijay Abraham I <kishon@ti.com>
7 */
8
9#include <linux/module.h>
10#include <linux/idr.h>
11#include <linux/slab.h>
12
13#include <linux/pci-epc.h>
14#include <linux/pci-epf.h>
15#include <linux/pci-ep-cfs.h>
16
17static DEFINE_IDR(functions_idr);
18static DEFINE_MUTEX(functions_mutex);
19static struct config_group *functions_group;
20static struct config_group *controllers_group;
21
22struct pci_epf_group {
23 struct config_group group;
24 struct config_group primary_epc_group;
25 struct config_group secondary_epc_group;
26 struct delayed_work cfs_work;
27 struct pci_epf *epf;
28 int index;
29};
30
31struct pci_epc_group {
32 struct config_group group;
33 struct pci_epc *epc;
34 bool start;
35};
36
37static inline struct pci_epf_group *to_pci_epf_group(struct config_item *item)
38{
39 return container_of(to_config_group(item), struct pci_epf_group, group);
40}
41
42static inline struct pci_epc_group *to_pci_epc_group(struct config_item *item)
43{
44 return container_of(to_config_group(item), struct pci_epc_group, group);
45}
46
47static int pci_secondary_epc_epf_link(struct config_item *epf_item,
48 struct config_item *epc_item)
49{
50 int ret;
51 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item->ci_parent);
52 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
53 struct pci_epc *epc = epc_group->epc;
54 struct pci_epf *epf = epf_group->epf;
55
56 ret = pci_epc_add_epf(epc, epf, SECONDARY_INTERFACE);
57 if (ret)
58 return ret;
59
60 ret = pci_epf_bind(epf);
61 if (ret) {
62 pci_epc_remove_epf(epc, epf, SECONDARY_INTERFACE);
63 return ret;
64 }
65
66 return 0;
67}
68
69static void pci_secondary_epc_epf_unlink(struct config_item *epc_item,
70 struct config_item *epf_item)
71{
72 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item->ci_parent);
73 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
74 struct pci_epc *epc;
75 struct pci_epf *epf;
76
77 WARN_ON_ONCE(epc_group->start);
78
79 epc = epc_group->epc;
80 epf = epf_group->epf;
81 pci_epf_unbind(epf);
82 pci_epc_remove_epf(epc, epf, SECONDARY_INTERFACE);
83}
84
85static struct configfs_item_operations pci_secondary_epc_item_ops = {
86 .allow_link = pci_secondary_epc_epf_link,
87 .drop_link = pci_secondary_epc_epf_unlink,
88};
89
90static const struct config_item_type pci_secondary_epc_type = {
91 .ct_item_ops = &pci_secondary_epc_item_ops,
92 .ct_owner = THIS_MODULE,
93};
94
95static struct config_group
96*pci_ep_cfs_add_secondary_group(struct pci_epf_group *epf_group)
97{
98 struct config_group *secondary_epc_group;
99
100 secondary_epc_group = &epf_group->secondary_epc_group;
101 config_group_init_type_name(secondary_epc_group, "secondary",
102 &pci_secondary_epc_type);
103 configfs_register_group(&epf_group->group, secondary_epc_group);
104
105 return secondary_epc_group;
106}
107
108static int pci_primary_epc_epf_link(struct config_item *epf_item,
109 struct config_item *epc_item)
110{
111 int ret;
112 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item->ci_parent);
113 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
114 struct pci_epc *epc = epc_group->epc;
115 struct pci_epf *epf = epf_group->epf;
116
117 ret = pci_epc_add_epf(epc, epf, PRIMARY_INTERFACE);
118 if (ret)
119 return ret;
120
121 ret = pci_epf_bind(epf);
122 if (ret) {
123 pci_epc_remove_epf(epc, epf, PRIMARY_INTERFACE);
124 return ret;
125 }
126
127 return 0;
128}
129
130static void pci_primary_epc_epf_unlink(struct config_item *epc_item,
131 struct config_item *epf_item)
132{
133 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item->ci_parent);
134 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
135 struct pci_epc *epc;
136 struct pci_epf *epf;
137
138 WARN_ON_ONCE(epc_group->start);
139
140 epc = epc_group->epc;
141 epf = epf_group->epf;
142 pci_epf_unbind(epf);
143 pci_epc_remove_epf(epc, epf, PRIMARY_INTERFACE);
144}
145
146static struct configfs_item_operations pci_primary_epc_item_ops = {
147 .allow_link = pci_primary_epc_epf_link,
148 .drop_link = pci_primary_epc_epf_unlink,
149};
150
151static const struct config_item_type pci_primary_epc_type = {
152 .ct_item_ops = &pci_primary_epc_item_ops,
153 .ct_owner = THIS_MODULE,
154};
155
156static struct config_group
157*pci_ep_cfs_add_primary_group(struct pci_epf_group *epf_group)
158{
159 struct config_group *primary_epc_group = &epf_group->primary_epc_group;
160
161 config_group_init_type_name(primary_epc_group, "primary",
162 &pci_primary_epc_type);
163 configfs_register_group(&epf_group->group, primary_epc_group);
164
165 return primary_epc_group;
166}
167
168static ssize_t pci_epc_start_store(struct config_item *item, const char *page,
169 size_t len)
170{
171 int ret;
172 bool start;
173 struct pci_epc *epc;
174 struct pci_epc_group *epc_group = to_pci_epc_group(item);
175
176 epc = epc_group->epc;
177
178 if (kstrtobool(page, &start) < 0)
179 return -EINVAL;
180
181 if (!start) {
182 pci_epc_stop(epc);
183 epc_group->start = 0;
184 return len;
185 }
186
187 ret = pci_epc_start(epc);
188 if (ret) {
189 dev_err(&epc->dev, "failed to start endpoint controller\n");
190 return -EINVAL;
191 }
192
193 epc_group->start = start;
194
195 return len;
196}
197
198static ssize_t pci_epc_start_show(struct config_item *item, char *page)
199{
200 return sysfs_emit(page, "%d\n", to_pci_epc_group(item)->start);
201}
202
203CONFIGFS_ATTR(pci_epc_, start);
204
205static struct configfs_attribute *pci_epc_attrs[] = {
206 &pci_epc_attr_start,
207 NULL,
208};
209
210static int pci_epc_epf_link(struct config_item *epc_item,
211 struct config_item *epf_item)
212{
213 int ret;
214 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item);
215 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
216 struct pci_epc *epc = epc_group->epc;
217 struct pci_epf *epf = epf_group->epf;
218
219 ret = pci_epc_add_epf(epc, epf, PRIMARY_INTERFACE);
220 if (ret)
221 return ret;
222
223 ret = pci_epf_bind(epf);
224 if (ret) {
225 pci_epc_remove_epf(epc, epf, PRIMARY_INTERFACE);
226 return ret;
227 }
228
229 return 0;
230}
231
232static void pci_epc_epf_unlink(struct config_item *epc_item,
233 struct config_item *epf_item)
234{
235 struct pci_epc *epc;
236 struct pci_epf *epf;
237 struct pci_epf_group *epf_group = to_pci_epf_group(epf_item);
238 struct pci_epc_group *epc_group = to_pci_epc_group(epc_item);
239
240 WARN_ON_ONCE(epc_group->start);
241
242 epc = epc_group->epc;
243 epf = epf_group->epf;
244 pci_epf_unbind(epf);
245 pci_epc_remove_epf(epc, epf, PRIMARY_INTERFACE);
246}
247
248static struct configfs_item_operations pci_epc_item_ops = {
249 .allow_link = pci_epc_epf_link,
250 .drop_link = pci_epc_epf_unlink,
251};
252
253static const struct config_item_type pci_epc_type = {
254 .ct_item_ops = &pci_epc_item_ops,
255 .ct_attrs = pci_epc_attrs,
256 .ct_owner = THIS_MODULE,
257};
258
259struct config_group *pci_ep_cfs_add_epc_group(const char *name)
260{
261 int ret;
262 struct pci_epc *epc;
263 struct config_group *group;
264 struct pci_epc_group *epc_group;
265
266 epc_group = kzalloc(sizeof(*epc_group), GFP_KERNEL);
267 if (!epc_group) {
268 ret = -ENOMEM;
269 goto err;
270 }
271
272 group = &epc_group->group;
273
274 config_group_init_type_name(group, name, &pci_epc_type);
275 ret = configfs_register_group(controllers_group, group);
276 if (ret) {
277 pr_err("failed to register configfs group for %s\n", name);
278 goto err_register_group;
279 }
280
281 epc = pci_epc_get(name);
282 if (IS_ERR(epc)) {
283 ret = PTR_ERR(epc);
284 goto err_epc_get;
285 }
286
287 epc_group->epc = epc;
288
289 return group;
290
291err_epc_get:
292 configfs_unregister_group(group);
293
294err_register_group:
295 kfree(epc_group);
296
297err:
298 return ERR_PTR(ret);
299}
300EXPORT_SYMBOL(pci_ep_cfs_add_epc_group);
301
302void pci_ep_cfs_remove_epc_group(struct config_group *group)
303{
304 struct pci_epc_group *epc_group;
305
306 if (!group)
307 return;
308
309 epc_group = container_of(group, struct pci_epc_group, group);
310 pci_epc_put(epc_group->epc);
311 configfs_unregister_group(&epc_group->group);
312 kfree(epc_group);
313}
314EXPORT_SYMBOL(pci_ep_cfs_remove_epc_group);
315
316#define PCI_EPF_HEADER_R(_name) \
317static ssize_t pci_epf_##_name##_show(struct config_item *item, char *page) \
318{ \
319 struct pci_epf *epf = to_pci_epf_group(item)->epf; \
320 if (WARN_ON_ONCE(!epf->header)) \
321 return -EINVAL; \
322 return sysfs_emit(page, "0x%04x\n", epf->header->_name); \
323}
324
325#define PCI_EPF_HEADER_W_u32(_name) \
326static ssize_t pci_epf_##_name##_store(struct config_item *item, \
327 const char *page, size_t len) \
328{ \
329 u32 val; \
330 struct pci_epf *epf = to_pci_epf_group(item)->epf; \
331 if (WARN_ON_ONCE(!epf->header)) \
332 return -EINVAL; \
333 if (kstrtou32(page, 0, &val) < 0) \
334 return -EINVAL; \
335 epf->header->_name = val; \
336 return len; \
337}
338
339#define PCI_EPF_HEADER_W_u16(_name) \
340static ssize_t pci_epf_##_name##_store(struct config_item *item, \
341 const char *page, size_t len) \
342{ \
343 u16 val; \
344 struct pci_epf *epf = to_pci_epf_group(item)->epf; \
345 if (WARN_ON_ONCE(!epf->header)) \
346 return -EINVAL; \
347 if (kstrtou16(page, 0, &val) < 0) \
348 return -EINVAL; \
349 epf->header->_name = val; \
350 return len; \
351}
352
353#define PCI_EPF_HEADER_W_u8(_name) \
354static ssize_t pci_epf_##_name##_store(struct config_item *item, \
355 const char *page, size_t len) \
356{ \
357 u8 val; \
358 struct pci_epf *epf = to_pci_epf_group(item)->epf; \
359 if (WARN_ON_ONCE(!epf->header)) \
360 return -EINVAL; \
361 if (kstrtou8(page, 0, &val) < 0) \
362 return -EINVAL; \
363 epf->header->_name = val; \
364 return len; \
365}
366
367static ssize_t pci_epf_msi_interrupts_store(struct config_item *item,
368 const char *page, size_t len)
369{
370 u8 val;
371
372 if (kstrtou8(page, 0, &val) < 0)
373 return -EINVAL;
374
375 to_pci_epf_group(item)->epf->msi_interrupts = val;
376
377 return len;
378}
379
380static ssize_t pci_epf_msi_interrupts_show(struct config_item *item,
381 char *page)
382{
383 return sysfs_emit(page, "%d\n",
384 to_pci_epf_group(item)->epf->msi_interrupts);
385}
386
387static ssize_t pci_epf_msix_interrupts_store(struct config_item *item,
388 const char *page, size_t len)
389{
390 u16 val;
391
392 if (kstrtou16(page, 0, &val) < 0)
393 return -EINVAL;
394
395 to_pci_epf_group(item)->epf->msix_interrupts = val;
396
397 return len;
398}
399
400static ssize_t pci_epf_msix_interrupts_show(struct config_item *item,
401 char *page)
402{
403 return sysfs_emit(page, "%d\n",
404 to_pci_epf_group(item)->epf->msix_interrupts);
405}
406
407PCI_EPF_HEADER_R(vendorid)
408PCI_EPF_HEADER_W_u16(vendorid)
409
410PCI_EPF_HEADER_R(deviceid)
411PCI_EPF_HEADER_W_u16(deviceid)
412
413PCI_EPF_HEADER_R(revid)
414PCI_EPF_HEADER_W_u8(revid)
415
416PCI_EPF_HEADER_R(progif_code)
417PCI_EPF_HEADER_W_u8(progif_code)
418
419PCI_EPF_HEADER_R(subclass_code)
420PCI_EPF_HEADER_W_u8(subclass_code)
421
422PCI_EPF_HEADER_R(baseclass_code)
423PCI_EPF_HEADER_W_u8(baseclass_code)
424
425PCI_EPF_HEADER_R(cache_line_size)
426PCI_EPF_HEADER_W_u8(cache_line_size)
427
428PCI_EPF_HEADER_R(subsys_vendor_id)
429PCI_EPF_HEADER_W_u16(subsys_vendor_id)
430
431PCI_EPF_HEADER_R(subsys_id)
432PCI_EPF_HEADER_W_u16(subsys_id)
433
434PCI_EPF_HEADER_R(interrupt_pin)
435PCI_EPF_HEADER_W_u8(interrupt_pin)
436
437CONFIGFS_ATTR(pci_epf_, vendorid);
438CONFIGFS_ATTR(pci_epf_, deviceid);
439CONFIGFS_ATTR(pci_epf_, revid);
440CONFIGFS_ATTR(pci_epf_, progif_code);
441CONFIGFS_ATTR(pci_epf_, subclass_code);
442CONFIGFS_ATTR(pci_epf_, baseclass_code);
443CONFIGFS_ATTR(pci_epf_, cache_line_size);
444CONFIGFS_ATTR(pci_epf_, subsys_vendor_id);
445CONFIGFS_ATTR(pci_epf_, subsys_id);
446CONFIGFS_ATTR(pci_epf_, interrupt_pin);
447CONFIGFS_ATTR(pci_epf_, msi_interrupts);
448CONFIGFS_ATTR(pci_epf_, msix_interrupts);
449
450static struct configfs_attribute *pci_epf_attrs[] = {
451 &pci_epf_attr_vendorid,
452 &pci_epf_attr_deviceid,
453 &pci_epf_attr_revid,
454 &pci_epf_attr_progif_code,
455 &pci_epf_attr_subclass_code,
456 &pci_epf_attr_baseclass_code,
457 &pci_epf_attr_cache_line_size,
458 &pci_epf_attr_subsys_vendor_id,
459 &pci_epf_attr_subsys_id,
460 &pci_epf_attr_interrupt_pin,
461 &pci_epf_attr_msi_interrupts,
462 &pci_epf_attr_msix_interrupts,
463 NULL,
464};
465
466static int pci_epf_vepf_link(struct config_item *epf_pf_item,
467 struct config_item *epf_vf_item)
468{
469 struct pci_epf_group *epf_vf_group = to_pci_epf_group(epf_vf_item);
470 struct pci_epf_group *epf_pf_group = to_pci_epf_group(epf_pf_item);
471 struct pci_epf *epf_pf = epf_pf_group->epf;
472 struct pci_epf *epf_vf = epf_vf_group->epf;
473
474 return pci_epf_add_vepf(epf_pf, epf_vf);
475}
476
477static void pci_epf_vepf_unlink(struct config_item *epf_pf_item,
478 struct config_item *epf_vf_item)
479{
480 struct pci_epf_group *epf_vf_group = to_pci_epf_group(epf_vf_item);
481 struct pci_epf_group *epf_pf_group = to_pci_epf_group(epf_pf_item);
482 struct pci_epf *epf_pf = epf_pf_group->epf;
483 struct pci_epf *epf_vf = epf_vf_group->epf;
484
485 pci_epf_remove_vepf(epf_pf, epf_vf);
486}
487
488static void pci_epf_release(struct config_item *item)
489{
490 struct pci_epf_group *epf_group = to_pci_epf_group(item);
491
492 mutex_lock(&functions_mutex);
493 idr_remove(&functions_idr, epf_group->index);
494 mutex_unlock(&functions_mutex);
495 pci_epf_destroy(epf_group->epf);
496 kfree(epf_group);
497}
498
499static struct configfs_item_operations pci_epf_ops = {
500 .allow_link = pci_epf_vepf_link,
501 .drop_link = pci_epf_vepf_unlink,
502 .release = pci_epf_release,
503};
504
505static struct config_group *pci_epf_type_make(struct config_group *group,
506 const char *name)
507{
508 struct pci_epf_group *epf_group = to_pci_epf_group(&group->cg_item);
509 struct config_group *epf_type_group;
510
511 epf_type_group = pci_epf_type_add_cfs(epf_group->epf, group);
512 return epf_type_group;
513}
514
515static void pci_epf_type_drop(struct config_group *group,
516 struct config_item *item)
517{
518 config_item_put(item);
519}
520
521static struct configfs_group_operations pci_epf_type_group_ops = {
522 .make_group = &pci_epf_type_make,
523 .drop_item = &pci_epf_type_drop,
524};
525
526static const struct config_item_type pci_epf_type = {
527 .ct_group_ops = &pci_epf_type_group_ops,
528 .ct_item_ops = &pci_epf_ops,
529 .ct_attrs = pci_epf_attrs,
530 .ct_owner = THIS_MODULE,
531};
532
533static void pci_epf_cfs_work(struct work_struct *work)
534{
535 struct pci_epf_group *epf_group;
536 struct config_group *group;
537
538 epf_group = container_of(work, struct pci_epf_group, cfs_work.work);
539 group = pci_ep_cfs_add_primary_group(epf_group);
540 if (IS_ERR(group)) {
541 pr_err("failed to create 'primary' EPC interface\n");
542 return;
543 }
544
545 group = pci_ep_cfs_add_secondary_group(epf_group);
546 if (IS_ERR(group)) {
547 pr_err("failed to create 'secondary' EPC interface\n");
548 return;
549 }
550}
551
552static struct config_group *pci_epf_make(struct config_group *group,
553 const char *name)
554{
555 struct pci_epf_group *epf_group;
556 struct pci_epf *epf;
557 char *epf_name;
558 int index, err;
559
560 epf_group = kzalloc(sizeof(*epf_group), GFP_KERNEL);
561 if (!epf_group)
562 return ERR_PTR(-ENOMEM);
563
564 mutex_lock(&functions_mutex);
565 index = idr_alloc(&functions_idr, epf_group, 0, 0, GFP_KERNEL);
566 mutex_unlock(&functions_mutex);
567 if (index < 0) {
568 err = index;
569 goto free_group;
570 }
571
572 epf_group->index = index;
573
574 config_group_init_type_name(&epf_group->group, name, &pci_epf_type);
575
576 epf_name = kasprintf(GFP_KERNEL, "%s.%d",
577 group->cg_item.ci_name, epf_group->index);
578 if (!epf_name) {
579 err = -ENOMEM;
580 goto remove_idr;
581 }
582
583 epf = pci_epf_create(epf_name);
584 if (IS_ERR(epf)) {
585 pr_err("failed to create endpoint function device\n");
586 err = -EINVAL;
587 goto free_name;
588 }
589
590 epf->group = &epf_group->group;
591 epf_group->epf = epf;
592
593 kfree(epf_name);
594
595 INIT_DELAYED_WORK(&epf_group->cfs_work, pci_epf_cfs_work);
596 queue_delayed_work(system_wq, &epf_group->cfs_work,
597 msecs_to_jiffies(1));
598
599 return &epf_group->group;
600
601free_name:
602 kfree(epf_name);
603
604remove_idr:
605 mutex_lock(&functions_mutex);
606 idr_remove(&functions_idr, epf_group->index);
607 mutex_unlock(&functions_mutex);
608
609free_group:
610 kfree(epf_group);
611
612 return ERR_PTR(err);
613}
614
615static void pci_epf_drop(struct config_group *group, struct config_item *item)
616{
617 config_item_put(item);
618}
619
620static struct configfs_group_operations pci_epf_group_ops = {
621 .make_group = &pci_epf_make,
622 .drop_item = &pci_epf_drop,
623};
624
625static const struct config_item_type pci_epf_group_type = {
626 .ct_group_ops = &pci_epf_group_ops,
627 .ct_owner = THIS_MODULE,
628};
629
630struct config_group *pci_ep_cfs_add_epf_group(const char *name)
631{
632 struct config_group *group;
633
634 group = configfs_register_default_group(functions_group, name,
635 &pci_epf_group_type);
636 if (IS_ERR(group))
637 pr_err("failed to register configfs group for %s function\n",
638 name);
639
640 return group;
641}
642EXPORT_SYMBOL(pci_ep_cfs_add_epf_group);
643
644void pci_ep_cfs_remove_epf_group(struct config_group *group)
645{
646 if (IS_ERR_OR_NULL(group))
647 return;
648
649 configfs_unregister_default_group(group);
650}
651EXPORT_SYMBOL(pci_ep_cfs_remove_epf_group);
652
653static const struct config_item_type pci_functions_type = {
654 .ct_owner = THIS_MODULE,
655};
656
657static const struct config_item_type pci_controllers_type = {
658 .ct_owner = THIS_MODULE,
659};
660
661static const struct config_item_type pci_ep_type = {
662 .ct_owner = THIS_MODULE,
663};
664
665static struct configfs_subsystem pci_ep_cfs_subsys = {
666 .su_group = {
667 .cg_item = {
668 .ci_namebuf = "pci_ep",
669 .ci_type = &pci_ep_type,
670 },
671 },
672 .su_mutex = __MUTEX_INITIALIZER(pci_ep_cfs_subsys.su_mutex),
673};
674
675static int __init pci_ep_cfs_init(void)
676{
677 int ret;
678 struct config_group *root = &pci_ep_cfs_subsys.su_group;
679
680 config_group_init(root);
681
682 ret = configfs_register_subsystem(&pci_ep_cfs_subsys);
683 if (ret) {
684 pr_err("Error %d while registering subsystem %s\n",
685 ret, root->cg_item.ci_namebuf);
686 goto err;
687 }
688
689 functions_group = configfs_register_default_group(root, "functions",
690 &pci_functions_type);
691 if (IS_ERR(functions_group)) {
692 ret = PTR_ERR(functions_group);
693 pr_err("Error %d while registering functions group\n",
694 ret);
695 goto err_functions_group;
696 }
697
698 controllers_group =
699 configfs_register_default_group(root, "controllers",
700 &pci_controllers_type);
701 if (IS_ERR(controllers_group)) {
702 ret = PTR_ERR(controllers_group);
703 pr_err("Error %d while registering controllers group\n",
704 ret);
705 goto err_controllers_group;
706 }
707
708 return 0;
709
710err_controllers_group:
711 configfs_unregister_default_group(functions_group);
712
713err_functions_group:
714 configfs_unregister_subsystem(&pci_ep_cfs_subsys);
715
716err:
717 return ret;
718}
719module_init(pci_ep_cfs_init);
720
721static void __exit pci_ep_cfs_exit(void)
722{
723 configfs_unregister_default_group(controllers_group);
724 configfs_unregister_default_group(functions_group);
725 configfs_unregister_subsystem(&pci_ep_cfs_subsys);
726}
727module_exit(pci_ep_cfs_exit);
728
729MODULE_DESCRIPTION("PCI EP CONFIGFS");
730MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
731MODULE_LICENSE("GPL v2");