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 
17 static DEFINE_IDR(functions_idr);
18 static DEFINE_MUTEX(functions_mutex);
19 static struct config_group *functions_group;
20 static struct config_group *controllers_group;
21 
22 struct 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 
32 struct pci_epc_group {
33 	struct config_group group;
34 	struct pci_epc *epc;
35 	bool start;
36 };
37 
38 static 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 
43 static 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 
48 static 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 
70 static 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 
86 static 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 
91 static 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 
96 static 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 
109 static 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 
131 static 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 
147 static 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 
152 static 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 
157 static 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 
169 static 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 
202 static 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 
207 CONFIGFS_ATTR(pci_epc_, start);
208 
209 static struct configfs_attribute *pci_epc_attrs[] = {
210 	&pci_epc_attr_start,
211 	NULL,
212 };
213 
214 static 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 
236 static 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 
252 static struct configfs_item_operations pci_epc_item_ops = {
253 	.allow_link	= pci_epc_epf_link,
254 	.drop_link	= pci_epc_epf_unlink,
255 };
256 
257 static 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 
263 struct 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 
295 err_epc_get:
296 	configfs_unregister_group(group);
297 
298 err_register_group:
299 	kfree(epc_group);
300 
301 err:
302 	return ERR_PTR(ret);
303 }
304 EXPORT_SYMBOL(pci_ep_cfs_add_epc_group);
305 
306 void 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 }
318 EXPORT_SYMBOL(pci_ep_cfs_remove_epc_group);
319 
320 #define PCI_EPF_HEADER_R(_name)						       \
321 static 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)					       \
330 static 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)					       \
344 static 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)					       \
358 static 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 
371 static 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 
384 static 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 
391 static 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 
404 static 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 
411 PCI_EPF_HEADER_R(vendorid)
412 PCI_EPF_HEADER_W_u16(vendorid)
413 
414 PCI_EPF_HEADER_R(deviceid)
415 PCI_EPF_HEADER_W_u16(deviceid)
416 
417 PCI_EPF_HEADER_R(revid)
418 PCI_EPF_HEADER_W_u8(revid)
419 
420 PCI_EPF_HEADER_R(progif_code)
421 PCI_EPF_HEADER_W_u8(progif_code)
422 
423 PCI_EPF_HEADER_R(subclass_code)
424 PCI_EPF_HEADER_W_u8(subclass_code)
425 
426 PCI_EPF_HEADER_R(baseclass_code)
427 PCI_EPF_HEADER_W_u8(baseclass_code)
428 
429 PCI_EPF_HEADER_R(cache_line_size)
430 PCI_EPF_HEADER_W_u8(cache_line_size)
431 
432 PCI_EPF_HEADER_R(subsys_vendor_id)
433 PCI_EPF_HEADER_W_u16(subsys_vendor_id)
434 
435 PCI_EPF_HEADER_R(subsys_id)
436 PCI_EPF_HEADER_W_u16(subsys_id)
437 
438 PCI_EPF_HEADER_R(interrupt_pin)
439 PCI_EPF_HEADER_W_u8(interrupt_pin)
440 
441 CONFIGFS_ATTR(pci_epf_, vendorid);
442 CONFIGFS_ATTR(pci_epf_, deviceid);
443 CONFIGFS_ATTR(pci_epf_, revid);
444 CONFIGFS_ATTR(pci_epf_, progif_code);
445 CONFIGFS_ATTR(pci_epf_, subclass_code);
446 CONFIGFS_ATTR(pci_epf_, baseclass_code);
447 CONFIGFS_ATTR(pci_epf_, cache_line_size);
448 CONFIGFS_ATTR(pci_epf_, subsys_vendor_id);
449 CONFIGFS_ATTR(pci_epf_, subsys_id);
450 CONFIGFS_ATTR(pci_epf_, interrupt_pin);
451 CONFIGFS_ATTR(pci_epf_, msi_interrupts);
452 CONFIGFS_ATTR(pci_epf_, msix_interrupts);
453 
454 static 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 
470 static 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 
481 static 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 
492 static 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 
503 static 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 
509 static 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  */
531 static 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 
551 static 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 
568 static 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 
589 static 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 
638 free_name:
639 	kfree(epf_name);
640 
641 remove_idr:
642 	mutex_lock(&functions_mutex);
643 	idr_remove(&functions_idr, epf_group->index);
644 	mutex_unlock(&functions_mutex);
645 
646 free_group:
647 	kfree(epf_group);
648 
649 	return ERR_PTR(err);
650 }
651 
652 static void pci_epf_drop(struct config_group *group, struct config_item *item)
653 {
654 	config_item_put(item);
655 }
656 
657 static struct configfs_group_operations pci_epf_group_ops = {
658 	.make_group     = &pci_epf_make,
659 	.drop_item      = &pci_epf_drop,
660 };
661 
662 static const struct config_item_type pci_epf_group_type = {
663 	.ct_group_ops	= &pci_epf_group_ops,
664 	.ct_owner	= THIS_MODULE,
665 };
666 
667 struct 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 }
679 EXPORT_SYMBOL(pci_ep_cfs_add_epf_group);
680 
681 void 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 }
688 EXPORT_SYMBOL(pci_ep_cfs_remove_epf_group);
689 
690 static const struct config_item_type pci_functions_type = {
691 	.ct_owner	= THIS_MODULE,
692 };
693 
694 static const struct config_item_type pci_controllers_type = {
695 	.ct_owner	= THIS_MODULE,
696 };
697 
698 static const struct config_item_type pci_ep_type = {
699 	.ct_owner	= THIS_MODULE,
700 };
701 
702 static 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 
712 static 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 
747 err_controllers_group:
748 	configfs_unregister_default_group(functions_group);
749 
750 err_functions_group:
751 	configfs_unregister_subsystem(&pci_ep_cfs_subsys);
752 
753 err:
754 	return ret;
755 }
756 module_init(pci_ep_cfs_init);
757 
758 static 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 }
764 module_exit(pci_ep_cfs_exit);
765 
766 MODULE_DESCRIPTION("PCI EP CONFIGFS");
767 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>");
768