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 delayed_work cfs_work; 27 struct pci_epf *epf; 28 int index; 29 }; 30 31 struct pci_epc_group { 32 struct config_group group; 33 struct pci_epc *epc; 34 bool start; 35 }; 36 37 static 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 42 static 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 47 static 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 69 static 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 85 static 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 90 static 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 95 static 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 108 static 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 130 static 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 146 static 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 151 static 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 156 static 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 168 static 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 198 static 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 203 CONFIGFS_ATTR(pci_epc_, start); 204 205 static struct configfs_attribute *pci_epc_attrs[] = { 206 &pci_epc_attr_start, 207 NULL, 208 }; 209 210 static 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 232 static 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 248 static struct configfs_item_operations pci_epc_item_ops = { 249 .allow_link = pci_epc_epf_link, 250 .drop_link = pci_epc_epf_unlink, 251 }; 252 253 static 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 259 struct 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 291 err_epc_get: 292 configfs_unregister_group(group); 293 294 err_register_group: 295 kfree(epc_group); 296 297 err: 298 return ERR_PTR(ret); 299 } 300 EXPORT_SYMBOL(pci_ep_cfs_add_epc_group); 301 302 void 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 } 314 EXPORT_SYMBOL(pci_ep_cfs_remove_epc_group); 315 316 #define PCI_EPF_HEADER_R(_name) \ 317 static 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) \ 326 static 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) \ 340 static 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) \ 354 static 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 367 static 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 380 static 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 387 static 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 400 static 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 407 PCI_EPF_HEADER_R(vendorid) 408 PCI_EPF_HEADER_W_u16(vendorid) 409 410 PCI_EPF_HEADER_R(deviceid) 411 PCI_EPF_HEADER_W_u16(deviceid) 412 413 PCI_EPF_HEADER_R(revid) 414 PCI_EPF_HEADER_W_u8(revid) 415 416 PCI_EPF_HEADER_R(progif_code) 417 PCI_EPF_HEADER_W_u8(progif_code) 418 419 PCI_EPF_HEADER_R(subclass_code) 420 PCI_EPF_HEADER_W_u8(subclass_code) 421 422 PCI_EPF_HEADER_R(baseclass_code) 423 PCI_EPF_HEADER_W_u8(baseclass_code) 424 425 PCI_EPF_HEADER_R(cache_line_size) 426 PCI_EPF_HEADER_W_u8(cache_line_size) 427 428 PCI_EPF_HEADER_R(subsys_vendor_id) 429 PCI_EPF_HEADER_W_u16(subsys_vendor_id) 430 431 PCI_EPF_HEADER_R(subsys_id) 432 PCI_EPF_HEADER_W_u16(subsys_id) 433 434 PCI_EPF_HEADER_R(interrupt_pin) 435 PCI_EPF_HEADER_W_u8(interrupt_pin) 436 437 CONFIGFS_ATTR(pci_epf_, vendorid); 438 CONFIGFS_ATTR(pci_epf_, deviceid); 439 CONFIGFS_ATTR(pci_epf_, revid); 440 CONFIGFS_ATTR(pci_epf_, progif_code); 441 CONFIGFS_ATTR(pci_epf_, subclass_code); 442 CONFIGFS_ATTR(pci_epf_, baseclass_code); 443 CONFIGFS_ATTR(pci_epf_, cache_line_size); 444 CONFIGFS_ATTR(pci_epf_, subsys_vendor_id); 445 CONFIGFS_ATTR(pci_epf_, subsys_id); 446 CONFIGFS_ATTR(pci_epf_, interrupt_pin); 447 CONFIGFS_ATTR(pci_epf_, msi_interrupts); 448 CONFIGFS_ATTR(pci_epf_, msix_interrupts); 449 450 static 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 466 static 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 477 static 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 488 static 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 499 static 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 505 static 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 515 static void pci_epf_type_drop(struct config_group *group, 516 struct config_item *item) 517 { 518 config_item_put(item); 519 } 520 521 static 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 526 static 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 533 static 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 552 static 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 601 free_name: 602 kfree(epf_name); 603 604 remove_idr: 605 mutex_lock(&functions_mutex); 606 idr_remove(&functions_idr, epf_group->index); 607 mutex_unlock(&functions_mutex); 608 609 free_group: 610 kfree(epf_group); 611 612 return ERR_PTR(err); 613 } 614 615 static void pci_epf_drop(struct config_group *group, struct config_item *item) 616 { 617 config_item_put(item); 618 } 619 620 static struct configfs_group_operations pci_epf_group_ops = { 621 .make_group = &pci_epf_make, 622 .drop_item = &pci_epf_drop, 623 }; 624 625 static const struct config_item_type pci_epf_group_type = { 626 .ct_group_ops = &pci_epf_group_ops, 627 .ct_owner = THIS_MODULE, 628 }; 629 630 struct 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 } 642 EXPORT_SYMBOL(pci_ep_cfs_add_epf_group); 643 644 void 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 } 651 EXPORT_SYMBOL(pci_ep_cfs_remove_epf_group); 652 653 static const struct config_item_type pci_functions_type = { 654 .ct_owner = THIS_MODULE, 655 }; 656 657 static const struct config_item_type pci_controllers_type = { 658 .ct_owner = THIS_MODULE, 659 }; 660 661 static const struct config_item_type pci_ep_type = { 662 .ct_owner = THIS_MODULE, 663 }; 664 665 static 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 675 static 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 710 err_controllers_group: 711 configfs_unregister_default_group(functions_group); 712 713 err_functions_group: 714 configfs_unregister_subsystem(&pci_ep_cfs_subsys); 715 716 err: 717 return ret; 718 } 719 module_init(pci_ep_cfs_init); 720 721 static 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 } 727 module_exit(pci_ep_cfs_exit); 728 729 MODULE_DESCRIPTION("PCI EP CONFIGFS"); 730 MODULE_AUTHOR("Kishon Vijay Abraham I <kishon@ti.com>"); 731 MODULE_LICENSE("GPL v2"); 732