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 <[email protected]>
   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 <[email protected]>");
 731 MODULE_LICENSE("GPL v2");