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