drivers/pci/endpoint/pci-ep-cfs.c

   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>");